@triflux/remote 10.37.0 → 10.39.0

package/cto/events.mjs

@@ -6,6 +6,7 @@ import {
   unlinkSync,
 } from "node:fs";
 import { basename, join } from "node:path";
+import { resolveLakeRootDir } from "./lake-root.mjs";
 
 export const CTO_EVENT_SCHEMA_VERSION = "cto-event.v1";
 export const DEFAULT_CTO_EVENT_SOURCE = "tfx_cto_event";
@@ -41,6 +42,98 @@ export const CTO_HYGIENE_STATUSES = Object.freeze([
 const EVENT_TYPE_SET = new Set(CTO_EVENT_TYPES);
 const STATUS_SET = new Set(CTO_HYGIENE_STATUSES);
 
+const EVENT_PRESETS = Object.freeze({
+  "context-save": {
+    event: "checkpoint_saved",
+    source: "gstack_context_save",
+    actor: { cli: "gstack context-save" },
+    ownerSurface: "gstack context-save -> tfx cto event context-save",
+  },
+  "checkpoint-saved": {
+    event: "checkpoint_saved",
+    ownerSurface: "checkpoint wrapper -> tfx cto event checkpoint-saved",
+  },
+  "context-restore": {
+    event: "checkpoint_restored",
+    source: "gstack_context_restore",
+    actor: { cli: "gstack context-restore" },
+    ownerSurface: "gstack context-restore -> tfx cto event context-restore",
+  },
+  "checkpoint-restored": {
+    event: "checkpoint_restored",
+    ownerSurface: "checkpoint wrapper -> tfx cto event checkpoint-restored",
+  },
+  "pr-created": {
+    event: "pr_created",
+    source: "tfx_pr_lifecycle",
+    actor: { cli: "gh pr create" },
+    ownerSurface: "gh pr create/merge/close -> tfx cto event pr-created",
+  },
+  "pr-merged": {
+    event: "pr_merged_or_closed",
+    source: "tfx_pr_lifecycle",
+    status: "completed",
+    actor: { cli: "gh pr merge" },
+    ownerSurface:
+      "gh pr create/merge/close -> tfx cto event pr-merged-or-closed",
+  },
+  "pr-closed": {
+    event: "pr_merged_or_closed",
+    source: "tfx_pr_lifecycle",
+    status: "completed",
+    actor: { cli: "gh pr close" },
+    ownerSurface:
+      "gh pr create/merge/close -> tfx cto event pr-merged-or-closed",
+  },
+  "pr-merged-or-closed": {
+    event: "pr_merged_or_closed",
+    source: "tfx_pr_lifecycle",
+    actor: { cli: "gh pr merge/close" },
+    ownerSurface:
+      "gh pr create/merge/close -> tfx cto event pr-merged-or-closed",
+  },
+});
+
+const OPTION_KEYS = Object.freeze({
+  event: "event",
+  "event-type": "event",
+  source: "source",
+  summary: "summary",
+  now: "now",
+  ts: "ts",
+  status: "status",
+  "session-id": "session_id",
+  "parent-session-id": "parent_session_id",
+  "restored-from-session-id": "restored_from_session_id",
+  "checkpoint-id": "checkpoint_id",
+  "artifact-path": "artifact_path",
+  artifact: "artifact_path",
+  "task-id": "task_id",
+  branch: "branch",
+  "last-seen-at": "last_seen_at",
+  "stale-reason": "stale_reason",
+  "hygiene-key": "hygiene_key",
+  "hygiene-kind": "hygiene_kind",
+  "hygiene-id": "hygiene_id",
+  "hygiene-action": "hygiene_action",
+  "project-root": "project_root",
+  "worktree-path": "worktree_path",
+  worktree: "worktree_path",
+  issue: "issue_refs",
+  "issue-ref": "issue_refs",
+  "issue-refs": "issue_refs",
+  pr: "pr_refs",
+  "pr-ref": "pr_refs",
+  "pr-refs": "pr_refs",
+  "actor-cli": "actor.cli",
+  "actor-session-id": "actor.session_id",
+  "actor-agent-id": "actor.agent_id",
+  "actor-host": "actor.host",
+  "owner-surface": "owner_surface",
+});
+
+const COLLECTION_KEYS = new Set(["issue_refs", "pr_refs"]);
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -107,6 +200,124 @@ function normalizeActor(actor) {
   return Object.keys(normalized).length > 0 ? normalized : null;
 }
 
+function optionName(raw) {
+  return String(raw || "")
+    .replace(/^--?/u, "")
+    .trim();
+}
+
+function appendCollection(target, key, value) {
+  const values = String(value ?? "")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+  if (values.length === 0) return;
+  if (!Array.isArray(target[key])) target[key] = [];
+  target[key].push(...values);
+}
+
+function putPathValue(target, keyPath, value) {
+  if (keyPath.startsWith("actor.")) {
+    const key = keyPath.slice("actor.".length);
+    target.actor ||= {};
+    target.actor[key] = value;
+    return;
+  }
+  if (COLLECTION_KEYS.has(keyPath)) {
+    appendCollection(target, keyPath, value);
+    return;
+  }
+  target[keyPath] = value;
+}
+
+function parseEventArgs(args = []) {
+  const fields = {};
+  const positional = [];
+  let json = false;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (!arg?.startsWith?.("--")) {
+      positional.push(arg);
+      continue;
+    }
+
+    const eqIndex = arg.indexOf("=");
+    const rawName = eqIndex >= 0 ? arg.slice(0, eqIndex) : arg;
+    const name = optionName(rawName);
+    const mapped = OPTION_KEYS[name];
+    if (!mapped) {
+      throw new Error(`unknown tfx cto event option: --${name}`);
+    }
+
+    let value = eqIndex >= 0 ? arg.slice(eqIndex + 1) : null;
+    if (value === null) {
+      const next = args[i + 1];
+      if (typeof next === "string" && !next.startsWith("--")) {
+        value = next;
+        i += 1;
+      } else {
+        value = "true";
+      }
+    }
+    putPathValue(fields, mapped, value);
+  }
+
+  return {
+    presetName: positional[0] || null,
+    extraPositionals: positional.slice(1),
+    fields,
+    json,
+  };
+}
+
+function mergeActor(defaultActor, overrideActor) {
+  const actor = { ...(defaultActor || {}), ...(overrideActor || {}) };
+  return Object.keys(actor).length > 0 ? actor : undefined;
+}
+
+function defaultEventSummary(input) {
+  if (input.event === "checkpoint_saved") {
+    return `context-save checkpoint ${input.checkpoint_id}`;
+  }
+  if (input.event === "checkpoint_restored") {
+    return `context-restore checkpoint ${input.checkpoint_id}`;
+  }
+  if (input.event === "pr_created") {
+    const [pr] = normalizeNumericRefs(input.pr_refs);
+    return pr ? `PR #${pr} created` : "PR created";
+  }
+  if (input.event === "pr_merged_or_closed") {
+    const [pr] = normalizeNumericRefs(input.pr_refs);
+    return pr ? `PR #${pr} merged or closed` : "PR merged or closed";
+  }
+  return undefined;
+}
+
+function validateRunEventInput(input) {
+  if (!input.event) {
+    throw new Error("tfx cto event requires a preset or --event <event_type>");
+  }
+
+  if (
+    ["checkpoint_saved", "checkpoint_restored"].includes(input.event) &&
+    !maybeString(input.checkpoint_id)
+  ) {
+    throw new Error(`tfx cto event ${input.event} requires --checkpoint-id`);
+  }
+
+  if (
+    ["pr_created", "pr_merged_or_closed"].includes(input.event) &&
+    normalizeNumericRefs(input.pr_refs).length === 0
+  ) {
+    throw new Error(`tfx cto event ${input.event} requires --pr`);
+  }
+}
+
 function putString(target, key, value) {
   const normalized = maybeString(value);
   if (normalized) target[key] = normalized;
@@ -220,3 +431,59 @@ export async function appendCtoEvent(lakeRoot, input, opts = {}) {
     } catch {}
   }
 }
+
+export async function runEvent(args = [], opts = {}) {
+  const parsed = parseEventArgs(args);
+  if (parsed.extraPositionals.length > 0) {
+    throw new Error(
+      `unexpected tfx cto event argument: ${parsed.extraPositionals[0]}`,
+    );
+  }
+  const preset = parsed.presetName ? EVENT_PRESETS[parsed.presetName] : null;
+  if (parsed.presetName && !preset && !parsed.fields.event) {
+    throw new Error(`unknown tfx cto event preset: ${parsed.presetName}`);
+  }
+
+  const rootDir = opts.rootDir || resolveLakeRootDir(process.cwd());
+  const lakeRoot = opts.lakeRoot || join(rootDir, ".triflux", "lake");
+  const stdout = opts.stdout || process.stdout;
+  const jsonOut = opts.json === true || parsed.json;
+  const ownerSurface =
+    parsed.fields.owner_surface ||
+    preset?.ownerSurface ||
+    "external wrapper -> tfx cto event --event";
+
+  const input = {
+    ...(preset || {}),
+    ...parsed.fields,
+    actor: mergeActor(preset?.actor, parsed.fields.actor),
+  };
+  delete input.ownerSurface;
+  delete input.owner_surface;
+  if (!input.project_root) input.project_root = rootDir;
+  if (!input.summary) input.summary = defaultEventSummary(input);
+
+  validateRunEventInput(input);
+
+  const result = await appendCtoEvent(lakeRoot, input, {
+    stderr: opts.stderr,
+    lockRetries: opts.ledgerLockRetries,
+    lockRetryDelayMs: opts.ledgerLockRetryDelayMs,
+  });
+  const payload = {
+    appended: result.appended,
+    owner_surface: ownerSurface,
+    event: result.event,
+  };
+
+  if (jsonOut) {
+    stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  } else {
+    const status = result.appended ? "appended" : "skipped";
+    stdout.write(
+      `[tfx cto event] ${status} ${result.event.event} via ${ownerSurface}\n`,
+    );
+  }
+
+  return payload;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.37.0",
+  "version": "10.39.0",
   "description": "triflux remote — team mode, psmux, MCP workers, SQLite store.",
   "type": "module",
   "main": "hub/index.mjs",

package/scripts/lib/gemini-profiles.mjs

@@ -8,23 +8,49 @@ import {
 import { homedir } from "node:os";
 import { join } from "node:path";
 
+// 모델명 SSOT. 값은 agy 1.0.x `agy models` 가 출력하는 display name 형식이다
+// (`--model` 인자가 이 문자열을 받는다). 옛 `gemini-*-preview` ID 형식이 아님.
 const DEFAULT_GEMINI_PROFILES = {
-  model: "gemini-3.1-pro-preview",
+  model: "Gemini 3.5 Flash (Medium)",
   profiles: {
+    flash35_low: {
+      model: "Gemini 3.5 Flash (Low)",
+      hint: "3.5 Flash (Low) — 경량·저비용",
+    },
+    flash35: {
+      model: "Gemini 3.5 Flash (Medium)",
+      hint: "3.5 Flash (Medium) — 기본, 비용·속도 균형",
+    },
+    flash35_high: {
+      model: "Gemini 3.5 Flash (High)",
+      hint: "3.5 Flash (High) — 코드/추론 강화",
+    },
+    pro31_low: {
+      model: "Gemini 3.1 Pro (Low)",
+      hint: "3.1 Pro (Low) — 플래그십 경량",
+    },
     pro31: {
-      model: "gemini-3.1-pro-preview",
-      hint: "3.1 Pro — 플래그십 (1M ctx, 멀티모달)",
+      model: "Gemini 3.1 Pro (High)",
+      hint: "3.1 Pro (High) — 플래그십 최고 (긴 컨텍스트/복잡 추론)",
     },
     flash3: {
-      model: "gemini-3-flash-preview",
-      hint: "3.0 Flash — 빠른 응답, 비용 효율",
+      model: "Gemini 3 Flash",
+      hint: "3.0 Flash — 레거시 호환",
     },
-    pro25: { model: "gemini-2.5-pro", hint: "2.5 Pro — 안정 (추론 강화)" },
-    flash25: { model: "gemini-2.5-flash", hint: "2.5 Flash — 경량 범용" },
-    lite25: { model: "gemini-2.5-flash-lite", hint: "2.5 Flash Lite — 최경량" },
   },
 };
 
+// 1회 마이그레이션 테이블: 옛 ID 형식 모델값 → agy display name.
+// null = deprecated(2.5 계열) → 해당 프로필 제거 대상.
+const LEGACY_MODEL_MIGRATION = {
+  "gemini-3.1-pro-preview": "Gemini 3.1 Pro (High)",
+  "gemini-3-flash-preview": "Gemini 3 Flash",
+  "gemini-2.5-pro": null,
+  "gemini-2.5-flash": null,
+  "gemini-2.5-flash-lite": null,
+};
+const LEGACY_PROFILE_NAMES = ["pro25", "flash25", "lite25"];
+
 const DEFAULT_PROFILE_COUNT = Object.keys(
   DEFAULT_GEMINI_PROFILES.profiles,
 ).length;
@@ -80,6 +106,39 @@ function ensureGeminiProfiles({
     )
       cfg.profiles = {};
 
+    // ── 1회 마이그레이션: deprecated 2.5 프로필 prune + 옛 ID 형식 → display name ──
+    // merge-only 로직만으로는 기존 사용자 파일에 남은 stale 프로필/옛 모델 ID 가
+    // 정리되지 않으므로, 신규 default 를 채우기 전에 마이그레이션을 먼저 적용한다.
+    let migrated = false;
+    for (const legacy of LEGACY_PROFILE_NAMES) {
+      if (cfg.profiles[legacy]) {
+        delete cfg.profiles[legacy];
+        migrated = true;
+      }
+    }
+    for (const [pname, pval] of Object.entries(cfg.profiles)) {
+      const mid = typeof pval === "string" ? pval : pval?.model;
+      if (mid && Object.hasOwn(LEGACY_MODEL_MIGRATION, mid)) {
+        const repl = LEGACY_MODEL_MIGRATION[mid];
+        if (repl === null) {
+          delete cfg.profiles[pname];
+        } else if (typeof pval === "string") {
+          cfg.profiles[pname] = repl;
+        } else {
+          cfg.profiles[pname].model = repl;
+        }
+        migrated = true;
+      }
+    }
+    if (
+      typeof cfg.model === "string" &&
+      Object.hasOwn(LEGACY_MODEL_MIGRATION, cfg.model)
+    ) {
+      // 옛 ID 형식 기본값은 구버전 자동 생성값이므로 새 기본(DEFAULT)으로 정규화한다.
+      cfg.model = DEFAULT_GEMINI_PROFILES.model;
+      migrated = true;
+    }
+
     let added = 0;
     for (const [name, value] of Object.entries(
       DEFAULT_GEMINI_PROFILES.profiles,
@@ -91,7 +150,12 @@ function ensureGeminiProfiles({
     }
     if (!cfg.model) cfg.model = DEFAULT_GEMINI_PROFILES.model;
 
-    if (added > 0) {
+    if (added > 0 || migrated) {
+      if (migrated) {
+        try {
+          copyFileSync(profilesPath, profilesPath + `.bak.${Date.now()}`);
+        } catch {}
+      }
       writeFileSync(profilesPath, JSON.stringify(cfg, null, 2) + "\n", {
         encoding: "utf8",
         mode: 0o600,