@triflux/core 10.51.0 → 10.52.0

package/hub/reflexion.mjs

@@ -1,290 +0,0 @@
-// 오류 패턴 정규화 및 adaptive rule 관리
-
-export const ADAPTIVE_RULE_TYPE = "adaptive";
-const DEFAULT_CONFIDENCE = 0.5;
-const ADAPTIVE_PROMOTION_STEP = 0.1;
-const ADAPTIVE_DECAY_STEP = 0.1;
-const ADAPTIVE_DELETE_THRESHOLD = 0.3;
-
-function clampConfidence(value) {
-  const next = Number(value);
-  if (!Number.isFinite(next)) return DEFAULT_CONFIDENCE;
-  return Math.max(0, Math.min(1, next));
-}
-
-function safeJson(value) {
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "";
-  }
-}
-
-function pickString(...values) {
-  return (
-    values.find((value) => typeof value === "string" && value.trim())?.trim() ||
-    ""
-  );
-}
-
-/** @deprecated 세션 기반 decay 제거로 미사용. 세션 인식 복원 시 재활용 예정. */
-function pickSessionCount(...values) {
-  const raw = values.find((value) => Number.isFinite(Number(value)));
-  return raw == null ? 0 : Math.max(0, Math.trunc(Number(raw)));
-}
-
-function pickSessionId(errorContext = {}) {
-  return pickString(
-    errorContext.session_id,
-    errorContext.sessionId,
-    errorContext.context?.session_id,
-    errorContext.context?.sessionId,
-  );
-}
-
-function pickProjectSlug(errorContext = {}) {
-  return pickString(
-    errorContext.projectSlug,
-    errorContext.project_slug,
-    errorContext.context?.projectSlug,
-    errorContext.context?.project_slug,
-  );
-}
-
-function compactObject(value) {
-  return Object.fromEntries(
-    Object.entries(value).filter(([, entry]) => entry != null && entry !== ""),
-  );
-}
-
-function buildErrorText(errorContext = {}) {
-  const parts = [
-    pickString(errorContext.tool_output),
-    pickString(errorContext.error),
-    pickString(errorContext.tool_input?.command),
-    errorContext.tool_result == null ? "" : safeJson(errorContext.tool_result),
-  ].filter(Boolean);
-  return parts.join("\n").trim();
-}
-
-function buildAdaptiveContext(errorContext = {}) {
-  return compactObject({
-    source: "PostToolUseFailure",
-    tool_name: pickString(errorContext.tool_name),
-    agent: pickString(errorContext.agent, errorContext.context?.agent),
-    cli: pickString(errorContext.cli, errorContext.context?.cli),
-    command: pickString(errorContext.tool_input?.command),
-    file: pickString(
-      errorContext.tool_input?.file_path,
-      errorContext.context?.file,
-    ),
-    project_slug: pickProjectSlug(errorContext),
-  });
-}
-
-function buildAdaptiveSolution(errorContext = {}, errorText = "") {
-  const explicit = pickString(
-    errorContext.systemMessage,
-    errorContext.additionalContext,
-    errorContext.hint,
-  );
-  if (explicit) return explicit;
-  const toolName = pickString(errorContext.tool_name) || "tool";
-  const command = pickString(errorContext.tool_input?.command);
-  const summary = errorText.split("\n")[0]?.trim() || "반복 실패 패턴";
-  if (command)
-    return `${toolName} 재시도 전 입력을 검증하세요: ${command}\n원인: ${summary}`;
-  return `${toolName} 재시도 전 실패 원인을 검증하세요: ${summary}`;
-}
-
-function parseAdaptiveRuleId(ruleId, projectSlug = "") {
-  const value = pickString(ruleId);
-  if (!value) return null;
-  const nulSeparator = value.indexOf("\u0000");
-  if (nulSeparator > 0) {
-    return {
-      project_slug: value.slice(0, nulSeparator),
-      pattern: value.slice(nulSeparator + 1),
-    };
-  }
-  if (projectSlug && value.startsWith(`${projectSlug}:`)) {
-    return {
-      project_slug: projectSlug,
-      pattern: value.slice(projectSlug.length + 1),
-    };
-  }
-  return null;
-}
-
-function resolveAdaptiveRuleIdentity(
-  ruleIdOrProjectSlug,
-  patternOrErrorContext,
-) {
-  if (typeof patternOrErrorContext === "string") {
-    return {
-      project_slug: pickString(ruleIdOrProjectSlug),
-      pattern: pickString(patternOrErrorContext),
-    };
-  }
-
-  const errorContext =
-    patternOrErrorContext && typeof patternOrErrorContext === "object"
-      ? patternOrErrorContext
-      : {};
-  const projectSlug = pickString(pickProjectSlug(errorContext));
-  const fromRuleId = parseAdaptiveRuleId(ruleIdOrProjectSlug, projectSlug);
-  const errorText = pickString(
-    errorContext.error_pattern,
-    errorContext.pattern,
-    errorContext.error,
-    errorContext.errorText,
-    errorContext.errorMessage,
-    buildErrorText(errorContext),
-  );
-  const pattern = pickString(normalizeError(errorText), fromRuleId?.pattern);
-  return {
-    project_slug: pickString(projectSlug, fromRuleId?.project_slug),
-    pattern,
-  };
-}
-
-function listAdaptiveRulesFromStore(store, projectSlug) {
-  if (!store?.listAdaptiveRules) return [];
-  const rules = store.listAdaptiveRules(projectSlug);
-  return Array.isArray(rules) ? rules : [];
-}
-
-/**
- * 에러 메시지를 정규화된 패턴 시그니처로 변환
- * 파일 경로, 줄 번호, 타임스탬프, UUID, 숫자 리터럴을 플레이스홀더로 치환
- * @param {string} errorMessage
- * @returns {string}
- */
-export function normalizeError(errorMessage) {
-  if (!errorMessage || typeof errorMessage !== "string") return "";
-  let p = errorMessage;
-  p = p.replace(/[A-Za-z]:\\[\w\\.\-/]+/g, "<FILE>");
-  p = p.replace(/(?:\/[\w.-]+){2,}/g, "<FILE>");
-  p = p.replace(/:(\d+)(:\d+)?(?=[\s,)\]]|$)/g, ":<LINE>");
-  p = p.replace(/\b[Ll]ine\s+\d+/g, "line <LINE>");
-  p = p.replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}[\w.+-]*/g, "<TIME>");
-  p = p.replace(
-    /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi,
-    "<ID>",
-  );
-  p = p.replace(/\b[0-9a-f]{32,}\b/gi, "<ID>");
-  p = p.replace(/\b\d{10,13}\b/g, "<TIME>");
-  p = p.replace(/\b\d{4,}\b/g, "<NUM>");
-  return p.toLowerCase().replace(/\s+/g, " ").trim();
-}
-
-/**
- * PostToolUseFailure 컨텍스트에서 adaptive rule payload 생성
- * @param {object} errorContext
- * @returns {object|null}
- */
-export function adaptiveRuleFromError(errorContext = {}) {
-  const errorText = buildErrorText(errorContext);
-  const pattern = normalizeError(errorText);
-  if (!pattern) return null;
-  return {
-    type: ADAPTIVE_RULE_TYPE,
-    error_pattern: pattern,
-    error_message: errorText,
-    context: buildAdaptiveContext(errorContext),
-    solution: buildAdaptiveSolution(errorContext, errorText),
-    solution_code: null,
-    adaptive_state: (() => {
-      const sessionId = pickSessionId(errorContext);
-      const sessionCount = pickSessionCount(
-        errorContext.sessionCount,
-        errorContext.session_count,
-      );
-      return {
-        project_slug: pickProjectSlug(errorContext),
-        session_ids: sessionId ? [sessionId] : [],
-        session_occurrences: sessionId ? 1 : 0,
-        last_seen_session: sessionCount,
-        last_decay_session: sessionCount,
-      };
-    })(),
-    confidence: DEFAULT_CONFIDENCE,
-    hit_count: 1,
-    success_count: 0,
-  };
-}
-
-/**
- * 동일 패턴이 여러 세션에서 재발하면 adaptive rule confidence를 승격
- * 현재 (projectSlug, pattern)과 구형 (ruleId, errorContext) 시그니처를 모두 지원한다.
- * @param {object} store — store-adapter 인스턴스 (findAdaptiveRule, updateRuleConfidence 필요)
- * @param {string} ruleIdOrProjectSlug
- * @param {object|string} patternOrErrorContext
- * @returns {object|null}
- */
-export function promoteRule(store, ruleIdOrProjectSlug, patternOrErrorContext) {
-  if (!store.findAdaptiveRule || !store.updateRuleConfidence) return null;
-  const identity = resolveAdaptiveRuleIdentity(
-    ruleIdOrProjectSlug,
-    patternOrErrorContext,
-  );
-  if (!identity.project_slug || !identity.pattern) return null;
-  const rule = store.findAdaptiveRule(identity.project_slug, identity.pattern);
-  if (!rule) return null;
-  const promoted = clampConfidence(rule.confidence + ADAPTIVE_PROMOTION_STEP);
-  return store.updateRuleConfidence(
-    identity.project_slug,
-    identity.pattern,
-    promoted,
-    { hit_count_increment: 1 },
-  );
-}
-
-/**
- * 7일 이상 미관측된 adaptive rules의 confidence를 -0.1 감소, 임계값 이하면 삭제
- * @param {object} store — store-adapter 인스턴스 (listAdaptiveRules, updateRuleConfidence, deleteAdaptiveRule 필요)
- * @param {number} _sessionCount — 하위 호환용 (현재 미사용)
- * @param {string} [projectSlug] — 특정 프로젝트만 대상. 미지정 시 전체 스캔
- * @returns {{ updated: Array, deleted: string[] }}
- */
-export function decayRules(store, _sessionCount, projectSlug) {
-  if (!store.listAdaptiveRules) return { updated: [], deleted: [] };
-  const result = { updated: [], deleted: [] };
-  const rules = listAdaptiveRulesFromStore(store, projectSlug);
-  for (const rule of rules) {
-    // 7일 이상 미관측된 규칙만 decay 대상
-    const ageDays =
-      (Date.now() - (rule.last_seen_ms || 0)) / (24 * 3600 * 1000);
-    if (ageDays < 7) continue;
-    const decayed = clampConfidence(rule.confidence - ADAPTIVE_DECAY_STEP);
-    if (decayed <= ADAPTIVE_DELETE_THRESHOLD) {
-      if (store.deleteAdaptiveRule(rule.project_slug, rule.pattern)) {
-        result.deleted.push(`${rule.project_slug}:${rule.pattern}`);
-      }
-      continue;
-    }
-    if (decayed < rule.confidence) {
-      const updated = store.updateRuleConfidence(
-        rule.project_slug,
-        rule.pattern,
-        decayed,
-        { hit_count_increment: 0 },
-      );
-      if (updated) result.updated.push(updated);
-    }
-  }
-  return result;
-}
-
-/**
- * 신뢰도 자동 조정 (success_count / hit_count, 샘플 크기 기반 감쇠)
- * hit_count가 작으면 0.5(기본값)쪽으로 보수적으로 수렴
- * @param {object} entry - { hit_count, success_count }
- * @returns {number} 0~1 사이 신뢰도
- */
-export function recalcConfidence(entry) {
-  if (!entry?.hit_count || entry.hit_count <= 0) return DEFAULT_CONFIDENCE;
-  const ratio = entry.success_count / entry.hit_count;
-  const decay = Math.min(1, entry.hit_count / 10);
-  return ratio * decay + DEFAULT_CONFIDENCE * (1 - decay);
-}

package/hub/role-contract.mjs

@@ -1,312 +0,0 @@
-const PROJECT_ID_RE = /^prj_[A-Za-z0-9_-]{22}$/u;
-const SCOPE_ID_RE = /^scp_[A-Za-z0-9_-]{22}$/u;
-const BASE64URL_RE = /^[A-Za-z0-9_-]+$/u;
-
-export const ROLE_KINDS = Object.freeze(["cto", "lead"]);
-export const ROLE_REACHABILITY_STATES = Object.freeze([
-  "electable",
-  "elected-probing",
-  "active",
-  "unreachable",
-  "quarantined",
-]);
-export const ROLE_STATUS_SCHEMA_VERSION = "tfx.roles.v2";
-export const LEGACY_ROLE_SNAPSHOT_FIELDS = Object.freeze([
-  "role",
-  "status",
-  "leader_agent_id",
-  "previous_leader_agent_id",
-  "leader_epoch",
-  "lease_expires_ms",
-  "candidate_source",
-  "candidate_count",
-  "live_candidate_count",
-  "pending_count",
-  "transferred_count",
-  "last_transition_ms",
-  "last_reason",
-  "candidates",
-]);
-
-function roleContractError(code, message = code) {
-  const error = new Error(message);
-  error.code = code;
-  return error;
-}
-
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function canonicalJsonRoleKey(key) {
-  return key.role_kind === "lead"
-    ? `{"project_id":${JSON.stringify(key.project_id)},"role_kind":"lead","scope_id":${JSON.stringify(key.scope_id)}}`
-    : `{"project_id":${JSON.stringify(key.project_id)},"role_kind":"cto"}`;
-}
-
-/**
- * Validate and normalize the only two valid dynamic role identities.
- *
- * @param {unknown} input
- * @returns {{project_id: string, role_kind: "cto"} | {project_id: string, role_kind: "lead", scope_id: string}}
- */
-export function normalizeRoleKey(input) {
-  if (!isRecord(input)) throw roleContractError("ROLE_KEY_INVALID");
-
-  const fields = Object.keys(input);
-  const allowed = new Set(["project_id", "role_kind", "scope_id"]);
-  if (fields.some((field) => !allowed.has(field))) {
-    throw roleContractError("ROLE_KEY_FIELD_UNSUPPORTED");
-  }
-
-  const { project_id: projectId, role_kind: roleKind } = input;
-  if (typeof projectId !== "string" || !PROJECT_ID_RE.test(projectId)) {
-    throw roleContractError("PROJECT_ID_INVALID");
-  }
-  if (!ROLE_KINDS.includes(roleKind)) {
-    throw roleContractError("ROLE_KIND_UNSUPPORTED");
-  }
-
-  const hasScope = Object.hasOwn(input, "scope_id");
-  if (roleKind === "cto") {
-    if (hasScope) throw roleContractError("ROLE_SCOPE_FORBIDDEN");
-    return { project_id: projectId, role_kind: "cto" };
-  }
-
-  if (!hasScope || typeof input.scope_id !== "string") {
-    throw roleContractError("SCOPE_REQUIRED");
-  }
-  if (!SCOPE_ID_RE.test(input.scope_id)) {
-    throw roleContractError("SCOPE_ID_INVALID");
-  }
-  return { project_id: projectId, role_kind: "lead", scope_id: input.scope_id };
-}
-
-/** @param {unknown} key */
-export function encodeRoleKey(key) {
-  const normalized = normalizeRoleKey(key);
-  const wire = `rk2.${Buffer.from(canonicalJsonRoleKey(normalized), "utf8").toString("base64url")}`;
-  if (Buffer.byteLength(wire, "utf8") > 512) {
-    throw roleContractError("ROLE_KEY_WIRE_TOO_LONG");
-  }
-  return wire;
-}
-
-/** @param {unknown} wire */
-export function decodeRoleKey(wire) {
-  if (typeof wire !== "string" || Buffer.byteLength(wire, "utf8") > 512) {
-    throw roleContractError("ROLE_KEY_WIRE_INVALID");
-  }
-  if (!wire.startsWith("rk2.")) throw roleContractError("ROLE_KEY_WIRE_PREFIX");
-
-  const encoded = wire.slice(4);
-  if (!encoded || !BASE64URL_RE.test(encoded)) {
-    throw roleContractError("ROLE_KEY_NON_CANONICAL");
-  }
-
-  let parsed;
-  try {
-    const canonicalSource = Buffer.from(encoded, "base64url").toString("utf8");
-    parsed = JSON.parse(canonicalSource);
-  } catch {
-    throw roleContractError("ROLE_KEY_NON_CANONICAL");
-  }
-
-  let normalized;
-  try {
-    normalized = normalizeRoleKey(parsed);
-  } catch (error) {
-    if (error?.code) throw error;
-    throw roleContractError("ROLE_KEY_NON_CANONICAL");
-  }
-  if (encodeRoleKey(normalized) !== wire) {
-    throw roleContractError("ROLE_KEY_NON_CANONICAL");
-  }
-  return normalized;
-}
-
-/** @param {unknown} key */
-export function roleTopicAddress(key) {
-  return `topic:role:${encodeRoleKey(key)}`;
-}
-
-const TRANSITION_ROWS = [
-  ["electable", "candidate_selected", "elected-probing", "reserve_holder"],
-  ["electable", "standup_reserved", "elected-probing", "reserve_standup"],
-  ["electable", "no_candidate", "electable", "record_blocked_no_candidate"],
-  [
-    "electable",
-    "candidates_excluded",
-    "quarantined",
-    "schedule_exclusion_expiry",
-  ],
-  ["elected-probing", "probe_succeeded", "elected-probing", "send_activation"],
-  ["elected-probing", "activation_acked", "active", "record_activation_ack"],
-  [
-    "elected-probing",
-    "probe_failed",
-    "unreachable",
-    "exclude_failed_candidate",
-  ],
-  ["elected-probing", "wake_failed", "unreachable", "exclude_failed_candidate"],
-  ["elected-probing", "ack_timeout", "unreachable", "exclude_failed_candidate"],
-  [
-    "elected-probing",
-    "holder_lease_expired",
-    "electable",
-    "revoke_holder_epoch_fence",
-  ],
-  [
-    "active",
-    "holder_lease_expired",
-    "electable",
-    "revoke_holder_preserve_backlog",
-  ],
-  ["active", "holder_offline", "electable", "revoke_holder_preserve_backlog"],
-  ["active", "transport_failed", "unreachable", "fence_active_authority"],
-  ["active", "charter_reissued", "elected-probing", "reserve_reack"],
-  [
-    "unreachable",
-    "alternate_candidate_available",
-    "electable",
-    "failover_candidate",
-  ],
-  ["unreachable", "retry_due", "elected-probing", "reserve_retry_epoch"],
-  ["unreachable", "retries_exhausted", "quarantined", "schedule_quarantine"],
-  [
-    "quarantined",
-    "exclusion_expired",
-    "electable",
-    "restore_candidate_eligibility",
-  ],
-  ["quarantined", "candidate_registered", "electable", "clear_quarantine"],
-  ["quarantined", "locator_registered", "electable", "clear_quarantine"],
-  ["quarantined", "capability_registered", "electable", "clear_quarantine"],
-  ...ROLE_REACHABILITY_STATES.flatMap((state) => [
-    [state, "stale_ack", state, "reject_stale_ack"],
-    [state, "scope_closed", null, "remove_registry"],
-  ]),
-];
-
-export const ROLE_REACHABILITY_TRANSITIONS = Object.freeze(
-  TRANSITION_ROWS.map(([from, trigger, to, action]) =>
-    Object.freeze({ from, trigger, to, action }),
-  ),
-);
-
-const TRANSITIONS_BY_KEY = new Map(
-  ROLE_REACHABILITY_TRANSITIONS.map((transition) => [
-    `${transition.from}:${transition.trigger}`,
-    transition,
-  ]),
-);
-
-/**
- * Apply one already-guarded reachability event. Guard evaluation and all side
- * effects deliberately remain outside this inert contract kernel.
- */
-export function reduceRoleReachabilityTransition(state, trigger) {
-  if (!ROLE_REACHABILITY_STATES.includes(state)) {
-    throw roleContractError("ROLE_REACHABILITY_STATE_INVALID");
-  }
-  const transition = TRANSITIONS_BY_KEY.get(`${state}:${trigger}`);
-  if (!transition) throw roleContractError("INVALID_ROLE_TRANSITION");
-  return trigger === "stale_ack"
-    ? { state: transition.to, action: transition.action, code: "STALE_EPOCH" }
-    : { state: transition.to, action: transition.action };
-}
-
-function snapshotLegacyDetails(snapshot) {
-  const legacy = isRecord(snapshot.legacy) ? snapshot.legacy : {};
-  return {
-    candidate_source:
-      legacy.candidate_source ?? snapshot.candidate_source ?? null,
-    transferred_count:
-      legacy.transferred_count ?? snapshot.transferred_count ?? 0,
-    candidates: legacy.candidates ?? snapshot.candidates ?? [],
-  };
-}
-
-/**
- * Construct the v2 status envelope in deterministic role-key order.
- * `generatedAtMs` is supplied by the caller so the kernel has no clock.
- */
-export function createRoleStatusEnvelopeV2({
-  items = [],
-  generatedAtMs,
-  projectId,
-} = {}) {
-  if (!Number.isFinite(generatedAtMs)) {
-    throw roleContractError("ROLE_STATUS_GENERATED_AT_REQUIRED");
-  }
-  if (
-    projectId !== undefined &&
-    (typeof projectId !== "string" || !PROJECT_ID_RE.test(projectId))
-  ) {
-    throw roleContractError("PROJECT_ID_INVALID");
-  }
-  if (!Array.isArray(items))
-    throw roleContractError("ROLE_STATUS_ITEMS_INVALID");
-
-  return {
-    schema_version: ROLE_STATUS_SCHEMA_VERSION,
-    generated_at_ms: generatedAtMs,
-    ...(projectId === undefined ? {} : { project_id: projectId }),
-    items: [...items].sort((left, right) =>
-      String(left?.role_key_wire || "").localeCompare(
-        String(right?.role_key_wire || ""),
-      ),
-    ),
-  };
-}
-
-/**
- * Project the single exact-project CTO into the legacy `roles.cto` shape.
- * The optional `legacy` detail preserves fields that v2 callers do not use.
- */
-export function projectLegacyCtoStatus(envelope, projectId) {
-  if (
-    !isRecord(envelope) ||
-    envelope.schema_version !== ROLE_STATUS_SCHEMA_VERSION ||
-    !Array.isArray(envelope.items)
-  ) {
-    throw roleContractError("ROLE_STATUS_ENVELOPE_INVALID");
-  }
-  if (typeof projectId !== "string" || !PROJECT_ID_RE.test(projectId)) {
-    throw roleContractError("SCOPE_REQUIRED");
-  }
-
-  const snapshot = envelope.items.find((item) => {
-    const key = item?.role_key;
-    return key?.project_id === projectId && key?.role_kind === "cto";
-  });
-  if (!snapshot) return { cto: null };
-
-  const status =
-    snapshot.state === "active"
-      ? "active"
-      : snapshot.state === "electable" || snapshot.state === "elected-probing"
-        ? "electable"
-        : "offline";
-  const legacy = snapshotLegacyDetails(snapshot);
-  return {
-    cto: {
-      role: "cto",
-      status,
-      leader_agent_id:
-        status === "active" ? (snapshot.holder_agent_id ?? null) : null,
-      previous_leader_agent_id: snapshot.previous_holder_agent_id ?? null,
-      leader_epoch: snapshot.epoch,
-      lease_expires_ms:
-        status === "active" ? (snapshot.lease_expires_ms ?? null) : null,
-      candidate_source: legacy.candidate_source,
-      candidate_count: snapshot.candidate_count,
-      live_candidate_count: snapshot.live_candidate_count,
-      pending_count: snapshot.pending_count,
-      transferred_count: legacy.transferred_count,
-      last_transition_ms: snapshot.last_transition_ms,
-      last_reason: snapshot.last_reason,
-      candidates: legacy.candidates,
-    },
-  };
-}