elanous 0.2.32 → 0.2.35

package/src/intake-plane/already-built-hint.ts

@@ -0,0 +1,91 @@
+// ── ALREADY-BUILT-HINT — «이미 있는 기능» 알림 원시함수 (UX · 0.2.34 칸) ──────────
+//
+// RFC-harness-full-journey-as-graph §4f 판정 — 다른 폴더의 «이미 있는 기능»을 새 요구로
+// 넣으면 근거 링크(커밋·파일) 붙은 알림을 낸다 · 관련 없으면 0건 · 거절한 짝은 다시 묻지
+// 않는다. 순수 함수·부수효과 0. 관련도 점수는 세션 검색의 trigram FTS5 원시함수
+// (src/session/search-index.ts rankByTrigramFts — BM25, 낮을수록 관련도 높음)를 그대로
+// 재사용한다. 호출 지점은 인테이크 요구 퍼널이다 — readRequirementFunnel(요구 퍼널 입구)이
+// features/refusedFeatures 를 runRequirementFunnel 로 넘기고, recordAlreadyBuiltHints 가
+// alreadyBuiltHints 를 불러 결과를 requirements.intake/hint 로 관측한다. 그 행 자체를
+// 생산하는 쪽(DEV-FEATURE-MAP)은 별도 칸 몫이다.
+
+import { rankByTrigramFts, type RankedDoc, type RankResult } from '../session/search-index.js';
+import { hashContent } from '../hasher.js';
+
+/** DEV-FEATURE-MAP 한 행 — «이미 있는 기능» 후보. evidence 가 비면 그 행은 버린다(근거 없으면 침묵). */
+export interface AlreadyBuiltFeature {
+  readonly devProject: string;
+  readonly feature: string;
+  readonly text: string;
+  readonly evidence: { readonly commit?: string; readonly file?: string };
+}
+
+/** 거절한 짝 — «요구 해시 ⊕ feature». 요구 해시는 hashContent(request)(sha256 hex). */
+export interface AlreadyBuiltRefusedPair {
+  readonly requestHash: string;
+  readonly feature: string;
+}
+
+export type AlreadyBuiltHintKind = 'already' | 'similar';
+
+/** A compact notification: one best match and at most two related matches. */
+const MAX_ALREADY_BUILT_HINTS = 3;
+
+/** 힌트 1건 — 근거 링크(커밋·파일) + BM25 점수(낮을수록 관련도 높음). */
+export interface AlreadyBuiltHint {
+  readonly kind: AlreadyBuiltHintKind;
+  readonly devProject: string;
+  readonly feature: string;
+  readonly evidence: { readonly commit?: string; readonly file?: string };
+  readonly score: number;
+}
+
+/** 근거 유무 — commit·file 중 하나라도 실값(빈 문자열 제외)이면 근거 있음. */
+function hasEvidence(evidence: AlreadyBuiltFeature['evidence']): boolean {
+  return (evidence.commit != null && evidence.commit !== '') || (evidence.file != null && evidence.file !== '');
+}
+
+/**
+ * 새 요구가 «이미 있는 기능»을 가리키는지 판정하는 순수 함수.
+ *
+ * - 후보의 배열 인덱스를 sessionId 로 사용해 rankByTrigramFts(request, docs) 로
+ *   BM25 관련도 점수를 매긴다(재사용 · 낮을수록 높음).
+ * - evidence 가 비면 그 행은 버리고(근거 없으면 침묵) refused 짝(요구 해시 ⊕ feature)에
+ *   있는 행은 뺀다.
+ * - 매칭 행 중 관련도순 상위 3건만 내고, 첫 행(최고 관련도)은 kind='already',
+ *   그 뒤는 kind='similar'.
+ * - 관련 없는 요구·3자 미만 요구·FTS 오류·남는 후보 없음 → [] (출력 없음 = 침묵).
+ */
+export function alreadyBuiltHints(
+  request: string,
+  features: readonly AlreadyBuiltFeature[],
+  refused: readonly AlreadyBuiltRefusedPair[],
+): AlreadyBuiltHint[] {
+  const requestHash = hashContent(request);
+  const candidates = features.filter((f) =>
+    hasEvidence(f.evidence)
+    && !refused.some((p) => p.requestHash === requestHash && p.feature === f.feature),
+  );
+  if (candidates.length === 0) return [];
+
+  const docs: RankedDoc[] = candidates.map((f, index) => ({
+    sessionId: String(index),
+    content: f.text,
+  }));
+  const ranked: RankResult[] | null = rankByTrigramFts(request, docs);
+  if (!ranked || ranked.length === 0) return []; // 관련 없는 요구 · <3자 · FTS 오류 → 침묵
+
+  const hints: AlreadyBuiltHint[] = [];
+  for (const r of ranked.slice(0, MAX_ALREADY_BUILT_HINTS)) {
+    const f = candidates[Number(r.sessionId)];
+    if (!f) continue;
+    hints.push({
+      kind: hints.length === 0 ? 'already' : 'similar',
+      devProject: f.devProject,
+      feature: f.feature,
+      evidence: { ...f.evidence },
+      score: r.score,
+    });
+  }
+  return hints;
+}

package/src/intake-plane/requirement-funnel.ts

@@ -12,6 +12,7 @@ import { getUserConfig } from '../user-config.js';
 import { dateKey } from '../time/format.js';
 import { cardIndexPath, CardStore, type TaskCard } from '../task-cards/card-store.js';
 import { loadIntakeLedger, type IntakeItem } from './items.js';
+import { alreadyBuiltHints, type AlreadyBuiltFeature, type AlreadyBuiltRefusedPair } from './already-built-hint.js';
 import { RequirementLedger } from '../requirements/requirement-ledger.js';
 import { parseRubric, rubricGrade, rubricScore } from '../release-loop/rubric.js';
 
@@ -70,6 +71,10 @@ export interface FunnelOptions {
   adopt?: (candidate: RequirementCandidate, version: string, cellId: string, evidence: string) => void;
   /** REQ-INTAKE-ALL (0.2.25) piece 1: REQ-LEDGER side-record — every candidate captured once (idempotent on candidate id); adopted decisions fold to `placed`. */
   ledger?: RequirementLedger;
+  /** ALREADY-BUILT-HINT (0.2.34 · RFC-harness-full-journey-as-graph §4f): the DEV-FEATURE-MAP rows to compare arrivals against. Absent → no comparison, no `intake.hint` events. Intentional boundary (next piece): the live state-based caller (`src/briefing/brief-items.ts` — `readRequirementFunnel({ stateDir, now })`) does not yet supply these rows, so hints stay silent in live runs until the DEV-FEATURE-MAP cell supplies them. */
+  features?: readonly AlreadyBuiltFeature[];
+  /** Rejected pairs (request hash ⊕ feature) — a refused pair is never asked again. */
+  refusedFeatures?: readonly AlreadyBuiltRefusedPair[];
 }
 
 /** How many of the last 24 hours' unlinked directives the single P0 brief line names (the full backlog is one count). */
@@ -118,6 +123,26 @@ function gate(candidate: RequirementCandidate, options: FunnelOptions, used: num
   return null;
 }
 
+/**
+ * ALREADY-BUILT-HINT (0.2.34 · RFC-harness-full-journey-as-graph §4f) — compare one arrival group's statement
+ * against the DEV-FEATURE-MAP evidence rows through the pure `alreadyBuiltHints` function. Each returned hint
+ * becomes one `intake.hint` observation carrying the match's evidence link (commit · file); no match, an
+ * evidence-less row or a refused pair yields nothing (silence). Side-record only — a hint failure must never
+ * change the funnel result (same try/catch shape as the ledger capture below). E4 absence note:
+ * seat-state/MK/green-e4/ALREADY-BUILT-HINT.md.
+ */
+function recordAlreadyBuiltHints(candidate: RequirementCandidate, options: FunnelOptions): void {
+  if (!options.features?.length) return;
+  try {
+    for (const hint of alreadyBuiltHints(candidate.text, options.features, options.refusedFeatures ?? [])) {
+      debug.log('requirements.intake', 'hint', { id: candidate.id, link: candidate.link, kind: hint.kind,
+        devProject: hint.devProject, feature: hint.feature, evidence: { ...hint.evidence }, score: hint.score });
+    }
+  } catch (error) {
+    debug.log('requirements.intake', 'hint-failed', { id: candidate.id, error: error instanceof Error ? error.message : String(error) });
+  }
+}
+
 /** RUBRIC-PLACE: use the release placement engine's priority, deadline, capacity and predecessor checks, not an invented score. */
 export function runRequirementFunnel(options: FunnelOptions): RequirementFunnelResult {
   const { sources, cells, now } = options;
@@ -139,6 +164,7 @@ export function runRequirementFunnel(options: FunnelOptions): RequirementFunnelR
   for (const members of groups.values()) {
     members.sort((a, b) => a.receivedAt.localeCompare(b.receivedAt));
     const candidate = members.find(member => member.source === 'directive') ?? members[0]!;
+    recordAlreadyBuiltHints(candidate, options);
     const linked = members.map(member => linkFor(member, cells)).find(Boolean);
     const evidence = members.map(member => `${member.link} (${member.receivedAt})`).join(' · ');
     if (linked) {
@@ -256,7 +282,8 @@ export function captureFunnelCandidates(candidates: readonly RequirementDecision
 /** Existing ledgers only; no source collector or sender is started here. Side effect: captures every candidate into this universe's REQ-LEDGER (REQ-INTAKE-ALL). */
 export function readRequirementFunnel(options: { stateDir?: string; now?: Date; mode?: 'shadow' | 'live'; dailyCap?: number;
   allowedLicenses?: readonly string[]; grounding?: readonly IncomingRequirement[]; coordination?: readonly IncomingRequirement[];
-  linear?: readonly IncomingRequirement[]; placement?: PlacementDeps } = {}): RequirementFunnelResult {
+  linear?: readonly IncomingRequirement[]; placement?: PlacementDeps; features?: readonly AlreadyBuiltFeature[];
+  refusedFeatures?: readonly AlreadyBuiltRefusedPair[] } = {}): RequirementFunnelResult {
   const stateDir = options.stateDir ?? elanousStateRoot();
   const now = options.now ?? new Date();
   const config = (getUserConfig().raw.intake as { requirementFunnel?: { mode?: 'shadow' | 'live'; dailyCap?: number; allowedLicenses?: string[] } } | undefined)?.requirementFunnel;
@@ -328,6 +355,7 @@ export function readRequirementFunnel(options: { stateDir?: string; now?: Date;
     coordination: today(options.coordination ?? cardRequests.coordination), linear: today(options.linear ?? cardRequests.linear) }, historicalDirectives, cells, now, mode,
     dailyCap, adoptedToday: todayCount, allowedLicenses, placement: { ...options.placement, schedules },
     ledger: new RequirementLedger({ stateDir }),
+    features: options.features, refusedFeatures: options.refusedFeatures,
     adopt: (candidate, version, cellId, evidence) => {
       placeCell({ id: cellId, title: candidate.text, owner: candidate.owner ?? 'OP', priority: candidate.priority ?? 'P1',
         predecessors: [], ...(candidate.deadlineVersion ? { deadlineVersion: candidate.deadlineVersion } : {}) }, { ...options.placement, now, schedules });

package/src/knowhow/pack.ts

@@ -0,0 +1,199 @@
+/** Shared, deterministic retrieval contract for TUI and task-agent knowhow. */
+
+export const KNOWHOW_PACK_DEFAULT_K = 8;
+export const KNOWHOW_PACK_DEFAULT_CHAR_BUDGET = 32_000;
+
+export type KnowhowSourceKind = 'KNOWHOW.md' | 'PLAYBOOK' | 'know-candidates' | 'autopsy';
+export type KnowhowKind = 'fact' | 'warning' | 'heuristic' | 'playbook' | 'case';
+
+export const KNOWHOW_HALF_LIFE_DAYS: Readonly<Record<KnowhowKind, number>> = {
+  fact: 14,
+  warning: 30,
+  heuristic: 90,
+  playbook: 60,
+  case: Number.POSITIVE_INFINITY,
+};
+
+export interface KnowhowTarget {
+  surface: string;
+  scope: string;
+  tool?: string;
+  commandClass?: string;
+}
+
+/** Values are normalized by the consumer; the shared core compares them exactly. */
+export interface KnowhowFailureSignature {
+  kind: string;
+  stableCode: string;
+  normalizedArgsHash: string;
+}
+
+export interface KnowhowFragment {
+  id: string;
+  target: KnowhowTarget;
+  signature: KnowhowFailureSignature;
+  text: string;
+  kind: KnowhowKind;
+  source: { kind: KnowhowSourceKind; path: string; ref: string };
+  status: 'verified' | 'candidate' | 'challenged' | 'rejected';
+  confidence: number;
+  verifiedAt: string;
+  expiresAt: string;
+}
+
+export interface KnowhowPackRequest {
+  target: KnowhowTarget;
+  signature: KnowhowFailureSignature;
+  now?: number;
+  maxItems?: number;
+  maxChars?: number;
+}
+
+export interface KnowhowPack {
+  snippets: Array<Pick<KnowhowFragment, 'id' | 'text' | 'source' | 'status' | 'confidence' | 'verifiedAt'>>;
+  omittedCount: number;
+  diagnostics: string[];
+}
+
+function sameTarget(a: KnowhowTarget, b: KnowhowTarget): boolean {
+  return a.surface === b.surface
+    && a.scope === b.scope
+    && a.tool === b.tool
+    && a.commandClass === b.commandClass;
+}
+
+function sameSignature(a: KnowhowFailureSignature, b: KnowhowFailureSignature): boolean {
+  return a.kind === b.kind
+    && a.stableCode === b.stableCode
+    && a.normalizedArgsHash === b.normalizedArgsHash;
+}
+
+function timestamp(value: string): number | null {
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function compareText(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function validTarget(value: unknown): value is KnowhowTarget {
+  if (!isRecord(value)) return false;
+  return typeof value.surface === 'string' && value.surface.trim().length > 0
+    && typeof value.scope === 'string' && value.scope.trim().length > 0
+    && (value.tool === undefined || typeof value.tool === 'string')
+    && (value.commandClass === undefined || typeof value.commandClass === 'string');
+}
+
+function validSignature(value: unknown): value is KnowhowFailureSignature {
+  return isRecord(value)
+    && typeof value.kind === 'string' && value.kind.trim().length > 0
+    && typeof value.stableCode === 'string' && value.stableCode.trim().length > 0
+    && typeof value.normalizedArgsHash === 'string' && value.normalizedArgsHash.trim().length > 0;
+}
+
+function validFragment(fragment: KnowhowFragment, request: KnowhowPackRequest, now: number): boolean {
+  const verifiedAt = timestamp(fragment.verifiedAt);
+  const expiresAt = timestamp(fragment.expiresAt);
+  return fragment.status === 'verified'
+    && Object.hasOwn(KNOWHOW_HALF_LIFE_DAYS, fragment.kind)
+    && Number.isFinite(fragment.confidence)
+    && fragment.confidence >= 0 && fragment.confidence <= 1
+    && ['KNOWHOW.md', 'PLAYBOOK', 'know-candidates', 'autopsy'].includes(fragment.source.kind)
+    && fragment.id.trim().length > 0
+    && fragment.text.trim().length > 0
+    && fragment.source.path.trim().length > 0
+    && fragment.source.ref.trim().length > 0
+    && verifiedAt !== null && verifiedAt <= now
+    && expiresAt !== null && expiresAt > now
+    && expiresAt >= verifiedAt
+    && (now - verifiedAt <= KNOWHOW_HALF_LIFE_DAYS[fragment.kind]
+      * 24 * 60 * 60 * 1000)
+    && sameTarget(fragment.target, request.target)
+    && sameSignature(fragment.signature, request.signature);
+}
+
+/**
+ * Select only verified, unexpired fragments for an exact target and failure
+ * signature. Whole snippets are admitted or omitted; this function never
+ * truncates evidence-bearing text. Invalid limits and malformed input fail
+ * open as an empty pack, leaving the caller's existing path usable.
+ */
+export function buildKnowhowPack(
+  fragments: readonly KnowhowFragment[],
+  request: KnowhowPackRequest,
+): KnowhowPack {
+  try {
+    const inputCount = Array.isArray(fragments) ? fragments.length : 0;
+    if (!isRecord(request) || !validTarget(request.target) || !validSignature(request.signature)) {
+      return { snippets: [], omittedCount: inputCount, diagnostics: ['invalid-request'] };
+    }
+    if (!Array.isArray(fragments)) {
+      return { snippets: [], omittedCount: 0, diagnostics: ['invalid-fragments'] };
+    }
+    const maxItems = request.maxItems ?? KNOWHOW_PACK_DEFAULT_K;
+    const maxChars = request.maxChars ?? KNOWHOW_PACK_DEFAULT_CHAR_BUDGET;
+    const now = request.now ?? Date.now();
+    if (!Number.isFinite(now) || !Number.isInteger(maxItems) || maxItems < 0
+      || !Number.isInteger(maxChars) || maxChars < 0) {
+      return { snippets: [], omittedCount: inputCount, diagnostics: ['invalid-request'] };
+    }
+
+    const sorted = [...fragments].filter((fragment) => validFragment(fragment, request, now)).sort((a, b) => {
+      // Most recently verified wins; the id is the stable tie breaker.
+      return timestamp(b.verifiedAt)! - timestamp(a.verifiedAt)!
+        || compareText(a.id, b.id)
+        || compareText(a.verifiedAt, b.verifiedAt)
+        || b.confidence - a.confidence
+        || compareText(a.expiresAt, b.expiresAt)
+        || compareText(a.source.kind, b.source.kind)
+        || compareText(a.source.path, b.source.path)
+        || compareText(a.source.ref, b.source.ref)
+        || compareText(a.text, b.text);
+    });
+    const seen = new Set<string>();
+    const eligible = sorted.filter((fragment) => {
+      if (seen.has(fragment.id)) return false;
+      seen.add(fragment.id);
+      return true;
+    });
+
+    const snippets: KnowhowPack['snippets'] = [];
+    let chars = 0;
+    for (const fragment of eligible) {
+      if (snippets.length >= maxItems) break;
+      const snippet: KnowhowPack['snippets'][number] = {
+        id: fragment.id,
+        text: fragment.text,
+        source: {
+          kind: fragment.source.kind,
+          path: fragment.source.path,
+          ref: fragment.source.ref,
+        },
+        status: fragment.status,
+        confidence: fragment.confidence,
+        verifiedAt: fragment.verifiedAt,
+      };
+      // Budget the complete serialized snippet, including provenance metadata.
+      const snippetChars = JSON.stringify(snippet).length;
+      if (chars + snippetChars > maxChars) continue;
+      snippets.push(snippet);
+      chars += snippetChars;
+    }
+    return {
+      snippets,
+      omittedCount: fragments.length - snippets.length,
+      diagnostics: [],
+    };
+  } catch {
+    return {
+      snippets: [],
+      omittedCount: Array.isArray(fragments) ? fragments.length : 0,
+      diagnostics: ['fragment-validation-failed'],
+    };
+  }
+}

package/src/light-cli.ts

@@ -0,0 +1,111 @@
+import { Command } from 'commander';
+import type { LightCliRoute } from './cli/light-entry-route.js';
+
+/** Dispatch a small operational command without loading the full command registry. */
+export async function runLightCli(route: LightCliRoute): Promise<void> {
+  // Root instance flags stay on the full entry for the four hot commands.
+  // Other light routes can still accept them; invoke the same shared bootstrap
+  // helpers as src/index.ts, and only load those helpers when a flag is present.
+  const args = process.argv.slice(2);
+  // The legacy entry resolves the config root for operational commands and
+  // warns when the removed ELANOUS_CONFIG_DIR env var disagrees with it.
+  // Preserve that observable warning on hot routes without loading the
+  // resolver for the common case where the ignored env var is absent.
+  if (['msg', 'pty', 'logs', 'tasks'].includes(route) && process.env.ELANOUS_CONFIG_DIR !== undefined) {
+    const { getElanousConfigDir } = await import('./elanous-config-dir.js');
+    getElanousConfigDir();
+  }
+  const hasRootInstanceFlag = args.some(arg => ['--test', '--config-dir', '--test-state-dir', '--state-dir']
+    .some(flag => arg === flag || arg.startsWith(`${flag}=`)));
+  if (hasRootInstanceFlag) {
+    const [{ applyTestStateDirFlagFromArgv }, { applyTestFlagFromArgv }, { applyConfigDirFlagFromArgv }] = await Promise.all([
+      import('./cli/test-state-dir-flag.js'),
+      import('./cli/test-flag.js'),
+      import('./cli/config-dir-flag.js'),
+    ]);
+    applyTestStateDirFlagFromArgv();
+    applyTestFlagFromArgv();
+    applyConfigDirFlagFromArgv();
+  }
+
+  const program = new Command().name('elanous').enablePositionalOptions();
+  switch (route) {
+    case 'msg': {
+      const { registerMsgCommands } = await import('./cli/msg-cli.js');
+      registerMsgCommands(program);
+      break;
+    }
+    case 'release': {
+      const { registerReleaseChecklistReadCommands } = await import('./cli/release-checklist-read-cli.js');
+      registerReleaseChecklistReadCommands(program);
+      break;
+    }
+    case 'tasks': {
+      const { registerTasksCommands } = await import('./cli/tasks-cli.js');
+      registerTasksCommands(program);
+      break;
+    }
+    case 'pty': {
+      const { registerPtyTakeoverCommands } = await import('./cli/pty-takeover-cli.js');
+      registerPtyTakeoverCommands(program);
+      break;
+    }
+    case 'logs': {
+      const { registerLogsCommands } = await import('./cli/logs-cli.js');
+      registerLogsCommands(program);
+      break;
+    }
+    case 'config': {
+      const { getUserConfig } = await import('./user-config.js');
+      const { redactSecrets, redactSecretText } = await import('./debug/log.js');
+      const { resolveCurrentInstance } = await import('./instance/current.js');
+      const redactDisplay = (value: unknown): unknown => {
+        if (Array.isArray(value)) return value.map(redactDisplay);
+        if (value !== null && typeof value === 'object') {
+          return Object.fromEntries(Object.entries(value as Record<string, unknown>).map(([key, child]) => [
+            redactSecretText(key), redactDisplay(child),
+          ]));
+        }
+        return typeof value === 'string' ? redactSecretText(value) : value;
+      };
+      const config = program.command('config').description('Inspect and edit ~/.config/elanous/config.json');
+      config.command('get [path]')
+        .description('Print all config or one dotted path, e.g. llm.provider (secrets redacted by default)')
+        .option('--reveal', 'Print unredacted output and record the reveal')
+        .action(async (path: string | undefined) => {
+          if (resolveCurrentInstance().kind === 'test' && String(resolveCurrentInstance().layer) === 'tree-derived') {
+            console.error('⚠️ test 우주의 config를 읽습니다 — 운영 값은 --config-dir ~/.elanous');
+          }
+          const config = getUserConfig() as unknown as Record<string, unknown>;
+          const lookup = (root: unknown): unknown => {
+            let value = root;
+            for (const part of path?.split('.').filter(Boolean) ?? []) {
+              if (value === null || typeof value !== 'object') return undefined;
+              value = (value as Record<string, unknown>)[part];
+            }
+            return value;
+          };
+          const selected = path ? (lookup(config) ?? lookup(config.raw)) : config;
+          if (selected === undefined) {
+            const { error } = await import('./ui.js');
+            error(`config path not found: ${path}`);
+            process.exitCode = 1;
+            return;
+          }
+          const displayKey = path?.split('.').filter(Boolean).at(-1);
+          const display = displayKey
+            ? redactDisplay(redactSecrets({ [displayKey]: selected })[displayKey])
+            : redactDisplay(redactSecrets(selected));
+          console.log(typeof display === 'string' ? display : JSON.stringify(display, null, 2));
+        });
+      break;
+    }
+  }
+
+  try {
+    await program.parseAsync(['node', 'elanous', ...process.argv.slice(2)]);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}

package/src/llm/opengateway-models.ts

@@ -0,0 +1,11 @@
+/** First-slice OpenGateway models observed through a successful streamed chat turn. */
+export const OPENGATEWAY_VERIFIED_MODELS = [
+  'opengateway/deepseek/deepseek-v4.1-flash-ultrafast',
+  'opengateway/z-ai/glm-5.3-flash-ultrafast',
+] as const;
+
+export const OPENGATEWAY_DEFAULT_MODEL = OPENGATEWAY_VERIFIED_MODELS[0];
+
+export function isVerifiedOpenGatewayModel(model: string): boolean {
+  return (OPENGATEWAY_VERIFIED_MODELS as readonly string[]).includes(model);
+}

package/src/llm/provider-credentials.ts

@@ -38,6 +38,7 @@ const ENV_KEY_OVERLAY: Readonly<Record<string, string>> = {
   // 결정 2026-09-23 — openrouter 모델은 BUILTIN_CATALOG 가 아니라 발견 폴드(`catalog/providers/openrouter.yaml`
   //   apiKeyEnv)에서 온다 ⇒ 파생 맵이 비어 하니스 자식에게 키가 릴레이되지 않았다(env 로만 키를 둔 사용자는 자식이 죽는다).
   openrouter: 'OPENROUTER_API_KEY',
+  opengateway: 'OPENGATEWAY_API_KEY',
 };
 
 /** 키가 필요 없는 provider — 자격증명 부재가 **정상**이다(누락 경고를 내면 안 됨).
@@ -188,6 +189,19 @@ interface ResolveCredentialInput {
  * ⚠️ ③ 이 마지막인 것이 이 수리의 핵심이다. 종전엔 ③ 이 **무조건 첫 번째**였고, 그래서 provider 가
  * 바뀌어도 옛 provider 의 키가 따라갔다(= 401 의 근본). provider 가 바뀌었으면 base 키는 **틀린 키**다.
  */
+/** Every explicit OpenGateway key in host config. The Pod compares all sources before apply. */
+export function configuredOpenGatewayKeys(llm: {
+  provider?: string;
+  apiKey?: string;
+  rotation?: readonly { provider: string; apiKey?: string }[];
+}): string[] {
+  const values = [
+    ...(llm.provider === 'opengateway' ? [llm.apiKey] : []),
+    ...(llm.rotation ?? []).filter((entry) => entry.provider === 'opengateway').map((entry) => entry.apiKey),
+  ];
+  return [...new Set(values.map((value) => value?.trim()).filter((value): value is string => Boolean(value)))];
+}
+
 export function resolveProviderCredential(input: ResolveCredentialInput): ResolvedCredential {
   const { provider, rotation, baseApiKey, baseProvider } = input;
   const env = input.env ?? process.env;

package/src/llm/provider-detect.ts

@@ -31,7 +31,7 @@ export interface ProviderDetectDeps {
 
 const LIMIT_MS = 3_000;
 const CLAUDE_LIMIT_MS = 5_000;
-const ORDER = ['openai-codex', 'anthropic', 'grok', 'gemini', 'openrouter', 'openai', 'ollama', 'local'] as const;
+const ORDER = ['openai-codex', 'anthropic', 'grok', 'gemini', 'openrouter', 'openai', 'ollama', 'local', 'opengateway'] as const;
 const AGENT_RANK = { 'claude-code': -2, antigravity: -1 } as const;
 const SOURCE_PRIORITY: Readonly<Record<string, number>> = {
   'elanous-auth': 0,
@@ -44,6 +44,7 @@ const ENV_KEYS: Readonly<Record<string, readonly string[]>> = {
   grok: ['XAI_API_KEY', 'GROK_API_KEY', 'GROK_CODE_XAI_API_KEY'],
   gemini: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'],
   openrouter: ['OPENROUTER_API_KEY'],
+  opengateway: ['OPENGATEWAY_API_KEY'],
   openai: ['OPENAI_API_KEY'],
 };
 
@@ -158,6 +159,12 @@ export async function detectProviders(deps: ProviderDetectDeps = {}): Promise<De
     updateClaude();
     const agyInstall = Promise.resolve().then(() => isDirectory(join(home, '.gemini', 'antigravity-cli'))).catch(() => false);
     const files = [
+      // The installed CLI can discover the key even when the shell has not exported it.
+      // Read only; the value is never included in the detection result.
+      Promise.resolve().then(async () => {
+        const path = join(env.ELANOUS_KEY_CACHE_DIR?.trim() || join(home, '.cache'), 'opengateway_api_key');
+        if (await isFile(path) && populated(await file(path))) add('opengateway', 'apikey', 'cache:OPENGATEWAY_API_KEY');
+      }).catch(() => {}),
       json(storePath).then((store) => {
         const providers = record(store?.providers);
         if (!providers) return;

package/src/llm/runtime-model-family.ts

@@ -4,7 +4,7 @@ import type { LLMProviderName } from '../user-config.js';
  *  `src/llm/model-defaults.ts` (that module imports this file). */
 export type RuntimeLlmModelFamily =
   | 'grok' | 'anthropic' | 'openai' | 'openai-codex' | 'gemini' | 'local'
-  | 'kimi' | 'qwen' | 'glm' | 'openrouter' | 'bedrock' | 'unknown';
+  | 'kimi' | 'qwen' | 'glm' | 'openrouter' | 'opengateway' | 'bedrock' | 'unknown';
 
 export function inferRuntimeLlmModelFamily(model: string | undefined): RuntimeLlmModelFamily {
   if (!model) return 'unknown';
@@ -13,6 +13,7 @@ export function inferRuntimeLlmModelFamily(model: string | undefined): RuntimeLl
   // ⛔ 2026-09-23 — 게이트웨이 접두가 «먼저»다. 안 그러면 `openrouter/anthropic/claude-…` 가 `anthropic` 으로
   //   읽혀 openrouter 와 «비호환»이 되고, `openrouter/z-ai/…` 는 `unknown` 이라 아무 provider 와도 «호환»이 됐다.
   if (m.startsWith('openrouter/')) return 'openrouter';
+  if (m.startsWith('opengateway/')) return 'opengateway';
   // ⭐ BEDROCK-PROVIDER — Bedrock 전용 꼴(`anthropic.claude-…`·지역 접두·`bedrock/…`)이 `includes('claude')` 보다 «먼저».
   //   1st-party id(`claude-…`)는 그대로 anthropic 이다(불변).
   if (m.startsWith('bedrock/') || /^(?:[a-z]{2,6}\.)?anthropic\.claude-/.test(m)) return 'bedrock';