elanous 0.2.40 → 0.2.41

package/src/cli/msg-cli.ts

@@ -1,13 +1,20 @@
 import type { Command } from 'commander';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
 import { ensureAuthToken } from '../auth/acp-token.js';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { canonicalSeatId, openMsgStore, openMsgStoreReadOnly, type Message, type MsgStore } from '../msg/msg-store.js';
 import { clearPostOffice, ensurePostOffice, writePostOffice } from '../msg/msg-post-office.js';
+import { acquireLockSync } from '../storage/file-lock.js';
+import { GitHubMsgMirrorTransport } from '../msg/msg-mirror-github.js';
+import { configuredMirrorTarget, runMsgMirrorTick, type MirrorTarget, type MsgMirrorStateStore, type MsgMirrorTransport } from '../msg/msg-mirror-runner.js';
+import { JsonMsgMirrorStateStore } from '../msg/msg-mirror-state.js';
 import { startMsgSseServer } from '../msg/msg-sse-server.js';
+import { debug } from '../debug/log.js';
 import type { AgentReplyAddress, AgentReplyInput, AgentReplyResult } from '../loops/agent-reply.js';
 import { messageRouteFor, noReplyBodyNotice, unsupportedLoopAddressNotice } from '../loops/msg-address.js';
 import { resolveWake, wakeRecipient, type WakeDeps, type WakeOutcome } from '../loops/msg-wake.js';
-import type { RoleLlmSpec } from '../user-config.js';
+import { getUserConfig, type RoleLlmSpec } from '../user-config.js';
 
 /** The loop rows whose reply body is an LLM agent: `--agent-reply` picks one of these. */
 const AGENT_REPLY_ROLES = { COORDINATOR: 'coordinator', GUARDIAN: 'guardian' } as const;
@@ -22,6 +29,9 @@ export interface MsgCliDeps {
   signal?: AbortSignal;
   fetch?: typeof fetch;
   authToken?: () => string;
+  mirrorTarget?: MirrorTarget | null;
+  mirrorState?: MsgMirrorStateStore;
+  mirrorTransport?: MsgMirrorTransport;
   /** Wake-path resolution for `msg route` (tests inject; default reads pty manifest ⊕ seat folders). */
   wakeDeps?: WakeDeps;
   /** Attach the logs.db sink so `msg.wake` reaches `elanous logs` (a short CLI otherwise writes only the file trail). */
@@ -198,6 +208,52 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
     if (address !== to) throw new Error(`--agent-reply ${address} requires --to ${address}`);
   };
 
+  msg.command('mirror').description('Mirror selected seat messages to the configured GitHub issue')
+    .option('--dry-run', 'read the configured channel and ledger without writing')
+    .option('--watch', 'repeat until interrupted')
+    .option('--interval <seconds>', 'poll interval in watch mode (default 60)', '60')
+    .option('--json')
+    .action((opts: CommonOptions & { dryRun?: boolean; watch?: boolean; interval?: string }) => run(async () => {
+      const intervalSeconds = integer(opts.interval, '--interval', 60, 1, 3600);
+      const state = deps.mirrorState ?? new JsonMsgMirrorStateStore();
+      const configTarget = deps.mirrorTarget === undefined
+        ? configuredMirrorTarget(getUserConfig().raw.msgMirror) : deps.mirrorTarget ?? undefined;
+      const existingState = state.read();
+      if (!configTarget && !existingState) {
+        const result = { status: 'disabled', reason: 'msgMirror.target is not configured', target: null };
+        debug.log('msg.mirror', 'disabled', result);
+        out.log(opts.json ? JSON.stringify(result) : 'msg mirror 비활성: msgMirror.target 미설정');
+        return;
+      }
+      const store = openRead();
+      const transport = deps.mirrorTransport ?? new GitHubMsgMirrorTransport();
+      const signal = deps.signal;
+      try {
+        do {
+          let release = () => {};
+          if (state instanceof JsonMsgMirrorStateStore) {
+            mkdirSync(dirname(state.path), { recursive: true, mode: 0o700 });
+            release = acquireLockSync(`${state.path}.lock`, { breakDeadHolder: true });
+          }
+          let result: Awaited<ReturnType<typeof runMsgMirrorTick>>;
+          try {
+            result = await runMsgMirrorTick({
+              ...(configTarget ? { configuredTarget: configTarget } : {}),
+              ...(opts.dryRun ? { dryRun: true } : {}),
+              source: { listAfter: (after, limit) => store.listAfter(after, limit),
+                listWindow: (start, end) => store.listCreatedBetween(start, end), latestId: () => store.latestId() },
+              state, transport,
+            });
+          } finally { release(); }
+          debug.log('msg.mirror', 'tick', result);
+          out.log(opts.json ? JSON.stringify(result)
+            : `msg mirror ${result.status} · scanned ${result.scanned} · posted ${result.posted} · rotated ${result.rotated} · summaries ${result.summaries}`);
+          if (!opts.watch || signal?.aborted) break;
+          await sleep(intervalSeconds * 1000);
+        } while (!signal?.aborted);
+      } finally { store.close(); }
+    })());
+
   /**
    * Human-free live conversation: the selected address's LLM body answers the message that was just saved.
    * The durable ledger stays authoritative — `replyWithAgent` owns the one-reply-per-request transaction and

package/src/cli/pr-land-heavy-remote.ts

@@ -8,10 +8,8 @@ import { debug, redactSecretText } from '../debug/log.js';
 import { gateRemoteHostCap, realGateRemoteRunner, resolveGateRemoteSettings, runOnRemote, type GateRemoteRunner, type RemoteRunOutcome } from '../self-implement/gate-remote.js';
 
 const SHA = /^[0-9a-f]{40}$/i;
-// WSL still lands last: its gate environment was repaired (WSL-GATE-ENV, 2026-10-17 — baselineWorkspaceRoot in
-// scripts/ci-typecheck-changed.ts now picks the host disk /var/tmp instead of WSL's 20GiB tmpfs), so the host is
-// allowlisted as the third slot while node-b/node-c keep discovery order — the recorded host order stays part of the
-// evidence contract.
+// This is the stable fallback order when settings.host is unavailable; an explicitly configured allowlisted host
+// always leads, and the remaining allowlisted hosts retain their relative order.
 export const PR_LAND_HEAVY_HOSTS = ['node-b', 'node-c', 'host-e-wsl'] as const;
 export const PR_LAND_HEAVY_HOST = PR_LAND_HEAVY_HOSTS[0];
 export type PrLandHeavyHost = typeof PR_LAND_HEAVY_HOSTS[number];
@@ -74,14 +72,23 @@ function evidencePath(input: HeavyRemoteInput): string {
   return join(input.evidenceDir ?? join(effectiveInstanceRoot(), 'pr-land-heavy-results'), `${input.pr}.json`);
 }
 
+function validRootPlan(value: unknown): value is RootPlanSummary | null {
+  if (value === null) return true;
+  if (!value || typeof value !== 'object') return false;
+  const plan = value as Partial<RootPlanSummary>;
+  return (plan.mode === 'affected' || plan.mode === 'full')
+    && (plan.roots === null || (Number.isSafeInteger(plan.roots) && plan.roots >= 0))
+    && typeof plan.promoted === 'boolean'
+    && (plan.reason === null || typeof plan.reason === 'string');
+}
+
 function matchingEvidence(path: string, input: HeavyRemoteInput): HeavyRemoteEvidence | null {
   if (!existsSync(path)) return null;
   try {
     const data: HeavyRemoteEvidence = JSON.parse(readFileSync(path, 'utf8'));
     return data.schema === 2 && data.pr === input.pr && data.head === input.head
       && data.main === input.main && allowedHost(data.host) && Number.isFinite(data.elapsedMs)
-      && typeof data.interferenceMeasured === 'boolean'
-      && (data.rootPlan === null || (data.rootPlan?.mode === 'affected' || data.rootPlan?.mode === 'full')) ? data : null;
+      && typeof data.interferenceMeasured === 'boolean' && validRootPlan(data.rootPlan) ? data : null;
   } catch { return null; }
 }
 
@@ -214,9 +221,8 @@ export function ensurePrLandHeavyRemote(input: HeavyRemoteInput, deps: HeavyRemo
   const started = now();
   const deadline = started + settings.slotWaitSeconds * 1000;
   let outcome: RemoteRunOutcome = { kind: 'busy' };
-  const primaryHost: PrLandHeavyHost = settings.host;
-  let selectedHost: PrLandHeavyHost = primaryHost;
-  const hosts = [primaryHost, ...PR_LAND_HEAVY_HOSTS.filter((candidate) => candidate !== primaryHost)];
+  let selectedHost: PrLandHeavyHost = PR_LAND_HEAVY_HOSTS[0];
+  const hosts: readonly PrLandHeavyHost[] = [settings.host, ...PR_LAND_HEAVY_HOSTS.filter((host) => host !== settings.host)];
   wait: for (;;) {
     for (const host of hosts) {
       selectedHost = host;

package/src/cli/release-cli.ts

@@ -9,6 +9,7 @@
 //   elanous release resume  --run <runId> --from <node> [--waive <node> --reason <text>] [--accepted-regressions <json>] [--gate-executor <pod|host> [--gate-host <ssh-host>]] [--gate-pod-pool <pool>] [--json]
 //   elanous release auto-start [--window-minutes <n>] [--apply] [--json]
 //   elanous release recover --run <runId> --pick <sha...> [--from export-check] [--command-root <path>] [--repo-root <path>] [--no-partial] [--json]
+//   elanous release recover-landing --run <runId> --merge <full-sha> [--from export-check] [--repo-root <path>] [--no-partial] [--json]
 //   elanous release rehearsal tick [--apply] [--checkout <dir>] [--shards <n>] [--remote <host>] [--recovery-run <id>] [--json]
 //   elanous release preflight --version <x.y.z> [--publish-at <iso>] [--json]   (컷 − 60분 main export 포함 사전 점검 · 읽기 전용 · ⛔ 있으면 exit 1)
 //   elanous release cut-branch --version <x.y.z> [--base <sha>] --pick <sha>... [--append] [--dry-run]
@@ -45,7 +46,7 @@ import { isIsolatedLedgerWriteRoot } from '../hq/ledger-write-target.js';
 import { runUnattendedRelease, type UnattendedReleaseDeps } from '../../scripts/release-loop/unattended-release.js';
 import { publishAtError } from '../../scripts/release-loop/publish-at.js';
 import { cutReleaseBranch } from '../../scripts/release-loop/cut-branch.js';
-import { planResumeReleaseRun, recoverReleaseRun, resumeReleaseRun, ReleaseRecoverStopped, type RecoverReleaseDeps } from '../../scripts/release-loop/resume-release.js';
+import { planResumeReleaseRun, recoverLandingPartialOption, recoverReleaseRun, recoverReleaseRunFromLanding, resumeReleaseRun, ReleaseRecoverStopped, type RecoverReleaseDeps } from '../../scripts/release-loop/resume-release.js';
 import type { AcceptedRegression } from '../../scripts/release-loop/resume.js';
 import type { PrereleaseKind } from '../../scripts/release-loop/release-version.js';
 import { releaseReadiness } from '../../scripts/release-loop/release-readiness.js';
@@ -1388,6 +1389,31 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
         }
       }, (r) => r.stages.every((stage) => stage.outcome === 'ok'));
     });
+  release.command('recover-landing')
+    .description('착지 알림 수동 재생 입구 — merge SHA로 중복을 억제하고 append → tip 고정 → export-check 재개를 수행한다. release-loop event hook 착지 전에는 사람이 직접 호출한다')
+    .requiredOption('--run <runId>', '실패한 release-loop 런 ID')
+    .requiredOption('--merge <sha>', 'main에 착지한 수리 커밋의 전체 40자리 SHA')
+    .option('--from <node>', '재개 시작 노드 — 기본 export-check')
+    .option('--command-root <path>', '재개 명령을 실행할 checkout — 생략 시 append tip 임시 checkout')
+    .option('--repo-root <path>', 'append를 실행할 checkout — origin remote 필요')
+    .option('--no-partial', 'Pod image digest 등이 맞지 않으면 전체 gate를 실행하며 부분 재검을 사용하지 않음')
+    .option('--json', '결과 한 줄 JSON(stdout) · 사람 줄은 stderr')
+    .action(async (o: { run: string; merge: string; from?: string; commandRoot?: string; repoRoot?: string; partial?: boolean; json?: boolean }) => {
+      await jsonAction(o.json, async (log) => {
+        try {
+          const partial = recoverLandingPartialOption(o.partial);
+          return await recoverReleaseRunFromLanding({ runId: o.run, mergeSha: o.merge,
+            ...(o.from === undefined ? {} : { from: o.from }),
+            ...(o.commandRoot === undefined ? {} : { commandRoot: o.commandRoot }),
+            ...(o.repoRoot === undefined ? {} : { repoRoot: o.repoRoot }),
+            ...(partial === undefined ? {} : { partial }) },
+          { ...resumeDeps, onSource: log });
+        } catch (caught) {
+          if (!(caught instanceof ReleaseRecoverStopped)) throw caught;
+          return { ok: false as const, error: caught.message, stages: [...caught.stages], notRun: [...caught.notRun], duplicate: false };
+        }
+      }, (r) => r.duplicate || r.stages.every((stage) => stage.outcome === 'ok'));
+    });
   release.command('gate-history')
     .description('GATE-FAIL-HISTORY (0.2.29) — 판을 넘는 게이트 실패 표 — 모든 release-loop·light-rc 런 원장 ⊕ gate-verdict 에서 시험 파일별 introduced·preexisting·env·flaky 횟수 · 마지막 실패 판 · 원인 PR(수리 PR 본문 «원인 #N»)')
     .option('--since <판|일>', '이 판(x.y.z)부터 · 또는 그 날(YYYY-MM-DD) 이후 시작된 런부터')

package/src/cli/sim-cli.ts

@@ -1,4 +1,6 @@
 import type { Command } from 'commander';
+import { getTestStateRoot } from '../nexus/paths.js';
+import { runReleaseSimRigIfFile } from '../ux-sim/release-sim-rig.js';
 import { runScenarioFile } from '../ux-sim/scenario.js';
 
 export function registerSimCommands(program: Command): void {
@@ -7,7 +9,11 @@ export function registerSimCommands(program: Command): void {
     .description('등록된 UX simulation 시나리오를 test 우주에서 실행한다')
     .action(async (scenarioFile: string) => {
       try {
-        const result = await runScenarioFile(scenarioFile);
+        // Enforce isolation before either runner inspects the supplied path. Otherwise
+        // release-graph dispatch can leak a path-validation error outside test mode.
+        if (!getTestStateRoot()) throw new Error('scenario runner requires --test isolated mode');
+        const releaseResult = await runReleaseSimRigIfFile(scenarioFile);
+        const result = releaseResult ?? await runScenarioFile(scenarioFile);
         console.log(JSON.stringify(result));
         if (!result.pass) process.exitCode = 1;
       } catch (error) {

package/src/cli/tasks-cli.ts

@@ -473,14 +473,15 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
   return null;
 }
 
-/** stderr 파일의 첫 비어 있지 않은 줄(최대 4KB 만 읽는다 — 원 로그 꼬리를 싣지 않는다). */
-function firstStderrLine(path: string): string {
+/** Advisory lines may precede the actual fatal error. Keep the full stderr as evidence. */
+function actionableStderrLine(path: string): string {
   try {
     const fd = openSync(path, 'r');
     try {
       const buf = Buffer.alloc(4096);
       const n = readSync(fd, buf, 0, buf.length, 0);
-      return buf.subarray(0, n).toString('utf8').split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0) ?? '';
+      const lines = buf.subarray(0, n).toString('utf8').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+      return lines.find((line) => /^(?:❌|error:|fatal:)/i.test(line)) ?? lines[0] ?? '';
     } finally { closeSync(fd); }
   } catch { return ''; }
 }
@@ -529,7 +530,7 @@ export async function defaultTaskLauncher(args: string[], cwd?: string, context?
     : undefined;
   if (timer) clearTimeout(timer);
   if (early && early.code !== 0) {
-    const first = firstStderrLine(stderrPath);
+    const first = actionableStderrLine(stderrPath);
     const cause = `child rc=${early.code ?? early.signal ?? 'unknown'}${first ? `: ${first}` : ''}`;
     const { boundRunStopCause, recordRunStop, runStopRecorded, RUN_STOP_EVENT } = await import('../self-implement/run-stop.js');
     const hasStop = deps.hasStop ?? ((id: string) => {

package/src/codex/models.ts

@@ -1,8 +1,7 @@
 // ── OpenAI Codex model catalog ──
 //
-// Curated subset of the full OpenAI Codex CLI model roster — the six
-// options that cover the most common use cases without overwhelming
-// the onboarding picker. Source: omni-crawl sweep on 2026-04-14 across
+// Curated subset of the full OpenAI Codex CLI model roster, covering
+// common use cases without overwhelming the onboarding picker. Source: omni-crawl sweep on 2026-04-14 across
 //   - developers.openai.com/api/docs/models/{all,codex-mini-latest,gpt-5-codex}
 //   - developers.openai.com/codex/models
 //   - platform.openai.com/docs/models
@@ -20,10 +19,9 @@
 // 2026-09-09 refresh (live 1차 대조 — developers.openai.com/api/내부 문서 `gpt-6-astra`
 // ⊕ openai.com/api/pricing/ ⊕ `codex exec --model gpt-6-astra` 실호출):
 //   + gpt-6-astra  (2026-09-03 출시 · 현 최상단)
-//   + gpt-5.6-terra (elanous 가 «실제로» 기본으로 쓰는 모델 — llm.model 이 이 값이다)
-// ⛔ recommended 를 gpt-5.5 → gpt-5.6-terra 로 옮겼다. 이 표의 recommended 는 「가장 센 것」이
-//   아니라 「기본으로 골라도 되는 것」이고, 그 자리에 두 세대 전 모델이 앉아 있었다.
-//   astra 는 recommended 가 «아니다» — terra 대비 input 4배·output 3.3배라 기본값이 될 수 없다.
+//   + gpt-5.6-terra (at the time, the configured `llm.model` default)
+// GPT-6.1 refresh (2026-10-28): recommended is GPT-6.1 Terra; Sol is available for higher-cost deep work.
+// `recommended` means a safe default, not the strongest model; Astra remains opt-in due to its higher cost.
 
 export type CodexModelTier = 'flagship' | 'balanced' | 'cheap' | 'specialist' | 'legacy';
 
@@ -44,11 +42,21 @@ export interface CodexModel {
   recommended?: boolean;
 }
 
-/** Six curated models for the 1-point setup picker. Ordering
- *  reflects the UI: recommended first, then by descending tier. */
+/** Curated models for the 1-point setup picker. Ordering reflects the UI:
+ *  recommended first, then by descending tier. */
 export const CODEX_MODELS: CodexModel[] = [
   {
-    // 📏 2026-09-25 캐시 읽기 단가 = 입력의 10%(OpenRouter 목록 gpt-6-astra 1.0 · sol 0.2 · luna 0.01) — 없으면 캐시분이 입력 단가로 10배 매겨졌다.
+    id: 'gpt-6.1-terra',
+    label: 'GPT-6.1 Terra',
+    tier: 'balanced',
+    description: 'Recommended everyday Codex model. 500K context; $1/$5 per million tokens, cached input $0.05.',
+    contextWindow: 500_000,
+    pricingUsd: { inputPerM: 1.0, outputPerM: 5.0, cacheReadPerM: 0.05 },
+    recommended: true,
+  },
+  {
+    // Cache-read rates: Astra $1.00/M, GPT-6.1 Sol $0.10/M, Terra $0.05/M, Luna $0.01/M.
+    // Per OP 2026-10-28 price direction, legacy GPT-6 Sol also uses $0.10/M for cost estimates.
     id: 'gpt-6-astra',
     label: 'GPT-6 Astra (frontier)',
     tier: 'flagship',
@@ -56,14 +64,21 @@ export const CODEX_MODELS: CodexModel[] = [
     contextWindow: 1_050_000,
     pricingUsd: { inputPerM: 10.0, outputPerM: 50.0, cacheReadPerM: 1.0 },
   },
+  {
+    id: 'gpt-6.1-sol',
+    label: 'GPT-6.1 Sol',
+    tier: 'flagship',
+    description: 'Higher-capability reasoning and coding model. 500K context; $2/$10 per million tokens, cached input $0.10.',
+    contextWindow: 500_000,
+    pricingUsd: { inputPerM: 2.0, outputPerM: 10.0, cacheReadPerM: 0.1 },
+  },
   {
     id: 'gpt-6-sol',
-    label: 'GPT-6 Sol',   // «recommended» 표시는 목록이 `recommended: true` 로 붙인다 — 라벨에도 쓰면 두 번 뜬다(UX 8)
-    tier: 'balanced',
-    description: 'elanous 운영 기본(대표 2026-09-23). 복합 코딩·agentic 워크플로. Reasoning «Highest» 인데 가격은 5.6 Terra 와 같은 입력·더 싼 출력. 1.05M ctx, effort none..max(기본 medium).',
+    label: 'GPT-6 Sol',
+    tier: 'legacy',
+    description: 'Legacy GPT-6 Sol retained for compatibility; GPT-6.1 Sol is its higher-performing successor at the same price, while Terra is a lower-cost default.',
     contextWindow: 1_050_000,
-    pricingUsd: { inputPerM: 2.0, outputPerM: 10.0, cacheReadPerM: 0.2 },
-    recommended: true,
+    pricingUsd: { inputPerM: 2.0, outputPerM: 10.0, cacheReadPerM: 0.1 },
   },
   {
     id: 'gpt-6-luna',

package/src/core-turn/run-core-turn.ts

@@ -33,6 +33,8 @@ import type {
   CoreTurnStopReason,
 } from './types.js';
 
+const CORE_TURN_TOOL_RESULT_INLINE_LIMIT_BYTES = 50 * 1024;
+
 /** Classify an error thrown out of `streamLLMWithTools` into the
  *  Core-turn stop-reason set. Abort wins over everything else;
  *  credential rejection (`isAuthRejectionError`) is distinct from a
@@ -329,6 +331,7 @@ export async function runCoreTurn(
         researchTurn,
         signal: ctx.signal,
         ...(ctx.requestSizeGuard ? { requestSizeGuard: ctx.requestSizeGuard } : {}),
+        toolResultInlineLimitBytes: CORE_TURN_TOOL_RESULT_INLINE_LIMIT_BYTES,
         ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}),
         ...(ctx.maxToolTurns !== undefined ? { maxTurns: ctx.maxToolTurns } : {}),
         ...(ctx.initialProvider !== undefined

package/src/core-turn/run-goal-loop.ts

@@ -211,6 +211,40 @@ export function isInterimReportShaped(text: string): boolean {
   return INTERIM_REPORT_SHAPED.test(text);
 }
 
+// TUI-FACT-TOOL-REPEAT — 턴 안에서 같은 값을 보장하는 안정 read-only 도구만 억제한다.
+//   Registry-wide readOnly metadata는 없다(FU). Live/poll·stream-consuming 조회(MsgList,
+//   ChecklistList, PtyShellPoll, AgentOutput), 외부 조회와 쓰기 동작은 이 좁은 목록 밖이다.
+const GOAL_LOOP_READ_ONLY_TOOL_NAMES: ReadonlySet<string> = new Set([
+  'Read', 'Grep', 'Glob', 'ListDir', 'release_status', 'self_recall', 'ops_seats', 'decisions_pending', 'proact_meter',
+]);
+
+/** TUI-FACT-TOOL-REPEAT — 중복 판정 키: 도구명 + 인자의 stable 직렬화(키 순서와 무관하게 같은 내용=같은 키). */
+function goalLoopReadOnlyCallKey(name: string, args: Record<string, unknown>): string {
+  return `${name}:${stableSerializeToolArgs(args)}`;
+}
+
+function stableSerializeToolArgs(value: unknown): string {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value) ?? String(value);
+  if (Array.isArray(value)) return `[${value.map(stableSerializeToolArgs).join(',')}]`;
+  const entries = Object.entries(value as Record<string, unknown>)
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    .map(([key, entry]) => `${JSON.stringify(key)}:${stableSerializeToolArgs(entry)}`);
+  return `{${entries.join(',')}}`;
+}
+
+type ReadOnlyRepeatCacheEntry =
+  | { kind: 'inflight'; pending: Promise<unknown> }
+  | { kind: 'ok'; result: unknown }
+  | { kind: 'error'; error: unknown };
+
+/** TUI-FACT-TOOL-REPEAT — 오류 캐시 적중 시 재호출 없이 돌려주는 억제 안내: 실패 근거를 실어
+ *  이 도구를 다시 호출하지 말고, 이 실패를 설명하는 최종 답으로 종결하게 유도한다. */
+function buildReadOnlyRepeatSuppressedNotice(name: string, error: unknown): string {
+  const reason = error instanceof Error ? error.message : String(error);
+  return `[tool repeat suppressed] ${name} 은(는) 이 턴에서 이미 같은 인자로 실패했습니다(오류: ${reason}). `
+    + `재시도는 억제되어 실제로 실행하지 않았습니다 — 이 도구를 다시 호출하지 말고, 이 실패 근거를 설명하는 최종 답을 지금 작성하세요.`;
+}
+
 /** 목표 실행 계약 — 첫 turn 앞에 leading system 메시지로 주입. codex 자체 prompt.md /
  *  ext-goal continuation.md 의 지속·anti-shrink·증거완료 언어 이식. ASCII + 한국어. */
 export const GOAL_SYSTEM_PREAMBLE = [
@@ -790,6 +824,30 @@ export async function runGoalLoop(
     let turnNewMessages: LLMMessage[] = [];
     let dispatchCount = 0;
     toolCallsThisIteration = 0;
+    // TUI-FACT-TOOL-REPEAT — 이번 core 턴의 read-only 중복 억제 캐시. 턴 시작마다 새로 만든다
+    //   (캐시는 현재 턴 밖으로 유지하지 않는다 — 다음 반복은 새 턴이라 같은 조회도 다시 실제 실행된다).
+    const readOnlyRepeatCache = new Map<string, ReadOnlyRepeatCacheEntry>();
+    let readOnlyRepeatGeneration = 0;
+    const invalidateReadOnlyRepeatCache = () => {
+      readOnlyRepeatGeneration += 1;
+      readOnlyRepeatCache.clear();
+    };
+    const dispatchEffect = (
+      name: string, args: Record<string, unknown>, dctx: Parameters<CoreTurnContext["dispatchTool"]>[2],
+      ack?: () => Promise<unknown>,
+    ) => {
+      // A write or external effect can change a later read in this same turn. Clear before dispatch,
+      // then clear again on settlement so an in-flight read cannot repopulate stale data.
+      invalidateReadOnlyRepeatCache();
+      let dispatched: Promise<unknown>;
+      try {
+        dispatched = Promise.resolve(seatDispatch(name, args, dctx, ack ? (() => ack()) : undefined));
+      } catch (error) {
+        invalidateReadOnlyRepeatCache();
+        return Promise.reject(error);
+      }
+      return dispatched.finally(invalidateReadOnlyRepeatCache);
+    };
     let iterInputTokens = 0;
     let iterOutputTokens = 0;
     let iterCacheReadTokens = 0;
@@ -932,9 +990,37 @@ export async function runGoalLoop(
           // 종결 신호는 예산 거부를 받지 않는다(#28503 terminalToolNames 계약과 같은 방향). 그 밖의 진행 선언
           // (in_progress·blocked)은 도구 한 번으로 세고 상한 뒤엔 같은 안내로 거부한다(리뷰 r2 — 61번 넘게 불러도 안 막히던 구멍).
           if ((args as { status?: unknown }).status === 'complete') return ack();
-          return seatDispatch(name, args, dctx, ack);
+          return dispatchEffect(name, args, dctx, ack);
+        }
+        // TUI-FACT-TOOL-REPEAT — update_goal 가로채기 판정 «뒤» read-only 실 실행 직전:
+        //   동일 read-only tool+args 는 이 턴에서 실제 실행 1회 이하(성공 결과 재사용 · 오류 재시도 억제).
+        //   쓰기·외부 효과 도구는 허용목록 밖이라 억제 없이 매번 실제 실행된다(경계 보존).
+        if (GOAL_LOOP_READ_ONLY_TOOL_NAMES.has(name)) {
+          const repeatKey = goalLoopReadOnlyCallKey(name, args);
+          const cachedRepeat = readOnlyRepeatCache.get(repeatKey);
+          if (cachedRepeat !== undefined) {
+            try {
+              debug.log('goal.loop', 'readonly-tool-repeat-suppressed', {
+                sessionId: ctx.sessionId, ...runAttribution, iteration: iterations,
+                tool: name, dispatch: dispatchCount, outcome: cachedRepeat.kind,
+              }, { level: 'info' });
+            } catch {
+              // Observability must not change the suppressed result.
+            }
+            if (cachedRepeat.kind === 'inflight') return cachedRepeat.pending;
+            if (cachedRepeat.kind === 'ok') return Promise.resolve(cachedRepeat.result);
+            return Promise.resolve(buildReadOnlyRepeatSuppressedNotice(name, cachedRepeat.error));
+          }
+          const generation = readOnlyRepeatGeneration;
+          const dispatchedRead = Promise.resolve(seatDispatch(name, args, dctx));
+          readOnlyRepeatCache.set(repeatKey, { kind: 'inflight', pending: dispatchedRead });
+          dispatchedRead.then(
+            (result) => { if (generation === readOnlyRepeatGeneration) readOnlyRepeatCache.set(repeatKey, { kind: 'ok', result }); },
+            (error) => { if (generation === readOnlyRepeatGeneration) readOnlyRepeatCache.set(repeatKey, { kind: 'error', error }); },
+          );
+          return dispatchedRead;
         }
-        return seatDispatch(name, args, dctx);
+        return dispatchEffect(name, args, dctx);
       },
       callbacks: {
         ...ctx.callbacks,

package/src/dashboard/acp-boot.ts

@@ -135,6 +135,17 @@ export interface DashboardAcpBootDeps {
    *  blocks). Dashboard stashes this into its history store so the
    *  next turn sees real tool evidence. */
   pushTurnToolHistory(messages: readonly LLMMessage[]): void;
+  /** TUI-TOKEN-GUARD-WIRE — replace the chat history store in place after the
+   *  request-size cap compacted it, so the next prompt reads the compacted
+   *  history (not the original 400+ messages). Absent = no write-back. */
+  replaceChatHistory?(messages: readonly ChatMessage[]): void;
+  /** Test seam — request-size cap override (defaults to 400k chars). */
+  requestSizeMaxChars?: number;
+  /** Test seam — the live compactor used for the history write-back. */
+  compactHistoryMessages?: (
+    messages: LLMMessage[],
+    ctx: { sessionId: string; activeModelId?: string },
+  ) => Promise<{ messages: LLMMessage[]; reason: string } | null>;
   /** Optional: agent name/version piped into the ACP handshake. */
   agentName?: string;
   agentVersion?: string;
@@ -219,6 +230,7 @@ export async function bootDashboardAcpSession(
   const gateway = deps.approvalGateway;
   const opts: DashboardSessionOptions = {
     cwd: deps.getCwd(),
+    tuiRouting: true,
     getMessages: ({ sessionId, userText }) => buildTurnMessages(deps, sessionId, userText),
     getTools: ({ sessionId, userText }) => {
       const tools = [...deps.getTools({ userText })];
@@ -229,6 +241,13 @@ export async function bootDashboardAcpSession(
     onTurnComplete: ({ newMessages }) => {
       deps.pushTurnToolHistory(newMessages);
     },
+    ...(deps.replaceChatHistory
+      ? {
+          compactPersistedHistory: ({ sessionId, userText }: { sessionId: string; userText: string }) =>
+            compactDashboardChatHistory(deps, { sessionId, userText }),
+        }
+      : {}),
+    ...(deps.requestSizeMaxChars !== undefined ? { requestSizeMaxChars: deps.requestSizeMaxChars } : {}),
     resolveModel: ({ userText }) => {
       const model = deps.getActiveModel({ userText });
       return model ?? undefined;
@@ -413,6 +432,58 @@ export function createDefaultRequestPermissionHandler(
  *  contains the latest user message for the direct path, so this
  *  helper does NOT append another one; callers that haven't stored
  *  the user message yet should do so before invoking `.send()`. */
+/** TUI-TOKEN-GUARD-WIRE — compact the dashboard chat history store in place.
+ *  Keeps a trailing current-turn user message verbatim (buildTurnMessages
+ *  detects it) and writes the result back through `replaceChatHistory`. */
+export async function compactDashboardChatHistory(
+  deps: Pick<DashboardAcpBootDeps, 'getChatHistory' | 'replaceChatHistory' | 'getActiveModel' | 'compactHistoryMessages'>,
+  ctx: { sessionId: string; userText: string },
+): Promise<{ fired: boolean; reason: string }> {
+  if (!deps.replaceChatHistory) return { fired: false, reason: 'no-history-writer' };
+  const history = [...deps.getChatHistory()];
+  const last = history[history.length - 1];
+  const trailingUser = isCurrentDashboardUser(last, ctx.userText) ? last : undefined;
+  const body = (trailingUser ? history.slice(0, -1) : history) as unknown as LLMMessage[];
+  if (body.length === 0) return { fired: false, reason: 'empty-history' };
+  const activeModelId = deps.getActiveModel({ userText: ctx.userText }) ?? undefined;
+  const compacted = deps.compactHistoryMessages
+    ? await deps.compactHistoryMessages(body, { sessionId: ctx.sessionId, ...(activeModelId ? { activeModelId } : {}) })
+    : await (async () => {
+        const { compactLiveMessages } = await import('../session/request-size-guard.js');
+        const { getUserConfig } = await import('../user-config.js');
+        const chatCfg = getUserConfig().chat;
+        return compactLiveMessages(body, {
+          sessionId: ctx.sessionId,
+          ...(activeModelId ? { activeModelId } : {}),
+          ...(chatCfg?.autoCompact?.preserveLastN !== undefined ? { preserveLastN: chatCfg.autoCompact.preserveLastN } : {}),
+          ...(chatCfg?.compact?.archiveEnabled !== undefined ? { archiveEnabled: chatCfg.compact.archiveEnabled } : {}),
+        });
+      })();
+  if (!compacted) return { fired: false, reason: 'compaction-no-op' };
+  const next = [
+    ...(compacted.messages as unknown as ChatMessage[]),
+    ...(trailingUser ? [trailingUser] : []),
+  ];
+  deps.replaceChatHistory(next);
+  debug.log('dashboard.acp', 'chat-history-compacted', {
+    before: history.length,
+    after: next.length,
+    reason: compacted.reason,
+  });
+  return { fired: true, reason: `history-${compacted.reason}` };
+}
+
+function isCurrentDashboardUser(
+  message: ChatMessage | undefined,
+  userText: string,
+): message is ChatMessage {
+  if (message?.role !== 'user') return false;
+  if (typeof message.content === 'string') return message.content === userText;
+  return message.content.some((block) =>
+    Boolean(block && typeof block === 'object' && 'text' in block
+      && typeof block.text === 'string' && block.text === userText));
+}
+
 function buildTurnMessages(
   deps: DashboardAcpBootDeps,
   sessionId: string,
@@ -425,9 +496,7 @@ function buildTurnMessages(
   // don't need to re-add. This mirrors the dashboard's current flow
   // where `chat.history.push(userMsg)` runs BEFORE streamLLMWithTools.
   const last = history[history.length - 1];
-  const hasTrailingUser = last?.role === 'user'
-    && typeof last.content === 'string'
-    && last.content.includes(userText);
+  const hasTrailingUser = isCurrentDashboardUser(last as ChatMessage | undefined, userText);
   if (hasTrailingUser) {
     return [...preamble, ...history];
   }

package/src/dashboard/index.ts

@@ -15491,6 +15491,12 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         pushTurnToolHistory: (msgs) => {
           for (const m of msgs) chat.history.push(m as ChatMessage);
         },
+        // TUI-TOKEN-GUARD-WIRE — the request-size cap writes its compaction back here so the
+        // next prompt reads the compacted history instead of reloading the original.
+        replaceChatHistory: (msgs) => {
+          chat.history.length = 0;
+          for (const m of msgs) chat.history.push(m);
+        },
         // F1 — Phase 3 · ACP `requestPermission` gateway. Routes
         // every inbound permission request to the dashboard's shared
         // approval modal so the UX matches direct-dispatch approvers

package/src/dashboard/turn-preamble.ts

@@ -15,7 +15,7 @@
 
 import type { LLMMessage } from '../llm.js';
 import type { ModelFamily } from '../models/prompts.js';
-import { debug } from '../debug/log.js';
+import { debug, redactSecretText } from '../debug/log.js';
 import type { NativeToolCatalogEntry } from '../native-tool-catalog.js';
 import { buildUniversalPreamble } from '../prompt-library/universal-preamble.js';
 import { buildSeatBootSystemMessages, type SeatBootDeps } from './seat-boot-preamble.js';
@@ -343,6 +343,17 @@ function buildDashboardTurnPreambleUnmeasured(
         debug.log('tui.notify', notificationOnlyWake ? 'notification-only-turn' : 'notification-with-user-request', {
           notificationCount: pendingNotifications.length,
         });
+        // Preserve bounded, secret-redacted evidence of the exact XML body
+        // delivered to the model. This lets live TUI diagnosis distinguish
+        // an opened turn from a notification whose fields were dropped.
+        const safeXml = redactSecretText(taskNotificationsXml);
+        const xmlPreview = safeXml.slice(0, 2_000);
+        debug.log('tui.notify', 'notification-payload', {
+          notificationCount: pendingNotifications.length,
+          xmlChars: taskNotificationsXml.length,
+          xmlPreview,
+          xmlPreviewTruncated: safeXml.length > xmlPreview.length,
+        }, { compact: { stringMax: 2_100 } });
         preamble.push({ role: 'user', content: taskNotificationsXml });
       }
     });