elanous 0.2.24 → 0.2.27

package/src/intelligence-map/catalog-feed.ts

@@ -0,0 +1,119 @@
+// ── MK · 0.2.26 칸 CATALOG-FEED — signed catalog feed ──────────────────
+//
+// Folds a ModelCatalog into a verifiable feed document and verifies it on
+// the receiving side:
+//   buildCatalogFeed  — canonicalize (models sorted by id, stable-key JSON)
+//                       + sha256 content digest.
+//   signCatalogFeed   — ed25519 signature over the feed document (base64).
+//   verifyCatalogFeed — reject tampered / forged feeds with a reason.
+//
+// Design = 내부 문서 `RFC-smart-model-routing-and-catalog-2026-10-10` §판올림=카탈로그 동봉.
+// This piece is the judgment only — key generation/holding, the daily
+// publish cron, and fetching are the next slice.
+//
+// 🔎 세 얼굴 — 관측: verify 거부는 debug.log('intelligence-map.catalog-feed',
+// 'verify-rejected', { reason }) 로 남는다. 판단 근거: digest 는 «정렬·키 고정
+// JSON» 의 sha256 hex 라 서명과 무관하게 내용 변조를 가른다. 수복·인계: 거부
+// 사유가 'digest-mismatch' 면 서명 키는 맞고 «내용»이 바뀌었다 — 발행 측 카탈로그를
+// 다시 잰다; 'bad-signature' 면 키가 다르다.
+
+import { createHash, sign as cryptoSign, verify as cryptoVerify } from 'node:crypto';
+import { debug } from '../debug/log.js';
+import type { ModelCatalog, ModelEntry } from './types.js';
+
+export interface CatalogFeed {
+  schema: 'elanous.catalog-feed/1';
+  issuedAt: string;
+  models: ModelEntry[];
+  digest: string;
+}
+
+export interface SignedCatalogFeed {
+  feed: CatalogFeed;
+  signature: string;
+}
+
+export type CatalogFeedVerifyResult =
+  | { ok: true; feed: CatalogFeed }
+  | { ok: false; reason: 'bad-signature' | 'digest-mismatch' | 'schema' };
+
+/** Canonical JSON — sorted object keys, deterministic spacing. Arrays keep
+ *  order; `models` is sorted by `id` before this is applied. */
+function canonicalJson(value: unknown): string {
+  // undefined follows JSON.stringify: dropped as an object key, null in an
+  // array — so a feed survives a JSON round trip with the same digest.
+  if (value === undefined) return 'null';
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
+  const obj = value as Record<string, unknown>;
+  const keys = Object.keys(obj).filter((k) => obj[k] !== undefined).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(obj[k])}`).join(',')}}`;
+}
+
+/** sha256 hex of the canonical (sorted, key-stable) JSON of the feed. */
+function feedDigest(feed: Omit<CatalogFeed, 'digest'>): string {
+  return createHash('sha256').update(canonicalJson(feed)).digest('hex');
+}
+
+/** Fold a catalog into a signed-feed-ready document. `models` is sorted by
+ *  id so byte-identical catalogs always produce the same digest. */
+export function buildCatalogFeed(catalog: ModelCatalog, issuedAt: Date): CatalogFeed {
+  const models = [...catalog.models].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  const base = {
+    schema: 'elanous.catalog-feed/1' as const,
+    issuedAt: issuedAt.toISOString(),
+    models,
+  };
+  return { ...base, digest: feedDigest(base) };
+}
+
+/** Sign the feed document (whole feed, digest included) with an ed25519
+ *  private key (PEM). Signature is base64 over the canonical JSON of the
+ *  feed. */
+export function signCatalogFeed(
+  feed: CatalogFeed,
+  privateKeyPem: string,
+): { feed: CatalogFeed; signature: string } {
+  const signature = cryptoSign(null, Buffer.from(canonicalJson(feed)), privateKeyPem).toString('base64');
+  return { feed, signature };
+}
+
+/** Verify a signed feed: schema → content digest (recomputed, catches
+ *  tampering that keeps the original digest) → signature. Rejected feeds
+ *  are logged (제1원칙 관측) so the receiver's self-cognition can see why a
+ *  feed was refused. */
+export function verifyCatalogFeed(signed: SignedCatalogFeed, publicKeyPem: string): CatalogFeedVerifyResult {
+  if (signed === null || typeof signed !== 'object') return reject('schema');
+  const { feed, signature } = signed;
+  if (feed === null || typeof feed !== 'object' || feed.schema !== 'elanous.catalog-feed/1' || typeof feed.issuedAt !== 'string' || !Array.isArray(feed.models)
+    || typeof feed.digest !== 'string' || typeof signature !== 'string' || !feed.models.every(isModelEntryShape)) {
+    return reject('schema');
+  }
+  const { digest: _digest, ...body } = feed;
+  if (feedDigest(body) !== feed.digest) return reject('digest-mismatch');
+  let sigOk = false;
+  try {
+    sigOk = cryptoVerify(null, Buffer.from(canonicalJson(feed)), publicKeyPem, Buffer.from(signature, 'base64'));
+  } catch {
+    sigOk = false;
+  }
+  if (!sigOk) return reject('bad-signature');
+  return { ok: true, feed };
+}
+
+/** Required ModelEntry fields at the receiving boundary — a signed feed with
+ *  a model missing any of these is a schema failure, not a usable catalog. */
+function isModelEntryShape(m: unknown): boolean {
+  if (m === null || typeof m !== 'object') return false;
+  const e = m as Record<string, unknown>;
+  const finite = (v: unknown) => typeof v === 'number' && Number.isFinite(v);
+  const strings = (v: unknown) => Array.isArray(v) && v.every((x) => typeof x === 'string');
+  return typeof e.id === 'string' && e.id.length > 0 && typeof e.provider === 'string' && typeof e.family === 'string'
+    && finite(e.contextWindow) && finite(e.inputPerMtok) && finite(e.outputPerMtok)
+    && typeof e.local === 'boolean' && strings(e.tags) && strings(e.bestFor);
+}
+
+function reject(reason: 'bad-signature' | 'digest-mismatch' | 'schema'): { ok: false; reason: typeof reason } {
+  debug.log('intelligence-map.catalog-feed', 'verify-rejected', { reason });
+  return { ok: false, reason };
+}

package/src/intelligence-map/model-watch-intake.ts

@@ -103,6 +103,46 @@ export async function runModelWatchIntake(
   return { candidates, proposal, perSource };
 }
 
+export type PriceField = 'inputPerMtok' | 'outputPerMtok';
+
+export interface PriceChange {
+  id: string;
+  field: PriceField;
+  /** Price currently in the catalog (USD per 1M tokens). */
+  before: number;
+  /** Price the watched page reports. */
+  after: number;
+}
+
+const PRICE_FIELDS: readonly PriceField[] = ['inputPerMtok', 'outputPerMtok'];
+
+/** Price differences between the catalog and the watched pages. The merge
+ *  only fills undefined fields, so a repriced model shows up in
+ *  `proposal.updated` with no trace of the new price — this reports it.
+ *  A catalog price of 0 means "not priced yet" and is not a change. */
+export function detectPriceChanges(result: Pick<WatchIntakeResult, 'candidates' | 'proposal'>): PriceChange[] {
+  const current = new Map(result.proposal.catalog.models.map((model) => [model.id, model]));
+  const updated = new Set(result.proposal.updated);
+  const changes: PriceChange[] = [];
+  for (const candidate of result.candidates) {
+    const entry = current.get(candidate.id);
+    if (!entry || !updated.has(candidate.id)) continue;
+    for (const field of PRICE_FIELDS) {
+      const before = entry[field];
+      const after = candidate[field];
+      if (typeof after !== 'number' || !Number.isFinite(after) || after < 0) continue;
+      if (typeof before !== 'number' || before <= 0 || before === after) continue;
+      changes.push({ id: candidate.id, field, before, after });
+    }
+  }
+  return changes;
+}
+
+export function formatPriceChange(change: PriceChange): string {
+  const label = change.field === 'inputPerMtok' ? 'input' : 'output';
+  return `${change.id} ${label} $${change.before}→$${change.after} /Mtok`;
+}
+
 function errorMessage(error: unknown): string {
   try {
     const message = error instanceof Error ? error.message : String(error);

package/src/intelligence-map/model-watch-mission.ts

@@ -21,7 +21,13 @@ import { lookupLlmTierSpec } from '../model-tier/index.js';
 import type { LlmRunner } from '../model-tier/preset-suggest-llm.js';
 import type { LLMProviderName } from '../user-config.js';
 import { getUserConfig } from '../user-config.js';
-import { runModelWatchIntake, type WatchIntakeResult, type WatchPage } from './model-watch-intake.js';
+import {
+  detectPriceChanges,
+  formatPriceChange,
+  runModelWatchIntake,
+  type WatchIntakeResult,
+  type WatchPage,
+} from './model-watch-intake.js';
 
 export function getModelWatchProposalPath(home: string = homedir()): string {
   return join(home, '.elanous', 'model-watch-proposals.jsonl');
@@ -93,6 +99,13 @@ export async function runModelIntelligenceWatch(
       line: `Classification incomplete for zero-candidate sources: ${abnormalEmptySources.join(', ')}`,
     });
   }
+  const priceChanges = detectPriceChanges(result);
+  if (priceChanges.length > 0) {
+    await safeLog(log, 'intelligence-map.model-watch', 'price-changes', {
+      changes: priceChanges,
+      line: `Price changes vs catalog: ${priceChanges.map(formatPriceChange).join('; ')}`,
+    });
+  }
   await safeLog(log, 'intelligence-map.model-watch', 'pass', {
     pages: pages.length,
     candidates: result.candidates.length,

package/src/llm/open-weight-discipline.ts

@@ -0,0 +1,21 @@
+/** OpenRouter(`openrouter/…`) GLM·Kimi·Qwen 전용 도구 호출 규율 — 다른 군 상수와 합성하지 않는 독립 상수.
+ *
+ *  2026-10-11 GLM-PROMPT-TUNE 첫 조각: `llm.ts` 동결(RFC #25983)을 위해 상수를 이 파일로 옮겼다.
+ *  줄 둘을 추가했다 — 실측 약점 둘을 겨냥한다:
+ *    ⑴ 그라운딩 비교 8회 중 GLM 3회 전부 «Grep 으로만 확인하고 Read 는 안 했다»고 스스로 적고
+ *       그 경로를 증거로 써 grounding-evidence 기각
+ *    ⑵ 상 칸에서 PR 없이 라운드만 도는 no-progress(부검반 ×26)
+ *  다른 군(codex·grok·local·claude·gemini·gpt·other)의 요청 바이트는 불변 — 이 상수는
+ *  open-weight 계열에만 주입된다(`TOOL_DISCIPLINE_BY_FAMILY`).
+ *
+ *  ⛔ `llm.ts` 의 `selectIntentClassificationMessages` 가 이 상수와 «정확 일치»로 분류기를
+ *     걸러 내므로, 주입부는 상수를 그대로 싣는다(합성 금지). */
+export const OPEN_WEIGHT_TOOL_DISCIPLINE = [
+  '[open-weight tool-use discipline]',
+  '- 도구로 할 수 있는 일은 이번 응답에서 바로 도구를 호출하라. "먼저 읽겠다" 또는 "확인하겠다" 같은 계획만 말하고 응답을 끝내지 마라.',
+  '- 작업을 시작하는 첫 응답에는 도구 호출이 하나 이상 있어야 한다.',
+  '- 도구 호출 인자는 해당 도구의 스키마에 맞는 JSON 으로 내라.',
+  '- 충분한 근거가 모이면 도구 호출 없이 최종 답을 평문으로 써서 끝내라.',
+  '- 증거·근거로 적는 파일은 이번 작업에서 Read 로 연 파일만 — Grep·Glob 결과만으로 내용을 단정하지 마라.',
+  '- 구현을 끝냈다고 말하기 전에 바꾼 파일과 돌린 시험 명령·결과를 적어라.',
+].join('\n');

package/src/llm/openai-sampling-fields.ts

@@ -0,0 +1,89 @@
+/**
+ * ⛔⭐ OpenAI Chat Completions 의 «출력 상한» 칸 이름은 모델 세대로 갈린다.
+ *
+ * `gpt-5` 이후 계열은 `max_tokens` 를 ***거부한다*** — 400 `unsupported_parameter` 를 내고
+ * *"Use 'max_completion_tokens' instead"* 라고 말한다. `gpt-4o` 계열은 반대로 옛 이름만 받는다.
+ *
+ * 📏 2026-08-22 실측: `provider auto` 의 티어 사다리가 `gpt-5.6-*` 로 바뀐 뒤(`#11161`)
+ * 3시간 만에 이 400 이 **93건** 났고 «가속»했다(20h:2 → 21h:16 → 22h:30 → 23h:45).
+ * 7일 창에서 그 이전 발생은 ***0***이다. ⇒ 칸 이름을 모델로 갈라야 한다.
+ *
+ * ⚠️ 값을 «안 보내는» 선택은 하지 않는다 — 상한이 사라지면 비용이 조용히 는다.
+ */
+/**
+ * ⛔⭐⭐ **브랜드마다 «칸 이름」이 다르다**(2026-09-12). `makeOpenAICompatProvider` 는 `grok` 과
+ * `openai` 를 «한 경로»로 태우는데, 종전엔 둘 다 옛 칸(`max_tokens`·`temperature`)을 «생으로» 박았다.
+ * ⇒ `openai` 브랜드의 새 세대(`gpt-5`+)는 그 둘을 «거부»한다 — 400 `unsupported_parameter`.
+ *
+ * 📏 실측 2026-09-12: `gpt-6-astra · maxTokens=2048 · api.openai.com/v1/chat/completions` 가 400 을 받았고,
+ *   그 400 이 `review.done` 미실행 57건 중 ***30건***의 사유였다(무인 리뷰가 그만큼 «안 돌았다»).
+ *
+ * ⭐ 자는 «이미» 있었다 — `openAiOutputTokenField`·`openAiTemperatureField`. ***이 호출부가 안 물었을 뿐이다.***
+ * 🪞 같은 파일의 `stripLocalLlmSpec` 이 「두 builder 중 하나만 정규화했다」로 난 사고의 처방이었다.
+ *   ***같은 모양이 다시 났다*** — 그래서 이번에도 «순수 함수로 뽑아» 양쪽이 같은 자를 쓰게 한다.
+ *
+ * ⛔ grok 은 옛 칸을 그대로 받는다 — 바꾸지 않는다.
+ */
+export function openAiCompatSamplingFields(
+  brand: string,
+  model: string,
+  temperature: number,
+  maxTokens: number,
+): Record<string, number> {
+  return brand === 'openai'
+    ? { ...openAiTemperatureField(model, temperature), ...openAiOutputTokenField(model, maxTokens) }
+    : { temperature, max_tokens: maxTokens };
+}
+
+export function openAiOutputTokenField(model: string, maxTokens: number): Record<string, number> {
+  return isNewGenerationOpenAiModel(model)
+    ? { max_completion_tokens: maxTokens }
+    : { max_tokens: maxTokens };
+}
+
+/** `gpt-5` 이후 계열 판정 — 옛 Chat Completions 파라미터를 거부하는 세대.
+ *
+ *  🩸⭐⭐ **2026-09-12 — 이 자가 «늙어서» 400 이 돌아왔다.** 종전 문면은 `/^(?:gpt-5|o[1-9])/` 라
+ *  ***`gpt-6` 계열을 «못 봤다»***. 그래서 `gpt-6-astra` 가 `max_tokens` 로 나갔고 400 을 받았다:
+ *    `Unsupported parameter: 'max_tokens' is not supported with this model. Use 'max_completion_tokens'`
+ *  📏 실측(2026-09-12 · 12시간 창): `review.done` 200행 중 `reviewed=false` 57, 그중 ***30***이 이 400 이다.
+ *    ⊕ 요청 로그가 그것을 한 줄로 말한다 — `gpt-6-astra · maxTokens=2048 · api.openai.com/v1/chat/completions`.
+ *
+ *  ⇒ ⭐ **세대를 「이름 목록」으로 세지 않는다.** 번호를 «범위»로 읽어 다음 세대가 와도 안 늙게 한다.
+ *    `gpt-5` 이상(두 자리 포함) ⊕ `o1`~`o9`. ⛔ `gpt-4` 이하와 로컬 모델은 종전대로 옛 칸을 쓴다.
+ *
+ *  🌐 **외부 그라운딩**(2026-09-12 · omni-crawl `fc-dev`) — 같은 사고가 «업스트림에도» 있었다:
+ *    · `quantumnous/new-api#7211` — *"GPT-6 Astra 未命中原来的 GPT-5 前缀判断"* (똑같은 접두 판정 누락)
+ *    · `genkit-ai/genkit#6320`   — *"max_tokens is sent verbatim and rejected by reasoning models"*
+ *    · Azure AI docs            — `gpt-6-astra`(2026-09-03) Chat Completions ⊕ Reasoning
+ *    · overchat.ai              — *"Astra does not support `temperature`, `top_p`, `top_logprobs`"*
+ *      ⇒ ✅ 우리가 `temperature` 를 «생략»하는 것이 외부 사실과 «맞는다».
+ *      ⚠️ `top_p`·`logprobs` 는 이 경로가 «안 보낸다»(local 프리셋 경로만 보낸다) — 그래서 조치 없음.
+ *
+ *  ⚖️ ⛔ **알려진 트레이드오프 — new-api 는 «반대» 결론을 냈다.** 그들은
+ *    *"모든 미래 GPT 메이저를 GPT-5 로 묶으면 서로 다른 모델의 파라미터 규칙이 엮인다"* 며
+ *    ***미지의 미래 메이저는 추론하지 않는다***로 갔다(명시 목록 + 날짜 스냅샷).
+ *    ⇒ 우리는 «반대»를 택했다. 이유: ***목록이 늙어서 이 사고가 났기 때문***이다
+ *      (이 저장소에서 실제로 리뷰 미실행 30건을 냈다). 새 규칙은 «새 관례 쪽으로» 실패한다.
+ *    📌 그러므로 ***`gpt-N` 중 옛 칸을 «되찾는» 모델이 나오면 이 자가 틀린다.*** 그때는
+ *      여기서 갈지 말고 «모델별 능력 선언»으로 옮긴다(new-api 가 간 길). 지금은 그 표본이 0이다. */
+export function isNewGenerationOpenAiModel(model: string): boolean {
+  const match = /^gpt-(\d+)/i.exec(model);
+  if (match) return Number.parseInt(match[1]!, 10) >= 5;
+  return /^o[1-9]/i.test(model);
+}
+
+/**
+ * ⛔⭐ 같은 세대가 `temperature` 도 거부한다 — 400 `unsupported_value`,
+ * *"Only the default (1) value is supported"*.
+ *
+ * 📏 2026-08-22 실측: `max_tokens` 를 고친 «2분 뒤»(00:13:03Z)부터 이 400 이 났고
+ * 90분에 **41건**이었다. ⇒ ***한 파라미터만 고치면 다음 파라미터에서 막힌다.***
+ * ⚠️ 그때 나는 「수리 뒤 400 이 0건」이라 보고했는데, 그 자가 `grep max_completion_tokens`
+ * 라서 «새 400»을 못 봤다 — ***좁은 자로 「나았다」를 읽었다.***
+ *
+ * ⇒ 값을 «1로 보내지» 않고 ***칸을 생략***한다. 서버 기본이 1이고, 보내면 또 다른 거부를 부른다.
+ */
+export function openAiTemperatureField(model: string, temperature: number): Record<string, number> {
+  return isNewGenerationOpenAiModel(model) ? {} : { temperature };
+}

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

@@ -0,0 +1,61 @@
+import type { LLMProviderName } from '../user-config.js';
+
+/** Lightweight model-id family — prefix/substring only. No catalog, no
+ *  `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';
+
+export function inferRuntimeLlmModelFamily(model: string | undefined): RuntimeLlmModelFamily {
+  if (!model) return 'unknown';
+  const m = model.trim().toLowerCase();
+  if (!m) return 'unknown';
+  // ⛔ 2026-09-23 — 게이트웨이 접두가 «먼저»다. 안 그러면 `openrouter/anthropic/claude-…` 가 `anthropic` 으로
+  //   읽혀 openrouter 와 «비호환»이 되고, `openrouter/z-ai/…` 는 `unknown` 이라 아무 provider 와도 «호환»이 됐다.
+  if (m.startsWith('openrouter/')) return 'openrouter';
+  // ⭐ 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';
+  if (m.includes('grok')) return 'grok';
+  if (m.includes('claude')) return 'anthropic';
+  if (m.startsWith('gemini-') || m.includes('gemini')) return 'gemini';
+  if (m.startsWith('local:')) return 'local';
+  if (m.startsWith('kimi')) return 'kimi';
+  if (m.startsWith('qwen')) return 'qwen';
+  if (m.startsWith('glm')) return 'glm';
+  // openai-codex 구독 모델만 여기 — gpt-5.5 등 Chat Completions 모델은 openai.
+  // ⛔ openai 와 openai-codex 를 한 계열로 접지 마라. 서로 다른 엔드포인트다.
+  // ✅ 2026-09-23 (대표 ⒜ 결정) — ***`gpt-6` 를 여기 «더했다».***
+  //   종전엔 `gpt-6-*` 가 아래 `startsWith('gpt-')` 로 떨어져 `openai` 가 됐고, 그래서
+  //   ***사다리가 «자기 가드가 거부하는 모델»을 가리켰다*** (`CODEX.loaded = gpt-6-astra`).
+  //   📏 구독 경로 실호출로 확인(codex-cli 0.155.1): gpt-6-sol · luna · astra 전부 응답.
+  //   ⚠️ 이 셋은 API 로도 불린다(`/v1/models` 에 있다). 「계열」이 재는 것은 «가용성»이 아니라
+  //      ***「우리가 어느 문으로 보내나」***다 — 5.6 계열도 API 에 있지만 여기로 온다.
+  if (m.includes('codex') || m.startsWith('gpt-5.6') || m.startsWith('gpt-6')) return 'openai-codex';
+  // Exact o1/o3/o4 ids are standard OpenAI models; prefix-only (`o1-`) misses them.
+  if (
+    m.startsWith('gpt-')
+    || m === 'o1' || m.startsWith('o1-')
+    || m === 'o3' || m.startsWith('o3-')
+    || m === 'o4' || m.startsWith('o4-')
+  ) return 'openai';
+  return 'unknown';
+}
+
+/** Cycle-safe compatibility: same-provider model overrides pass;
+ *  cross-family ids fail. Unknown prefixes and `auto` stay silent.
+ *  ⛔ `openai` 와 `openai-codex` 는 별개 provider — 양방향 호환으로 접지 않는다. */
+export function isRuntimeLlmModelCompatibleWithProvider(
+  provider: LLMProviderName,
+  model: string | undefined,
+): boolean {
+  if (!model) return true;
+  if (provider === 'auto') return true;
+  const family = inferRuntimeLlmModelFamily(model);
+  if (family === 'unknown') return true;
+  if (provider === 'local') return family === 'local';
+  // bedrock 은 1st-party claude id 도 받는다(공급자가 `anthropic.` 접두로 바꿔 보낸다).
+  if (provider === 'bedrock') return family === 'bedrock' || family === 'anthropic';
+  return provider === family;
+}
+

package/src/llm/zai-coding-plan.ts

@@ -122,6 +122,26 @@ export interface ZaiErrorClass {
   resetRaw: string | null;
 }
 
+/** Provider-neutral signal shape for supervisors coordinating plan-limit recovery. */
+export interface ProviderPlanLimitSignal {
+  provider: string;
+  kind: 'plan-limit';
+  resetAt: number | null;
+  overage: string;
+}
+
+/** Extract the structured recovery signal from a Z.ai 1308 response; unrelated errors return null. */
+export function extractZaiPlanLimitSignal(
+  status: number,
+  bodyText: string,
+  overage: string,
+): ProviderPlanLimitSignal | null {
+  const classified = classifyZaiError(status, bodyText);
+  if (!classified || classified.code !== 1308 || classified.kind !== 'plan-limit') return null;
+  return { provider: 'glm', kind: 'plan-limit', resetAt: classified.resetAt, overage };
+}
+
+
 const PLAN_LIMIT = new Set([1308, 1310]);
 const BALANCE_LIMIT = new Set([1113, 1316, 1317, 1318, 1319, 1320, 1321]);
 const PLAN_UNAVAILABLE = new Set([1309, 1311, 1313, 1314, 1315]);
@@ -433,13 +453,15 @@ export class ZaiCodingPlanLimitError extends Error {
   readonly code: number;
   readonly limitKind: ZaiLimitKind;
   readonly resetAt: number | null;
-  constructor(opts: { code: number; limitKind: ZaiLimitKind; resetAt: number | null; policy: ZaiOveragePolicy; reason: string }) {
+  readonly planLimitSignal?: ProviderPlanLimitSignal;
+  constructor(opts: { code: number; limitKind: ZaiLimitKind; resetAt: number | null; policy: ZaiOveragePolicy; reason: string; planLimitSignal?: ProviderPlanLimitSignal }) {
     const when = opts.resetAt ? ` · 리셋 ${new Date(opts.resetAt).toISOString()}` : '';
     super(`GLM Coding Plan 한도(code ${opts.code} · ${opts.limitKind}${when}) — 정책 llm.zaiCodingPlan.overage=${opts.policy}: ${opts.reason}`);
     this.name = 'ZaiCodingPlanLimitError';
     this.code = opts.code;
     this.limitKind = opts.limitKind;
     this.resetAt = opts.resetAt;
+    if (opts.planLimitSignal) this.planLimitSignal = opts.planLimitSignal;
   }
 }
 
@@ -575,6 +597,9 @@ export function makeZaiCodingPlanProvider(cfg: UCLLMConfig, deps: ZaiProviderDep
           const status = (error as { status?: unknown })?.status;
           const bodyText = (error as { bodyText?: unknown })?.bodyText;
           const cls = typeof status === 'number' && typeof bodyText === 'string' ? classifyZaiError(status, bodyText) : null;
+          const planLimitSignal = typeof status === 'number' && typeof bodyText === 'string'
+            ? extractZaiPlanLimitSignal(status, bodyText, settings.overage)
+            : null;
           if (!cls || cls.kind === 'rate' || cls.kind === 'other') {
             if (cls) debug.log('zai.coding-plan', 'error', { code: cls.code, kind: cls.kind, model: wireModel }, { level: 'warn' });
             throw error;
@@ -588,6 +613,7 @@ export function makeZaiCodingPlanProvider(cfg: UCLLMConfig, deps: ZaiProviderDep
           if (action === 'stop' || emitted) {
             throw new ZaiCodingPlanLimitError({
               code: cls.code, limitKind: cls.kind, resetAt: cls.resetAt, policy: settings.overage,
+              ...(planLimitSignal ? { planLimitSignal } : {}),
               reason: emitted ? '출력이 이미 나간 뒤라 폴백하지 않는다' : '리셋까지 멈춘다',
             });
           }

package/src/llm.ts

@@ -42,6 +42,7 @@ import {
 } from './session-runtime/retry-policy.js';
 import { fetchApiWithRetry, OverloadFailoverError, type FetchApiWithRetryOpts } from './session-runtime/retry-api.js';
 import { BedrockProvider, isBedrockCompatibleModel, makeBedrockProvider } from './llm/bedrock-provider.js';
+import { OPEN_WEIGHT_TOOL_DISCIPLINE } from './llm/open-weight-discipline.js';
 import { makeZaiCodingPlanProvider, zaiCodingPlanAvailable } from './llm/zai-coding-plan.js';
 import { isOpenRouterDeepSeekWireModel, nonEmptyReasoningDetails, openRouterDeepSeekCatalogEffort, openRouterDeepSeekEffort, openRouterDeepSeekRequestExtras, openRouterNeedsKimiToolSchema } from './llm/openrouter-deepseek.js';
 import { resolveModelAlias } from './intelligence-map/model-alias.js';
@@ -5165,14 +5166,9 @@ const LOCAL_TOOL_DISCIPLINE = [
   '- 범위 읽기만으로 판단할 수 없을 때에만 전체 읽기를 선택하고, 읽은 뒤에는 다음 행동을 계속 결정하라.',
 ].join('\n');
 
-/** OpenRouter(`openrouter/…`) GLM·Kimi·Qwen 전용 도구 호출 규율 — 다른 군 상수와 합성하지 않는 독립 상수. */
-export const OPEN_WEIGHT_TOOL_DISCIPLINE = [
-  '[open-weight tool-use discipline]',
-  '- 도구로 할 수 있는 일은 이번 응답에서 바로 도구를 호출하라. "먼저 읽겠다" 또는 "확인하겠다" 같은 계획만 말하고 응답을 끝내지 마라.',
-  '- 작업을 시작하는 첫 응답에는 도구 호출이 하나 이상 있어야 한다.',
-  '- 도구 호출 인자는 해당 도구의 스키마에 맞는 JSON 으로 내라.',
-  '- 충분한 근거가 모이면 도구 호출 없이 최종 답을 평문으로 써서 끝내라.',
-].join('\n');
+// ⭐ 2026-10-11 GLM-PROMPT-TUNE: 상수 정의는 `src/llm/open-weight-discipline.ts` 로 옮겼다(llm.ts 동결 RFC #25983).
+//    llm.ts 는 이 재수출만 남긴다 — 기존 임포트 경로(`./llm.js`)를 그대로 지킨다.
+export { OPEN_WEIGHT_TOOL_DISCIPLINE };
 
 /** 모델군 → 그 군에 주입할 툴 규율(없으면 `null`). **능력 술어 판** — 2026-08-14.
  *
@@ -11703,92 +11699,16 @@ export function getProviderForConfig(
 import { getModelFamily } from './models/prompts.js';
 import type { ModelFamily } from './models/prompts.js';
 
-/**
- * ⛔⭐ OpenAI Chat Completions 의 «출력 상한» 칸 이름은 모델 세대로 갈린다.
- *
- * `gpt-5` 이후 계열은 `max_tokens` 를 ***거부한다*** — 400 `unsupported_parameter` 를 내고
- * *"Use 'max_completion_tokens' instead"* 라고 말한다. `gpt-4o` 계열은 반대로 옛 이름만 받는다.
- *
- * 📏 2026-08-22 실측: `provider auto` 의 티어 사다리가 `gpt-5.6-*` 로 바뀐 뒤(`#11161`)
- * 3시간 만에 이 400 이 **93건** 났고 «가속»했다(20h:2 → 21h:16 → 22h:30 → 23h:45).
- * 7일 창에서 그 이전 발생은 ***0***이다. ⇒ 칸 이름을 모델로 갈라야 한다.
- *
- * ⚠️ 값을 «안 보내는» 선택은 하지 않는다 — 상한이 사라지면 비용이 조용히 는다.
- */
-/**
- * ⛔⭐⭐ **브랜드마다 «칸 이름」이 다르다**(2026-09-12). `makeOpenAICompatProvider` 는 `grok` 과
- * `openai` 를 «한 경로»로 태우는데, 종전엔 둘 다 옛 칸(`max_tokens`·`temperature`)을 «생으로» 박았다.
- * ⇒ `openai` 브랜드의 새 세대(`gpt-5`+)는 그 둘을 «거부»한다 — 400 `unsupported_parameter`.
- *
- * 📏 실측 2026-09-12: `gpt-6-astra · maxTokens=2048 · api.openai.com/v1/chat/completions` 가 400 을 받았고,
- *   그 400 이 `review.done` 미실행 57건 중 ***30건***의 사유였다(무인 리뷰가 그만큼 «안 돌았다»).
- *
- * ⭐ 자는 «이미» 있었다 — `openAiOutputTokenField`·`openAiTemperatureField`. ***이 호출부가 안 물었을 뿐이다.***
- * 🪞 같은 파일의 `stripLocalLlmSpec` 이 「두 builder 중 하나만 정규화했다」로 난 사고의 처방이었다.
- *   ***같은 모양이 다시 났다*** — 그래서 이번에도 «순수 함수로 뽑아» 양쪽이 같은 자를 쓰게 한다.
- *
- * ⛔ grok 은 옛 칸을 그대로 받는다 — 바꾸지 않는다.
- */
-export function openAiCompatSamplingFields(
-  brand: string,
-  model: string,
-  temperature: number,
-  maxTokens: number,
-): Record<string, number> {
-  return brand === 'openai'
-    ? { ...openAiTemperatureField(model, temperature), ...openAiOutputTokenField(model, maxTokens) }
-    : { temperature, max_tokens: maxTokens };
-}
-
-export function openAiOutputTokenField(model: string, maxTokens: number): Record<string, number> {
-  return isNewGenerationOpenAiModel(model)
-    ? { max_completion_tokens: maxTokens }
-    : { max_tokens: maxTokens };
-}
-
-/** `gpt-5` 이후 계열 판정 — 옛 Chat Completions 파라미터를 거부하는 세대.
- *
- *  🩸⭐⭐ **2026-09-12 — 이 자가 «늙어서» 400 이 돌아왔다.** 종전 문면은 `/^(?:gpt-5|o[1-9])/` 라
- *  ***`gpt-6` 계열을 «못 봤다»***. 그래서 `gpt-6-astra` 가 `max_tokens` 로 나갔고 400 을 받았다:
- *    `Unsupported parameter: 'max_tokens' is not supported with this model. Use 'max_completion_tokens'`
- *  📏 실측(2026-09-12 · 12시간 창): `review.done` 200행 중 `reviewed=false` 57, 그중 ***30***이 이 400 이다.
- *    ⊕ 요청 로그가 그것을 한 줄로 말한다 — `gpt-6-astra · maxTokens=2048 · api.openai.com/v1/chat/completions`.
- *
- *  ⇒ ⭐ **세대를 「이름 목록」으로 세지 않는다.** 번호를 «범위»로 읽어 다음 세대가 와도 안 늙게 한다.
- *    `gpt-5` 이상(두 자리 포함) ⊕ `o1`~`o9`. ⛔ `gpt-4` 이하와 로컬 모델은 종전대로 옛 칸을 쓴다.
- *
- *  🌐 **외부 그라운딩**(2026-09-12 · omni-crawl `fc-dev`) — 같은 사고가 «업스트림에도» 있었다:
- *    · `quantumnous/new-api#7211` — *"GPT-6 Astra 未命中原来的 GPT-5 前缀判断"* (똑같은 접두 판정 누락)
- *    · `genkit-ai/genkit#6320`   — *"max_tokens is sent verbatim and rejected by reasoning models"*
- *    · Azure AI docs            — `gpt-6-astra`(2026-09-03) Chat Completions ⊕ Reasoning
- *    · overchat.ai              — *"Astra does not support `temperature`, `top_p`, `top_logprobs`"*
- *      ⇒ ✅ 우리가 `temperature` 를 «생략»하는 것이 외부 사실과 «맞는다».
- *      ⚠️ `top_p`·`logprobs` 는 이 경로가 «안 보낸다»(local 프리셋 경로만 보낸다) — 그래서 조치 없음.
- *
- *  ⚖️ ⛔ **알려진 트레이드오프 — new-api 는 «반대» 결론을 냈다.** 그들은
- *    *"모든 미래 GPT 메이저를 GPT-5 로 묶으면 서로 다른 모델의 파라미터 규칙이 엮인다"* 며
- *    ***미지의 미래 메이저는 추론하지 않는다***로 갔다(명시 목록 + 날짜 스냅샷).
- *    ⇒ 우리는 «반대»를 택했다. 이유: ***목록이 늙어서 이 사고가 났기 때문***이다
- *      (이 저장소에서 실제로 리뷰 미실행 30건을 냈다). 새 규칙은 «새 관례 쪽으로» 실패한다.
- *    📌 그러므로 ***`gpt-N` 중 옛 칸을 «되찾는» 모델이 나오면 이 자가 틀린다.*** 그때는
- *      여기서 갈지 말고 «모델별 능력 선언»으로 옮긴다(new-api 가 간 길). 지금은 그 표본이 0이다. */
-export function isNewGenerationOpenAiModel(model: string): boolean {
-  const match = /^gpt-(\d+)/i.exec(model);
-  if (match) return Number.parseInt(match[1]!, 10) >= 5;
-  return /^o[1-9]/i.test(model);
-}
-
-/**
- * ⛔⭐ 같은 세대가 `temperature` 도 거부한다 — 400 `unsupported_value`,
- * *"Only the default (1) value is supported"*.
- *
- * 📏 2026-08-22 실측: `max_tokens` 를 고친 «2분 뒤»(00:13:03Z)부터 이 400 이 났고
- * 90분에 **41건**이었다. ⇒ ***한 파라미터만 고치면 다음 파라미터에서 막힌다.***
- * ⚠️ 그때 나는 「수리 뒤 400 이 0건」이라 보고했는데, 그 자가 `grep max_completion_tokens`
- * 라서 «새 400»을 못 봤다 — ***좁은 자로 「나았다」를 읽었다.***
- *
- * ⇒ 값을 «1로 보내지» 않고 ***칸을 생략***한다. 서버 기본이 1이고, 보내면 또 다른 거부를 부른다.
- */
-export function openAiTemperatureField(model: string, temperature: number): Record<string, number> {
-  return isNewGenerationOpenAiModel(model) ? {} : { temperature };
-}
+// COMPAT(llm-facade-openai-sampling-fields) · 기존 llm.ts 공개 API 유지.
+import {
+  openAiCompatSamplingFields,
+  openAiOutputTokenField,
+  isNewGenerationOpenAiModel,
+  openAiTemperatureField,
+} from './llm/openai-sampling-fields.js';
+export {
+  openAiCompatSamplingFields,
+  openAiOutputTokenField,
+  isNewGenerationOpenAiModel,
+  openAiTemperatureField,
+};

package/src/machines/machine-ledger.ts

@@ -10,6 +10,16 @@ export interface MachineRow {
   locationStatus: string;
   role: string;
   duties: string;
+  /** Fleet intent only. Live membership comes from Nexus machine resources. */
+  fleet?: MachineFleetIntent;
+}
+
+export interface MachineFleetIntent {
+  sshName: string;
+  role: 'worker' | 'hq';
+  platform: 'darwin' | 'linux' | 'wsl';
+  podPool: string;
+  cap: number;
 }
 
 export interface DeviceRow {
@@ -59,18 +69,36 @@ export function validateMachineLedger(value: unknown): MachineLedger {
   keys(data, ['title', 'policy', 'machines', 'devices', 'rules', 'changes'], 'ledger');
   if (!Array.isArray(data.machines) || !Array.isArray(data.devices)) throw new Error('invalid machines or devices');
   const ids = new Set<string>();
-  const rows = <T extends { id: string }>(entries: unknown[], fields: string[], label: string): T[] => entries.map((entry, index) => {
+  const rows = <T extends { id: string }>(entries: unknown[], fields: string[], label: string, extraFields: string[] = []): T[] => entries.map((entry, index) => {
     const row = record(entry, `${label}[${index}]`);
-    keys(row, fields, label);
+    keys(row, [...fields, ...extraFields], label);
     const result = Object.fromEntries(fields.map((field) => [field, text(row[field], `${label}.${field}`)])) as T;
     if (!idPattern.test(result.id) || ids.has(result.id)) throw new Error(`empty, duplicate or invalid id: ${result.id}`);
     ids.add(result.id);
     return result;
   });
+  const machines = rows<MachineRow>(data.machines, ['id', 'name', 'specs', 'locationStatus', 'role', 'duties'], 'machines', ['fleet']);
+  const sshNames = new Set<string>();
+  for (let index = 0; index < machines.length; index++) {
+    const raw = record(data.machines[index], `machines[${index}]`);
+    if (raw.fleet === undefined) continue;
+    const fleet = record(raw.fleet, `machines[${index}].fleet`);
+    keys(fleet, ['sshName', 'role', 'platform', 'podPool', 'cap'], 'fleet');
+    const sshName = text(fleet.sshName, 'fleet.sshName');
+    const role = text(fleet.role, 'fleet.role');
+    const platform = text(fleet.platform, 'fleet.platform');
+    const podPool = text(fleet.podPool, 'fleet.podPool');
+    if (!idPattern.test(sshName) || sshNames.has(sshName)) throw new Error(`duplicate or invalid fleet.sshName: ${sshName}`);
+    if (role !== 'worker' && role !== 'hq') throw new Error(`invalid fleet.role: ${role}`);
+    if (platform !== 'darwin' && platform !== 'linux' && platform !== 'wsl') throw new Error(`invalid fleet.platform: ${platform}`);
+    if (!Number.isSafeInteger(fleet.cap) || (fleet.cap as number) < 0) throw new Error('invalid fleet.cap');
+    sshNames.add(sshName);
+    machines[index]!.fleet = { sshName, role, platform, podPool, cap: fleet.cap as number };
+  }
   return {
     title: text(data.title, 'title'),
     policy: list(data.policy, 'policy'),
-    machines: rows<MachineRow>(data.machines, ['id', 'name', 'specs', 'locationStatus', 'role', 'duties'], 'machines'),
+    machines,
     devices: rows<DeviceRow>(data.devices, ['id', 'name', 'status', 'purpose'], 'devices'),
     rules: list(data.rules, 'rules'),
     changes: list(data.changes, 'changes'),