jutell 2.0.0 → 2.0.1

package/README.md

@@ -1,39 +1,186 @@
-# jutell
+# JuTell
 
-**Tell your coding agent what you actually mean — and understand what it actually did.**
+**Tell your agent what you mean. Understand what it did.**
 
-Before work, JuTell clarifies only the decisions that would actually change the result (at most one concise question) and checks project facts itself. After work, it turns the result into a plain-language report: what changed, what's actually verified, what's still unknown, and what to do next. It never guarantees your agent's answers — it keeps both directions honest.
+[![npm version](https://img.shields.io/npm/v/jutell.svg)](https://www.npmjs.com/package/jutell)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/ju0o/jutell/blob/main/LICENSE)
+[![node: >=18](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](https://nodejs.org)
+![Codex: Supported](https://img.shields.io/badge/Codex-Supported-brightgreen)
+![Claude Code: Beta](https://img.shields.io/badge/Claude%20Code-Beta-yellow)
+![OpenCode: Beta](https://img.shields.io/badge/OpenCode-Beta-yellow)
+
+For people who can tell a coding agent what they want, but don't want to read code or logs just to
+know whether it actually worked.
 
 ```bash
 npm install -g jutell
 jutell
 ```
 
-`jutell` finds the coding agents you already have installed, asks for one approval, connects them, and hands you straight back to your normal session — no per-agent setup command needed for a normal first run.
+That's the whole setup. `jutell` finds the coding agents already installed on your machine, asks
+for one approval, connects them, and hands you straight back to your normal session.
 
-| Agent | Status |
-|---|---|
-| Codex | Supported |
-| Claude Code | Beta |
-| OpenCode | Beta |
+JuTell sits **beside** a coding agent you already use — Codex, Claude Code, or OpenCode. It checks
+project facts before work and separates verified from assumed after it. It is not an AI model, and
+it does not provide or replace your agent.
 
-To connect (or reconnect) one specific agent by hand, use `jutell use codex` / `jutell use claude` / `jutell use opencode` — this is the manual/repair path, not the normal first run.
+## The problem it solves
 
-**한국어 사용자라면:** 전체 문서와 한국어 안내는 [GitHub 저장소의 README.ko.md](https://github.com/ju0o/jutell/blob/main/README.ko.md)에 있습니다.
+AI coding agents made writing code faster. They didn't fix two older problems:
 
-Full docs, images, and the complete feature walkthrough live on [GitHub](https://github.com/ju0o/jutell#readme).
+- **Before work** — it's hard to explain exactly what you mean, and an agent that guesses wrong can
+  quietly do the wrong thing.
+- **After work** — a wall of diffs and "I tested it" don't tell you what's real and what's assumed.
 
-<details>
-<summary>Build from source instead (contributors / verifying the repo directly)</summary>
+JuTell doesn't write code. It makes the conversation around the code honest, on both ends.
 
-Most people should use the npm install above.
+## What it actually looks like
 
-```bash
-cd packages/cli
-npm install
-npm pack
-npm install -g ./jutell-2.0.0.tgz
+A real first run, on a project with OpenCode installed:
+
+```console
+$ jutell
+JuTell
+
+Found coding agents:
+
+Codex        not detected
+OpenCode     found
+Claude Code  not detected
+
+Connecting JuTell...
+OpenCode connected.
+
+Open a new conversation in OpenCode and JuTell applies automatically.
+```
+
+Then check it honestly — note that it does **not** claim the agent session picked it up, because it
+cannot see that from here:
+
+```console
+$ jutell status
+JuTell status
+
+CLI: 2.0.1
+Skill: installed
+AGENTS.md: JuTell block present
+OpenCode MCP: enabled (auto-start on new session)
+Codex MCP: not registered
+Current agent session applied: needs direct confirmation
+Profile: balanced
+Telemetry: disabled
+External transmission: none
 ```
-</details>
 
-The legacy `beginner-bridge` command is a compatibility alias for the same functionality and tells you to switch to `jutell` when you run it. The CLI does not collect or transmit your project code, prompts, AI answers, Git diffs, or secrets.
+And when something looks wrong:
+
+```console
+$ jutell doctor
+OK       Node version: Node 22.22.1
+OK       Skill file: verified
+OK       Skill version: 2.0.1 (installed copy matches)
+OK       MCP server live connection (Stdio): JuTell server responded with 5 tools
+OK       External transmission code: no outbound patterns in the MCP build
+Check    Current agent session applied: must be confirmed in that agent's session
+Warning  Codex MCP: not registered
+```
+
+`doctor` marks every line OK / warning / needs-a-closer-look, and never prints full paths or secret
+values.
+
+## The rule it follows
+
+JuTell does not call something "verified" unless it actually checked it. On a real run that changed
+an empty-search message's styling, it reported:
+
+| | |
+|---|---|
+| Code checked | the style values actually changed |
+| Test checked | the existing test still passed |
+| Real browser view | **not checked** — no browser was available |
+| Your action | Open the screen once and look. |
+
+It does not turn "looks right in code" into "confirmed on screen."
+
+If you are verifying the source instead of installing from npm, `npm pack` in
+`packages/cli` creates `jutell-2.0.1.tgz`; ordinary users do not need this path.
+
+## Supported agents & platforms
+
+| What you need | Status |
+|---|---|
+| **Codex** | Supported |
+| **Claude Code** | Beta |
+| **OpenCode** | Beta |
+| Windows | Tested |
+| Ubuntu | Limited testing |
+| macOS | Available / unverified |
+
+You need a coding agent first — JuTell connects to one you already installed.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `jutell` | Finds installed agents and offers to connect them. |
+| `jutell status` | Installation, connection, profile, and feature status. |
+| `jutell doctor` | Checks for setup problems. |
+| `jutell use codex` / `claude` / `opencode` | Connect one agent by hand (repair path). |
+| `jutell on` / `jutell off` | Turn the connection on or off. |
+| `jutell upgrade` | Refresh the installed Skill/config/MCP. |
+| `jutell uninstall` | Remove JuTell's managed setup. |
+
+Reports can be tuned with a project `.jutell.json` — profiles `minimal`, `balanced`, `learning`,
+`detailed` change explanation length, never the underlying facts or risk.
+
+## First things to try
+
+1. "Change the login button to blue."
+2. "Please make signup simpler."
+3. "Make the empty search box show a helpful message."
+
+For 1 and 3, JuTell should let your agent get on with it. For "make signup simpler," it should read
+the project first and ask **one** grounded question only if a real choice remains — not turn your
+request into a questionnaire.
+
+## What JuTell is — and is not
+
+**Is:** a communication layer beside your coding agent · clarifies material intent before work ·
+explains actual work and evidence after it.
+
+**Is not:** an AI model · a replacement coding agent · a correctness guarantee · a full autonomous
+debugger · a multi-agent orchestrator.
+
+## Trust and privacy
+
+JuTell explains work using files, Git, and command output already on your computer. It does not
+collect or send your project code, prompts, raw agent answers, diffs, or secrets. Telemetry is off
+by default and its storage/transmission is not implemented at this stage.
+
+## Install trouble on Ubuntu/Linux
+
+If `npm install -g jutell` fails with `EACCES` / permission denied, that's a common npm global
+folder ownership issue, not something specific to JuTell. **Avoid `sudo npm install -g jutell`** —
+it leaves root-owned files that cause the same problem again. Two safe fixes:
+[Ubuntu/Linux install permission error](https://github.com/ju0o/jutell/blob/main/docs/CLI_INSTALLATION.md).
+
+## 한국어
+
+전체 한국어 문서는 [README.ko.md](https://github.com/ju0o/jutell/blob/main/README.ko.md)에 있습니다.
+비개발자도 "승인해도 되는가", "무엇을 직접 확인해야 하는가"를 판단할 수 있게 하는 것이 목적입니다.
+
+## More
+
+Full walkthrough with images, a real report, a real failure, and an honest efficiency snapshot:
+[GitHub README](https://github.com/ju0o/jutell#readme) ·
+[2.0.0 release showcase](https://github.com/ju0o/jutell/blob/main/docs/releases/2.0.0-showcase.md) ·
+[Changelog](https://github.com/ju0o/jutell/blob/main/CHANGELOG.md) ·
+[MCP integration](https://github.com/ju0o/jutell/blob/main/docs/MCP_INTEGRATION.md)
+
+## Support
+
+JuTell is free and MIT-licensed, and it stays that way. If it saved you time:
+
+[![Support on Ko-fi](https://img.shields.io/badge/Ko--fi-support-FF5E5B?logo=ko-fi&logoColor=white)](https://ko-fi.com/ju0o___)
+
+Not supporting changes nothing — every feature stays available to everyone.

package/assets/mcp-server/index.js

@@ -5,7 +5,7 @@ import { activeFeatures, beginnerReportRules, bridgeStatus, reportPreferences, s
 import { recordToolCall } from './tools/usage-counters.js';
 const server = new McpServer({
     name: 'JuTell',
-    version: '2.0.0',
+    version: '2.0.1',
 }, {
     instructions: 'JuTell by Ju0 is a local read-only report helper. Read only project configuration and approved report rules. Never access project code, Git diff, prompts, AI answers, secrets, or external networks. Skill mode remains available if this MCP server is disabled or unavailable. When both jutell and beginner_bridge servers are visible, prefer the canonical jutell server; use beginner_bridge only for compatibility. For owner-facing reports, apply the JuTell reporting guidance before composing the final answer. Prefer these tools over re-reading the JuTell Skill reference files when both are available, since a tool call returns the same project-specific rules in one step. Call get_beginner_report_rules once, at task completion, right before writing the final report — not after every file read, shell command, or edit, and not to verify work that is already done. If these tools are unavailable or blocked, fall back to the JuTell Skill files without interrupting the task, and never tell the user JuTell MCP was used unless a JuTell tool call actually returned a result in this task.',
 });

package/assets/skill/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: beginner-bridge
-jutellSkillVersion: "2.0.0"
+jutellSkillVersion: "2.0.1"
 schemaVersion: 1
 description: JuTell by Ju0 creates concise, evidence-based work reports for non-developers, separating observed facts, code-based expectations, verification results, risks, and user actions. The legacy Skill ID is retained for compatibility.
 ---

package/assets/version.json

@@ -1,5 +1,5 @@
 {
-  "cli": "2.0.0",
+  "cli": "2.0.1",
   "skill": "확인 필요",
   "mcp": "0.1.0",
   "admin": "0.1.0"

package/dist/cli.js

@@ -11,6 +11,7 @@ import { useCommand, connectCommand, disconnectCommand, switchCommand } from './
 import { sessionCommand } from './commands/session/index.js';
 import { upgradeCommand } from './commands/upgrade.js';
 import { migrateCommand } from './commands/migrate.js';
+import { maybeShowFundingNotice } from './output/funding.js';
 function safeError(message, verbose) {
     if (verbose)
         return message;
@@ -21,6 +22,9 @@ function safeError(message, verbose) {
 export async function run(argv = process.argv.slice(2), io = createIo(), legacyAlias = false) {
     if (legacyAlias)
         io.write('`beginner-bridge`는 이전 명령입니다. 앞으로는 `jutell` 사용을 권장합니다.');
+    const fundingSuppressed = argv.includes('--no-funding');
+    if (fundingSuppressed)
+        argv = argv.filter((a) => a !== '--no-funding');
     if (argv.includes('--version')) {
         io.write((await readVersionInfo()).cli);
         return 0;
@@ -72,6 +76,7 @@ export async function run(argv = process.argv.slice(2), io = createIo(), legacyA
             await sessionCommand(paths, options, io, extraArgs);
         else
             throw new Error(`알 수 없는 명령입니다: ${command}`);
+        maybeShowFundingNotice(paths, io, fundingSuppressed);
         return 0;
     }
     catch (error) {

package/dist/commands/migrate.js

@@ -102,11 +102,27 @@ export async function migrateCommand(paths, options, io) {
             const legacyPattern = /# BEGINNER_BRIDGE_CLI_MCP_BEGIN[\s\S]*?# BEGINNER_BRIDGE_CLI_MCP_END\n?/m;
             const legacyPattern2 = /# BEGINNER_BRIDGE_MCP_BEGIN[\s\S]*?# BEGINNER_BRIDGE_MCP_END\n?/m;
             let next = text.replace(legacyPattern, '').replace(legacyPattern2, '');
-            // Also remove unmarked legacy with heuristic: if beginner_bridge still present but not in managed block, check evidence
-            if (/^\s*\[mcp_servers\.beginner_bridge\]/m.test(next) && /(?:assets|apps)[\\/]mcp-server/i.test(next.slice(next.search(/^\s*\[mcp_servers\.beginner_bridge\]/m), next.search(/^\s*\[mcp_servers\.beginner_bridge\]/m) + 1200))) {
-                // Remove that section (from header until next header/marker or end)
-                const idx = next.search(/^\s*\[mcp_servers\.beginner_bridge\]/m);
-                const after = next.slice(idx);
+            // Also remove unmarked legacy with heuristic: if beginner_bridge still present but not in managed block, check evidence.
+            // Use indexOf (not a `\s*`-prefixed regex .search()) to find the header: `^\s*\[...\]` lets
+            // `\s*` swallow a preceding blank line, so .search() can return an index *before* the literal
+            // `[` - e.g. when `use codex` leaves a blank-line separator above this block (its normal
+            // output shape). `after.slice(1)` below then only strips 1 of those whitespace chars, lands
+            // back inside the same header, and "the next header" it finds is this one again, so nothing
+            // ever gets cut. indexOf always anchors exactly at `[`, where slice(1) is meant to start from.
+            const beginnerHeader = '[mcp_servers.beginner_bridge]';
+            const headerIdx = next.indexOf(beginnerHeader);
+            if (headerIdx >= 0) {
+                // Bound the section to *this table only* (up to the next `[section]` header,
+                // the canonical marker, or EOF) before doing anything else with it. The
+                // evidence check below must only ever look inside that bound - a flat N-char
+                // lookahead from the header (the previous approach) reads past this table's
+                // own end into whatever comes next in the file, and a JuTell-managed config
+                // almost always has the real `assets/mcp-server` canonical entry sitting
+                // right after the legacy one - so that flat window would find canonical's
+                // path and treat it as evidence for the *unrelated* entry above it, deleting
+                // a genuinely unrelated user-owned `beginner_bridge` server that merely
+                // happens to sit next to JuTell's own block in the same file.
+                const after = next.slice(headerIdx);
                 const nextHeader = after.slice(1).search(/^\s*\[mcp_servers\./m);
                 const nextMarker = after.search(/#\s*JUTELL_CLI_MCP_BEGIN/m);
                 let cut = after.length;
@@ -114,7 +130,10 @@ export async function migrateCommand(paths, options, io) {
                     cut = Math.min(cut, nextHeader + 1);
                 if (nextMarker >= 0)
                     cut = Math.min(cut, nextMarker);
-                next = next.slice(0, idx) + after.slice(cut);
+                const ownSection = after.slice(0, cut);
+                if (/(?:assets|apps)[\\/]mcp-server/i.test(ownSection)) {
+                    next = next.slice(0, headerIdx) + after.slice(cut);
+                }
             }
             next = next.replace(/\n{3,}/g, '\n\n').trim();
             await writeTextSafely(file, next ? `${next}\n` : '');

package/dist/commands/status.js

@@ -55,14 +55,16 @@ export async function getStatus(paths) {
     const warnings = [];
     if (!config.valid)
         warnings.push('설정 파일을 읽지 못해 balanced 기본값을 사용 중입니다.');
+    if (config.invalidLimitsFields.length)
+        warnings.push(`.jutell.json의 limits 값 중 숫자가 아닌 항목이 있어 기본값을 대신 사용했습니다: ${config.invalidLimitsFields.join(', ')}. 실제 파일 값은 바뀌지 않았으니 직접 고쳐주세요.`);
     if (registration.conflict)
         warnings.push('같은 이름의 관리되지 않는 Codex MCP 설정이 있어 자동 변경하지 않았습니다.');
     if (opencode.conflict)
         warnings.push('OpenCode 설정에 같은 이름의 관리되지 않는 MCP 항목이 있어 자동 변경하지 않았습니다.');
     if (registration.bothRegistered)
-        warnings.push('Codex에 canonical jutell과 legacy beginner_bridge MCP가 모두 있습니다. 자동 정리하지 않았습니다. 이전 항목 제거는 추후 안전한 마이그레이션에서 안내합니다.');
+        warnings.push('Codex에 canonical jutell과 legacy beginner_bridge MCP가 모두 있습니다. 자동 정리하지 않았습니다. 이전 항목을 정리하려면 jutell migrate --clean 을 실행하세요.');
     if (opencode.bothRegistered)
-        warnings.push('OpenCode에 canonical jutell과 legacy beginner_bridge MCP가 모두 있습니다. 자동 정리하지 않았습니다. 이전 항목 제거는 추후 안전한 마이그레이션에서 안내합니다.');
+        warnings.push('OpenCode에 canonical jutell과 legacy beginner_bridge MCP가 모두 있습니다. 자동 정리하지 않았습니다. 이전 항목을 정리하려면 jutell migrate --clean 을 실행하세요.');
     if (registration.legacyRegistered && !registration.canonicalRegistered)
         warnings.push('Codex에 이전 beginner_bridge 항목만 있습니다. jutell use codex 를 실행하면 보존하면서 새 jutell 항목을 추가합니다.');
     if (opencode.legacyRegistered && !opencode.canonicalRegistered)
@@ -176,9 +178,14 @@ export async function getDoctorResults(paths) {
     checks.push({ name: 'Claude Code MCP', status: claude.registered ? '정상' : '주의', detail: claude.registered ? `${claude.claudeScope} 범위(${claude.claudeScope === 'user' ? '사용자 전역' : '현재 프로젝트'})에 등록되어 있습니다.` : 'Claude Code MCP가 등록되지 않았습니다.' });
     checks.push({ name: config.source === 'legacy' ? '.beginner-bridge.json' : '.jutell.json', status: config.valid ? '정상' : '오류', detail: config.exists ? (config.valid ? (config.source === 'legacy' ? '이전 설정 파일을 읽었습니다. 새 .jutell.json이 없으면 사용합니다.' : '설정 형식을 확인했습니다.') : '설정이 올바르지 않아 기본값을 사용합니다.') : '없으면 기본 설정을 사용합니다.' });
     const featuresValid = Object.keys(config.config.features).every((id) => FEATURE_IDS.includes(id));
-    const limitsValid = config.config.limits.maxMainFiles >= 1 && config.config.limits.maxMainFiles <= 10 && config.config.limits.maxGlossaryTerms >= 0 && config.config.limits.maxGlossaryTerms <= 10 && config.config.limits.compactReportMaxSentences >= 4 && config.config.limits.compactReportMaxSentences <= 30;
+    // Range check runs on the already-normalized (defaulted) values, so it can never itself
+    // fail - normalizeConfig() only ever produces values inside these ranges. Fold in
+    // invalidLimitsFields (computed from the raw, pre-normalization file) so a malformed
+    // value that got silently replaced with its default is still reported as unhealthy,
+    // not "정상" for a file whose actual on-disk content doesn't match what's checked.
+    const limitsValid = config.config.limits.maxMainFiles >= 1 && config.config.limits.maxMainFiles <= 10 && config.config.limits.maxGlossaryTerms >= 0 && config.config.limits.maxGlossaryTerms <= 10 && config.config.limits.compactReportMaxSentences >= 4 && config.config.limits.compactReportMaxSentences <= 30 && config.invalidLimitsFields.length === 0;
     checks.push({ name: '공식 Feature ID', status: featuresValid ? '정상' : '오류', detail: featuresValid ? '현재 공식 ID만 확인했습니다.' : '지원하지 않는 Feature ID가 있습니다.' });
-    checks.push({ name: 'limits', status: limitsValid ? '정상' : '오류', detail: limitsValid ? '허용 범위를 확인했습니다.' : '허용 범위를 벗어난 값이 있습니다.' });
+    checks.push({ name: 'limits', status: limitsValid ? '정상' : '오류', detail: config.invalidLimitsFields.length ? `숫자가 아닌 값이 있어 기본값을 대신 사용했습니다: ${config.invalidLimitsFields.join(', ')}.` : limitsValid ? '허용 범위를 확인했습니다.' : '허용 범위를 벗어난 값이 있습니다.' });
     checks.push({ name: '로컬 관리자 빌드', status: await exists(adminEntry) ? '정상' : '오류', detail: await exists(adminEntry) ? '관리자 화면 파일을 확인했습니다.' : '관리자 화면 파일이 없습니다.' });
     checks.push({ name: '포트 사용 가능 여부', status: await portAvailable() ? '정상' : '주의', detail: '127.0.0.1의 임시 포트를 확인했습니다.' });
     checks.push({ name: '쓰기 권한', status: await writeCheck(paths) ? '정상' : '오류', detail: '로컬 상태 폴더에 임시 파일을 만들고 삭제했습니다.' });

package/dist/commands/use.js

@@ -2,7 +2,7 @@ import { assets, codexScopedPaths, packageRoot } from '../config/paths.js';
 import { readCodexRegistration, registerMcp, snapshot, restore } from '../config/managed.js';
 import { ensureBridgeConfig, setMcpEnabled } from '../installer/config.js';
 import { installSkill, recordSkillFiles, removeAddedSkillFiles } from '../installer/skill.js';
-import { agentsFile, ensureJuTellAgentsBlock } from '../installer/agents.js';
+import { agentsFile, claudeMdFile, ensureJuTellAgentsBlock } from '../installer/agents.js';
 import { opencodeDetected, readOpenCodeRegistration, registerOpenCodeMcp, setOpenCodeEnabled } from '../installer/opencode.js';
 import { readClaudeRegistration, registerClaudeMcp, removeClaudeMcp } from '../installer/claude.js';
 import { findProvider, supportedProviderNames } from '../installer/providers.js';
@@ -54,8 +54,12 @@ async function resolveTarget(args, io) {
 async function registrationSnapshots(paths) {
     const opencode = await readOpenCodeRegistration(paths, packageRoot(), false);
     const files = [paths.configFile, paths.codexConfigFile, codexScopedPaths(paths).codexConfigFile, opencode.file, paths.claudeConfigFile];
+    // registerClaudeMcp writes CLAUDE.md before touching the MCP entry (see its
+    // comment) - snapshot it too so a failure partway through `use claude`
+    // rolls it back along with AGENTS.md instead of leaving it added while the
+    // MCP registration itself got rolled back.
     if (paths.scope === 'project')
-        files.push(agentsFile(paths.targetRoot));
+        files.push(agentsFile(paths.targetRoot), claudeMdFile(paths.targetRoot));
     return Promise.all(files.map((file) => snapshot(file)));
 }
 async function registerProviderEnabled(paths, provider, io) {
@@ -63,7 +67,7 @@ async function registerProviderEnabled(paths, provider, io) {
     await adapter.register(paths, true);
     const current = await adapter.read(paths, true);
     if (current.canonicalRegistered && current.legacyRegistered) {
-        io.write('\n이전 beginner_bridge 항목을 그대로 두고 새 jutell 항목을 추가했습니다.\n이전 항목은 자동으로 삭제하지 않습니다. 제거는 추후 안전한 마이그레이션에서 안내합니다.');
+        io.write('\n이전 beginner_bridge 항목을 그대로 두고 새 jutell 항목을 추가했습니다.\n이전 항목은 자동으로 삭제하지 않습니다. 정리하려면 jutell migrate --clean 을 실행하세요.');
     }
     if (provider.id === 'codex') {
         io.write('\nCodex는 MCP 서버 목록을 사용자 전역 설정에서만 읽습니다.\nJuTell 프로젝트 규칙(AGENTS.md, Skill, 설정)은 이 프로젝트에 그대로 두고,\nCodex MCP 연결만 사용자 전역 설정(Codex 홈)에 등록했습니다.');

package/dist/config/managed.js

@@ -109,19 +109,40 @@ export function normalizeConfig(value) {
         voice: { preset: voicePreset },
     };
 }
+const LIMITS_KEYS = ['maxMainFiles', 'maxGlossaryTerms', 'compactReportMaxSentences'];
+// normalizeConfig() silently substitutes the schema default for any limits field that
+// isn't a valid integer - correct for making the CLI keep working, but it never signals
+// that the substitution happened, so a user's own (invalid) edit is silently overridden
+// with no way to notice. Computed separately here (readBridgeConfig has the raw parsed
+// object; normalizeConfig only returns the already-normalized result) so status/doctor
+// can warn about it without changing normalizeConfig's own return shape or call sites.
+function invalidLimitsFields(parsed) {
+    if (!('limits' in parsed))
+        return []; // never set - nothing of the user's is being overridden
+    const limits = parsed.limits;
+    // `limits` present but not a plain object (a string, array, number, boolean, or null)
+    // is the same silent-override problem one level up: normalizeConfig()'s own
+    // `input.limits && typeof === 'object' && !Array.isArray` guard treats any of these
+    // as if `limits` were `{}` and defaults every field - so report all three as invalid
+    // rather than picking apart a shape that was never a fields-object to begin with.
+    if (!limits || typeof limits !== 'object' || Array.isArray(limits))
+        return [...LIMITS_KEYS];
+    const record = limits;
+    return LIMITS_KEYS.filter((key) => key in record && !(typeof record[key] === 'number' && Number.isInteger(record[key])));
+}
 export async function readBridgeConfig(paths) {
     const preferred = await readText(paths.configFile);
     const raw = preferred ?? await readText(paths.legacyConfigFile);
     const source = preferred !== undefined ? 'new' : raw !== undefined ? 'legacy' : 'default';
     if (!raw)
-        return { config: await defaultConfig(), exists: false, valid: true, source };
+        return { config: await defaultConfig(), exists: false, valid: true, source, invalidLimitsFields: [] };
     try {
         const parsed = JSON.parse(raw);
         const valid = parsed.version === 1 && typeof parsed.profile === 'string' && PROFILES.includes(parsed.profile);
-        return { config: normalizeConfig(parsed), exists: true, valid, source };
+        return { config: normalizeConfig(parsed), exists: true, valid, source, invalidLimitsFields: invalidLimitsFields(parsed) };
     }
     catch {
-        return { config: await defaultConfig(), exists: true, valid: false, source };
+        return { config: await defaultConfig(), exists: true, valid: false, source, invalidLimitsFields: [] };
     }
 }
 export async function writeBridgeConfig(paths, config) {

package/dist/installer/agents.js

@@ -19,12 +19,22 @@ function markerPattern() {
 export function agentsFile(projectRoot) {
     return path.join(projectRoot, 'AGENTS.md');
 }
-export async function hasJuTellAgentsBlock(projectRoot) {
-    const content = await readText(agentsFile(projectRoot));
+// Claude Code does not auto-discover `AGENTS.md` the way Codex/OpenCode do - it
+// auto-loads `CLAUDE.md` instead (verified empirically: a project with only an
+// AGENTS.md canary instruction was never followed, the same canary in CLAUDE.md
+// always was). Without this, `jutell use claude` reports a healthy MCP
+// connection while the agent never learns to read SKILL.md or call jutell_*
+// tools, because the one file telling it to do that sits somewhere Claude Code
+// doesn't automatically read. Same managed block, same markers, second file -
+// see `ensureJuTellClaudeMdBlock` below, wired in from installer/claude.ts.
+export function claudeMdFile(projectRoot) {
+    return path.join(projectRoot, 'CLAUDE.md');
+}
+async function hasManagedBlock(file) {
+    const content = await readText(file);
     return Boolean(content && markerPattern().test(content));
 }
-export async function ensureJuTellAgentsBlock(projectRoot) {
-    const file = agentsFile(projectRoot);
+async function ensureManagedBlock(file) {
     const current = await readText(file) ?? '';
     const next = markerPattern().test(current)
         ? current.replace(markerPattern(), managedBlock).replace(/\n{3,}/g, '\n\n').trimEnd() + '\n'
@@ -33,8 +43,7 @@ export async function ensureJuTellAgentsBlock(projectRoot) {
         await writeTextSafely(file, next);
     return { changed: next !== current };
 }
-export async function removeJuTellAgentsBlock(projectRoot) {
-    const file = agentsFile(projectRoot);
+async function removeManagedBlock(file) {
     const current = await readText(file);
     if (!current || !markerPattern().test(current))
         return { changed: false };
@@ -42,3 +51,21 @@ export async function removeJuTellAgentsBlock(projectRoot) {
     await writeTextSafely(file, next ? `${next}\n` : '');
     return { changed: true };
 }
+export async function hasJuTellAgentsBlock(projectRoot) {
+    return hasManagedBlock(agentsFile(projectRoot));
+}
+export async function ensureJuTellAgentsBlock(projectRoot) {
+    return ensureManagedBlock(agentsFile(projectRoot));
+}
+export async function removeJuTellAgentsBlock(projectRoot) {
+    return removeManagedBlock(agentsFile(projectRoot));
+}
+export async function hasJuTellClaudeMdBlock(projectRoot) {
+    return hasManagedBlock(claudeMdFile(projectRoot));
+}
+export async function ensureJuTellClaudeMdBlock(projectRoot) {
+    return ensureManagedBlock(claudeMdFile(projectRoot));
+}
+export async function removeJuTellClaudeMdBlock(projectRoot) {
+    return removeManagedBlock(claudeMdFile(projectRoot));
+}

package/dist/installer/claude.js

@@ -2,6 +2,7 @@ import { execFileSync } from 'node:child_process';
 import path from 'node:path';
 import { readText } from '../config/managed.js';
 import { claudeHome } from '../config/paths.js';
+import { ensureJuTellClaudeMdBlock, removeJuTellClaudeMdBlock } from './agents.js';
 export const CLAUDE_MCP_KEY = 'jutell';
 function normalizeForCompare(value) {
     return value.replace(/\\/g, '/').toLowerCase();
@@ -119,6 +120,14 @@ function runClaude(args, paths) {
     });
 }
 export async function registerClaudeMcp(paths, packageRoot, enabled) {
+    // Claude Code auto-loads `CLAUDE.md`, not `AGENTS.md` (verified empirically -
+    // see the comment on ensureJuTellClaudeMdBlock). Without a managed CLAUDE.md,
+    // the MCP server below connects fine but the agent never learns to read
+    // SKILL.md or call jutell_* tools, since AGENTS.md alone isn't guaranteed to
+    // be discovered. Ensured unconditionally (before the idempotent early-return
+    // below) so a repeat `use claude` still restores it if a user deleted it.
+    if (paths.scope === 'project')
+        await ensureJuTellClaudeMdBlock(paths.targetRoot);
     const current = await readClaudeRegistration(paths, packageRoot, enabled);
     const config = await readClaudeConfig(paths);
     if (config === undefined)
@@ -147,6 +156,13 @@ export async function registerClaudeMcp(paths, packageRoot, enabled) {
 }
 export async function removeClaudeMcp(paths, packageRoot) {
     const current = await readClaudeRegistration(paths, packageRoot, false);
+    // CLAUDE.md is Claude-specific (no other provider reads it, same way only
+    // OpenCode reads its own opencode.json mcp block) - unlike AGENTS.md, which
+    // stays shared across providers and is only ever touched by disable/uninstall.
+    // Removed here unconditionally so disconnect/switch/uninstall - every caller
+    // of removeClaudeMcp - clean it up too, not just the MCP entry.
+    if (paths.scope === 'project')
+        await removeJuTellClaudeMdBlock(paths.targetRoot);
     if (!current.registered)
         return current;
     try {

package/dist/output/format.js

@@ -140,7 +140,7 @@ export function parseOptions(args) {
 }
 export function scopeLabel(scope) { return scope === 'global' ? '사용자 전역' : '현재 프로젝트'; }
 export function printHelp(io) {
-    io.write(`JuTell CLI 2.0.0
+    io.write(`JuTell CLI 2.0.1
 
 시작할 때는 jutell만 입력하면 됩니다.
 설치된 Coding Agent(Codex, OpenCode, Claude Code)를 찾아 연결하고,

package/dist/output/funding.js

@@ -0,0 +1,38 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const FUNDING_URL = 'https://ko-fi.com/ju0o___';
+const MARKER_FILE = 'funding-notice-shown';
+function truthy(value) {
+    if (!value)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return normalized !== '' && normalized !== '0' && normalized !== 'false';
+}
+/**
+ * Shows the support line at most once per machine, and only in a real
+ * terminal. Never runs in CI, never blocks, and never changes the exit code:
+ * any failure here is swallowed so a funding message can't break a command.
+ */
+export function maybeShowFundingNotice(paths, io, suppressed) {
+    try {
+        if (suppressed)
+            return;
+        if (truthy(process.env.JUTELL_NO_FUNDING))
+            return;
+        if (truthy(process.env.CI))
+            return;
+        if (!process.stdout.isTTY)
+            return;
+        const marker = path.join(paths.dataRoot, MARKER_FILE);
+        if (fs.existsSync(marker))
+            return;
+        fs.mkdirSync(paths.dataRoot, { recursive: true });
+        fs.writeFileSync(marker, new Date().toISOString());
+        io.write('');
+        io.write(`JuTell은 무료이고 앞으로도 무료입니다. 도움이 되셨다면: ${FUNDING_URL}`);
+        io.write('이 안내는 다시 표시되지 않습니다. (끄기: JUTELL_NO_FUNDING=1 또는 --no-funding)');
+    }
+    catch {
+        // A support message must never affect the command result.
+    }
+}

package/dist/process/mcpProbe.js

@@ -6,7 +6,7 @@ const INITIALIZE = JSON.stringify({
     jsonrpc: '2.0',
     id: 1,
     method: 'initialize',
-    params: { protocolVersion: PROTOCOL_VERSION, capabilities: {}, clientInfo: { name: 'jutell-doctor', version: '2.0.0' } },
+    params: { protocolVersion: PROTOCOL_VERSION, capabilities: {}, clientInfo: { name: 'jutell-doctor', version: '2.0.1' } },
 });
 const INITIALIZED = JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' });
 const TOOLS_LIST = JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jutell",
-  "version": "2.0.0",
-  "description": "JuTell by Ju0 — non-developer harness for AI coding agents (Skill, MCP, local dashboard)",
+  "version": "2.0.1",
+  "description": "Understand what your AI coding agent actually did - a clarify-before / verify-after layer for Codex, Claude Code and OpenCode",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -11,16 +11,31 @@
   "bugs": {
     "url": "https://github.com/ju0o/jutell/issues"
   },
+  "funding": {
+    "type": "ko_fi",
+    "url": "https://ko-fi.com/ju0o___"
+  },
   "keywords": [
     "jutell",
     "ai",
+    "ai-agent",
+    "coding-agent",
     "agent",
     "harness",
-    "mcp",
-    "skill",
     "codex",
+    "claude-code",
+    "claude",
     "opencode",
-    "claude-code"
+    "mcp",
+    "mcp-server",
+    "skill",
+    "cli",
+    "developer-tools",
+    "ai-tools",
+    "llm",
+    "code-review",
+    "vibe-coding",
+    "korean"
   ],
   "author": "Ju0",
   "engines": {