elanous 0.2.36 → 0.2.37

package/src/index.ts

@@ -3919,8 +3919,11 @@ selfCmd
   .option('--json', '한 줄에 한 항목으로 재직렬화해 출력한다(원문 공백·빈 줄은 보존되지 않는다)')
   .option('--all', 'logs와 같은 전 인스턴스 연합 원장 조회를 한다')
   .option('--include-test', '--all 연합에 격리 test 인스턴스도 포함한다')
-  .action(async (runId: string, opts: { json?: boolean; all?: boolean; includeTest?: boolean }) => {
-    const { describeFederatedMissingRunLedger, describeMissingRunLedger, lookupRunLedger, renderRunLedger } = await import('./self-implement/run-ledger.js');
+  // ⛔⭐ 합성 exit 를 «쓰지» 않고 enter/exit/orphan 만 대조한다 — 원장을 읽기만 하는 분류다.
+  //    중단된 런이 exit 없이 남긴 graph.unit 방문을 «완료»로 오해하지 않게 CLI 에서 직접 잰다.
+  .option('--unit-visits', 'graph.unit enter/exit/orphan 대조만 출력한다(원장은 읽기만 한다)')
+  .action(async (runId: string, opts: { json?: boolean; all?: boolean; includeTest?: boolean; unitVisits?: boolean }) => {
+    const { classifyGraphUnitVisits, describeFederatedMissingRunLedger, describeMissingRunLedger, lookupRunLedger, renderRunLedger } = await import('./self-implement/run-ledger.js');
     try {
       const lookup = lookupRunLedger(runId, { all: opts.all, ...(opts.includeTest === undefined ? {} : { includeTest: opts.includeTest }) });
       if (lookup.matches.length === 0) {
@@ -3947,6 +3950,18 @@ selfCmd
       const match = lookup.matches[0]!;
       if (opts.json && match.skippedTrailingBytes !== undefined) console.error(`skipped incomplete trailing run ledger line: ${match.skippedTrailingBytes} bytes`);
       if (opts.all && !opts.json) console.log(`run ledger found in universe: ${match.targetName ?? 'current'} (${match.ledgerDirectory})`);
+      if (opts.unitVisits) {
+        const classification = classifyGraphUnitVisits(match.entries);
+        if (opts.json) {
+          await writeStdoutJson(JSON.stringify(classification) + '\n');
+          return;
+        }
+        console.log(`graph.unit enter=${classification.enterCount} exit=${classification.exitCount} orphan=${classification.orphanCount}`);
+        for (const visit of classification.orphanUnitVisits) {
+          console.log(`orphan unit=${visit.unit ?? '-'} node=${visit.nodeId ?? '-'} childRunId=${visit.childRunId ?? '-'} enteredAt=${visit.enteredAt ?? '-'}`);
+        }
+        return;
+      }
       if (opts.json) await writeStdoutJson(match.entries.map((entry) => JSON.stringify(entry)).join('\n') + '\n');
       else console.log(renderRunLedger(match.entries));
     } catch (error) {
@@ -4201,12 +4216,17 @@ selfCmd
 selfCmd
   .command('running-runs')
   .description('원장과 살아 있는 PTY를 함께 읽어 현재 자율 런 판정을 출력한다')
+  .argument('[runId]', '같은 ID로 단일 런의 원본 완료 결과(kind·reason·next)를 재조회한다 (생략 시 전체)')
   .option('--json', '구조화된 JSON으로 출력한다')
   .option('--include-test', '연합 관측에 격리 test 인스턴스도 포함한다')
-  .action(async (opts: { json?: boolean; includeTest?: boolean }) => {
+  .action(async (runId: string | undefined, opts: { json?: boolean; includeTest?: boolean }) => {
     try {
       const { queryRunningRuns, renderRunningRuns } = await import('./self-implement/running-runs.js');
-      const result = queryRunningRuns({ includeTest: opts.includeTest, caller: 'cli' });
+      const result = queryRunningRuns({
+        includeTest: opts.includeTest,
+        caller: 'cli',
+        ...(runId === undefined ? {} : { runIds: [runId] }),
+      });
       const output = `${opts.json ? JSON.stringify(result) : renderRunningRuns(result)}\n`;
       await writeStdoutJson(output);
     } catch (error) {
@@ -4461,6 +4481,9 @@ selfCmd
     try {
       const { runGoalAuthorCli, formatGoalAuthorSelfInspection, formatGoalInterviewRound } = await import('./self-implement/goal-author-cli.js');
       // 설정 졸업 1-c(2026-09-26): 되묻기 자동 답변은 늘 켠다 — `harness ask/say` 와 같은 동작(옵션 없음).
+      // Production self author → runGoalAuthorCli → writeAuthoredGoal → tracedPathsSection:
+      // missing traced paths are corrected or skipped; a required correction ledger write
+      // failure propagates through this call to the error handler instead of reporting success.
       const result = await runGoalAuthorCli(parts, { ...opts, selfResolveClarifications: true });
       console.log(result.path);
       // ⭐ grounding 상태를 함께 알린다 — 이 장치의 알려진 약점이 여기서 드러나야 한다.
@@ -4718,10 +4741,17 @@ selfCmd
   .option('--remote [host]', 'GATE-REMOTE — 같은 커밋을 원격 호스트(기본 config gateRemote.host=node-b)에서 돌리고 결과만 가져온다(깨끗한 트리 · --pr 은 로컬)')
   .option('--local', '원격 실행을 끄고 명시적으로 로컬에서 돌린다')
   .option('--artifact-dir <dir>', '조각별 지금/기준 JUnit ⊕ summary.json 을 이 디렉토리에 남긴다(판정 불변 · JUnit 은 --shards 경로만 · 원격 실행이면 그 호스트에서 가져온다)')
-  .action(async (opts: { changed?: boolean; base?: string; pr?: string; shards?: string | boolean; fixedShardDistribution?: boolean; includeImporters?: boolean; remote?: string | boolean; local?: boolean; artifactDir?: string }) => {
+  .option('--orchestration-id <id>', 'GATE-REMOTE-SHARD-PLAN — 조각 오케스트레이션 id. --shard-id · --shard-position 와 세벌 세트로만 쓰고 원격 명령줄에 그대로 실린다')
+  .option('--shard-id <id>', 'GATE-REMOTE-SHARD-PLAN — 조각 id(예: <orchestration-id>/shard-2). 원격 명령줄에 그대로 실린다')
+  .option('--shard-position <n>', 'GATE-REMOTE-SHARD-PLAN — 조각 위치(1부터 정수). 원격 명령줄에 그대로 실린다')
+  .option('--shard-plan <path>', 'GATE-REMOTE-SHARD-PLAN — 조각 계획 파일 경로. 주면 원격 명령줄에 --shard-plan 으로 실린다')
+  .action(async (opts: { changed?: boolean; base?: string; pr?: string; shards?: string | boolean; fixedShardDistribution?: boolean; includeImporters?: boolean; remote?: string | boolean; local?: boolean; artifactDir?: string; orchestrationId?: string; shardId?: string; shardPosition?: string; shardPlan?: string }) => {
     if (!opts.changed && opts.shards === undefined) { ui.error('self gate requires --changed or --shards'); process.exitCode = 2; return; }
     if (opts.fixedShardDistribution && opts.shards === undefined) { ui.error('self gate: --fixed-shard-distribution requires --shards <n>'); process.exitCode = 2; return; }
     if (opts.artifactDir !== undefined && !opts.artifactDir.trim()) { ui.error('self gate: --artifact-dir needs a non-empty directory'); process.exitCode = 2; return; }
+    const shardIdentityFlags = [opts.orchestrationId, opts.shardId, opts.shardPosition].filter((value) => value !== undefined).length;
+    if (shardIdentityFlags !== 0 && shardIdentityFlags !== 3) { ui.error('self gate: --orchestration-id, --shard-id and --shard-position are used as a set'); process.exitCode = 2; return; }
+    if (opts.shardPosition !== undefined && !/^[1-9]\d*$/.test(opts.shardPosition)) { ui.error('self gate: --shard-position needs a positive integer'); process.exitCode = 2; return; }
     // The root strips `--local` from argv anywhere (remote-bookmark attach · src/cli/remote-resolve.ts) before Commander
     // sees it, so this subcommand reads it from the untouched process.argv.
     opts.local = !!opts.local || process.argv.slice(2).includes('--local');
@@ -4766,12 +4796,23 @@ selfCmd
         remoteArtifacts = remoteCommitSupportsArtifactDir(repo) ? { dir: newRemoteArtifactDir() } : { unsupported: true };
       }
       // origin/main is pinned to this machine's origin/main on the host; any other base is passed as its resolved sha.
-      const remoteArgv = (sha: (ref: string) => string) => remoteSelfGateArgv({
-        changed: opts.changed, base: opts.base, shards, fixedShardDistribution: opts.fixedShardDistribution,
-        includeImporters: opts.includeImporters,
-        // A measured commit without this option rejects it (exit ≠ 0) — read as not passed, never as a silent measured run.
-        artifactDir: remoteArtifacts && 'dir' in remoteArtifacts ? remoteArtifacts.dir : undefined,
-      }, sha);
+      const remoteArgv = (sha: (ref: string) => string) => {
+        const argv = remoteSelfGateArgv({
+          changed: opts.changed, base: opts.base, shards, fixedShardDistribution: opts.fixedShardDistribution,
+          includeImporters: opts.includeImporters,
+          // A measured commit without this option rejects it (exit ≠ 0) — read as not passed, never as a silent measured run.
+          artifactDir: remoteArtifacts && 'dir' in remoteArtifacts ? remoteArtifacts.dir : undefined,
+        }, sha);
+        // GATE-REMOTE-SHARD-PLAN — the shard identity rides the remote command line so each host run is attributable to its
+        // shard. A measured commit without these options rejects them (exit ≠ 0): unmeasured, never a silent pass.
+        if (opts.orchestrationId === undefined) return argv;
+        const { remoteShardArgArgs } = require('./self-dev/shard-run.js') as typeof import('./self-dev/shard-run.js');
+        return [...argv, ...remoteShardArgArgs({
+          orchestrationId: opts.orchestrationId, shardId: opts.shardId!,
+          totalShards: typeof shards === 'number' && Number.isSafeInteger(shards) && shards >= 1 ? shards : 1,
+          position: Number(opts.shardPosition),
+        }, { planFile: opts.shardPlan })];
+      };
       const { gateHostReservationRoot } = await import('./release-loop/gate-host-reservation.js');
       process.exitCode = await dispatchHeavyCheck({
         tool: 'self-gate', repo, installPwa: true, remoteArgv, refs: opts.base ? [opts.base] : [], reservationRoot: gateHostReservationRoot(),
@@ -6283,6 +6324,7 @@ selfCmd
         return { status: r.status, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
       },
       reviewPullRequest,
+      reviewRepositoryPath: process.cwd(),
       readReferencedFile: createRepositoryReferencedFileReader(process.cwd()),
       renderReview,
       // ⛔⭐ 하드코딩 금지(🩸 2026-09-23 실측: 여기 'medium' 이 박혀 있었다) — 무인 리뷰와 «같은» 규칙.
@@ -7898,6 +7940,16 @@ const selfDevCmd = program
           // ⭐ 저작 «전»에 끊는다 — 100초를 쓰지 않는다. 우회는 --force-preflight 로 그대로 열려 있다.
           throw new DevPipelineError('저작 전 예비 검사에서 막혔다 — 위 이름을 확인하라 (우회: --force-preflight)');
         }
+        if (flowResult.kind === 'stopped-by-timebox') {
+          // ⭐⭐ AUTHOR-TIMEBOX NOT-GROUNDED — 저작 결과 줄은 흐름이 이미 썼다. 발사하지 않고 여기서 끝낸다.
+          releaseAuthoringLease();
+          if (opts.json) {
+            const terminalResult = { kind: 'self', ok: false, stage: 'author-timebox-not-grounded', goalFile: flowResult.goalFile };
+            await writeStdoutJson(`${JSON.stringify(terminalResult)}\n`);
+          }
+          completionGuard.conclude();
+          process.exit(1);
+        }
         askAuthoredFile = flowResult.goalFile;
         if (flowResult.kind === 'stopped-by-preflight') {
           releaseAuthoringLease();
@@ -12159,6 +12211,54 @@ export function rootResumeIdAt(rawArgs: readonly string[], resumeFlagIdx: number
   return next !== undefined && !next.startsWith('-') ? next : undefined;
 }
 
+/** TUI-CONTINUE-SESSION (0.2.35) — `--continue` 가 «어느 세션» 을 이어받나를 정하는 조회 창구. */
+export interface ContinueSessionLookup {
+  /** cwd 가 속한 프로젝트 id — 매칭 없으면 null. */
+  projectIdForCwd: (cwd: string) => string | null;
+  /** 그 프로젝트의 최신 세션 id — 없으면 null. */
+  latestForProject: (projectId: string) => string | null;
+  /** 전역 최신 세션 id — 없으면 null. */
+  latestGlobal: () => string | null;
+  /** 지금 활성 표지가 가리키는 세션 id — 없으면 null. */
+  activeSessionId: () => string | null;
+}
+
+const realContinueSessionLookup: ContinueSessionLookup = {
+  projectIdForCwd: (cwd) => suggestProjectForFolder(cwd)?.id ?? null,
+  latestForProject: (projectId) => listSessions({ limit: 1, projectId })[0]?.id ?? null,
+  latestGlobal: () => listSessions({ limit: 1 })[0]?.id ?? null,
+  activeSessionId: () => getActiveSessionId(),
+};
+
+/**
+ * TUI-CONTINUE-SESSION (0.2.35) — `--continue`(id 없는 `--resume`)의 «최근 세션» 을 cwd 기준으로
+ * 먼저 좁힌다: cwd 가 속한 프로젝트(`primaryFolder` 또는 그 하위 디렉토리)의 최신 세션 id.
+ * 매칭 프로젝트가 없거나 그 프로젝트에 세션이 하나도 없으면 전역 최신으로 폴백한다 —
+ * 프로젝트와 무관한 디렉토리·화면의 이어가기 동작은 종전 그대로다.
+ */
+export function latestSessionIdForContinue(
+  cwd: string = process.cwd(),
+  lookup: ContinueSessionLookup = realContinueSessionLookup,
+): string | null {
+  const projectId = lookup.projectIdForCwd(cwd);
+  const localId = projectId ? lookup.latestForProject(projectId) : null;
+  return localId ?? lookup.latestGlobal();
+}
+
+/**
+ * cwd 가 프로젝트 안이면 활성 표지보다 cwd 프로젝트의 최신 세션 선택을 우선한다.
+ * 프로젝트 밖에서는 종전처럼 활성 표지가 전역 최신보다 우선한다.
+ */
+export function activeSessionIdForContinue(
+  cwd: string = process.cwd(),
+  lookup: ContinueSessionLookup = realContinueSessionLookup,
+): string | null {
+  const active = lookup.activeSessionId();
+  if (!active) return null;
+  const cwdProjectId = lookup.projectIdForCwd(cwd);
+  return cwdProjectId ? null : active;
+}
+
 export function filterDashboardArgs(rawArgs: readonly string[], resumeFlagIdx?: number): string[] {
   const rootResumeFlagIdx = resumeFlagIdx ?? rawArgs.findIndex((arg, index) =>
     // ⛔ `-r` 은 «더 이상» resume 의 별칭이 아니다 — 원격 북마크(`--remote`)의 단축형이다.
@@ -12407,8 +12507,11 @@ async function main(): Promise<void> {
     // 명시 인자가 있으면 env 를 «읽지도» 않는다(폐기 경고가 명시 이어하기에 섞이지 않게).
     readEnvId: () => readDeprecatedEnvForResume('ELANOUS_RESUME_SESSION').value ?? null,
     latest: () => resolveLatestSessionId({
-      activeSessionId: () => getActiveSessionId(),
-      latestSessionId: () => listSessions({ limit: 1 })[0]?.id ?? null,
+      // TUI-CONTINUE-SESSION (0.2.35) — 활성 표지가 «다른 프로젝트» 세션이면 버리고 cwd 기준으로 고른다.
+      activeSessionId: () => activeSessionIdForContinue(),
+      // TUI-CONTINUE-SESSION (0.2.35) — «지금 이 디렉토리» 의 프로젝트 최근 세션을 먼저 본다.
+      //   그 프로젝트에 세션이 없으면 종전대로 전역 최신으로 폴백(다른 화면 동작 보존).
+      latestSessionId: () => latestSessionIdForContinue(),
       // TUI-H8-FOLLOW ① — 활성 표지가 사라진 세션이면 최신 세션으로(#28509 리뷰 should-fix).
       sessionExists: (id) => loadSession(id) !== null,
     }),

package/src/instance/test-write-guard-real-transport.fixture.ts

@@ -0,0 +1,52 @@
+// Child fixture for test-write-guard.test.ts (TEST-PROD-LEAK-2 ledger): call-through wrappers installed over
+// the ORIGINAL spill and send functions must not soften the outbound-alert guard. spillLongContent gets a
+// mock.module call-through wrapper (not a fake — it delegates to the original) that counts operational S3
+// upload attempts, and the original curl send primitive gets a bare pass-through spy that counts external
+// sends. The refusal must fire BEFORE spillLongContent runs, so the ledger prints 0 s3Uploads and 0
+// curlCalls alongside the refusal reason. Prints {refused, refusalReason, curlCalls, s3Uploads}.
+import { mock, spyOn } from 'bun:test';
+import * as childProcess from 'node:child_process';
+
+// Pass-through wrapper over the original external-send primitive (curl via execFileSync), installed before
+// outbound-alert is imported so even the module-load capture of the «real» sender sees a wrapper, not a fake.
+const sendWrapper = spyOn(childProcess, 'execFileSync');
+
+const spill = await import('../storage/content-spill.js');
+const originalSpill = spill.spillLongContent;
+let s3Uploads = 0;
+await mock.module('../storage/content-spill.js', () => ({
+  ...spill,
+  spillLongContent: (...args: Parameters<typeof originalSpill>) => {
+    s3Uploads += 1; // every spill that reaches the original is an operational S3 upload attempt
+    return originalSpill(...args);
+  },
+}));
+
+const { sendTelegramDirect } = await import('../domains/outbound-alert.js');
+const { getUserConfig } = await import('../user-config.js');
+const base = getUserConfig();
+const config = { ...base, telegram: { ...base.telegram, channels: undefined, botToken: '2:fake', homeChannel: 2 } } as typeof base;
+type DirectDeps = NonNullable<Parameters<typeof sendTelegramDirect>[2]>;
+const deps = { config } as DirectDeps;
+// LEAK2_INJECT_SENDRAW=1 also injects a real (non-test-double) send transport into the delivery deps — a
+// plain curl-invoking function, no mock scaffolding — so the companion ledger proves the guard refuses an
+// injected external transport, not merely an empty one.
+if (process.env.LEAK2_INJECT_SENDRAW === '1') {
+  (deps as { sendRaw?: (url: string) => string }).sendRaw = (url) =>
+    childProcess.execFileSync('curl', ['-sS', url], { encoding: 'utf8' }) as string;
+  // An injected transport turns the external branch off (:710 — a test double cannot target the ops
+  // universe), so the companion ledger proves the ops-routed branch: the routing roots resolve inside the
+  // ops universe, exactly as production does, and the guard refuses it faked or not.
+  const { EXTRA_OPS_ROOTS_ENV } = await import('../instance/test-write-guard.js');
+  const { getElanousConfigDir } = await import('../elanous-config-dir.js');
+  process.env[EXTRA_OPS_ROOTS_ENV] = getElanousConfigDir();
+}
+let refused = false;
+let refusalReason = '';
+try {
+  sendTelegramDirect('private-alert-body', 'ops-alert', deps);
+} catch (e) {
+  refused = true;
+  refusalReason = e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+}
+console.log(JSON.stringify({ refused, refusalReason, curlCalls: sendWrapper.mock.calls.length, s3Uploads }));

package/src/llm/route-decision.ts

@@ -8,6 +8,7 @@
 
 import type { LLMProviderName, ReasoningLevel, LlmRoutePolicyConfig } from '../user-config.js';
 import { classifyMissionTier1, type MissionKind } from './mission-router.js';
+import type { SessionSource } from '../session/index.js';
 import { lookupLlmTierSpec } from '../model-tier/llm-tier-map.js';
 
 export type RouteDecisionSource = 'explicit-pin' | 'codex-tier-policy' | 'legacy-default' | 'active-provider-default' | 'execution-backend';
@@ -111,6 +112,8 @@ export interface ResolveRouteDecisionInput {
   provider: LLMProviderName;
   configuredModel?: string;
   text: string;
+  /** Telegram keeps its non-deep coding tier; other surfaces retain the configured quick model. */
+  surface?: SessionSource;
   /** A per-turn/slash/user model choice.  It always wins. */
   explicitModel?: string;
   routePolicy?: LlmRoutePolicyConfig;
@@ -145,6 +148,16 @@ export function resolveRouteDecision(input: ResolveRouteDecisionInput): RouteDec
     };
   }
   const policyMode = input.routePolicy?.mode;
+  // Unspecified callers keep the configured quick model for compatibility; Telegram alone owns the coding-tier exception.
+  if (input.provider === 'openai-codex' && input.surface !== 'telegram' && policyMode === undefined && mission === 'quick' && input.configuredModel) {
+    return {
+      provider: input.provider,
+      model: input.configuredModel,
+      source: 'active-provider-default',
+      rationale: 'configured model preserved for quick mission',
+      mission,
+    };
+  }
   if (input.provider === 'openai-codex' && policyMode !== 'active-provider') {
     const deep = mission === 'plan' || mission === 'review';
     const tier = deep ? 'best' : 'better';

package/src/llm-tool-name.ts

@@ -0,0 +1,37 @@
+/** Provider wire names have a deliberately smaller alphabet than MCP names.
+ * Keep the source name in the TUI/tool catalog and use this reversible map
+ * only for one provider request and its returned tool calls. */
+export interface ProviderToolNameMap {
+  toProviderName(name: string): string;
+  toOriginalName(name: string): string;
+}
+
+export function sanitizeProviderToolName(name: string): string {
+  const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '_');
+  return sanitized.length > 0 ? sanitized : 'tool';
+}
+
+/** Build a deterministic, collision-free mapping for the complete request
+ * namespace. Repeated source names intentionally share one wire name. */
+export function createProviderToolNameMap(names: readonly string[]): ProviderToolNameMap {
+  const originalToProvider = new Map<string, string>();
+  const providerToOriginal = new Map<string, string>();
+
+  for (const original of names) {
+    if (originalToProvider.has(original)) continue;
+
+    const base = sanitizeProviderToolName(original);
+    let candidate = base;
+    let suffix = 2;
+    while (providerToOriginal.has(candidate)) {
+      candidate = `${base}__${suffix++}`;
+    }
+    originalToProvider.set(original, candidate);
+    providerToOriginal.set(candidate, original);
+  }
+
+  return {
+    toProviderName: (name) => originalToProvider.get(name) ?? sanitizeProviderToolName(name),
+    toOriginalName: (name) => providerToOriginal.get(name) ?? name,
+  };
+}

package/src/llm-tool-schema.ts

@@ -0,0 +1,35 @@
+/** Convert legacy JSON Schema tuple `items` arrays to the modern
+ * `prefixItems` form used by Grok's OpenAI-compatible tool validator.
+ * Other schema keywords, including min/maxItems and coordinate constraints,
+ * are preserved recursively. */
+export function sanitizeToolSchemaForGrok(schema: unknown): unknown {
+  if (Array.isArray(schema)) return schema.map(sanitizeToolSchemaForGrok);
+  if (!schema || typeof schema !== 'object') return schema;
+
+  const record = schema as Record<string, unknown>;
+  const tupleItems = Array.isArray(record.items) ? record.items : undefined;
+  const hasPrefixItems = Array.isArray(record.prefixItems);
+  const hasAdditionalItems = Object.prototype.hasOwnProperty.call(record, 'additionalItems');
+  const output: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(record)) {
+    if (key === 'additionalItems' || (key === 'items' && tupleItems)) continue;
+    output[key] = sanitizeToolSchemaForGrok(value);
+  }
+
+  if (tupleItems) {
+    output.prefixItems = tupleItems.map(sanitizeToolSchemaForGrok);
+  }
+  if (hasAdditionalItems && (tupleItems || hasPrefixItems)) {
+    output.items = sanitizeToolSchemaForGrok(record.additionalItems);
+  }
+
+  return output;
+}
+
+/** OpenRouter model ids may include the provider prefix; callers can pass
+ * either the catalog id or the already-normalized wire id. */
+export function isOpenRouterGrokModel(model: string): boolean {
+  const wireModel = model.replace(/^openrouter\//i, '');
+  return /^x-ai\/grok(?:[-/]|$)/i.test(wireModel);
+}

package/src/llm.ts

@@ -3,7 +3,7 @@
 // Auto-routes based on model name prefix, or picks the first available provider.
 
 import { wellFormedLLMMessages } from './llm-wellformed.js';
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { testFakeLlmEnabled, testFakeLlmProvider } from './ux-sim/fake-llm.js';
 import { realpathSync } from 'node:fs';
 import { resolve } from 'node:path';
@@ -61,6 +61,8 @@ 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';
 import { closestMatches } from './tool-name-suggest.js';
+import { createProviderToolNameMap } from './llm-tool-name.js';
+import { isOpenRouterGrokModel, sanitizeToolSchemaForGrok } from './llm-tool-schema.js';
 import { undoTurnRuntime } from './tool-runtime/undo-turn-runtime.js';
 import { listSnapshots } from './undo-turn/index.js';
 // Zero-dep spec module (no tool-runtime registry) — safe for this hot path.
@@ -276,6 +278,61 @@ export interface LLMToolSpec {
   parameters: Record<string, unknown>;   // JSONSchema
 }
 
+function toolUseNames(messages: readonly LLMMessage[]): string[] {
+  return messages.flatMap((message) => Array.isArray(message.content)
+    ? message.content.flatMap((block) => block.type === 'tool_use' ? [block.name] : [])
+    : []);
+}
+
+function mapProviderToolNamesInMessages(
+  messages: readonly LLMMessage[],
+  mapName: (name: string) => string,
+): LLMMessage[] {
+  return messages.map((message) => {
+    if (!Array.isArray(message.content)) return message;
+    let changed = false;
+    const content = message.content.map((block) => {
+      if (block.type !== 'tool_use') return block;
+      const name = mapName(block.name);
+      if (name === block.name) return block;
+      changed = true;
+      return { ...block, name };
+    });
+    return changed ? { ...message, content } : message;
+  });
+}
+
+function restoreProviderToolCallNames(
+  events: AsyncIterable<LLMStreamEvent>,
+  mapName: (name: string) => string,
+): AsyncIterableIterator<LLMStreamEvent> {
+  // Forward cancellation directly to the provider iterator. An async
+  // generator wrapper waits for a pending `next()` before servicing
+  // `return()`, which can strand the idle watchdog on a hanging stream.
+  const iterator = events[Symbol.asyncIterator]();
+  const mapped: AsyncIterableIterator<LLMStreamEvent> = {
+    [Symbol.asyncIterator]() { return mapped; },
+    async next(value?: unknown) {
+      const result = await iterator.next(value);
+      if (result.done) return { done: true, value: result.value };
+      const event = result.value;
+      return {
+        done: false,
+        value: event.type === 'tool_call' ? { ...event, name: mapName(event.name) } : event,
+      };
+    },
+    async return(value?: void) {
+      if (iterator.return) return iterator.return(value);
+      return { done: true, value };
+    },
+    async throw(error?: unknown) {
+      if (iterator.throw) return iterator.throw(error);
+      throw error;
+    },
+  };
+  return mapped;
+}
+
 /** Events produced by a streaming provider call. Text deltas arrive
  *  incrementally; tool_call events are emitted as COMPLETE units once
  *  the provider finishes streaming the tool_use block — callers don't
@@ -359,6 +416,8 @@ export interface LLMOpts {
   usageRole?: ModelRole;
   /** Optional per-call metering phase; absent calls keep the existing ledger shape. */
   usagePhase?: string;
+  /** Optional per-call self-dev job kind; absent calls keep the existing ledger shape. */
+  usageJobKind?: string;
   /** Optional streamLLM usage-ledger site override (defaults to "stream-llm"). */
   usageSite?: string;
   /**
@@ -2556,7 +2615,7 @@ export function sanitizeToolSchemaForKimi(schema: unknown): unknown {
   ]));
 }
 
-export function toOpenAITools(tools: LLMToolSpec[] | undefined, kimi = false): any[] | undefined {
+export function toOpenAITools(tools: LLMToolSpec[] | undefined, kimi = false, grokTupleItems = false): any[] | undefined {
   const unique = dedupeToolsByName(tools);
   if (!unique || unique.length === 0) return undefined;
   return unique.map(t => ({
@@ -2565,7 +2624,9 @@ export function toOpenAITools(tools: LLMToolSpec[] | undefined, kimi = false): a
       name: t.name, description: t.description,
       parameters: kimi
         ? sanitizeToolSchemaForKimi(strictifyToolSchema(t.parameters))
-        : strictifyToolSchema(t.parameters),
+        : grokTupleItems
+          ? sanitizeToolSchemaForGrok(strictifyToolSchema(t.parameters))
+          : strictifyToolSchema(t.parameters),
     },
   }));
 }
@@ -4868,7 +4929,7 @@ export async function streamLLM(
     if (consumed.ok) {
       if (consumed.usage !== 'unmeasured') {
         try {
-          logAgentTurnUsage(activeModel, consumed.usage, { providerName: activeProvider.name, site: opts.usageSite ?? 'stream-llm', role: opts.usageRole, phase: opts.usagePhase });
+          logAgentTurnUsage(activeModel, consumed.usage, { providerName: activeProvider.name, site: opts.usageSite ?? 'stream-llm', role: opts.usageRole, phase: opts.usagePhase, jobKind: opts.usageJobKind });
         } catch { /* best-effort observation */ }
       }
       debug.log('llm', 'outcome', { provider: activeProvider.name, status: 'ok', kind: 'streamLLM', durationMs: Date.now() - started });
@@ -8104,17 +8165,19 @@ export function billingRouteForProvider(provider: string | undefined, model: str
 }
 
 /** Observe usage with optional site/role metadata; a provider-name string remains supported. */
-export function logAgentTurnUsage(model: string, usage: LLMUsage, providerNameOrOptions?: string | { providerName?: string; site?: string; role?: ModelRole; phase?: string }): void {
+export function logAgentTurnUsage(model: string, usage: LLMUsage, providerNameOrOptions?: string | { providerName?: string; site?: string; role?: ModelRole; phase?: string; jobKind?: string }): void {
   try {
     const providerName = typeof providerNameOrOptions === 'string' ? providerNameOrOptions : providerNameOrOptions?.providerName;
     const site = (typeof providerNameOrOptions === 'string' ? undefined : providerNameOrOptions?.site) ?? 'agent-turn';
     const role = typeof providerNameOrOptions === 'string' ? undefined : providerNameOrOptions?.role;
     const phase = typeof providerNameOrOptions === 'string' ? undefined : providerNameOrOptions?.phase;
+    const jobKind = typeof providerNameOrOptions === 'string' ? undefined : providerNameOrOptions?.jobKind;
     const billing = billingRouteForProvider(providerName, model);
     debug.log('llm.usage', 'llm-usage', {
       site,
       ...(role !== undefined ? { role } : {}),
       ...(phase !== undefined ? { phase } : {}),
+      ...(jobKind !== undefined ? { jobKind } : {}),
       model,
       ...(usage.provider !== undefined && { provider: usage.provider }),
       // ⭐ `provider` 는 «선 어댑터»(openai/anthropic)다 — 과금 주체는 별칭 칸으로(BACKLOG B10).
@@ -8241,6 +8304,10 @@ function applyCodexBehaviorGuard(
   return enabled;
 }
 
+function orchestrationId(): string {
+  return randomUUID();
+}
+
 export async function streamLLMWithTools(
   messages: LLMMessage[],
   handlers: StreamWithToolsHandlers,
@@ -8261,10 +8328,13 @@ export async function streamLLMWithTools(
   let blockedProviders: ProviderFallbackAttempt[] = [];
   const effectiveModel = activeModel;
   const modelFamily = getModelFamily(effectiveModel);
+  const orchestration = orchestrationId();
+  const followupHardStopStats = { wouldBlock: 0, blocked: 0 };
   // Preserve pre-existing GPT-6 behavior while observing Codex-only sites.
   const codexBehaviorGuards = usesCodexBehaviorGuards(effectiveModel);
   const codexGuardCandidate = codexBehaviorGuards || isGpt6GenerationModel(effectiveModel);
   debug.log('llm.router', 'streamLLMWithTools', {
+    orchestrationId: orchestration,
     provider: provider.name,
     model: effectiveModel,
     modelFamily,
@@ -8821,7 +8891,28 @@ export async function streamLLMWithTools(
             debug.log('llm.request', 'lone-surrogate-fixed', { site: 'tool-loop', provider: activeProvider.name, messages: wf.fixedMessages, strings: wf.fixedStrings }, { level: 'warn' });
             history.splice(0, history.length, ...wf.messages);
           }
-          streamIter = activeProvider.streamChat!(history, turnOpts)[Symbol.asyncIterator]();
+          // Provider function names have a narrower wire alphabet than MCP
+          // names. Keep catalog/history names canonical inside the tool loop,
+          // and translate only this request plus the corresponding response.
+          const nameMap = createProviderToolNameMap([
+            ...(turnOpts.tools ?? []).map((tool) => tool.name),
+            ...toolUseNames(history),
+            ...(turnOpts.toolChoice && typeof turnOpts.toolChoice === 'object'
+              ? [turnOpts.toolChoice.name]
+              : []),
+          ]);
+          const providerOpts: LLMOpts = {
+            ...turnOpts,
+            tools: turnOpts.tools?.map((tool) => ({ ...tool, name: nameMap.toProviderName(tool.name) })),
+            toolChoice: turnOpts.toolChoice && typeof turnOpts.toolChoice === 'object'
+              ? { name: nameMap.toProviderName(turnOpts.toolChoice.name) }
+              : turnOpts.toolChoice,
+          };
+          const providerMessages = mapProviderToolNamesInMessages(history, nameMap.toProviderName);
+          streamIter = restoreProviderToolCallNames(
+            activeProvider.streamChat!(providerMessages, providerOpts),
+            nameMap.toOriginalName,
+          )[Symbol.asyncIterator]();
         }
         step = await Promise.race([
           streamIter.next().then((r) => ({ idle: false as const, r })),
@@ -8998,7 +9089,7 @@ export async function streamLLMWithTools(
         // ⭐ 주 에이전트 턴의 토큰·비용을 «게이트 없이» 남긴다(2026-09-24 실측: 이 줄이 없어 3시간 `llm.usage`
         //   18행이 전부 곁가지 두 자리였고, 하니스 런 비용의 거의 전부가 관측 밖이었다). 곁가지와 같은 모양 ·
         //   모르는 모델은 금액 대신 `cost.kind='unknown'`. runId 는 debug.log 가 붙인다. 실패해도 턴은 계속.
-        logAgentTurnUsage(activeModel, ev.usage, { providerName: activeProvider.name, role: opts.usageRole, phase: opts.usagePhase });
+        logAgentTurnUsage(activeModel, ev.usage, { providerName: activeProvider.name, role: opts.usageRole, phase: opts.usagePhase, jobKind: opts.usageJobKind });
         // Wave A1 (2026-05-04) — turn-level cache hit rate forensic.
         // Each provider's usage event carries inputTokens / outputTokens
         // / cacheReadInputTokens (when cache hit). Emit the per-turn
@@ -9388,13 +9479,23 @@ export async function streamLLMWithTools(
       // done, just write the answer" UX which we must not preempt.
       const codexImmediateInspectActionStop = followupInspectActionHeld && followupHardStopEnabled;
       if (followupHardStopHeld) {
-        noteGpt6CodexGuard('followup-hard-stop', effectiveModel,
-          (codexImmediateInspectStop && codexInspectSynthesisGrace <= 0)
+        const followupHardStopBlocked = (codexImmediateInspectStop && codexInspectSynthesisGrace <= 0)
           || (codexImmediateRepairStop && codexRepairActionGrace <= 0)
-          || (codexImmediateInspectActionStop && codexInspectActionGrace <= 0));
+          || (codexImmediateInspectActionStop && codexInspectActionGrace <= 0);
+        noteGpt6CodexGuard('followup-hard-stop', effectiveModel, followupHardStopBlocked);
+        if (isGpt6GenerationModel(effectiveModel)) {
+          followupHardStopStats.wouldBlock++;
+          if (followupHardStopBlocked) followupHardStopStats.blocked++;
+          debug.log('llm.router', 'tool-loop.followup-hard-stop.guard-observed', {
+            orchestrationId: orchestration,
+            guard: 'followup-hard-stop',
+            ...followupHardStopStats,
+          });
+        }
       }
       if (codexImmediateInspectStop && codexInspectSynthesisGrace <= 0) {
         debug.log('llm.router', 'tool-loop.inspect-synthesis-phase.codex-immediate-stop', {
+          orchestrationId: orchestration,
           turn,
           maxTurns,
           autoNarrowedReadCount,
@@ -11399,7 +11500,12 @@ function makeOpenAICompatProvider(
         throw new Error(`${name} unavailable: configure apiKey via \`elanous setup\``);
       }
       const activeModel = opts.model || model;
-      const tools = toOpenAITools(opts.tools, name === 'openrouter' && openRouterNeedsKimiToolSchema(openRouterWireModel(activeModel)));
+      const wireModel = name === 'openrouter' ? openRouterWireModel(activeModel) : activeModel;
+      const tools = toOpenAITools(
+        opts.tools,
+        name === 'openrouter' && openRouterNeedsKimiToolSchema(wireModel),
+        name === 'openrouter' && isOpenRouterGrokModel(wireModel),
+      );
       const deepSeek = name === 'openrouter' && isOpenRouterDeepSeekWireModel(openRouterWireModel(activeModel));
       // OR-TOOLCHOICE-PASS (2026-10-10) — OpenRouter 경로만 호출자 toolChoice 를 싣는다.
       //   ⛔ grok/openai 호환 경로는 손대지 않는다(무회귀). toolChoice 가 없거나 tools 가 없으면 키 자체를 안 싣는다.
@@ -12026,6 +12132,12 @@ const OPENROUTER_ROUTE_FOR_WIP_PROVIDER = {
   glm: 'openrouter/z-ai/glm-5.3',
 } as const;
 
+/** Resolve a review model shortcut before either provider inference or the wire call. */
+export function resolveReviewModelAlias(model: string): string {
+  const resolved = resolveModelAlias(model.trim())!;
+  return OPENROUTER_ROUTE_FOR_WIP_PROVIDER[resolved.toLowerCase() as keyof typeof OPENROUTER_ROUTE_FOR_WIP_PROVIDER] ?? resolved;
+}
+
 /** Top-level resolver. Honors user-config first; falls through to
  *  env-var / auto-detect when provider is 'auto'. */
 export function getProviderForConfig(