elanous 0.2.23 → 0.2.24

package/src/llm.ts

@@ -21,6 +21,7 @@ import {
 } from './config.js';
 import { debug, redactSecrets, redactSecretText } from './debug/log.js';
 import { llmUsageCostFields } from './budget/llm-cost.js';
+import { accumulateByokUsage } from './llm/openrouter-byok-cost.js';
 import { ToolCallTiming } from './chat/tool-call-timing.js';
 import {
   dispatchWithParallelSafety,
@@ -41,6 +42,8 @@ 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 { 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';
 import { BUILTIN_CATALOG, reasoningEffortCeiling as reasoningEffortCeilingOf } from './intelligence-map/model-catalog.js';
 import { inferProviderFromModel as registryInferProviderFromModel } from './registry/normalize.js';
@@ -94,7 +97,8 @@ export interface ProviderToolMeta { thoughtSignature?: string; reasoningDetails?
 export interface ToolArgsInvalid { chars: number; finishReason: string | null }
 
 export type ContentBlock =
-  | { type: 'text';  text: string }
+  /** `providerMeta` — OR-DEEPSEEK-TUNE: OpenRouter deepseek/* 의 «도구 없는» assistant 턴 추론(reasoning_details) 운반. 다른 경로는 안 싣는다. */
+  | { type: 'text';  text: string; providerMeta?: ProviderToolMeta }
   | { type: 'image'; mediaType: string; base64: string }
   | { type: 'audio'; mediaType: string; base64: string }
   | { type: 'video'; mediaType: string; base64: string }
@@ -318,7 +322,9 @@ export type LLMStreamEvent =
       source?: string;
       revisedPrompt?: string;
     }
-  | { type: 'usage'; usage: import('./prompt-cache/types.js').LLMUsage };
+  | { type: 'usage'; usage: import('./prompt-cache/types.js').LLMUsage }
+  /** OR-DEEPSEEK-TUNE — 도구 호출이 없는 턴의 OpenRouter `reasoning_details`(스트림 끝에 한 번). deepseek/* 에서만 나온다. */
+  | { type: 'reasoning_details'; details: Array<Record<string, unknown>> };
 
 /** Tool-calling forcing (opencode parity · 2026-07-09). `'auto'` (default) lets
  *  the model decide; `'required'` forces at least one tool call; `'none'` blocks
@@ -338,6 +344,8 @@ export interface LLMOpts {
   onUsage?(usage: LLMUsage): void;
   /** Optional model role attached to this request's usage observation. */
   usageRole?: ModelRole;
+  /** Optional streamLLM usage-ledger site override (defaults to "stream-llm"). */
+  usageSite?: string;
   /**
    * ⭐⭐⭐ `B3`(2026-08-19 · 대표 지시 ②) — ***턴 «안»으로 들어오는 사용자 발화의 배수구.***
    *
@@ -473,6 +481,8 @@ export interface ToOpenAIMessagesOpts {
   acceptUserMessageImages?: boolean;
   /** OpenRouter 전용 — 도구 호출이 든 어시스턴트 메시지에 `reasoning_details` 를 되돌린다. 다른 제공자엔 안 싣는다(모르는 칸 400 방지). */
   echoReasoningDetails?: boolean;
+  /** OR-DEEPSEEK-TUNE — deepseek/* 만: 도구 없는 assistant 턴에도 되돌리고, 빈 조각은 걷는다(`src/llm/openrouter-deepseek.ts`). */
+  deepSeekReplay?: boolean;
 }
 
 /**
@@ -561,9 +571,10 @@ function toOpenAIMessages(
       .filter((b): b is Extract<ContentBlock, { type: 'text' }> => b.type === 'text')
       .map(b => b.text)
       .join('');
-    const reasoningDetails = opts.echoReasoningDetails
+    const foundDetails = opts.echoReasoningDetails
       ? toolUses.find((t) => t.providerMeta?.reasoningDetails?.length)?.providerMeta?.reasoningDetails
       : undefined;
+    const reasoningDetails = opts.deepSeekReplay ? nonEmptyReasoningDetails(foundDetails) : foundDetails;
     return [{
       role: m.role,
       content: textContent || null,
@@ -589,8 +600,12 @@ function toOpenAIMessages(
   // Composer Q3=B is the primary handler; this is the wire-side
   // defensive fallback for non-vision OpenAI / Grok / local routes.
   const acceptUserImages = opts.acceptUserMessageImages ?? true;
+  const textTurnDetails = opts.deepSeekReplay && m.role === 'assistant'
+    ? nonEmptyReasoningDetails(blocks.find((b): b is Extract<ContentBlock, { type: 'text' }> => b.type === 'text' && !!b.providerMeta?.reasoningDetails?.length)?.providerMeta?.reasoningDetails)
+    : undefined;
   return [{
     role: m.role,
+    ...(textTurnDetails ? { reasoning_details: textTurnDetails } : {}),
     content: blocks.map(block => {
       if (block.type === 'text') return { type: 'text', text: block.text };
       if (block.type === 'image') {
@@ -1126,7 +1141,7 @@ export async function* parseOpenAISSELines(
   /** OR-TOOLARGS-REPAIR (2026-10-10) — `flagInvalidToolArgs` 가 참이면(OpenRouter 경로) 인자 JSON 파싱 실패를
    *  `{}` 로 «조용히» 바꾸지 않고 `argsInvalid` 표지를 단다(도구 루프가 실행을 막는다) ⊕ 관측을 남긴다.
    *  ⛔ 생략·거짓이면 종전과 바이트 동일(다른 공급자 무변경). */
-  parseOpts: { flagInvalidToolArgs?: boolean } = {},
+  parseOpts: { flagInvalidToolArgs?: boolean; emitTrailingReasoningDetails?: boolean } = {},
 ): AsyncGenerator<LLMStreamEvent, void, unknown> {
   const flagInvalidToolArgs = parseOpts.flagInvalidToolArgs === true;
   const { parseOpenAIUsage } = await import('./prompt-cache/openai.js');
@@ -1352,6 +1367,11 @@ export async function* parseOpenAISSELines(
     yield { type: 'reasoning', kind: 'inline_delta', delta: tail.reasoningDelta };
   }
   yield* emitHarmonyTools(tail.toolCalls);
+  // OR-DEEPSEEK-TUNE — 도구 호출에 실리지 못한 추론(텍스트만 낸 턴)을 끝에 한 번 낸다. deepseek/* 만 켠다.
+  if (parseOpts.emitTrailingReasoningDetails) {
+    const details = takeReasoningDetails();
+    if (details) yield { type: 'reasoning_details', details };
+  }
 }
 
 /** Pick a stable provider name for `fetchApiWithRetry` telemetry from
@@ -1430,7 +1450,8 @@ async function* streamOpenAIEvents(
   try {
     // OR-TOOLARGS-REPAIR — 깨진 도구 인자 표지는 OpenRouter 엔드포인트에서만 켠다(다른 공급자 무변경).
     const flagInvalidToolArgs = inferOpenAIProviderName(url) === 'openrouter';
-    for await (const ev of parseOpenAISSELines(sseLineStream(response.body!), flagInvalidToolArgs ? { flagInvalidToolArgs } : {})) {
+    const emitTrailingReasoningDetails = flagInvalidToolArgs && typeof body?.model === 'string' && isOpenRouterDeepSeekWireModel(body.model);
+    for await (const ev of parseOpenAISSELines(sseLineStream(response.body!), flagInvalidToolArgs ? { flagInvalidToolArgs, ...(emitTrailingReasoningDetails ? { emitTrailingReasoningDetails } : {}) } : {})) {
       if (ev.type === 'text') textChars += ev.delta.length;
       else if (ev.type === 'tool_call') toolCalls++;
       yield ev;
@@ -4294,6 +4315,26 @@ function finalizeStreamingProviderModel(provider: LLMProvider, model: string): {
   return { provider: finalizedProvider, model: finalized.model };
 }
 
+/** ZAI-POD-CHILD(10-11 실측 · si-task-aaf5d691e4ed) — 레지스트리는 `glm-` 접두를 local 로 본다.
+ *  활성 provider 가 `glm`(`ELANOUS_LLM_PROVIDER=glm` 포함)일 때 모델 이름으로 provider 를 고르는 길
+ *  (gate 진단·리뷰 `getProvider(model)`)이 local 로 떨어져 «Local LLM unavailable» 로 죽었다.
+ *  ⇒ 그때만 설정 경로(`getProviderForConfig`)를 탄다 — 키가 있으면 Z.ai 공급자, 없으면 OpenRouter 안내 오류.
+ *  활성 provider 가 glm 이 아니면 undefined(종전 그대로). */
+function activeGlmProviderForModel(model: string): LLMProvider | undefined {
+  if (!model.trim().toLowerCase().startsWith('glm-')) return undefined;
+  let cfg: UserConfig;
+  try {
+    const { getUserConfig } = require('./user-config.js') as typeof import('./user-config.js');
+    cfg = getUserConfig();
+  } catch (e) {
+    debug.log('llm.router', 'getProvider.glm-config-unreadable', { requestedModel: model, error: e instanceof Error ? e.message : String(e) }, { level: 'warn' });
+    return undefined;
+  }
+  if (cfg.llm.provider !== 'glm') return undefined;
+  debug.log('llm.router', 'getProvider.glm-active', { requestedModel: model }, { level: 'info' });
+  return getProviderForConfig(cfg, model);
+}
+
 /**
  * Pick a provider based on the model name. If model is undefined, use first
  * available provider (preferring DEFAULT_PROVIDER env var if set).
@@ -4305,6 +4346,8 @@ export function getProvider(model?: string): LLMProvider {
     // ids (e.g. `claude-opus-4-7`) so prefix matching works. Existing
     // full ids pass through unchanged.
     const resolved = resolveModelAlias(model) ?? model;
+    const glmDirect = activeGlmProviderForModel(resolved);
+    if (glmDirect) return glmDirect;
     // Preserve the historical Chat Completions route for gpt-* model-only
     // requests, including future ids that the current catalog does not list.
     if (resolved.toLowerCase().startsWith('gpt-')) return PROVIDERS.openai!;
@@ -4443,6 +4486,7 @@ export function buildMessagesWithContext(
 // Re-export converters so tests/adapters can assert wire-format correctness.
 export { toOpenAIMessage, toOpenAIMessages, toAnthropicMessage, systemToAnthropicString };
 export { usesAdaptiveThinking, mapReasoningLevelToAnthropicThinking, mapReasoningLevelToAnthropicEffort, sseLineStream, retryOptsFor }; // src/llm/bedrock-provider.ts
+export { makeOpenAICompatProvider, makeOpenRouterProvider }; // src/llm/zai-coding-plan.ts
 
 /**
  * Best-effort classification of whether a model accepts image inputs.
@@ -4502,7 +4546,7 @@ export function isLikelyVisionModel(model: string | undefined): boolean {
 // ⭐ OPENROUTER-OPTIMIZE G9 — `reportedCostUsd`(OpenRouter `usage.cost`)도 싣는다. 빠지면 `stream-llm` 행이
 //   실청구액을 잃고 카탈로그 추정(대개 `cost.kind=unknown`)으로 떨어진다(리뷰·저작 행 실측).
 //   합산은 토큰 칸과 같은 규약이다 — OpenAI 호환 스트림은 `usage` 를 마지막 청크에 «한 번» 싣는다(누적 반복 보고 아님).
-type ObservedUsage = Pick<LLMUsage, 'inputTokens' | 'outputTokens' | 'cacheReadInputTokens' | 'cacheCreationInputTokens' | 'reportedCostUsd'>;
+type ObservedUsage = Pick<LLMUsage, 'inputTokens' | 'outputTokens' | 'cacheReadInputTokens' | 'cacheCreationInputTokens' | 'reportedCostUsd' | 'byok' | 'upstreamCostUsd'>;
 
 type ProviderTextResult =
   | { ok: true; full: string; usage: ObservedUsage | 'unmeasured' }
@@ -4513,7 +4557,7 @@ function accumulateUsage(usage: ObservedUsage | undefined, received: LLMUsage):
   for (const field of ['inputTokens', 'outputTokens', 'cacheReadInputTokens', 'cacheCreationInputTokens', 'reportedCostUsd'] as const) {
     if (received[field] !== undefined) total[field] = (total[field] ?? 0) + received[field];
   }
-  return total;
+  return accumulateByokUsage(total, received); // OR-BYOK-COST
 }
 
 async function consumeProviderText(
@@ -4637,7 +4681,7 @@ export async function streamLLM(
     if (consumed.ok) {
       if (consumed.usage !== 'unmeasured') {
         try {
-          logAgentTurnUsage(activeModel, consumed.usage, { providerName: activeProvider.name, site: 'stream-llm', role: opts.usageRole });
+          logAgentTurnUsage(activeModel, consumed.usage, { providerName: activeProvider.name, site: opts.usageSite ?? 'stream-llm', role: opts.usageRole });
         } catch { /* best-effort observation */ }
       }
       debug.log('llm', 'outcome', { provider: activeProvider.name, status: 'ok', kind: 'streamLLM', durationMs: Date.now() - started });
@@ -8214,11 +8258,16 @@ export async function streamLLMWithTools(
       },
     };
   }
+  // OR-DEEPSEEK-TUNE — 마지막 턴의 «도구 없는» 추론(deepseek/* 만 채워진다). 매 턴 시작에 비운다.
+  let turnReasoningDetails: Array<Record<string, unknown>> | undefined;
   const emitTurnComplete = (finalAssistantText?: string): void => {
     if (finalAssistantText && finalAssistantText.length > 0) {
       history.push({
         role: 'assistant',
-        content: [{ type: 'text', text: finalAssistantText }],
+        content: [{
+          type: 'text', text: finalAssistantText,
+          ...(turnReasoningDetails ? { providerMeta: { reasoningDetails: turnReasoningDetails } } : {}),
+        }],
       });
     }
     handlers.onTurnComplete?.(history.slice(initialHistoryLen));
@@ -8427,6 +8476,7 @@ export async function streamLLMWithTools(
       }
     }
     let turnText = '';
+    turnReasoningDetails = undefined;
     const pendingCalls: Array<{
       id: string;
       name: string;
@@ -8642,6 +8692,8 @@ export async function streamLLMWithTools(
         turnText += ev.delta;
         fullText += ev.delta;
         handlers.onText(ev.delta, fullText);
+      } else if (ev.type === 'reasoning_details') {
+        turnReasoningDetails = ev.details;
       } else if (ev.type === 'tool_call') {
         pendingCalls.push({
           id: ev.id,
@@ -10938,7 +10990,8 @@ function makeOpenAICompatProvider(
         throw new Error(`${name} unavailable: configure apiKey via \`elanous setup\``);
       }
       const activeModel = opts.model || model;
-      const tools = toOpenAITools(opts.tools, name === 'openrouter' && openRouterWireModel(activeModel).startsWith('moonshotai/'));
+      const tools = toOpenAITools(opts.tools, name === 'openrouter' && openRouterNeedsKimiToolSchema(openRouterWireModel(activeModel)));
+      const deepSeek = name === 'openrouter' && isOpenRouterDeepSeekWireModel(openRouterWireModel(activeModel));
       // OR-TOOLCHOICE-PASS (2026-10-10) — OpenRouter 경로만 호출자 toolChoice 를 싣는다.
       //   ⛔ grok/openai 호환 경로는 손대지 않는다(무회귀). toolChoice 가 없거나 tools 가 없으면 키 자체를 안 싣는다.
       const toolChoice = name === 'openrouter' && tools
@@ -10967,7 +11020,11 @@ function makeOpenAICompatProvider(
         acceptToolImagesViaFollowup: followup,
         acceptUserMessageImages: followup,
         ...(name === 'openrouter' ? { echoReasoningDetails: true } : {}),
+        ...(deepSeek ? { deepSeekReplay: true } : {}),
       }));
+      // OR-DEEPSEEK-TUNE — deepseek/* 만: 설정 기본값의 상류 고정(명시 라우팅이 없을 때) ⊕ 관측 `deepseek-replay`.
+      const deepSeekProvider = deepSeek ? openRouterDeepSeekRequestExtras(openRouterWireModel(activeModel), wireMessages,
+        (wire.extraBody as { provider?: unknown } | undefined)?.provider, cfg.openrouter?.providerPreferences, cfg.openrouter?.upstreamPins) : {};
       // OR-ANTHROPIC-CACHE (2026-10-10) — OpenRouter 뒤 anthropic/* · moonshotai/* 만 cache_control 중단점을 싣는다.
       //   ⛔ 다른 OpenRouter 모델과 grok/openai/local 호환 경로는 이 분기를 안 탄다 — 본문 바이트 동일(무회귀).
       const cacheFamily = name === 'openrouter' ? openRouterPromptCacheFamily(openRouterWireModel(activeModel)) : null;
@@ -11013,6 +11070,7 @@ function makeOpenAICompatProvider(
           ...(tools ? { tools } : {}),
           ...(toolChoice !== undefined ? { tool_choice: toolChoice } : {}),
           ...(wire.extraBody ?? {}),
+          ...deepSeekProvider,
           // OpenRouter alone resolves per-call effort against the configured level and catalog default.
           ...(name === 'openrouter'
             ? openRouterReasoningField(activeModel, opts.reasoningEffort, cfg.reasoningLevel)
@@ -11112,7 +11170,7 @@ const OPENROUTER_REASONING_EFFORT: Record<string, 'low' | 'medium' | 'high'> = {
 };
 function openRouterReasoningField(
   model: string, requested: string | undefined, configured: UCLLMConfig['reasoningLevel'],
-): { reasoning?: { effort: 'low' | 'medium' | 'high' }; verbosity?: 'low' | 'medium' | 'high' } {
+): { reasoning?: { effort: 'low' | 'medium' | 'high' | 'xhigh' }; verbosity?: 'low' | 'medium' | 'high' } {
   const wireModel = openRouterWireModel(model);
   // The catalog's model-specific open-weight verdict, not a vendor/slug prefix,
   // gates the default: an unregistered release may be closed-weight.
@@ -11121,13 +11179,18 @@ function openRouterReasoningField(
     (entry) => entry.id === slug && entry.openWeight === true,
   );
   const configEffort = configured === 'off' ? undefined : configured;
-  const source = requested !== undefined ? 'call' : configured !== undefined ? 'config' : openWeight ? 'default' : 'none';
-  const effort = requested ?? (configured !== undefined ? configEffort : openWeight ? 'medium' : undefined);
-  const sent = effort !== undefined && Object.hasOwn(OPENROUTER_REASONING_EFFORT, effort)
-    ? OPENROUTER_REASONING_EFFORT[effort] : undefined;
+  // OR-DEEPSEEK-TUNE — deepseek/* 의 기본은 카탈로그 손 레코드(YAML `reasoning`) · 없으면 아래 기존 폴백.
+  const catalogEffort = requested === undefined && configured === undefined ? openRouterDeepSeekCatalogEffort(model) : undefined;
+  const source = requested !== undefined ? 'call' : configured !== undefined ? 'config' : catalogEffort ? 'catalog' : openWeight ? 'default' : 'none';
+  const effort = requested ?? (configured !== undefined ? configEffort : catalogEffort ?? (openWeight ? 'medium' : undefined));
+  // OR-DEEPSEEK-TUNE — DeepSeek V4 는 자기 표(xhigh·max→xhigh · off→칸 없음 · src/llm/openrouter-deepseek.ts).
+  const deepSeekEffort = openRouterDeepSeekEffort(wireModel, effort);
+  const sent = deepSeekEffort !== undefined ? (deepSeekEffort ?? undefined)
+    : effort !== undefined && Object.hasOwn(OPENROUTER_REASONING_EFFORT, effort)
+      ? OPENROUTER_REASONING_EFFORT[effort] : undefined;
   const field = sent ? (wireModel.startsWith('anthropic/') ? 'verbosity' : 'reasoning') : 'none';
   debug.log('llm.openrouter', 'reasoning', { model, requested: requested ?? null, sent: sent ?? null, source, field });
-  return field === 'verbosity' ? { verbosity: sent }
+  return field === 'verbosity' ? { verbosity: sent as 'low' | 'medium' | 'high' }
     : field === 'reasoning' ? { reasoning: { effort: sent! } } : {};
 }
 
@@ -11532,8 +11595,16 @@ export function getProviderForConfig(
   model?: string,
 ): LLMProvider {
   const { provider } = userConfig.llm;
+  // CLAUDE-IMPL-LANE(10-11) — `claude-acp` 는 LLM provider 가 아니라 구독 ACP 구현 실행기 선택이다.
+  //   여기서 풀리면 모델 이름(claude-…)이 anthropic(API 키 provider)으로 넘어가 «구독» 런이 API 로 과금된다 → 거부.
+  //   구현은 implement seam 의 claude-acp 갈래(src/self-implement/claude-acp-implement.ts)만 쓴다.
+  if ((provider as string) === 'claude-acp') {
+    throw new Error('claude-acp 는 LLM provider 가 아니다 — 구독 ACP 구현 레인 전용(src/self-implement/claude-acp-implement.ts) · API provider 로 풀지 않는다');
+  }
   // ⛔ 2026-09-23 — `kimi`·`qwen`·`glm` 은 union·사다리에 있지만 «직결» 배선이 없다(사다리 `wip`).
   //   종전엔 `unknown provider: kimi` 로 «아무것도» 안 말하고 죽었다. 이제 실제로 도는 길이 있다(`openrouter`).
+  // ZAI-CODING-PLAN-PROVIDER(대표 10-11) — `ZAI_API_KEY` 가 있을 때만 glm 직결. 없으면 아래 안내 그대로(src/llm/zai-coding-plan.ts).
+  if (provider === 'glm' && zaiCodingPlanAvailable()) return makeZaiCodingPlanProvider({ ...userConfig.llm, model: model || userConfig.llm.model });
   const direct = OPENROUTER_ROUTE_FOR_WIP_PROVIDER[provider as keyof typeof OPENROUTER_ROUTE_FOR_WIP_PROVIDER];
   if (direct) {
     throw new Error(

package/src/loops/checker.ts

@@ -1,12 +1,13 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
 import { Database } from 'bun:sqlite';
 import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import * as registry from './registry.js';
 import { cronMatches } from '../domains/cron-match.js';
 import { resolveTimeZone } from '../time/format.js';
+import type { ScheduleRow } from '../domains/schedule-registry.js';
 import type { LoopEntry, LoopRun } from './registry.js';
 
 type LoopState = 'off' | 'unregistered' | 'failing' | 'late' | 'unknown' | 'alive';
@@ -23,6 +24,15 @@ export interface CheckEntry {
   lastRunAt?: string;
   lastStatus?: string;
   recentStatuses?: string[];
+  /** Inventory sighting of the scheduled registration (schedule-registry `last_seen`, refreshed on each inventory — not the first sighting); never represented as an execution. */
+  observedSince?: string;
+  /** Optional launcher evidence; absent values are not inferred from a missing heartbeat. */
+  health?: 'healthy' | 'degraded';
+  endsAt?: string;
+  installedVersion?: string;
+  expectedVersion?: string;
+  /** Registry graph path, supplied only by graph inventory. */
+  file?: string;
   enabled: boolean;
   registered: boolean;
 }
@@ -59,6 +69,110 @@ export function checkLoops(entries: CheckEntry[], now: Date, opts: { failureStat
   });
 }
 
+export type ScheduleFinding = { id: string; owner?: string; kind: 'late' | 'failing' | 'degraded' | 'end-expired' | 'version-mismatch'; reason: string; lastRunAt?: string };
+
+/** Additional scheduler evidence is evaluated only when supplied; the six-state CLI contract stays intact. */
+export function scheduleFindings(results: CheckResult[], now: Date): ScheduleFinding[] {
+  const findings: ScheduleFinding[] = [];
+  for (const row of results) {
+    if (!row.enabled || !row.registered) continue;
+    const common = { id: row.id, ...(row.owner ? { owner: row.owner } : {}),
+      ...(row.lastRunAt ? { lastRunAt: row.lastRunAt } : {}) };
+    if (row.state === 'late' || row.state === 'failing') findings.push({ ...common, kind: row.state, reason: row.reason });
+    else if (row.state === 'unknown' && !row.lastRunAt && row.observedSince && row.dueAt &&
+        Number.isFinite(Date.parse(row.observedSince)) && Number.isFinite(Date.parse(row.dueAt)) &&
+        Date.parse(row.observedSince) < Date.parse(row.dueAt))
+      findings.push({ ...common, kind: 'late', reason: `no run since observed registration ${row.observedSince}` });
+    if (row.health === 'degraded') findings.push({ ...common, kind: 'degraded', reason: 'launcher degraded' });
+    if (row.endsAt && Number.isFinite(Date.parse(row.endsAt)) && Date.parse(row.endsAt) <= now.getTime())
+      findings.push({ ...common, kind: 'end-expired', reason: `launcher ended at ${row.endsAt}` });
+    if (row.installedVersion && row.expectedVersion && row.installedVersion !== row.expectedVersion)
+      findings.push({ ...common, kind: 'version-mismatch', reason: `installed ${row.installedVersion}; expected ${row.expectedVersion}` });
+  }
+  return findings;
+}
+
+export function daemonScheduleEntries(rows: readonly ScheduleRow[], now: Date): CheckEntry[] {
+  return rows.filter(row => row.enabled && row.cron && (row.run_via === 'elanous' || row.run_via === 'trigger'))
+    .map(row => ({ id: row.id, owner: 'OP', enabled: true, registered: true, dueAt: dueBefore(row.cron!, now) ?? undefined,
+      ...(row.last_seen ? { observedSince: row.last_seen } : {}),
+      ...(row.last_run ? { lastRunAt: row.last_run } : {}),
+      ...(row.last_status ? { lastStatus: row.last_status, recentStatuses: [row.last_status] } : {}),
+    }));
+}
+
+export function versionEvidence(entries: CheckEntry[], repoRoot: string, stateRoot: string): CheckEntry[] {
+  return entries.map(entry => {
+    if (!entry.file || !/^[\w./-]+\.ya?ml$/.test(entry.file) || entry.file.split('/').includes('..')) return entry;
+    const graphPath = resolve(repoRoot, entry.file);
+    if (!graphPath.startsWith(resolve(repoRoot) + '/')) return entry;
+    const runsPath = join(stateRoot, 'graph-runs', entry.id);
+    try {
+      if (!existsSync(graphPath) || !existsSync(runsPath)) return entry;
+      const latest = readdirSync(runsPath).filter(name => name.endsWith('.json') && !name.endsWith('.decision.json'))
+        .sort((a, b) => statSync(join(runsPath, b)).mtimeMs - statSync(join(runsPath, a)).mtimeMs)[0];
+      if (!latest) return entry;
+      const run = JSON.parse(readFileSync(join(runsPath, latest), 'utf8')) as { graphId?: string; variant?: unknown; graphSnapshot?: { graphSha?: string } };
+      if (run.graphId !== entry.id || run.variant || !run.graphSnapshot?.graphSha) return entry;
+      const installedVersion = run.graphSnapshot.graphSha;
+      const current = createHash('sha256').update(readFileSync(graphPath)).digest('hex');
+      return { ...entry, installedVersion, expectedVersion: current };
+    } catch (error) {
+      debug.log('loop.checker', 'version-unavailable', { id: entry.id, reason: String(error) });
+      return entry;
+    }
+  });
+}
+
+export function launcherEvidence(entries: CheckEntry[], root: string): CheckEntry[] {
+  const path = join(root, 'msg', 'messages.db');
+  if (!existsSync(path)) return entries;
+  try {
+    const db = new Database(path, { readonly: true });
+    try {
+      if (!db.query("SELECT 1 FROM sqlite_master WHERE type='table' AND name='loop_signals'").get()) return entries;
+      const signals = db.query('SELECT loop_id, health, ends_at FROM loop_signals').all() as Array<{
+        loop_id: string; health: string; ends_at: string | null;
+      }>;
+      const byId = new Map(signals.map(signal => [signal.loop_id, signal]));
+      return entries.map(entry => {
+        const signal = byId.get(entry.id);
+        return signal ? { ...entry, ...(signal.health === 'degraded' ? { health: 'degraded' as const } : {}),
+          ...(signal.ends_at ? { endsAt: signal.ends_at } : {}) } : entry;
+      });
+    } finally { db.close(); }
+  } catch (error) {
+    debug.log('loop.checker', 'launcher-evidence-unavailable', { reason: String(error) });
+    return entries;
+  }
+}
+
+// Extend only an observed healthy launcher that is still heartbeating. The CAS prevents replacing a renewed lease.
+export function extendHealthyLauncher(root: string, finding: ScheduleFinding, now: Date): boolean {
+  if (finding.kind !== 'end-expired' || !Number.isFinite(now.getTime())) return false;
+  const path = join(root, 'msg', 'messages.db');
+  if (!existsSync(path)) return false;
+  const db = new Database(path);
+  try {
+    db.exec('PRAGMA busy_timeout = 10000');
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      const row = db.query('SELECT at, health, ends_at FROM loop_signals WHERE loop_id=?')
+        .get(finding.id) as { at: string; health: string; ends_at: string | null } | null;
+      const age = row ? now.getTime() - Date.parse(row.at) : NaN;
+      if (!row || row.health !== 'healthy' || !Number.isFinite(age) || age < 0 || age > 15 * 60_000 ||
+          !row.ends_at || !Number.isFinite(Date.parse(row.ends_at)) || Date.parse(row.ends_at) > now.getTime()) {
+        db.exec('COMMIT');
+        return false;
+      }
+      const result = db.query('UPDATE loop_signals SET ends_at=? WHERE loop_id=? AND at=? AND health=? AND ends_at=?')
+        .run(new Date(now.getTime() + 15 * 60_000).toISOString(), finding.id, row.at, row.health, row.ends_at);
+      db.exec('COMMIT');
+      return result.changes === 1;
+    } catch (error) { db.exec('ROLLBACK'); throw error; }
+  } finally { db.close(); }
+}
+
 export function countLoopStates(results: CheckResult[]): LoopCounts {
   const counts: LoopCounts = { alive: 0, late: 0, failing: 0, off: 0, unregistered: 0, unknown: 0 };
   for (const result of results) counts[result.state]++;
@@ -118,8 +232,14 @@ export interface CheckerDeps {
 }
 
 /** Appends only new daily keys to the seat request journal; never rewrites existing lines. */
-export function notifyOwners(results: CheckResult[], deps: CheckerDeps = {}): number {
-  const eligible = results.filter(result => result.owner && (result.state === 'late' || result.state === 'failing'));
+export function notifyOwners(results: CheckResult[], deps: CheckerDeps = {}, findings: ScheduleFinding[] = [], escalation = false): number {
+  const eligible = [
+    ...results.filter(result => result.owner && (result.state === 'late' || result.state === 'failing'))
+      .map(result => ({ ...result, alertState: result.state })),
+    ...findings.filter(result => result.owner && (result.kind !== 'late' && result.kind !== 'failing' ||
+      !results.some(row => row.id === result.id && row.state === result.kind)))
+      .map(result => ({ ...result, alertState: result.kind })),
+  ].filter(result => escalation ? result.owner !== 'OP' : true);
   if (!eligible.length) return 0;
   const now = deps.now ?? new Date();
   const path = join(deps.root ?? effectiveInstanceRoot(), 'seat-requests', 'requests.jsonl');
@@ -132,19 +252,38 @@ export function notifyOwners(results: CheckResult[], deps: CheckerDeps = {}): nu
     lock.exec('BEGIN EXCLUSIVE');
     try {
       const existing = new Set<string>();
+      const ownerRequests = new Map<string, { queuedAt?: string; status?: string }>();
       if (existsSync(path)) {
         for (const line of readFileSync(path, 'utf8').split('\n')) {
           if (line.trim()) {
-            const row = JSON.parse(line) as { key?: string };
-            if (row.key) existing.add(row.key);
+            const row = JSON.parse(line) as { key?: string; queuedAt?: string; status?: string };
+            if (row.key) {
+              existing.add(row.key);
+              ownerRequests.set(row.key, row);
+            }
           }
         }
       }
       let added = 0;
       for (const result of eligible) {
-        const key = `loopcheck:${result.id}:${now.toISOString().slice(0, 10)}:${result.state}`;
+        const ownerKey = `loopcheck:${result.id}:${now.toISOString().slice(0, 10)}:${result.alertState}`;
+        let requestKey = ownerKey;
+        if (escalation) {
+          const yesterday = new Date(now.getTime() - 24 * 3600_000).toISOString().slice(0, 10);
+          const priorKey = `loopcheck:${result.id}:${yesterday}:${result.alertState}`;
+          const prior = ownerRequests.get(priorKey);
+          if (prior?.status === 'queued' && prior.queuedAt &&
+              now.getTime() - Date.parse(prior.queuedAt) >= 30 * 60_000 && !existing.has(`${priorKey}:op`))
+            requestKey = priorKey;
+        }
+        const key = escalation ? `${requestKey}:op` : ownerKey;
         if (existing.has(key)) continue;
-        const row = { key, receiptId: key, seat: result.owner, text: `${result.id} ${result.state} — 마지막 ${result.lastRunAt ?? '없음'} · ${result.reason}`,
+        if (escalation) {
+          const request = ownerRequests.get(requestKey);
+          if (!request || request.status !== 'queued' || !request.queuedAt ||
+              now.getTime() - Date.parse(request.queuedAt) < 30 * 60_000) continue;
+        }
+        const row = { key, receiptId: key, seat: escalation ? 'OP' : result.owner, text: `${result.id} ${result.alertState} — 마지막 ${result.lastRunAt ?? '없음'} · ${result.reason}`,
           status: 'queued', queuedAt: now.toISOString(), source: 'loop-checker' };
         appendFileSync(path, JSON.stringify(row) + '\n');
         existing.add(key);

package/src/loops/orchestrator/resync-shadow.ts

@@ -10,11 +10,15 @@ import {
   type LlmMergeOutcome, type MergeGitSeam,
 } from '../../autopilot/build/llm-conflict-merge.js';
 
-type ResyncVerdict = 'saved' | 'merge-ok-tests-failed' | 'merge-ok-no-tests' | 'unresolved' | 'guard-tripped' | 'error';
+type ResyncVerdict = 'saved' | 'merge-ok-tests-failed' | 'merge-ok-no-tests' | 'unresolved' | 'guard-tripped' | 'push-rejected' | 'error';
+export type ResyncShadowMode = 'shadow' | 'live';
 interface ResyncShadowEntry {
   at: string;
   pr: number;
   head: string;
+  mode: ResyncShadowMode;
+  pushed: boolean;
+  labelRemoved: boolean;
   verdict: ResyncVerdict;
   status: LlmMergeOutcome['status'] | 'error';
   resolvedFiles: string[];
@@ -28,6 +32,7 @@ export interface ResyncShadowDeps {
   repoRoot?: string;
   instanceRoot?: string;
   runGh?: (args: string[]) => string;
+  runGit?: (args: string[]) => void;
   resolve?: (file: string, conflicted: string) => Promise<string>;
   gitSeam?: MergeGitSeam;
   runTests?: (cwd: string, files: string[]) => { ok: boolean; failedTests?: string[]; noTests?: boolean };
@@ -134,9 +139,10 @@ function defaultRunTests(cwd: string, files: string[]): { ok: boolean; failedTes
   return failedTests.length ? { ok: false, failedTests } : { ok: true };
 }
 
-/** Re-merge open conflicts only in disposable detached worktrees; no remote writes. */
-export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}): Promise<ResyncShadowSummary> {
+/** Re-merge open conflicts only in disposable detached worktrees; shadow mode never writes to remotes. */
+export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}, mode: ResyncShadowMode = 'shadow'): Promise<ResyncShadowSummary> {
   if (!Number.isSafeInteger(max) || max < 0) throw new Error('--max must be a nonnegative integer');
+  if (mode !== 'shadow' && mode !== 'live') throw new Error('mode must be shadow or live');
   const repoRoot = deps.repoRoot ?? resolve(import.meta.dir, '../../..');
   const gh = deps.runGh ?? ((args: string[]) => command('gh', args, repoRoot));
   const observed: unknown = JSON.parse(gh(['pr', 'list', '--state', 'open', '--json', 'number,headRefName,mergeable,isDraft,labels', '--limit', '1000']));
@@ -146,6 +152,7 @@ export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}): Pro
     throw new Error('incomplete or invalid PR observation');
   const candidates = (observed as OpenPr[]).filter(pr => pr.headRefName.startsWith('self-impl/')
     && pr.mergeable === 'CONFLICTING'
+    && (mode === 'shadow' || pr.labels.some(label => label.name === 'elanous:needs-rebase'))
     && !pr.labels.some(label => label.name === 'elanous:stalled' || label.name === 'elanous:superseded'))
     .sort((a, b) => a.number - b.number).slice(0, max);
   const ledger = join(deps.instanceRoot ?? effectiveInstanceRoot(), 'orchestrator', 'resync-shadow.jsonl');
@@ -154,6 +161,7 @@ export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}): Pro
   for (const pr of candidates) {
     const entry: ResyncShadowEntry = {
       at: (deps.now?.() ?? new Date()).toISOString(), pr: pr.number, head: pr.headRefName,
+      mode, pushed: false, labelRemoved: false,
       verdict: 'error', status: 'error', resolvedFiles: [], testFiles: [],
     };
     let tmp: string | undefined;
@@ -179,6 +187,21 @@ export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}): Pro
           if (!test.ok) entry.failedTests = test.failedTests?.length ? test.failedTests : ['test runner failed'];
         }
       } else entry.verdict = outcome.status === 'conflict-unresolved' || outcome.status === 'up-to-date' ? 'unresolved' : 'error';
+      if (mode === 'live' && entry.verdict === 'saved') {
+        try {
+          (deps.runGit ?? (args => { command('git', args, tmp!); }))(
+            ['push', 'origin', `HEAD:refs/heads/${pr.headRefName}`]);
+          entry.pushed = true;
+          gh(['pr', 'edit', String(pr.number), '--remove-label', 'elanous:needs-rebase']);
+          entry.labelRemoved = true;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          // push 가 이미 됐으면 원격은 살았다 — verdict 는 saved 로 두고 라벨 실패만 남긴다(다음 회차가 같은 PR 을 다시 고를 수 있다).
+          // push 실패는 거부 문구(rejected · non-fast-forward)일 때만 push-rejected · 인증·네트워크·시간초과는 error.
+          if (!entry.pushed) entry.verdict = /rejected|non-fast-forward|fetch first/i.test(message) ? 'push-rejected' : 'error';
+          entry.failedTests = [message];
+        }
+      }
     } catch (error) {
       entry.verdict = 'error';
       entry.failedTests = [error instanceof Error ? error.message : String(error)];
@@ -199,6 +222,9 @@ export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}): Pro
     mkdirSync(dirname(ledger), { recursive: true });
     appendFileSync(ledger, `${JSON.stringify(entry)}\n`);
     debug.log('loop.orchestrator', 'resync-shadow', { pr: entry.pr, verdict: entry.verdict, status: entry.status });
+    if (mode === 'live') debug.log('loop.orchestrator', 'resync-live', {
+      pr: entry.pr, verdict: entry.verdict, pushed: entry.pushed, labelRemoved: entry.labelRemoved,
+    });
     if (entry.verdict !== 'error') tried++;
     if (entry.verdict === 'saved') saved++;
   }
@@ -211,13 +237,14 @@ if (import.meta.main) {
   try {
     const args = process.argv.slice(2);
     if (args.includes('--help')) {
-      console.log('Usage: bun src/loops/orchestrator/resync-shadow.ts [--max N] [--json]');
+      console.log('Usage: bun src/loops/orchestrator/resync-shadow.ts [--max N] [--live] [--json]');
     } else {
       const index = args.indexOf('--max');
-      if (args.some((arg, i) => arg !== '--json' && arg !== '--max' && (index < 0 || i !== index + 1))
-        || (index >= 0 && (index === args.length - 1 || args.lastIndexOf('--max') !== index))) throw new Error('usage: resync-shadow.ts [--max N] [--json]');
+      if (args.some((arg, i) => arg !== '--json' && arg !== '--live' && arg !== '--max' && (index < 0 || i !== index + 1))
+        || (index >= 0 && (index === args.length - 1 || args.lastIndexOf('--max') !== index))) throw new Error('usage: resync-shadow.ts [--max N] [--live] [--json]');
       const max = index < 0 ? 3 : Number(args[index + 1]);
-      const summary = await runResyncShadow(max);
+      const mode: ResyncShadowMode = args.includes('--live') ? 'live' : 'shadow';
+      const summary = await runResyncShadow(max, {}, mode);
       console.log(process.argv.includes('--json') ? JSON.stringify(summary) : `resync-shadow candidates=${summary.candidates} tried=${summary.tried} saved=${summary.saved} savedRatio=${summary.savedRatio === null ? 'n/a' : `${(summary.savedRatio * 100).toFixed(1)}%`}`);
     }
   } catch (error) {

package/src/maturity/feature-maturity.ts

@@ -59,8 +59,8 @@ export const FEATURE_MATURITY = {
   },
   // Canonical CLI command names only; aliases inherit their command's grade.
   cliRoot: {
-    preview: 'beta', pty: 'beta', pr: 'beta', repo: 'beta', role: 'beta', machine: 'beta', 'agent-env': 'beta',
-    where: 'stable', shadow: 'beta', llm: 'beta', storage: 'beta', leader: 'beta',
+    preview: 'beta', pty: 'beta', pr: 'beta', repo: 'beta', role: 'beta', machine: 'beta', image: 'beta', 'agent-env': 'beta',
+    where: 'stable', bench: 'beta', shadow: 'beta', llm: 'beta', storage: 'beta', leader: 'beta',
     pod: 'beta', browser: 'beta', questions: 'beta', usage: 'stable', live: 'beta',
     research: 'beta', release: 'beta', know: 'beta', freeze: 'beta', flow: 'beta', seat: 'beta', hq: 'beta', steward: 'beta', coord: 'beta', context: 'beta', 'model-watch': 'beta', doctor: 'stable',
     control: 'beta', resources: 'beta', hooks: 'beta', setup: 'stable', start: 'stable',

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

@@ -425,12 +425,16 @@ const OPENROUTER: TierMap = {
 //   ⛔ bedrock 은 명시 선택 전용 — 이 표는 `--role-llm <role>=bedrock/<tier>` 같은 «명시» 해석에만 쓰인다.
 //   ⚠️ status = `wip`: 실 AWS 호출(계정별 5.5 접근 조건)을 아직 안 쟀고, 셋업 키 감지 표(PROVIDER_ENV_SPEC)에도
 //      없다(자격이 API 키가 아니라 AWS 체인이라). 첫 실호출 스모크 뒤 `shipping` 으로 올린다.
+//   ⭐ BEDROCK-RUNTIME-PATH(10-11): 메시지 엔드포인트(mantle)에 5.5 가 없어(📏 `GET /v1/models`) 사다리 id 를 전역 추론 프로필
+//      `global.anthropic.…`(runtime 경로 · bedrock.ts BEDROCK_MODELS 의 `route` 칸)로 옮겼다. 공급자 이름은 그대로 `bedrock`.
+//      📏 budget·balanced(haiku/sonnet 5.5)는 runtime 실호출 200 실측(ap-northeast-2) · opus 5.5 는 «추론 프로필 목록에 있음»까지만(호출 0).
+//      status 는 그대로 `wip` — `shipping` 은 셋업 키 감지 표(PROVIDER_ENV_SPEC) 칸을 요구한다(provider-wiring-contract 시험 · 범위 밖).
 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' },
+  budget:   { model: 'global.anthropic.claude-haiku-5-5',  reasoningLevel: 'off',    label: 'Claude Haiku 5.5 (Bedrock)',  rationale: 'Fast · cheap · bulk/classification', status: 'wip' },
+  balanced: { model: 'global.anthropic.claude-sonnet-5-5', reasoningLevel: 'off',    label: 'Claude Sonnet 5.5 (Bedrock)', rationale: 'Default · everyday coding (BEDROCK_DEFAULT_MODEL)', status: 'wip' },
+  better:   { model: 'global.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: 'global.anthropic.claude-opus-5-5',   reasoningLevel: 'medium', label: 'Claude Opus 5.5 · thinking medium (Bedrock)', rationale: 'Best reasoning · architecture', status: 'wip' },
+  loaded:   { model: 'global.anthropic.claude-opus-5-5',   reasoningLevel: 'high',   label: 'Claude Opus 5.5 · extended thinking (Bedrock)', rationale: 'Loaded · deep multi-step', status: 'wip' },
 };
 
 /** 가격·창 미측정이라 기존 tier 배치를 바꾸지 않고 명시 모델로만 고르는 칸.