triflux 10.9.12 → 10.9.13

package/bin/triflux.mjs

@@ -289,6 +289,41 @@ const CLI_COMMAND_SCHEMAS = Object.freeze({
       },
     },
   },
+  synapse: {
+    usage: "tfx synapse status [--json] [--registry <path>]",
+    description: "Synapse v1 세션 레지스트리 조회 (활성 스웜 세션 목록)",
+    subcommands: {
+      status: "활성 세션 테이블 표시 (host/branch/dirty/state/task)",
+    },
+    options: [
+      {
+        name: "--json",
+        type: "boolean",
+        description: "구조화된 JSON 출력",
+      },
+      {
+        name: "--registry",
+        type: "string",
+        description: "registry 파일 경로 오버라이드",
+      },
+    ],
+  },
+  why: {
+    usage: "tfx why <path> [--json]",
+    description: "해당 경로의 마지막 커밋에서 X-Intent 트레일러 추출",
+    options: [
+      {
+        name: "path",
+        type: "string",
+        description: "intent를 조회할 파일 경로",
+      },
+      {
+        name: "--json",
+        type: "boolean",
+        description: "구조화된 JSON 출력",
+      },
+    ],
+  },
   hub: {
     usage: "tfx hub <start|stop|status|ensure> [--port N] [--json]",
     description: "tfx-hub 프로세스 제어",
@@ -5306,6 +5341,26 @@ async function main() {
       }
       return;
     }
+    case "synapse": {
+      const { cmdSynapseStatus } = await import(
+        "../hub/team/synapse-cli.mjs"
+      );
+      const sub = cmdArgs[0] || "status";
+      if (sub !== "status") {
+        throw createCliError(`synapse 서브커맨드 미지원: ${sub}`, {
+          exitCode: EXIT_ARG_ERROR,
+          reason: "argError",
+          fix: "tfx synapse status [--json] [--registry <path>]",
+        });
+      }
+      await cmdSynapseStatus(cmdArgs.slice(1), { json: JSON_OUTPUT });
+      return;
+    }
+    case "why": {
+      const { cmdSynapseWhy } = await import("../hub/team/synapse-cli.mjs");
+      await cmdSynapseWhy(cmdArgs, { json: JSON_OUTPUT });
+      return;
+    }
     case "version":
     case "--version":
     case "-v":

package/hub/server.mjs

@@ -1486,6 +1486,17 @@ export async function startHub({
           "hub.public_dir",
         );
 
+        /**
+         * Hub 서버 정지 함수.
+         *
+         * Trade-off (F01 — 영구 poisoning 허용):
+         * 첫 정지 호출에서 cleanup 파이프라인이 실패하면 stopPromise는 실패 상태로
+         * 고정되고, 이후 모든 호출은 동일한 실패 promise를 반환합니다. stopPromise를
+         * null로 리셋하면 재시도가 가능하지만, router sweeper / transports / pipe 등이
+         * 이미 부분 해제된 상태에서 두 번째 close가 실행되면 use-after-close 및
+         * race condition을 유발합니다. 실패한 stopFn은 프로세스 전체 재시작으로 복구해야
+         * 하며, 이 동작은 의도된 설계입니다.
+         */
         const stopFn = async () => {
           if (stopPromise) return stopPromise;
 
@@ -1682,9 +1693,9 @@ function cleanupStaleSpawnSessions(log) {
 const QUOTA_CACHE_PATH = join(CACHE_DIR, "broker-quota-cache.json");
 
 async function checkSingleAccountQuota(acct) {
-  const authPath = join(PID_DIR, acct.authFile);
-  if (!existsSync(authPath)) return { id: acct.id, status: "no_auth" };
   try {
+    const authPath = join(PID_DIR, acct.authFile);
+    if (!existsSync(authPath)) return { id: acct.id, status: "no_auth" };
     const auth = JSON.parse(readFileSync(authPath, "utf8"));
     if (acct.provider === "codex") {
       const token = auth.tokens?.access_token || auth.OPENAI_API_KEY || "";
@@ -1712,7 +1723,12 @@ async function checkSingleAccountQuota(acct) {
 async function refreshAllAccountQuotas() {
   const snap = brokerInstance?.snapshot() || [];
   const checks = snap.filter(a => a.authFile).map(a => checkSingleAccountQuota(a));
-  const results = await Promise.all(checks);
+  const settled = await Promise.allSettled(checks);
+  const results = settled.map((s, i) =>
+    s.status === "fulfilled"
+      ? s.value
+      : { id: snap.filter(a => a.authFile)[i]?.id ?? "unknown", status: "error", message: String(s.reason?.message || s.reason).substring(0, 60) },
+  );
   // 캐시 저장
   try {
     writeFileSync(QUOTA_CACHE_PATH, JSON.stringify({ ts: Date.now(), results }));

package/hub/team/git-preflight.mjs

@@ -0,0 +1,286 @@
+// hub/team/git-preflight.mjs — Pre-flight safety check for dangerous git ops.
+// Blocks checkout/rebase/cherry-pick/reset/stash-pop/worktree-remove when they
+// would conflict with other active Synapse sessions' dirty files or claimed
+// leases. Fail-open by default: if registry/locks are unavailable, allow the op
+// with a warning (worktree isolation is the baseline safety net).
+
+/**
+ * Factory for git pre-flight check.
+ *
+ * @param {object} opts
+ * @param {{ getActive: () => Array<object> }} opts.registry — synapse-registry duck type
+ * @param {{ snapshot: () => Array<object> }} opts.locks — swarm-locks duck type
+ * @param {boolean} [opts.failOpen=true] — allow op when registry/locks throw or are missing
+ * @param {(level: string, msg: string, data?: object) => void} [opts.logger] — optional logger
+ * @returns {{
+ *   check: Function,
+ *   checkRebase: Function,
+ *   checkCheckout: Function,
+ *   checkCherryPick: Function,
+ *   checkReset: Function,
+ *   checkStashPop: Function,
+ *   checkWorktreeRemove: Function,
+ * }}
+ */
+export function createGitPreflight(opts = {}) {
+  const { registry, locks, failOpen = true, logger = null } = opts;
+
+  function log(level, msg, data) {
+    if (logger) {
+      try {
+        logger(level, msg, data);
+      } catch {
+        /* logger failure is non-fatal */
+      }
+      return;
+    }
+    if (level === "warn") {
+      console.warn(`[git-preflight] ${msg}`, data ?? "");
+    } else if (level === "error") {
+      console.error(`[git-preflight] ${msg}`, data ?? "");
+    }
+  }
+
+  // ── helpers ──────────────────────────────────────────────
+
+  function safeGetActive() {
+    try {
+      const value = registry?.getActive?.();
+      if (!Array.isArray(value)) return null;
+      return value;
+    } catch (err) {
+      log("warn", "registry.getActive threw", { error: err?.message });
+      return null;
+    }
+  }
+
+  function safeSnapshot() {
+    try {
+      const value = locks?.snapshot?.();
+      if (!Array.isArray(value)) return null;
+      return value;
+    } catch (err) {
+      log("warn", "locks.snapshot threw", { error: err?.message });
+      return null;
+    }
+  }
+
+  function failOpenDecision(reason) {
+    log("warn", "hub unavailable, failing open", { reason });
+    return { allowed: true, reason: "hub_unavailable_fail_open" };
+  }
+
+  function normalizeFiles(list) {
+    if (!Array.isArray(list)) return new Set();
+    return new Set(
+      list
+        .filter((f) => typeof f === "string" && f.length > 0)
+        .map((f) => f.replace(/\\/g, "/")),
+    );
+  }
+
+  function otherActiveSessions(active, sessionId) {
+    return active.filter((s) => s && s.sessionId && s.sessionId !== sessionId);
+  }
+
+  function otherLeases(snapshot, workerId) {
+    return snapshot.filter(
+      (entry) => entry && entry.workerId && entry.workerId !== workerId,
+    );
+  }
+
+  function buildConflict(file, session, holder) {
+    return {
+      file,
+      activeSession: session?.sessionId ?? holder ?? "unknown",
+      activeTask: session?.taskSummary ?? "",
+      ...(holder ? { leaseHolder: holder } : {}),
+    };
+  }
+
+  function recommend(conflicts) {
+    if (!conflicts.length) return "";
+    const first = conflicts[0];
+    const owner = first.leaseHolder || first.activeSession;
+    const task = first.activeTask
+      ? ` Active task: '${first.activeTask}'`
+      : "";
+    return `Wait for '${owner}' to finish, or coordinate via HITL.${task}`;
+  }
+
+  function blockedDecision(op, conflicts, extraReason) {
+    return {
+      allowed: false,
+      reason: extraReason || "overlap_with_active_session",
+      conflicts,
+      recommendation: recommend(conflicts),
+      op,
+    };
+  }
+
+  function allowedDecision() {
+    return { allowed: true };
+  }
+
+  // ── shared scanners ─────────────────────────────────────
+
+  function findDirtyFileConflicts(sessionId, workerId) {
+    const active = safeGetActive();
+    const snapshot = safeSnapshot();
+
+    if (active == null || snapshot == null) {
+      return failOpen ? { fallOpen: true } : { fallOpen: false, conflicts: [] };
+    }
+
+    const conflicts = [];
+    const seen = new Set();
+
+    for (const session of otherActiveSessions(active, sessionId)) {
+      const dirty = normalizeFiles(session.dirtyFiles);
+      for (const file of dirty) {
+        if (seen.has(file)) continue;
+        seen.add(file);
+        conflicts.push(buildConflict(file, session));
+      }
+    }
+
+    for (const lease of otherLeases(snapshot, workerId)) {
+      if (lease.leaseType && lease.leaseType !== "exclusive") continue;
+      const file = typeof lease.file === "string" ? lease.file : null;
+      if (!file || seen.has(file)) continue;
+      seen.add(file);
+      const sessionMeta = lease.sessionMeta || null;
+      conflicts.push(
+        buildConflict(
+          file,
+          sessionMeta
+            ? {
+                sessionId: sessionMeta.sessionId || lease.workerId,
+                taskSummary: sessionMeta.taskSummary || "",
+              }
+            : null,
+          lease.workerId,
+        ),
+      );
+    }
+
+    return { conflicts };
+  }
+
+  function findTargetFileConflicts(targetFiles, sessionId, workerId) {
+    const active = safeGetActive();
+    const snapshot = safeSnapshot();
+
+    if (active == null || snapshot == null) {
+      return failOpen ? { fallOpen: true } : { fallOpen: false, conflicts: [] };
+    }
+
+    const targets = normalizeFiles(targetFiles);
+    if (targets.size === 0) return { conflicts: [] };
+
+    const conflicts = [];
+    const seen = new Set();
+
+    for (const session of otherActiveSessions(active, sessionId)) {
+      const dirty = normalizeFiles(session.dirtyFiles);
+      for (const file of dirty) {
+        if (!targets.has(file) || seen.has(file)) continue;
+        seen.add(file);
+        conflicts.push(buildConflict(file, session));
+      }
+    }
+
+    for (const lease of otherLeases(snapshot, workerId)) {
+      if (lease.leaseType && lease.leaseType !== "exclusive") continue;
+      const file = typeof lease.file === "string" ? lease.file : null;
+      if (!file || !targets.has(file) || seen.has(file)) continue;
+      seen.add(file);
+      const sessionMeta = lease.sessionMeta || null;
+      conflicts.push(
+        buildConflict(
+          file,
+          sessionMeta
+            ? {
+                sessionId: sessionMeta.sessionId || lease.workerId,
+                taskSummary: sessionMeta.taskSummary || "",
+              }
+            : null,
+          lease.workerId,
+        ),
+      );
+    }
+
+    return { conflicts };
+  }
+
+  // ── public API ──────────────────────────────────────────
+
+  /**
+   * Core pre-flight check.
+   *
+   * @param {"checkout"|"rebase"|"cherry-pick"|"reset"|"stash-pop"|"worktree-remove"} op
+   * @param {{ targetFiles?: string[], branch?: string, ref?: string, worktreePath?: string }} args
+   * @param {{ sessionId: string, workerId?: string }} sessionContext
+   * @returns {{ allowed: boolean, reason?: string, conflicts?: object[], recommendation?: string, op?: string }}
+   */
+  function check(op, args = {}, sessionContext = {}) {
+    const sessionId = sessionContext.sessionId || "";
+    const workerId = sessionContext.workerId || sessionId;
+
+    switch (op) {
+      case "checkout":
+      case "rebase":
+      case "reset":
+      case "stash-pop": {
+        const res = findDirtyFileConflicts(sessionId, workerId);
+        if (res.fallOpen) return failOpenDecision(op);
+        if (res.conflicts.length > 0) return blockedDecision(op, res.conflicts);
+        return allowedDecision();
+      }
+      case "cherry-pick": {
+        const targets = Array.isArray(args.targetFiles) ? args.targetFiles : [];
+        const res = findTargetFileConflicts(targets, sessionId, workerId);
+        if (res.fallOpen) return failOpenDecision(op);
+        if (res.conflicts.length > 0) return blockedDecision(op, res.conflicts);
+        return allowedDecision();
+      }
+      case "worktree-remove": {
+        const active = safeGetActive();
+        if (active == null) return failOpenDecision(op);
+        const target = typeof args.worktreePath === "string"
+          ? args.worktreePath.replace(/\\/g, "/")
+          : "";
+        if (!target) return allowedDecision();
+        const conflicts = [];
+        for (const session of otherActiveSessions(active, sessionId)) {
+          const sessionPath = typeof session.worktreePath === "string"
+            ? session.worktreePath.replace(/\\/g, "/")
+            : "";
+          if (sessionPath && sessionPath === target) {
+            conflicts.push({
+              file: target,
+              activeSession: session.sessionId,
+              activeTask: session.taskSummary || "",
+            });
+          }
+        }
+        if (conflicts.length > 0) {
+          return blockedDecision(op, conflicts, "active_worktree");
+        }
+        return allowedDecision();
+      }
+      default:
+        return allowedDecision();
+    }
+  }
+
+  return Object.freeze({
+    check,
+    checkRebase: (args, ctx) => check("rebase", args, ctx),
+    checkCheckout: (args, ctx) => check("checkout", args, ctx),
+    checkCherryPick: (args, ctx) => check("cherry-pick", args, ctx),
+    checkReset: (args, ctx) => check("reset", args, ctx),
+    checkStashPop: (args, ctx) => check("stash-pop", args, ctx),
+    checkWorktreeRemove: (args, ctx) => check("worktree-remove", args, ctx),
+  });
+}

package/hub/team/swarm-intent.mjs

@@ -0,0 +1,216 @@
+// hub/team/swarm-intent.mjs — X-Intent helper utilities for semantic merge awareness
+
+const INTENT_TRAILER_REGEX = /^X-Intent:\s*(.+)$/m;
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeTouches(touches) {
+  if (!Array.isArray(touches)) return null;
+  return touches
+    .filter((item) => typeof item === "string")
+    .map((item) => item.trim().replace(/\\/g, "/"))
+    .filter(Boolean);
+}
+
+function normalizeIntent(intentObj) {
+  if (!intentObj || typeof intentObj !== "object" || Array.isArray(intentObj)) {
+    return null;
+  }
+
+  const scope = normalizeText(intentObj.scope);
+  const action = normalizeText(intentObj.action);
+  const reason = normalizeText(intentObj.reason);
+  const touches = normalizeTouches(intentObj.touches);
+
+  if (!scope || !action || !reason || !touches) {
+    return null;
+  }
+
+  return {
+    scope,
+    action,
+    reason,
+    touches,
+    invariant: normalizeText(intentObj.invariant),
+    conflictsWith: normalizeText(intentObj.conflictsWith),
+  };
+}
+
+function fallbackIntent(llmResponse) {
+  const responseText = String(llmResponse ?? "");
+  return {
+    scope: "unknown",
+    action: "unknown",
+    reason: responseText.slice(0, 100),
+    touches: [],
+    invariant: "",
+    conflictsWith: "",
+  };
+}
+
+function includesEitherWay(a, b) {
+  if (!a || !b) return false;
+  return a.includes(b) || b.includes(a);
+}
+
+function hasConflict(intentA, intentB) {
+  const conflictsWith = normalizeText(intentA?.conflictsWith).toLowerCase();
+  const scope = normalizeText(intentB?.scope).toLowerCase();
+  const action = normalizeText(intentB?.action).toLowerCase();
+
+  if (!conflictsWith) return false;
+  return (
+    includesEitherWay(conflictsWith, scope) ||
+    includesEitherWay(conflictsWith, action)
+  );
+}
+
+function getTouchesOverlap(intentA, intentB) {
+  const touchesA = new Set(
+    (normalizeTouches(intentA?.touches) ?? []).map((item) =>
+      item.toLowerCase(),
+    ),
+  );
+  const touchesB = (normalizeTouches(intentB?.touches) ?? []).map((item) =>
+    item.toLowerCase(),
+  );
+  return touchesB.filter((item) => touchesA.has(item));
+}
+
+/**
+ * Build prompts for an LLM to generate an X-Intent JSON object.
+ * @param {string[]} changedFiles
+ * @param {string} commitDiff
+ * @param {string} taskContext
+ * @returns {{ systemPrompt: string, userPrompt: string }}
+ */
+export function generateIntentPrompt(changedFiles, commitDiff, taskContext) {
+  const files = Array.isArray(changedFiles)
+    ? changedFiles.filter((filePath) => typeof filePath === "string")
+    : [];
+  const diffSnippet = String(commitDiff ?? "").slice(0, 4000);
+  const context = String(taskContext ?? "").trim();
+
+  return {
+    systemPrompt:
+      "You generate commit intent metadata for semantic merge awareness. Return only valid JSON with keys: scope, action, reason, touches, invariant, conflictsWith.",
+    userPrompt: [
+      "Create an intent object from the following commit context.",
+      "- scope/action/reason must be concise strings.",
+      "- touches must be an array of touched file paths.",
+      "- invariant/conflictsWith should be strings (empty if unknown).",
+      "- Return JSON only (no markdown).",
+      "",
+      `Task context:\n${context || "(none provided)"}`,
+      "",
+      `Changed files (${files.length}):\n${files.join("\n") || "(none)"}`,
+      "",
+      "Commit diff (first 4000 chars):",
+      diffSnippet || "(empty)",
+    ].join("\n"),
+  };
+}
+
+/**
+ * Format an intent object into an X-Intent commit trailer.
+ * @param {object} intentObj
+ * @returns {string}
+ */
+export function formatIntentTrailer(intentObj) {
+  return `X-Intent: ${JSON.stringify(intentObj)}`;
+}
+
+/**
+ * Parse an X-Intent trailer from a commit message.
+ * @param {string} commitMessage
+ * @returns {object | null}
+ */
+export function parseIntentTrailer(commitMessage) {
+  const message = String(commitMessage ?? "");
+  const match = message.match(INTENT_TRAILER_REGEX);
+  if (!match) return null;
+
+  try {
+    return JSON.parse(match[1]);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Classify the relation between two intents.
+ * @param {object} intentA
+ * @param {object} intentB
+ * @returns {{ relation: "complementary" | "complementary-risky" | "contradictory" | "independent", reason: string }}
+ */
+export function classifyIntentPair(intentA, intentB) {
+  if (hasConflict(intentA, intentB) || hasConflict(intentB, intentA)) {
+    return {
+      relation: "contradictory",
+      reason:
+        "conflictsWith on one intent matches the other intent scope/action",
+    };
+  }
+
+  const scopeA = normalizeText(intentA?.scope).toLowerCase();
+  const scopeB = normalizeText(intentB?.scope).toLowerCase();
+
+  if (scopeA && scopeB && scopeA === scopeB) {
+    const overlap = getTouchesOverlap(intentA, intentB);
+    if (overlap.length > 0) {
+      return {
+        relation: "complementary-risky",
+        reason: `same scope with overlapping touched files: ${overlap.join(", ")}`,
+      };
+    }
+
+    return {
+      relation: "complementary",
+      reason:
+        "same scope with no conflicting intent and no touched-file overlap",
+    };
+  }
+
+  return {
+    relation: "independent",
+    reason: "different scopes and no conflictsWith match detected",
+  };
+}
+
+/**
+ * Build a validated intent object from raw LLM response text.
+ * @param {string} llmResponse
+ * @returns {{ scope: string, action: string, reason: string, touches: string[], invariant: string, conflictsWith: string }}
+ */
+export function buildIntentFromLLMResponse(llmResponse) {
+  const responseText = String(llmResponse ?? "").trim();
+  const candidates = [];
+
+  const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)```/gi;
+  for (const match of responseText.matchAll(codeBlockRegex)) {
+    if (match[1]) candidates.push(match[1].trim());
+  }
+
+  candidates.push(responseText);
+
+  const firstBrace = responseText.indexOf("{");
+  const lastBrace = responseText.lastIndexOf("}");
+  if (firstBrace >= 0 && lastBrace > firstBrace) {
+    candidates.push(responseText.slice(firstBrace, lastBrace + 1));
+  }
+
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    try {
+      const parsed = JSON.parse(candidate);
+      const normalized = normalizeIntent(parsed);
+      if (normalized) return normalized;
+    } catch {
+      // ignore parse failures and continue trying other candidates
+    }
+  }
+
+  return fallbackIntent(responseText);
+}