jeo-code 0.8.20 → 0.8.21

package/CHANGELOG.md

@@ -6,6 +6,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
+## [0.8.21] - 2026-07-10
+_"반영할꺼 같은방식으로 체크하고 배포까지" — a rescan of the working tree (after the prior audit pass) turned up 15 uncommitted files: 3 genuinely distinct features left unwired by a concurrent session, partially casualty of an earlier accidental `git checkout` incident this session (disclosed in the 0.8.20 entry above). Each was independently traced from its existing plumbing, wired to a real call site, tested, and one live-verified end-to-end over a real PTY before shipping._
+
+### Added
+- **Session draft-restore** (`src/agent/session.ts`, `src/commands/launch/session-slash.ts`, `src/commands/launch.ts`, `src/commands/launch/input.ts`) — an unsent, half-typed prompt now survives a hard exit (Ctrl+D/EOF/disconnected terminal) and is restored into the prompt box on `/resume` (gajae-code parity). The read-side plumbing (`updateSessionDraft`, `header.draft`, `runSessionSlash` surfacing it) already existed; `launch.ts` never consumed it. Added `persistSessionDraft` (mirrors the existing `persistSessionModel` pattern) and a new pure predicate `draftFromUnsentLine` (`launch/input.ts`), wired into all 3 resume paths — the interactive picker, the mid-loop `/session resume` command, and `--resume <id>`/`--continue`'s non-interactive startup path (this third path had NO draft restoration at all before this fix). Live-verified: seeded a real session's draft, launched the real `bun src/cli.ts --resume <id>` under a genuine PTY, confirmed the exact unsent text appeared in the live prompt box.
+- **Evidence-gated goal verification** (`src/agent/goal-verifier.ts`, `src/agent/engine.ts`, `src/commands/launch.ts`) — an LLM-judged `MET` goal verdict is now deterministically downgraded to `NOT_MET` when the turn mutated files with no fresh verification evidence, closing the "gate theater" failure mode (an LLM asserting success without re-checked evidence). `applyEvidenceGate` (pure, already unit-tested with 5 tests) existed but was never called anywhere — the same disconnected-scaffolding pattern `RouteHistory` shipped with in 0.8.16/0.8.17. `onBeforeDone`'s signature now carries the SAME `sawMutation`/`sawVerification`/`verificationStale` signals the engine's own done-gate already computes; `launch.ts`'s goal-verifier closure now gates `verifyGoal`'s raw verdict through it before persisting or acting on it.
+
+### Fixed
+- **`toolTarget` dedup** (`src/agent/step-budget.ts`, `src/agent/task-tool.ts`) — `task-tool.ts` had a private copy of the same coarse-call-target labeler `step-budget.ts` needed for a new edit-thrashing novelty rule (a model rewriting the same file with different content every attempt no longer earns endless step-budget extensions — only the first attempt at a given target counts as novel). Moved to `step-budget.ts` (exported), `task-tool.ts` now imports it — confirmed byte-identical, zero behavior change.
+
+### Added (catalog)
+- **`gpt-5.6`** (`src/ai/model-catalog.ts`) — OpenAI's newest catalogued model, consistent with existing entries; correctly excluded from the OAuth-only `CODEX_MODELS` allow-list (live discovery handles that drift per its own documented contract, not a static edit).
+
+### Verified
+- `bun test test/launch-flags.test.ts test/session-draft-restore.test.ts test/step-budget.test.ts test/goal-verifier.test.ts test/task-tool.test.ts test/doctor.test.ts test/prompt-router-tiers.test.ts test/model-catalog.test.ts` — 128 pass / 0 fail.
+- Full `bun test` — 2906 pass / 0 fail across 291 files.
+- `bun run typecheck` — no errors.
+- Live PTY end-to-end: real session seeded with `updateSessionDraft`, real `bun src/cli.ts --resume <id>` subprocess, confirmed the exact restored text in the live prompt box.
+
 ## [0.8.20] - 2026-07-10
 _"모든 검증 다시 리뷰하고 변경사항 모두 체크해" — 4 fresh, skeptical subagents independently re-audited every change from v0.8.17-0.8.19 (bc8768f..92c6b7d) with zero trust in prior claims: a code-correctness auditor manually traced the Antigravity routing logic against the live catalog, a test-integrity auditor mutation-tested the new tests (confirmed each one genuinely fails when its fix is reverted) and ran the suite fresh, a live-behavior verifier re-reproduced all 4 behavioral claims from scratch with self-generated data (own session ids, own mock server, own HTTP status code), and a docs-accuracy auditor cross-checked every README/CHANGELOG claim against current code in isolated git worktrees. Verdict: all core logic and tests GENUINE/CONFIRMED CORRECT — but the audit surfaced 1 real doc staleness gap, 1 changelog count error, and 2 minor precision gaps, all fixed here._
 

package/README.ja.md

@@ -265,11 +265,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.21]** (2026-07-10) — "반영할꺼 같은방식으로 체크하고 배포까지" — a rescan of the working tree (after the prior audit pass) turned up 15 uncommitted files: 3 genuinely distinct features left unwired by a concurrent session, partially casualty of an earlier accidental `git checkout` incident this session (disclosed in the 0.8.20 entry above). Each was independently traced from its existing plumbing, wired to a real call site, tested, and one live-verified end-to-end over a real PTY before shipping.
 - **[0.8.20]** (2026-07-10) — "모든 검증 다시 리뷰하고 변경사항 모두 체크해" — 4 fresh, skeptical subagents independently re-audited every change from v0.8.17-0.8.19 (bc8768f..92c6b7d) with zero trust in prior claims: a code-correctness auditor manually traced the Antigravity routing logic against the live catalog, a test-integrity auditor mutation-tested the new tests (confirmed each one genuinely fails when its fix is reverted) and ran the suite fresh, a live-behavior verifier re-reproduced all 4 behavioral claims from scratch with self-generated data (own session ids, own mock server, own HTTP status code), and a docs-accuracy auditor cross-checked every README/CHANGELOG claim against current code in isolated git worktrees. Verdict: all core logic and tests GENUINE/CONFIRMED CORRECT — but the audit surfaced 1 real doc staleness gap, 1 changelog count error, and 2 minor precision gaps, all fixed here.
 - **[0.8.19]** (2026-07-09) — "프롬프트 라우팅에 안티그라비티 프로바이더의 경우, 안티그라비티용 소넷과 오퍼스도 3.5급으로 라우팅될수있도록해줘" — Antigravity re-exports 3 distinct model families (Anthropic Claude, Google Gemini, OpenAI GPT-OSS) behind one credential, structurally unlike every other provider. `high`/`complex` tier auto-select always resolved to Google's Gemini 3.5 rows: Anthropic's real 64,000-token output ceiling lost a same-thinking-tier tie to Google's 65,536 by a margin with no practical significance, and Gemini's 1M-token context further outranked Claude's real 200K window — so `antigravity/claude-sonnet-4-6`/`antigravity/claude-opus-4-6-thinking` were NEVER reachable through auto-select, even though both were already correctly `sizeClass`-tagged into the `high`/`complex` pools.
 - **[0.8.18]** (2026-07-09) — "라우팅 매 프롬프트마다 변경되는지, route why 의도대로 동작하는지 검증하고 배포할게있는지 확인해줘" — 2 parallel subagents live-verified per-prompt routing + `/route why` (including the previously-only-unit-tested post-call equivalent-model fallback path, now reproduced against a real mock 500-error server) and audited a disconnected `RouteHistory` class shipped as incomplete scaffolding in 0.8.16/0.8.17 (class + 11 tests existed, but nothing ever called it — no `/route history` subcommand, no wiring into the turn loop). Live testing also surfaced one real bug: the TUI footer's model/provider label never updated after a mid-turn fallback, staying on the pre-fallback model for the rest of that turn's render even though the backend decision (`lastRouteDecision`) was already correct.
 - **[0.8.17]** (2026-07-09) — "서브에이전트 이용해. 병렬루 부가 나머지모두 개선하고 검증후 배포까지하자" — a prior 4-way parallel subagent cross-verification pass found the README `[!CAUTION]` routing-lock block (added this session for "프롬프트 라우팅이 한번 정해지면 안바뀌는데?") was directionally correct but had 2 real inaccuracies, plus a concrete test-coverage gap: every existing pin/override regression test drove the lock via the `--model` CLI startup flag, never via typing `/model <name>` as an interactive slash command mid-session, and none proved persistence across 3+ consecutive turns.
-- **[0.8.16]** (2026-07-09) — "jeo code의 computer use 기능은 / 명령어로 설정할수있도록하고, 실동작검증까지진행해줘" — the desktop-automation `computer` tool was only togglable by hand-editing `computer.enabled` in `~/.jeo/config.json`; there was no in-session way to enable it for a single run without leaving a permanent config change behind.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -266,11 +266,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.21]** (2026-07-10) — "반영할꺼 같은방식으로 체크하고 배포까지" — a rescan of the working tree (after the prior audit pass) turned up 15 uncommitted files: 3 genuinely distinct features left unwired by a concurrent session, partially casualty of an earlier accidental `git checkout` incident this session (disclosed in the 0.8.20 entry above). Each was independently traced from its existing plumbing, wired to a real call site, tested, and one live-verified end-to-end over a real PTY before shipping.
 - **[0.8.20]** (2026-07-10) — "모든 검증 다시 리뷰하고 변경사항 모두 체크해" — 4 fresh, skeptical subagents independently re-audited every change from v0.8.17-0.8.19 (bc8768f..92c6b7d) with zero trust in prior claims: a code-correctness auditor manually traced the Antigravity routing logic against the live catalog, a test-integrity auditor mutation-tested the new tests (confirmed each one genuinely fails when its fix is reverted) and ran the suite fresh, a live-behavior verifier re-reproduced all 4 behavioral claims from scratch with self-generated data (own session ids, own mock server, own HTTP status code), and a docs-accuracy auditor cross-checked every README/CHANGELOG claim against current code in isolated git worktrees. Verdict: all core logic and tests GENUINE/CONFIRMED CORRECT — but the audit surfaced 1 real doc staleness gap, 1 changelog count error, and 2 minor precision gaps, all fixed here.
 - **[0.8.19]** (2026-07-09) — "프롬프트 라우팅에 안티그라비티 프로바이더의 경우, 안티그라비티용 소넷과 오퍼스도 3.5급으로 라우팅될수있도록해줘" — Antigravity re-exports 3 distinct model families (Anthropic Claude, Google Gemini, OpenAI GPT-OSS) behind one credential, structurally unlike every other provider. `high`/`complex` tier auto-select always resolved to Google's Gemini 3.5 rows: Anthropic's real 64,000-token output ceiling lost a same-thinking-tier tie to Google's 65,536 by a margin with no practical significance, and Gemini's 1M-token context further outranked Claude's real 200K window — so `antigravity/claude-sonnet-4-6`/`antigravity/claude-opus-4-6-thinking` were NEVER reachable through auto-select, even though both were already correctly `sizeClass`-tagged into the `high`/`complex` pools.
 - **[0.8.18]** (2026-07-09) — "라우팅 매 프롬프트마다 변경되는지, route why 의도대로 동작하는지 검증하고 배포할게있는지 확인해줘" — 2 parallel subagents live-verified per-prompt routing + `/route why` (including the previously-only-unit-tested post-call equivalent-model fallback path, now reproduced against a real mock 500-error server) and audited a disconnected `RouteHistory` class shipped as incomplete scaffolding in 0.8.16/0.8.17 (class + 11 tests existed, but nothing ever called it — no `/route history` subcommand, no wiring into the turn loop). Live testing also surfaced one real bug: the TUI footer's model/provider label never updated after a mid-turn fallback, staying on the pre-fallback model for the rest of that turn's render even though the backend decision (`lastRouteDecision`) was already correct.
 - **[0.8.17]** (2026-07-09) — "서브에이전트 이용해. 병렬루 부가 나머지모두 개선하고 검증후 배포까지하자" — a prior 4-way parallel subagent cross-verification pass found the README `[!CAUTION]` routing-lock block (added this session for "프롬프트 라우팅이 한번 정해지면 안바뀌는데?") was directionally correct but had 2 real inaccuracies, plus a concrete test-coverage gap: every existing pin/override regression test drove the lock via the `--model` CLI startup flag, never via typing `/model <name>` as an interactive slash command mid-session, and none proved persistence across 3+ consecutive turns.
-- **[0.8.16]** (2026-07-09) — "jeo code의 computer use 기능은 / 명령어로 설정할수있도록하고, 실동작검증까지진행해줘" — the desktop-automation `computer` tool was only togglable by hand-editing `computer.enabled` in `~/.jeo/config.json`; there was no in-session way to enable it for a single run without leaving a permanent config change behind.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -273,11 +273,11 @@ Huge thanks to [gajae-code](https://github.com/Yeachan-Heo/gajae-code) for the i
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.21]** (2026-07-10) — "반영할꺼 같은방식으로 체크하고 배포까지" — a rescan of the working tree (after the prior audit pass) turned up 15 uncommitted files: 3 genuinely distinct features left unwired by a concurrent session, partially casualty of an earlier accidental `git checkout` incident this session (disclosed in the 0.8.20 entry above). Each was independently traced from its existing plumbing, wired to a real call site, tested, and one live-verified end-to-end over a real PTY before shipping.
 - **[0.8.20]** (2026-07-10) — "모든 검증 다시 리뷰하고 변경사항 모두 체크해" — 4 fresh, skeptical subagents independently re-audited every change from v0.8.17-0.8.19 (bc8768f..92c6b7d) with zero trust in prior claims: a code-correctness auditor manually traced the Antigravity routing logic against the live catalog, a test-integrity auditor mutation-tested the new tests (confirmed each one genuinely fails when its fix is reverted) and ran the suite fresh, a live-behavior verifier re-reproduced all 4 behavioral claims from scratch with self-generated data (own session ids, own mock server, own HTTP status code), and a docs-accuracy auditor cross-checked every README/CHANGELOG claim against current code in isolated git worktrees. Verdict: all core logic and tests GENUINE/CONFIRMED CORRECT — but the audit surfaced 1 real doc staleness gap, 1 changelog count error, and 2 minor precision gaps, all fixed here.
 - **[0.8.19]** (2026-07-09) — "프롬프트 라우팅에 안티그라비티 프로바이더의 경우, 안티그라비티용 소넷과 오퍼스도 3.5급으로 라우팅될수있도록해줘" — Antigravity re-exports 3 distinct model families (Anthropic Claude, Google Gemini, OpenAI GPT-OSS) behind one credential, structurally unlike every other provider. `high`/`complex` tier auto-select always resolved to Google's Gemini 3.5 rows: Anthropic's real 64,000-token output ceiling lost a same-thinking-tier tie to Google's 65,536 by a margin with no practical significance, and Gemini's 1M-token context further outranked Claude's real 200K window — so `antigravity/claude-sonnet-4-6`/`antigravity/claude-opus-4-6-thinking` were NEVER reachable through auto-select, even though both were already correctly `sizeClass`-tagged into the `high`/`complex` pools.
 - **[0.8.18]** (2026-07-09) — "라우팅 매 프롬프트마다 변경되는지, route why 의도대로 동작하는지 검증하고 배포할게있는지 확인해줘" — 2 parallel subagents live-verified per-prompt routing + `/route why` (including the previously-only-unit-tested post-call equivalent-model fallback path, now reproduced against a real mock 500-error server) and audited a disconnected `RouteHistory` class shipped as incomplete scaffolding in 0.8.16/0.8.17 (class + 11 tests existed, but nothing ever called it — no `/route history` subcommand, no wiring into the turn loop). Live testing also surfaced one real bug: the TUI footer's model/provider label never updated after a mid-turn fallback, staying on the pre-fallback model for the rest of that turn's render even though the backend decision (`lastRouteDecision`) was already correct.
 - **[0.8.17]** (2026-07-09) — "서브에이전트 이용해. 병렬루 부가 나머지모두 개선하고 검증후 배포까지하자" — a prior 4-way parallel subagent cross-verification pass found the README `[!CAUTION]` routing-lock block (added this session for "프롬프트 라우팅이 한번 정해지면 안바뀌는데?") was directionally correct but had 2 real inaccuracies, plus a concrete test-coverage gap: every existing pin/override regression test drove the lock via the `--model` CLI startup flag, never via typing `/model <name>` as an interactive slash command mid-session, and none proved persistence across 3+ consecutive turns.
-- **[0.8.16]** (2026-07-09) — "jeo code의 computer use 기능은 / 명령어로 설정할수있도록하고, 실동작검증까지진행해줘" — the desktop-automation `computer` tool was only togglable by hand-editing `computer.enabled` in `~/.jeo/config.json`; there was no in-session way to enable it for a single run without leaving a permanent config change behind.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -265,11 +265,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.21]** (2026-07-10) — "반영할꺼 같은방식으로 체크하고 배포까지" — a rescan of the working tree (after the prior audit pass) turned up 15 uncommitted files: 3 genuinely distinct features left unwired by a concurrent session, partially casualty of an earlier accidental `git checkout` incident this session (disclosed in the 0.8.20 entry above). Each was independently traced from its existing plumbing, wired to a real call site, tested, and one live-verified end-to-end over a real PTY before shipping.
 - **[0.8.20]** (2026-07-10) — "모든 검증 다시 리뷰하고 변경사항 모두 체크해" — 4 fresh, skeptical subagents independently re-audited every change from v0.8.17-0.8.19 (bc8768f..92c6b7d) with zero trust in prior claims: a code-correctness auditor manually traced the Antigravity routing logic against the live catalog, a test-integrity auditor mutation-tested the new tests (confirmed each one genuinely fails when its fix is reverted) and ran the suite fresh, a live-behavior verifier re-reproduced all 4 behavioral claims from scratch with self-generated data (own session ids, own mock server, own HTTP status code), and a docs-accuracy auditor cross-checked every README/CHANGELOG claim against current code in isolated git worktrees. Verdict: all core logic and tests GENUINE/CONFIRMED CORRECT — but the audit surfaced 1 real doc staleness gap, 1 changelog count error, and 2 minor precision gaps, all fixed here.
 - **[0.8.19]** (2026-07-09) — "프롬프트 라우팅에 안티그라비티 프로바이더의 경우, 안티그라비티용 소넷과 오퍼스도 3.5급으로 라우팅될수있도록해줘" — Antigravity re-exports 3 distinct model families (Anthropic Claude, Google Gemini, OpenAI GPT-OSS) behind one credential, structurally unlike every other provider. `high`/`complex` tier auto-select always resolved to Google's Gemini 3.5 rows: Anthropic's real 64,000-token output ceiling lost a same-thinking-tier tie to Google's 65,536 by a margin with no practical significance, and Gemini's 1M-token context further outranked Claude's real 200K window — so `antigravity/claude-sonnet-4-6`/`antigravity/claude-opus-4-6-thinking` were NEVER reachable through auto-select, even though both were already correctly `sizeClass`-tagged into the `high`/`complex` pools.
 - **[0.8.18]** (2026-07-09) — "라우팅 매 프롬프트마다 변경되는지, route why 의도대로 동작하는지 검증하고 배포할게있는지 확인해줘" — 2 parallel subagents live-verified per-prompt routing + `/route why` (including the previously-only-unit-tested post-call equivalent-model fallback path, now reproduced against a real mock 500-error server) and audited a disconnected `RouteHistory` class shipped as incomplete scaffolding in 0.8.16/0.8.17 (class + 11 tests existed, but nothing ever called it — no `/route history` subcommand, no wiring into the turn loop). Live testing also surfaced one real bug: the TUI footer's model/provider label never updated after a mid-turn fallback, staying on the pre-fallback model for the rest of that turn's render even though the backend decision (`lastRouteDecision`) was already correct.
 - **[0.8.17]** (2026-07-09) — "서브에이전트 이용해. 병렬루 부가 나머지모두 개선하고 검증후 배포까지하자" — a prior 4-way parallel subagent cross-verification pass found the README `[!CAUTION]` routing-lock block (added this session for "프롬프트 라우팅이 한번 정해지면 안바뀌는데?") was directionally correct but had 2 real inaccuracies, plus a concrete test-coverage gap: every existing pin/override regression test drove the lock via the `--model` CLI startup flag, never via typing `/model <name>` as an interactive slash command mid-session, and none proved persistence across 3+ consecutive turns.
-- **[0.8.16]** (2026-07-09) — "jeo code의 computer use 기능은 / 명령어로 설정할수있도록하고, 실동작검증까지진행해줘" — the desktop-automation `computer` tool was only togglable by hand-editing `computer.enabled` in `~/.jeo/config.json`; there was no in-session way to enable it for a single run without leaving a permanent config change behind.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.8.20",
+  "version": "0.8.21",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/agent/engine.ts

@@ -27,7 +27,8 @@ import { isContextOverflowError, isRefusalError, friendlyProviderError } from ".
 import { runPreToolHooks, runPostTurnHooksForBatch } from "./hooks";
 import { truncateToolOutput, formatToolResultBody } from "./tool-output";
 export { TOOL_OUTPUT_MAX, READ_OUTPUT_MAX, TOOL_SPILL_THRESHOLD, MAX_TOOL_ARTIFACTS, truncateToolOutput, spillToolResult } from "./tool-output";
-import { StepBudget, dynamicStepBudgetConfig, resolveStepBudgetConfig, hashSignature, type StepBudgetConfig } from "./step-budget";
+import { StepBudget, dynamicStepBudgetConfig, resolveStepBudgetConfig, hashSignature, toolTarget, type StepBudgetConfig } from "./step-budget";
+
 import { historyTokens, trimToolResultsInPlace, stripReasoningArtifactsInPlace } from "./compaction";
 import { jeoEnv } from "../util/env";
 import { GUARD_LIMITS, isVerificationSignal, repeatHint, classifyDoneGate } from "./loop-guards";
@@ -1058,6 +1059,22 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
     // once per call here (instead of joining full sigs, hashing, then re-hashing
     // inside budget.record) avoids re-scanning a large write body 3× per step.
     const callSigs = toolCalls.map(c => hashSignature(`${c.tool}:${JSON.stringify(c.arguments ?? {})}`));
+    // Coarse per-call TARGET (e.g. `edit src/x.ts`) — feeds the budget's novelty rule
+    // separately from the exact-args digest above. A model that keeps rewriting the
+    // SAME file/command with slightly different content each attempt produces a fresh
+    // `callSigs` entry every time (never "seen" before) but the SAME `callTargets`
+    // entry, so that thrashing stops earning step-budget extensions after its first try.
+    // `toolTarget` falls back to the bare tool name when it can't find an identifying
+    // field (e.g. a custom/dynamic tool with no filePath/command/pattern argument) — that
+    // generic case carries NO real identity ("work" for every call), so treat it as "no
+    // coarse target" and let `budget.record` fall back to the exact-args signature
+    // instead (unchanged legacy novelty for tools this helper doesn't specifically know).
+    const callTargets = toolCalls.map(c => {
+      const t = toolTarget(c.tool, c.arguments);
+      return t.toLowerCase() === (c.tool || "").toLowerCase() ? undefined : t;
+    });
+
+
     const sig = callSigs.length === 1 ? callSigs[0] : hashSignature(callSigs.join(" | "));
     if (sig === lastSig) repeatCount++;
     else {
@@ -1313,7 +1330,8 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
     // edits plus one trivial successful read must not look like a progressing
     // step to the extension heuristic (that loophole earned endless extensions).
     for (let i = 0; i < toolCalls.length; i++) {
-      if (results[i].executed) budget.record(callSigs[i], results[i].success);
+      if (results[i].executed) budget.record(callSigs[i], results[i].success, callTargets[i]);
+
     }
     // done-verification guard bookkeeping: write/edit successes mark the turn as
     // mutating; a successful bash whose command/output looks like a test/build run

package/src/agent/step-budget.ts

@@ -168,17 +168,29 @@ export class StepBudget {
   }
 
   /** Record an executed tool call (ring-buffered to the scoring window).
-   *  Stored as a fixed-size digest — see `hashSignature` (memory bound). */
-  record(signature: string, success: boolean): void {
+   *  Stored as a fixed-size digest — see `hashSignature` (memory bound).
+   *
+   *  `targetKey` (optional) is the COARSE target (e.g. `edit src/x.ts`) the novelty rule
+   *  scores against, instead of `signature`'s full-args hash. Without it, retrying an
+   *  edit on the SAME file with slightly different content each attempt looks "novel"
+   *  forever (the exact args hash never repeats) and the extension heuristic reads that
+   *  edit-thrashing loop as endless progress. With it, only the FIRST attempt at a given
+   *  target counts as novel; grinding on the same file/command afterwards does not, so a
+   *  stuck rewrite loop stops earning extensions even though every individual call
+   *  "succeeds" and every exact signature is technically unique. Falls back to `signature`
+   *  when omitted (unchanged behavior for existing callers/tests). */
+  record(signature: string, success: boolean, targetKey?: string): void {
     const sig = hashSignature(signature);
-    if (!this.seen.has(sig)) {
-      this.seen.add(sig);
+    const noveltyKey = hashSignature(targetKey ?? signature);
+    if (!this.seen.has(noveltyKey)) {
+      this.seen.add(noveltyKey);
       this.novelSinceExtension++;
     }
     this.window.push({ signature: sig, success });
     if (this.window.length > this.cfg.windowSize) this.window.shift();
   }
 
+
   /** A mid-turn steering message arrived — fresh, user-driven work. Grant headroom
    *  (capped at the hard cap, without consuming the extension budget) and clear the
    *  scoring window so the new instruction is never declined by the previous
@@ -239,3 +251,31 @@ export class StepBudget {
     };
   }
 }
+/**
+ * A concise, gjc-style label for a tool call's actual TARGET (file / command / glob) —
+ * not just the bare tool name plus its full argument blob. Two calls that touch the SAME
+ * target (e.g. `edit src/x.ts` twice with different bodies) collapse to the same target
+ * key here even though `hashSignature` of their full arguments differs. Shared by the
+ * budget's novelty rule (below) and `task-tool.ts`'s live subagent monitor label — kept
+ * pure/local (no TUI dependency in the agent layer).
+ */
+export function toolTarget(tool: string, rawArgs: unknown): string {
+  const a = (rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs) ? rawArgs : {}) as Record<string, unknown>;
+  const t = (tool || "").toLowerCase();
+  const str = (...keys: string[]): string => {
+    for (const k of keys) { const v = a[k]; if (typeof v === "string" && v.length > 0) return v; }
+    return "";
+  };
+  if (t === "bash") {
+    const cmd = str("command", "cmd").split("\n")[0]!.trim();
+    return cmd ? `bash: ${cmd.length > 80 ? cmd.slice(0, 79) + "…" : cmd}` : "bash";
+  }
+  if (t === "read" || t === "write" || t === "edit") {
+    const f = str("filePath", "path");
+    return f ? `${t} ${f}` : t;
+  }
+  if (t === "find") { const g = str("globPattern", "pattern"); return g ? `find ${g}` : "find"; }
+  if (t === "search") { const p = str("pattern"); return p ? `search ${p}` : "search"; }
+  if (t === "task") { const r = str("role"); return r ? `task ${r}` : "task"; }
+  return tool || "tool";
+}

package/src/agent/task-tool.ts

@@ -10,6 +10,8 @@
  * `task` itself, so delegation cannot recurse infinitely.
  */
 import { runAgentLoop, type ToolHandler } from "./engine";
+import { toolTarget } from "./step-budget";
+
 import type { ToolResult } from "./tools";
 import type { Message } from "./loop";
 import { loadProjectContext, withProjectContext } from "./context-files";
@@ -146,31 +148,6 @@ export function taskToolProtocolLine(config?: Pick<Config, "subagents">): string
   );
 }
 
-/**
- * A concise, gjc-style label for a subagent's tool call — the actual TARGET (file / command /
- * glob), not just the bare tool name — so the parent's live monitor shows "read src/x.ts" or
- * "bash: bun test" instead of "read"/"bash". Kept local (no TUI dependency in the agent layer).
- */
-function toolTarget(tool: string, rawArgs: unknown): string {
-  const a = (rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs) ? rawArgs : {}) as Record<string, unknown>;
-  const t = (tool || "").toLowerCase();
-  const str = (...keys: string[]): string => {
-    for (const k of keys) { const v = a[k]; if (typeof v === "string" && v.length > 0) return v; }
-    return "";
-  };
-  if (t === "bash") {
-    const cmd = str("command", "cmd").split("\n")[0]!.trim();
-    return cmd ? `bash: ${cmd.length > 80 ? cmd.slice(0, 79) + "…" : cmd}` : "bash";
-  }
-  if (t === "read" || t === "write" || t === "edit") {
-    const f = str("filePath", "path");
-    return f ? `${t} ${f}` : t;
-  }
-  if (t === "find") { const g = str("globPattern", "pattern"); return g ? `find ${g}` : "find"; }
-  if (t === "search") { const p = str("pattern"); return p ? `search ${p}` : "search"; }
-  if (t === "task") { const r = str("role"); return r ? `task ${r}` : "task"; }
-  return tool || "tool";
-}
 
 function firstUsefulLine(output: string | undefined): string {
   if (!output) return "";

package/src/commands/launch/input.ts

@@ -415,6 +415,19 @@ export function captureLivePromptInputChunk(state: PromptInputQueue, chunk: stri
   return accepted;
 }
 
+/**
+ * Whether an in-flight readline line buffer (captured right before a hard
+ * exit — Ctrl+D/EOF/disconnected terminal) should be persisted as an unsent
+ * draft (gajae-code "unsent prompt survives /resume" parity). Whitespace-only
+ * or empty input is never a real draft. Pure predicate so the exit-path
+ * wiring in launch.ts (which owns the actual persistence side effect) stays
+ * thin and this decision is independently testable.
+ */
+export function draftFromUnsentLine(line: string | undefined): string | undefined {
+  const trimmed = (line ?? "").trim();
+  return trimmed ? trimmed : undefined;
+}
+
 /**
  * TTY "new input first" contract: fold any queued FULL lines (stray
  * Enter-terminated buffer noise, or older persisted queues) into the editable

package/src/commands/launch.ts

@@ -50,7 +50,7 @@ import { readGlobalConfig, saveConfigPatch, resolveWikiRoot } from "../agent/sta
 import { rememberModelPatch, recentModelsForDisplay } from "../agent/model-recency";
 import { describeModel, describeAllProviders, describeProvider, resolveProvider, thinkingMaxTokens, resolveMaxOutputTokens, thinkingToReasoningEffort, discoverModels, flattenModels, resolveSelection, catalogMetadata, catalogByProvider, resolveRoleModel, CODEX_MODELS, qualifyModelId, modelServableWithConfig, isLocalProviderReachable } from "../ai";
 import type { ProviderModelsResult, PickEntry, ProviderName, ModelRole, ThinkLevel } from "../ai";
-import { readGoalState, writeGoalState, clearGoalState, verifyGoal } from "../agent/goal-verifier";
+import { readGoalState, writeGoalState, clearGoalState, verifyGoal, applyEvidenceGate } from "../agent/goal-verifier";
 import { routePrompt, deriveCacheSessionKey, warnOnce, tierModelPool, selectFromPool, PROMPT_TIERS, withRoutingTierSetting, inferTierForModel, type PromptTier, type RouteDecision } from "../agent/prompt-router";
 import { RouteHistory } from "../agent/route-history";
 
@@ -110,6 +110,7 @@ import {
   latestSessionId,
   exportSession,
   updateSessionModel,
+  updateSessionDraft,
   appendCompaction,
   resolveSessionRef,
 } from "../agent/session";
@@ -163,6 +164,7 @@ import {
   boxVerticalNavAction,
   queuePromptInputChunk,
   captureLivePromptInputChunk,
+  draftFromUnsentLine,
   restoreQueuedLinesToPrefill,
   createInFlightAbortHarness,
   classifyMidTurnLine,
@@ -262,6 +264,7 @@ export {
   boxVerticalNavAction,
   queuePromptInputChunk,
   captureLivePromptInputChunk,
+  draftFromUnsentLine,
   restoreQueuedLinesToPrefill,
   createInFlightAbortHarness,
   classifyMidTurnLine,
@@ -687,6 +690,12 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   let lastUserInput = "";
   // Full untruncated text of the last assistant reply — surfaced in detail by Ctrl+O.
   let lastReply = "";
+  // Unsent draft restored from a NON-interactive resume path (`--resume <id>`,
+  // `--continue`/`-c`) — the interactive-picker and mid-loop `/session resume`
+  // paths feed `queuedPromptInput.partial` directly (declared much later); this
+  // one exists because `queuedPromptInput` isn't in scope yet at startup. Read
+  // once by `queuedPromptInput`'s own initializer below, then not touched again.
+  let startupDraft: string | undefined;
   // Full untruncated output of the most recent tool call — the clipped forge
   // card's `⟦Ctrl+O for more⟧` hint resolves here.
   let lastToolDetail: { tool: string; output: string } | null = null;
@@ -808,6 +817,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           // Restore the model this session was last using unless the CLI explicitly
           // pinned one (flags.model/role/provider → initialSessionModel wins).
           if (!initialSessionModel && header.model) sessionModel = header.model;
+          // Restore the unsent input-box draft (gajae-code parity) — see
+          // startupDraft's own doc comment for why this path can't feed
+          // queuedPromptInput.partial directly yet.
+          if (header.draft) startupDraft = header.draft;
           const modelNote = sessionModel ? ` · model ${sessionModel}` : "";
           console.log(`Resumed session ${id} (${messages.length} messages).${modelNote}`);
         } catch (err) {
@@ -841,6 +854,18 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     } catch { /* best-effort */ }
   };
 
+  // Persist (or clear) the unsent input-box draft into the session header so a
+  // later `/resume` restores it into the prompt (gajae-code parity: an
+  // in-progress prompt survives a quit + resume instead of being silently
+  // lost). Best-effort, same contract as persistSessionModel above — a
+  // header-rewrite failure must never abort the exit path that calls this.
+  const persistSessionDraft = async (draft: string): Promise<void> => {
+    if (flags.noSession || !sessionId) return;
+    try {
+      await updateSessionDraft(sessionId, draft, cwd);
+    } catch { /* best-effort */ }
+  };
+
   // `step N/M` display seed: the explicit --max-steps cap, else the dynamic budget's
   // rolling base — the engine's onBudget event keeps the denominator honest as it grows.
   const initialStepLimit = flags.maxSteps > 0 ? flags.maxSteps : initialDynamicStepLimit();
@@ -1282,7 +1307,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         // Todos checklist used to end a finished turn stuck at "✓0 ◐1 ·4 / 5"
         // because nothing ever forced the model to update item statuses).
         let turnTodos: { title: string; status: string }[] = [];
-        const onBeforeDone = async (reason: string): Promise<string | null> => {
+        const onBeforeDone = async (
+          reason: string,
+          evidence: { sawMutation: boolean; sawVerification: boolean; verificationStale: boolean },
+        ): Promise<string | null> => {
           const unfinished = turnTodos.filter(t => t.status !== "done");
           if (turnTodos.length > 0 && unfinished.length > 0) {
             return (
@@ -1304,7 +1332,12 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             }
 
             if (tui) tui.events().onNotice?.("[Goal Verifier] Running goal verification...");
-            const verdict = await verifyGoal(goalState.condition, history, activeModel);
+            const llmVerdict = await verifyGoal(goalState.condition, history, activeModel);
+            // Deterministic downgrade: a fresh MET from the transcript-only LLM
+            // judge still needs mutation/verification evidence to back it up —
+            // see applyEvidenceGate's own docs (goal-verifier.ts). NOT_MET/
+            // IMPOSSIBLE pass through unchanged; this only ever tightens MET.
+            const verdict = applyEvidenceGate(llmVerdict, evidence);
 
             goalState.verdicts.push({
               at: Date.now(),
@@ -2182,7 +2215,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // IMMEDIATELY on its next iteration, bypassing the "new input first" prefill contract
   // (the user explicitly invoked them — no second Enter).
   const pendingMidTurnCommands: string[] = [];
-  const queuedPromptInput: PromptInputQueue = { pendingLines: pendingStdinLines, partial: "", pastedLines: [], inPaste: false };
+  const queuedPromptInput: PromptInputQueue = { pendingLines: pendingStdinLines, partial: startupDraft ?? "", pastedLines: [], inPaste: false };
   queueBusyInput = (chunk: string) => captureLivePromptInputChunk(queuedPromptInput, chunk);
   queueBusyPasteActive = () => queuedPromptInput.inPaste;
   queueBusySnapshot = () => ({
@@ -2251,6 +2284,13 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // hard break, not a graceful `/exit`. Some Bun/tmux paths leave stdin.isTTY
     // false while stdout is still a TTY, so accept either side as interactive.
     if ((process.stdin.isTTY || process.stdout.isTTY || previewEnabled) && !gracefulReadlineClose) {
+      // Best-effort, fire-and-forget: persist whatever's still typed but unsent
+      // (Ctrl+D / EOF / disconnected terminal — no explicit discard gesture, unlike
+      // Ctrl+C's own "clear the box" contract, which stays untouched here) so
+      // `/resume` can restore it (see persistSessionDraft above). Must not block
+      // process.exit() below.
+      const draft = draftFromUnsentLine((rl as unknown as { line?: string }).line);
+      if (draft) void persistSessionDraft(draft);
       hardExitOnLoopEnd = true;
       forceExitFromCtrlC();
     }
@@ -3695,6 +3735,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     if (pickResult.sessionModel !== undefined) sessionModel = pickResult.sessionModel;
     if (pickResult.lastUserInput !== undefined) lastUserInput = pickResult.lastUserInput;
     if (pickResult.lastReply !== undefined) lastReply = pickResult.lastReply;
+    // Restore the unsent input-box draft left over at last save (gajae-code
+    // parity) — feeds the SAME "new input first" prefill path queued mid-turn
+    // lines already use, so it's visible in the box, Enter to run, Esc/Ctrl+U
+    // to discard, on the very first prompt of this resumed session.
+    if (pickResult.draft) queuedPromptInput.partial = pickResult.draft;
   }
 
   // Remote (Telegram) free-text reply / config command routing — wired here,
@@ -3898,6 +3943,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         if (result.sessionModel !== undefined) sessionModel = result.sessionModel;
         if (result.lastUserInput !== undefined) lastUserInput = result.lastUserInput;
         if (result.lastReply !== undefined) lastReply = result.lastReply;
+        // Restore the unsent input-box draft (see the resumeInteractive call
+        // site above for the full rationale) — `continue` below immediately
+        // re-enters the loop top, which consumes `queuedPromptInput.partial`
+        // as this next prompt's prefill.
+        if (result.draft) queuedPromptInput.partial = result.draft;
         continue;
       }
       if (input === "/retry") {