elanous 0.2.21 → 0.2.23

package/src/market/publish.ts

@@ -91,6 +91,8 @@ export interface PublishResult {
   ok: boolean;
   sequence: number;
   published: Array<{ name: string; version: string; sha256: string; bundled: string[] }>;
+  /** With keepExisting: previous index entries whose name has no folder under pluginsDir, carried over unchanged. */
+  kept: Array<{ name: string; version: string; sha256: string }>;
   skipped: Array<{ dir: string; reason: string; hits?: InternalRefHit[] }>;
   /** Published anyway, but a reviewer should look (e.g. a third-party graph relying on core recipes). */
   warnings: Array<{ dir: string; graph: string; reason: 'third-party-core-recipe'; recipes: string[] }>;
@@ -103,6 +105,8 @@ export function publishMarket(input: {
   market: { name: string; displayName: string };
   key: { keyId: string; privateKeyPem: string };
   source?: { repoUrl: string; sha: string; basePath: string };
+  /** Carry over previous entries whose name is not a plugin folder under pluginsDir (entry, archive and unpacked files untouched). */
+  keepExisting?: boolean;
   now?: Date;
 }): PublishResult {
   let sequence = 1;
@@ -307,6 +311,18 @@ export function publishMarket(input: {
       published.push({ name: manifest.name, version: manifest.version, sha256, bundled });
       debug.log('market.publish', 'bundled', { name: manifest.name, version: manifest.version, skills: bundled });
     }
+    const kept: PublishResult['kept'] = [];
+    if (input.keepExisting && previous) {
+      // Folders under pluginsDir own their names (even when skipped); every other previous entry stays as it was.
+      const present = new Set(readdirSync(input.pluginsDir).filter(dir => lstatSync(join(input.pluginsDir, dir)).isDirectory()));
+      for (const item of previous.plugins) {
+        if (present.has(item.name)) continue;
+        plugins.push(item);
+        kept.push({ name: item.name, version: item.version, sha256: item.artifact.sha256 });
+        debug.log('market.publish', 'kept', { name: item.name, version: item.version });
+      }
+      plugins.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    }
     const index: MarketplaceIndex = { name: input.market.name, interface: { displayName: input.market.displayName },
       sequence, generatedAt: (input.now ?? new Date()).toISOString(), plugins };
     const bytes = Buffer.from(JSON.stringify(index, null, 2) + '\n');
@@ -345,7 +361,7 @@ export function publishMarket(input: {
       signatureText: readFileSync(join(input.outDir, 'index.sig'), 'utf8'), trustedKeys });
     if (!verified.ok) throw new Error(`index verification failed: ${verified.reason}: ${verified.detail}`);
     for (const item of published) debug.log('market.publish', 'published', { name: item.name, version: item.version, sequence });
-    return { ok: !skipped.some(item => item.reason === 'internal-reference'), sequence, published, skipped, warnings };
+    return { ok: !skipped.some(item => item.reason === 'internal-reference'), sequence, published, kept, skipped, warnings };
   } catch (error) {
     const rawReason = error instanceof Error ? error.message : 'unknown-error';
     const reason = input.key.privateKeyPem && rawReason.includes(input.key.privateKeyPem) ? 'invalid signing key' : rawReason;

package/src/market/signed-index.ts

@@ -1,10 +1,31 @@
 import { createHash, createPublicKey, generateKeyPairSync, sign, verify } from 'node:crypto';
 
+export interface MarketplaceArtifact {
+  sha256: string;
+  bytes: number;
+  key: string;
+}
+
+export interface MarketplaceScopedPack {
+  name: string;
+  version: string;
+  description?: string;
+  artifact: MarketplaceArtifact;
+  visibility: 'public' | 'internal';
+  enterpriseId?: string;
+}
+
+export interface MarketplaceLoopBundle extends MarketplaceScopedPack {
+  graphs?: string[];
+}
+
 export interface MarketplaceIndex {
   name: string;
   interface: { displayName: string };
   sequence: number;
   generatedAt?: string;
+  knowledgePacks?: MarketplaceScopedPack[];
+  loopBundles?: MarketplaceLoopBundle[];
   plugins: Array<{
     name: string;
     source: { source: string; [key: string]: unknown };
@@ -57,6 +78,27 @@ function invalidIndex(value: unknown): string | null {
   if (value.generatedAt !== undefined && !string(value.generatedAt)) return 'generatedAt: expected string';
   if (!Array.isArray(value.plugins)) return 'plugins: expected array';
 
+  for (const collection of ['knowledgePacks', 'loopBundles'] as const) {
+    const entries = value[collection];
+    if (entries === undefined) continue;
+    if (!Array.isArray(entries)) return `${collection}: expected array`;
+    for (const [i, entry] of entries.entries()) {
+      const field = (name: string) => `${collection}[${i}] (${record(entry) && string(entry.name) ? entry.name : 'unnamed'}).${name}`;
+      if (!record(entry)) return field('expected object');
+      if (!string(entry.name) || !entry.name.trim()) return field('name: expected non-empty string');
+      if (!string(entry.version) || !entry.version.trim()) return field('version: expected non-empty string');
+      if (entry.description !== undefined && !string(entry.description)) return field('description: expected string');
+      if (entry.visibility !== 'public' && entry.visibility !== 'internal') return field('visibility: expected public or internal');
+      if (entry.visibility === 'internal' && (!string(entry.enterpriseId) || !entry.enterpriseId.trim())) return field('enterpriseId: required for internal entry');
+      if (entry.visibility === 'public' && entry.enterpriseId !== undefined) return field('enterpriseId: not allowed for public entry');
+      if (!record(entry.artifact)) return field('artifact: expected object');
+      if (!string(entry.artifact.sha256) || !/^[a-fA-F0-9]{64}$/.test(entry.artifact.sha256)) return field('artifact.sha256: expected 64 hex characters');
+      if (!Number.isSafeInteger(entry.artifact.bytes) || (entry.artifact.bytes as number) < 0) return field('artifact.bytes: expected non-negative integer');
+      if (!string(entry.artifact.key) || !entry.artifact.key.trim()) return field('artifact.key: expected non-empty string');
+      if (collection === 'loopBundles' && entry.graphs !== undefined && !stringArray(entry.graphs)) return field('graphs: expected string array');
+    }
+  }
+
   for (const [i, plugin] of value.plugins.entries()) {
     const field = (name: string) => `plugins[${i}] (${record(plugin) && string(plugin.name) ? plugin.name : 'unnamed'}).${name}`;
     if (!record(plugin)) return field('expected object');

package/src/maturity/feature-maturity.ts

@@ -117,6 +117,7 @@ export const FEATURE_MATURITY = {
     widget: 'tool',
     log: 'tool',
     loops: 'beta',
+    board: 'beta',
     persona: 'beta', // G3 b — 대화별 페르소나(GOAL-BENCH B7 #23836)
     memory: 'beta',
     export: 'stable',
@@ -161,7 +162,7 @@ export const FEATURE_MATURITY = {
     ping: 'stable', provider: 'stable', sessions: 'stable', fork: 'stable', resume: 'stable',
     decisions: 'stable', work: 'stable', cancel: 'stable',
     skills: 'beta', skill: 'beta', digest: 'beta', intake: 'beta', ad: 'beta',
-    taste: 'beta', missions: 'beta', attach: 'beta', detach: 'beta', now: 'beta', loops: 'beta', runs: 'beta', release: 'beta', away: 'beta', project: 'beta', wish: 'beta',
+    taste: 'beta', missions: 'beta', attach: 'beta', detach: 'beta', now: 'beta', loops: 'beta', runs: 'beta', board: 'beta', release: 'beta', away: 'beta', project: 'beta', wish: 'beta',
     brain: 'tool', cc: 'tool', cdx: 'tool', gem: 'tool', local: 'tool',
     harness: 'ops',
     // Existing commands outside the CXO four-grade menu list are owner-only.

package/src/mcp/mcp-oauth.ts

@@ -5,9 +5,8 @@
 // 다시 실어 보내는 «잇는» 모듈. 주소를 코드에 박지 않는다 — 호스트는
 // 전부 그 401 안내에서 그때 얻는다.
 //
-// 경계: 브라우저에서 누르는 구간은 만들지 않는다. 인가 주소를 조립해
-// AuthorizeHandler 로 돌려주는 데까지가 이 착지다.
-// 경계: 장치 코드 흐름은 다루지 않는다.
+// 브라우저 승인은 호출자(aside/CLI)의 책임이다. 브라우저를 쓸 수 없고
+// 인가 서버가 RFC 8628 을 광고할 때는 장치 코드로 자격을 얻는다.
 // 경계: 새 CLI 하위 명령은 더하지 않는다.
 
 import { join } from 'node:path';
@@ -36,6 +35,7 @@ export type McpOAuthErrorCode =
   | 'identity-mismatch'
   | 's256-unsupported'
   | 'registration'
+  | 'device'
   | 'state-mismatch'
   | 'token'
   | 'refresh';
@@ -70,9 +70,10 @@ export interface ProtectedResourceMetadata {
 
 export interface AuthorizationServerMetadata {
   issuer: string;
-  authorizationEndpoint: string;
+  authorizationEndpoint?: string;
   tokenEndpoint: string;
   registrationEndpoint?: string;
+  deviceAuthorizationEndpoint?: string;
   codeChallengeMethodsSupported: string[];
 }
 
@@ -81,6 +82,9 @@ export interface ClientRegistration {
   clientSecret?: string;
   /** 동적 등록 때 쓴 redirect_uri. 옛 등록에는 없다. */
   redirectUri?: string;
+  /** Registered now but not stored yet: the store still holds another client's tokens, so this registration is
+   *  committed only with its own tokens (exchangeAuthorizationCode). A cancelled login leaves the store as it was. */
+  pending?: boolean;
 }
 
 export interface AuthorizationRequest {
@@ -90,6 +94,8 @@ export interface AuthorizationRequest {
   redirectUri: string;
   issuer: string;
   clientId: string;
+  /** Set when the client registration is pending (see ClientRegistration.pending); in memory only. */
+  pendingRegistration?: { clientSecret?: string };
   scope?: string;
   resource?: string;
 }
@@ -364,14 +370,14 @@ export async function discoverAuthorizationServer(
   const issuer = stringField(body, 'issuer');
   const authorizationEndpoint = stringField(body, 'authorization_endpoint');
   const tokenEndpoint = stringField(body, 'token_endpoint');
-  if (!issuer || !authorizationEndpoint || !tokenEndpoint) {
+  if (!issuer || !tokenEndpoint || (!authorizationEndpoint && !stringField(body, 'device_authorization_endpoint'))) {
     throw new McpOAuthError(
       'discovery',
       'authorization server metadata is missing issuer, authorization_endpoint, or token_endpoint',
     );
   }
   requireHttpUrl(issuer, 'issuer');
-  requireHttpUrl(authorizationEndpoint, 'authorization_endpoint');
+  if (authorizationEndpoint) requireHttpUrl(authorizationEndpoint, 'authorization_endpoint');
   requireHttpUrl(tokenEndpoint, 'token_endpoint');
   // ⛔⭐⭐ RFC 8414 §3.3 — 돌려받은 `issuer` 는 «우리가 물어본» 인가서버
   //    식별자와 «같아야» 한다. 안 대조하면 metadata 를 쥔 쪽이 남의 issuer 를
@@ -385,11 +391,14 @@ export async function discoverAuthorizationServer(
   }
   const registrationEndpoint = stringField(body, 'registration_endpoint');
   if (registrationEndpoint) requireHttpUrl(registrationEndpoint, 'registration_endpoint');
+  const deviceAuthorizationEndpoint = stringField(body, 'device_authorization_endpoint');
+  if (deviceAuthorizationEndpoint) requireHttpUrl(deviceAuthorizationEndpoint, 'device_authorization_endpoint');
   return {
     issuer,
-    authorizationEndpoint,
+    ...(authorizationEndpoint ? { authorizationEndpoint } : {}),
     tokenEndpoint,
     ...(registrationEndpoint ? { registrationEndpoint } : {}),
+    ...(deviceAuthorizationEndpoint ? { deviceAuthorizationEndpoint } : {}),
     codeChallengeMethodsSupported: stringList(body, 'code_challenge_methods_supported'),
   };
 }
@@ -468,13 +477,15 @@ export function loadStoredRegistration(
 
 export async function ensureClientRegistration(
   metadata: AuthorizationServerMetadata,
-  opts: McpOAuthRuntimeOpts & { forceReregister?: boolean } = {},
+  opts: McpOAuthRuntimeOpts & { forceReregister?: boolean; deviceCode?: boolean } = {},
 ): Promise<ClientRegistration> {
   const path = storePath(opts);
   if (!opts.forceReregister) {
     const stored = loadStoredRegistration(metadata.issuer, { storePath: path });
-    // 옛 등록은 redirect_uri 기록이 없다 — 재사용하면 포트 불일치로 영원히 막힌다.
-    if (stored?.redirectUri) return stored;
+    // Browser registrations require a bound loopback URI. Device authorization reuses a client without one
+    // (a prior device client — its stored refresh token stays paired with it), or any client when it cannot register.
+    if (stored && opts.deviceCode && (!stored.redirectUri || !metadata.registrationEndpoint)) return stored;
+    if (stored?.redirectUri && !opts.deviceCode) return stored;
   }
   if (!metadata.registrationEndpoint) {
     throw new McpOAuthError(
@@ -493,9 +504,9 @@ export async function ensureClientRegistration(
       },
       body: JSON.stringify({
         client_name: CLIENT_NAME,
-        redirect_uris: [redirectUri],
-        grant_types: ['authorization_code', 'refresh_token'],
-        response_types: ['code'],
+        ...(opts.deviceCode ? {} : { redirect_uris: [redirectUri] }),
+        grant_types: opts.deviceCode ? ['urn:ietf:params:oauth:grant-type:device_code', 'refresh_token'] : ['authorization_code', 'refresh_token'],
+        response_types: opts.deviceCode ? [] : ['code'],
         token_endpoint_auth_method: 'none',
         application_type: 'native',
       }),
@@ -519,8 +530,15 @@ export async function ensureClientRegistration(
   const registration: ClientRegistration = {
     clientId,
     ...(clientSecret ? { clientSecret } : {}),
-    redirectUri,
+    ...(opts.deviceCode ? {} : { redirectUri }),
   };
+  // A device client is stored only with its first tokens (authorizeMcpDevice): until a device login succeeds,
+  // the stored registration and the refresh token paired with it stay as they were.
+  if (opts.deviceCode) return registration;
+  // A browser registration over another client's live tokens (e.g. after a device login) waits for its own
+  // tokens: storing it now would orphan the stored refresh token if this approval is cancelled or fails.
+  const existing = loadTokens(metadata.issuer, path);
+  if (existing?.tokens.refreshToken && existing.accountUuid && existing.accountUuid !== clientId) return { ...registration, pending: true };
   persistRegistration(metadata.issuer, registration, path);
   return registration;
 }
@@ -546,6 +564,7 @@ export function buildAuthorizationRequest(
       'authorization server does not advertise code_challenge_methods_supported=S256',
     );
   }
+  if (!metadata.authorizationEndpoint) throw new McpOAuthError('discovery', 'authorization server has no authorization_endpoint for browser login');
   const pkce = generatePkcePair();
   const redirectUri = opts.redirectUri ?? DEFAULT_REDIRECT_URI;
   const url = new URL(metadata.authorizationEndpoint);
@@ -565,6 +584,7 @@ export function buildAuthorizationRequest(
     redirectUri,
     issuer: metadata.issuer,
     clientId: registration.clientId,
+    ...(registration.pending ? { pendingRegistration: registration.clientSecret ? { clientSecret: registration.clientSecret } : {} } : {}),
     ...(scope ? { scope } : {}),
     ...(opts.resource ? { resource: opts.resource } : {}),
   };
@@ -673,13 +693,107 @@ function persistTokens(
       authMode: AUTH_MODE,
       ...(clientId ? { accountUuid: clientId } : {}),
       ...(clientSecret ? { organizationUuid: clientSecret } : {}),
-      ...(existing?.redirectUri ? { redirectUri: existing.redirectUri } : {}),
+      // A loopback URI belongs to the client that registered it — never carry it onto a different (device) client.
+      ...(existing?.redirectUri && (!registration || registration.clientId === existing.accountUuid) ? { redirectUri: existing.redirectUri } : {}),
       mirrorCodex: false,
     },
     path,
   );
 }
 
+export interface McpDeviceAuthorization {
+  userCode: string;
+  verificationUri: string;
+  verificationUriComplete?: string;
+}
+
+/** RFC 8628: only an advertised endpoint enables the fallback; tokens use the same issuer store. */
+export async function authorizeMcpDevice(
+  metadata: AuthorizationServerMetadata,
+  registration: ClientRegistration,
+  opts: McpOAuthRuntimeOpts & {
+    scope?: string;
+    resource?: string;
+    onDeviceCode: (code: McpDeviceAuthorization) => Promise<void> | void;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+  },
+): Promise<OAuthTokens> {
+  const endpoint = metadata.deviceAuthorizationEndpoint;
+  if (!endpoint) throw new McpOAuthError('device', 'authorization server does not advertise device_authorization_endpoint');
+  const fetchFn = fetchImpl(opts);
+  const post = async (url: string, fields: Record<string, string | undefined>) => {
+    let response: Awaited<ReturnType<McpOAuthFetch>>;
+    try {
+      response = await fetchFn(url, {
+        method: 'POST',
+        headers: { accept: 'application/json', 'content-type': 'application/x-www-form-urlencoded' },
+        body: formBody(fields),
+      });
+    } catch (error) {
+      throw new McpOAuthError('device', `device authorization request failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const text = await response.text();
+    return { status: response.status, body: parseJsonObject(text, 'device authorization response', 'device') };
+  };
+  const started = await post(endpoint, {
+    client_id: registration.clientId,
+    client_secret: registration.clientSecret,
+    scope: opts.scope,
+    resource: opts.resource,
+  });
+  const deviceCode = stringField(started.body, 'device_code');
+  const userCode = stringField(started.body, 'user_code');
+  const verificationUri = stringField(started.body, 'verification_uri');
+  if (started.status < 200 || started.status >= 300 || !deviceCode || !userCode || !verificationUri) {
+    const error = stringField(started.body, 'error');
+    throw new McpOAuthError('device', `device authorization returned HTTP ${started.status}${error ? ` (${error})` : ''} or missing required fields`);
+  }
+  requireHttpUrl(verificationUri, 'verification_uri');
+  const verificationUriComplete = stringField(started.body, 'verification_uri_complete');
+  if (verificationUriComplete) requireHttpUrl(verificationUriComplete, 'verification_uri_complete');
+  const seconds = started.body.expires_in;
+  if (typeof seconds !== 'number' || !Number.isFinite(seconds) || seconds <= 0) {
+    throw new McpOAuthError('device', 'device authorization response has invalid expires_in');
+  }
+  const now = opts.now ?? Date.now;
+  const deadline = now() + Math.min(seconds * 1000, 15 * 60_000);
+  let interval = typeof started.body.interval === 'number' && Number.isFinite(started.body.interval) && started.body.interval > 0
+    ? Math.max(1000, started.body.interval * 1000) : 5000;
+  await opts.onDeviceCode({ userCode, verificationUri, ...(verificationUriComplete ? { verificationUriComplete } : {}) });
+  const sleep = opts.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+  let attempts = 0;
+  while (now() < deadline) {
+    if (++attempts > Math.ceil(Math.min(seconds, 900)) + 1) throw new McpOAuthError('device', 'device authorization polling limit exceeded');
+    await sleep(Math.min(interval, deadline - now()));
+    if (now() >= deadline) break;
+    const polled = await post(metadata.tokenEndpoint, {
+      grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+      device_code: deviceCode,
+      client_id: registration.clientId,
+      client_secret: registration.clientSecret,
+      resource: opts.resource,
+    });
+    if (polled.status >= 200 && polled.status < 300) {
+      const accessToken = stringField(polled.body, 'access_token');
+      if (!accessToken) throw new McpOAuthError('token', 'device token response is missing access_token');
+      const tokens: OAuthTokens = {
+        accessToken,
+        refreshToken: stringField(polled.body, 'refresh_token') ?? '',
+        expiresAt: expiresAtFromSeconds(polled.body.expires_in),
+        tokenType: stringField(polled.body, 'token_type') ?? 'Bearer',
+        ...(stringField(polled.body, 'scope') ? { scope: stringField(polled.body, 'scope') } : {}),
+      };
+      persistTokens(metadata.issuer, tokens, registration, storePath(opts));
+      return tokens;
+    }
+    const error = stringField(polled.body, 'error');
+    if (error === 'slow_down') interval += 5000;
+    else if (error !== 'authorization_pending') throw new McpOAuthError('device', `device token request returned HTTP ${polled.status} (${error ?? 'unknown'})`);
+  }
+  throw new McpOAuthError('device', 'device authorization expired before approval');
+}
+
 export async function exchangeAuthorizationCode(
   metadata: AuthorizationServerMetadata,
   request: AuthorizationRequest,
@@ -688,7 +802,10 @@ export async function exchangeAuthorizationCode(
 ): Promise<OAuthTokens> {
   const code = verifyAuthorizationCallback(request, callback);
   const path = storePath(opts);
-  const registration = loadStoredRegistration(metadata.issuer, { storePath: path });
+  const pending = request.pendingRegistration;
+  const registration: ClientRegistration | null = pending
+    ? { clientId: request.clientId, ...(pending.clientSecret ? { clientSecret: pending.clientSecret } : {}), redirectUri: request.redirectUri }
+    : loadStoredRegistration(metadata.issuer, { storePath: path });
   const tokens = await postToken(
     metadata.tokenEndpoint,
     {
@@ -703,7 +820,9 @@ export async function exchangeAuthorizationCode(
     fetchImpl(opts),
     'token',
   );
-  persistTokens(
+  // A pending registration is committed together with the tokens it just earned.
+  if (pending) persistRegistration(metadata.issuer, registration!, path, tokens);
+  else persistTokens(
     metadata.issuer,
     tokens,
     registration ?? { clientId: request.clientId },

package/src/model-tier/llm-tier-map.ts

@@ -400,21 +400,50 @@ const GROK: TierMap = {
 //   kimi·qwen·glm 의 «첫 실제 경로». 사다리는 이름 기억이 아니라 ***실물 `/api/v1/models` 사실***로 골랐다
 //   (2026-09-23 실측 · 전 칸 `tools`·`reasoning` 지원 · 가격 $/MTok 입력/출력):
 //     budget   qwen3.8-flash      0.15/0.47  1M
-//     balanced glm-5.3            0.84/2.64  1.31M   ← 기본(OPENROUTER_MODEL)
+//     balanced glm-5.3            0.039/4.8  1.05M   ← 기본(OPENROUTER_MODEL)
+//     별도 모델 glm-5.3-flash     가격·창 미측정 (0으로 기록하지 않는다)
+//   📏 OP 10-10 OpenRouter 실측: GLM-5.3 입력 $0.039/MTok · 출력 $4.8/MTok · 창 1.05M.
 //     better   qwen3.8-max-0902   2/6        1M
 //     best     kimi-k3            3/15       1.05M
-//   ⇒ 가격순이면서 세 벤더를 «다» 덮는다. ⛔ 가격·창은 늙는다 — 카탈로그(`openrouter/*` 폴드)가 canonical.
+//   ⚠️ GLM 가격 갱신·flash 단가 미측정으로 가격순 주장은 보류한다. 가격·창은 늙는다 — 카탈로그(`openrouter/*` 폴드)가 canonical.
 //   `shipping` = «생성된다»(배선 계약). 도구 호출·도구 루프·elanous 실제 프롬프트 3/3 실측(리서치 문서 §9).
 //   ⚠️ `loaded` 의 reasoningLevel 은 wire 로 «안» 간다 — 측정상 OpenRouter `reasoning.effort` 를 보내면
 //      kimi·glm 이 «덜» 생각한다(필드 없음이 최대). 그래서 옮기지 않았다 — 리서치 문서 §9.
 const OPENROUTER: TierMap = {
   budget:   { model: 'openrouter/qwen/qwen3.8-flash',     label: 'Qwen 3.8 Flash (OpenRouter)',   rationale: 'Fast · cheap · 1M ctx',            status: 'shipping' },
-  balanced: { model: 'openrouter/z-ai/glm-5.3',           label: 'GLM 5.3 (OpenRouter)',          rationale: 'Default · 1.31M ctx',              status: 'shipping' },
+  balanced: { model: 'openrouter/z-ai/glm-5.3',           label: 'GLM 5.3 (OpenRouter)',          rationale: 'Default · $0.039/$4.8 per MTok · 1.05M ctx', status: 'shipping' },
   better:   { model: 'openrouter/qwen/qwen3.8-max-0902',  label: 'Qwen 3.8 Max (OpenRouter)',     rationale: 'Higher quality',                   status: 'shipping' },
   best:     { model: 'openrouter/moonshotai/kimi-k3',     label: 'Kimi K3 (OpenRouter)',          rationale: 'Best · Kimi flagship',             status: 'shipping' },
   loaded:   { model: 'openrouter/moonshotai/kimi-k3', reasoningLevel: 'high', label: 'Kimi K3 · reasoning high (OpenRouter)', rationale: 'Loaded · deep multi-step', status: 'shipping' },
 };
 
+// ── AWS Bedrock (BEDROCK-PROVIDER · 2026-10-11) ───────────────────
+//   ⭐ 판단: ANTHROPIC 사다리의 «추론 수준·역할 배치»를 그대로 두고, 모델은 Bedrock 메시지 엔드포인트에서
+//   확인한 5.5 계열 id(`src/llm/bedrock.ts` BEDROCK_MODELS · 출처 platform.claude.com «Claude in Amazon Bedrock»
+//   Supported models)로만 채운다. 아래 칸(budget·balanced)은 ANTHROPIC 이 haiku-4-5·sonnet-5 를 쓰지만, 이 PR 이
+//   카탈로그에 올린 Bedrock id 는 5.5 셋뿐이라 같은 등급의 5.5(haiku-5-5·sonnet-5-5)로 올렸다.
+//   ⛔ bedrock 은 명시 선택 전용 — 이 표는 `--role-llm <role>=bedrock/<tier>` 같은 «명시» 해석에만 쓰인다.
+//   ⚠️ status = `wip`: 실 AWS 호출(계정별 5.5 접근 조건)을 아직 안 쟀고, 셋업 키 감지 표(PROVIDER_ENV_SPEC)에도
+//      없다(자격이 API 키가 아니라 AWS 체인이라). 첫 실호출 스모크 뒤 `shipping` 으로 올린다.
+const BEDROCK: TierMap = {
+  budget:   { model: 'anthropic.claude-haiku-5-5',  reasoningLevel: 'off',    label: 'Claude Haiku 5.5 (Bedrock)',  rationale: 'Fast · cheap · bulk/classification', status: 'wip' },
+  balanced: { model: 'anthropic.claude-sonnet-5-5', reasoningLevel: 'off',    label: 'Claude Sonnet 5.5 (Bedrock)', rationale: 'Default · everyday coding (BEDROCK_DEFAULT_MODEL)', status: 'wip' },
+  better:   { model: 'anthropic.claude-opus-5-5',   reasoningLevel: 'medium', label: 'Claude Opus 5.5 · thinking medium (Bedrock)', rationale: 'ANTHROPIC better 와 같은 배치(구현 = Opus 5.5)', status: 'wip' },
+  best:     { model: 'anthropic.claude-opus-5-5',   reasoningLevel: 'medium', label: 'Claude Opus 5.5 · thinking medium (Bedrock)', rationale: 'Best reasoning · architecture', status: 'wip' },
+  loaded:   { model: 'anthropic.claude-opus-5-5',   reasoningLevel: 'high',   label: 'Claude Opus 5.5 · extended thinking (Bedrock)', rationale: 'Loaded · deep multi-step', status: 'wip' },
+};
+
+/** 가격·창 미측정이라 기존 tier 배치를 바꾸지 않고 명시 모델로만 고르는 칸.
+ *  소비 경로 = `lookupOpenRouterModelSpec()` ← `resolveRunFallback()`(openrouter 폴백 판정의 관측·ROUTE 결정). */
+const OPENROUTER_EXPLICIT_MODELS: Readonly<Record<string, LlmTierSpec>> = {
+  'z-ai/glm-5.3-flash': {
+    model: 'openrouter/z-ai/glm-5.3-flash',
+    label: 'GLM 5.3 Flash (OpenRouter)',
+    rationale: 'Fast · 가격/창 미측정',
+    status: 'shipping',
+  },
+};
+
 // ── Combined lookup ─────────────────────────────────────────────────
 
 /** Subset of LLMProviderName that has a tier ladder defined here.
@@ -433,6 +462,7 @@ export const LLM_TIER_MAP_BY_PROVIDER: Readonly<Record<LlmTierProvider, TierMap>
   glm: GLM,
   grok: GROK,
   openrouter: OPENROUTER,
+  bedrock: BEDROCK,
 } as const;
 
 /** 사람이 쓰는 tier 별칭 → canonical ModelTier. "grok low tier" 같은 자연어 헷갈림을 SSOT 로 흡수한다.
@@ -454,9 +484,23 @@ export function parseTierArg(raw: string): ModelTier | undefined {
  *  tsc 는 배열 누락을 못 잡는다(2026-09-23 `#19900` 이 `openrouter` 를 빠뜨려 배선 계약 자가 그것을
  *  한 번도 누르지 않았다). 자 = `provider-wiring-contract.test.ts`. */
 export const TIER_PROVIDERS: readonly LlmTierProvider[] = [
-  'anthropic', 'openai', 'openai-codex', 'gemini', 'grok', 'local', 'kimi', 'qwen', 'glm', 'openrouter',
+  'anthropic', 'openai', 'openai-codex', 'gemini', 'grok', 'local', 'kimi', 'qwen', 'glm', 'openrouter', 'bedrock',
 ];
 
+/** OpenRouter 모델 id(`openrouter/<vendor>/<model>` 또는 `<vendor>/<model>`)의 tier-map 칸.
+ *  명시 칸(`glm-5.3-flash` 등) → 5-tier 사다리 순으로 찾는다. 모르면 undefined(«미등록»을 기본값으로 접지 않는다). */
+export function lookupOpenRouterModelSpec(model: string): LlmTierSpec | undefined {
+  const bare = model.trim().replace(/^openrouter\//, '');
+  if (!bare) return undefined;
+  const explicit = OPENROUTER_EXPLICIT_MODELS[bare];
+  if (explicit) return explicit;
+  const wanted = `openrouter/${bare}`;
+  for (const tier of ['budget', 'balanced', 'better', 'best'] as const) {
+    if (OPENROUTER[tier].model === wanted) return OPENROUTER[tier];
+  }
+  return undefined;
+}
+
 /** Resolve the spec for (provider, tier).
  *  `auto` and unknown providers have no concrete provider ladder, so both use
  *  Anthropic's balanced default instead of crossing into the Codex family.

package/src/models/prompts.ts

@@ -29,8 +29,12 @@ export type ModelFamily =
   | 'grok'
   | 'gemini'
   | 'local'
+  | 'open-weight'
   | 'other';
 
+/** OpenRouter gateway prefix for OpenAI-served models (see OR-FAMILY-GPT6 in getModelFamily). */
+const OPENROUTER_OPENAI_PREFIX = 'openrouter/openai/';
+
 /** Infer the family from a model id. Mirrors `inferProviderFromModel`
  *  in llm.ts but returns a finer-grained tag (codex vs other gpt,
  *  specifically, because codex-family has the worst observed tool-
@@ -45,6 +49,23 @@ export function getModelFamily(modelId: string | undefined): ModelFamily {
   if (m.includes('grok')) return 'grok';
   if (m.startsWith('gemini-')) return 'gemini';
   if (m.startsWith('local:')) return 'local';
+  // OR-FAMILY-GPT6 — `openrouter/openai/<gpt-* | o1-/o3-/o4-*>` is the same model the direct
+  // path serves; when its bare id is 'gpt' there (gpt-6-*, gpt-4*, o-series) it gets 'gpt' here
+  // too, so it carries the gpt prompt pieces (hygiene addon · preamble addendum · chat variant ·
+  // tool-hint cap). Without this it fell to 'other'. ⛔ A 'codex' verdict (bare gpt-5*) is NOT
+  // taken: in llm.ts 'codex' also switches tool-loop behaviour (inspect/repair stops, Read
+  // auto-narrowing, exploration exemptions, idle timeout) — not just prompt text — and that is a
+  // separate decision. Ids with `codex` in them were already 'codex' above. Gateway-prefixed ids
+  // only — bare `openai/...` ids are not touched (same LM Studio reason as below).
+  if (m.startsWith(OPENROUTER_OPENAI_PREFIX) && getModelFamily(m.slice(OPENROUTER_OPENAI_PREFIX.length)) === 'gpt') {
+    return 'gpt';
+  }
+  // OpenRouter gateway ids only (`openrouter/<vendor>/<model>`). Bare vendor ids such as
+  // `qwen/qwen3-coder-30b` stay 'other' on purpose: LM Studio publishes native ids in that
+  // same shape (see getModelTier's local pattern), and this family must not reach local runs.
+  if (m.startsWith('openrouter/') && (m.includes('glm') || m.includes('kimi') || m.includes('qwen'))) {
+    return 'open-weight';
+  }
   return 'other';
 }
 
@@ -68,7 +89,7 @@ export function getModelFamily(modelId: string | undefined): ModelFamily {
 //     localhost).
 
 import type { LLMProviderName } from '../user-config.js';
-import type { SkillTier } from '../skills/runner.js';
+import type { SkillTier } from '../skills/skill-tier.js';
 import { LLM_TIER_MAP_BY_PROVIDER, TIER_PROVIDERS } from '../model-tier/llm-tier-map.js';
 
 function matchesAny(s: string, needles: string[]): boolean {