jutell 0.3.0

package/dist/commands/session/storage-command.js

@@ -0,0 +1,74 @@
+import { stdin as input } from 'node:process';
+import { askText } from './prompt.js';
+import { OPERATOR_STORAGE_ERROR, readOperatorStoragePath, ensureOperatorStorageDir, writeOperatorStoragePath, hasOperatorStorageConfig, removeOperatorStorageConfig, } from './operator-storage.js';
+function requireInteractiveConfirm() {
+    if (!input.isTTY) {
+        throw new Error('비대화형 실행에서는 `--yes`를 함께 지정해야 합니다. 확인 단계를 건너뜁니다.');
+    }
+}
+export async function storageCommand(paths, options, io, args) {
+    const sub = args[0] ?? '';
+    if (sub === 'set')
+        return storageSetCommand(paths, options, io, args[1]);
+    if (sub === 'reset')
+        return storageResetCommand(paths, options, io);
+    return storageStatusCommand(paths, io);
+}
+async function storageStatusCommand(paths, io) {
+    try {
+        const custom = await readOperatorStoragePath(paths.targetRoot);
+        if (custom === undefined) {
+            io.write('Session 저장 위치: 기본 저장 (사용 가능)');
+            io.write('별도 설정이 없으면 `.jutell-local/`의 기본 저장 위치를 사용합니다.');
+            io.write('바꾸려면 `jutell session storage set`을 실행하세요.');
+            return 0;
+        }
+        io.write('Session 저장 위치: 운영자 지정 저장 (사용 가능)');
+        return 0;
+    }
+    catch {
+        io.write('Session 저장 위치: 운영자 지정 저장 (사용 불가능)');
+        io.write(OPERATOR_STORAGE_ERROR);
+        return 1;
+    }
+}
+async function storageSetCommand(paths, options, io, explicitPath) {
+    let candidate = explicitPath?.trim() ?? '';
+    if (!candidate) {
+        candidate = (await askText('Session 저장 위치 (절대 경로):'))?.trim() ?? '';
+    }
+    if (!candidate) {
+        throw new Error('저장 위치를 입력해야 합니다. 예: `jutell session storage set <절대 경로>`');
+    }
+    await ensureOperatorStorageDir(candidate);
+    if (!options.yes) {
+        requireInteractiveConfirm();
+        const ok = await io.ask('지정한 위치에 Session을 저장하도록 설정합니다. 계속하시겠습니까?', false);
+        if (!ok) {
+            io.write('설정을 변경하지 않았습니다.');
+            return 0;
+        }
+    }
+    await writeOperatorStoragePath(paths.targetRoot, candidate);
+    io.write('운영자 Session 저장 위치를 설정했습니다.');
+    io.write('이제 모든 Session 기록은 지정한 로컬 위치에만 저장됩니다.');
+    return 0;
+}
+async function storageResetCommand(paths, options, io) {
+    if (!(await hasOperatorStorageConfig(paths.targetRoot))) {
+        io.write('설정된 운영자 Session 저장 위치가 없습니다.');
+        return 0;
+    }
+    if (!options.yes) {
+        requireInteractiveConfirm();
+        const ok = await io.ask('운영자 Session 저장 위치 설정만 제거합니다. Session 기록 파일은 지우지 않습니다. 계속하시겠습니까?', false);
+        if (!ok) {
+            io.write('설정을 제거하지 않았습니다.');
+            return 0;
+        }
+    }
+    await removeOperatorStorageConfig(paths.targetRoot);
+    io.write('운영자 Session 저장 위치 설정을 제거했습니다.');
+    io.write('다시 기본 로컬 저장 위치를 사용합니다.');
+    return 0;
+}

package/dist/commands/session/storage.js

@@ -0,0 +1,212 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+export const SESSION_FOLDER_BASE = 'collaboration-sessions';
+export const SESSION_META_FILE = 'session.json';
+export const SESSION_SUMMARY_FILE = 'SESSION_SUMMARY.md';
+export function sessionRoot(dataRoot) {
+    return path.join(dataRoot, SESSION_FOLDER_BASE);
+}
+export function pad2(n) {
+    return String(n).padStart(2, '0');
+}
+export function todayStamp(now = new Date()) {
+    const p = pad2;
+    return `${now.getFullYear()}-${p(now.getMonth() + 1)}-${p(now.getDate())}`;
+}
+// 레거시 단일 파일 기록: .jutell-local/collaboration-sessions/YYYY-MM-DD-session-NN.md
+// 이동·변환·삭제하지 않으며 참고 안내에만 사용한다.
+export function listLegacyFlatFiles(sessionRootDir, stamp) {
+    return fs.readdir(sessionRootDir).then((entries) => entries
+        .filter((entry) => new RegExp(`^${stamp}-session-\\d+\\.md$`).test(entry))
+        .sort()).catch(() => []);
+}
+export function isValidPageFile(file) {
+    return /^page-\d+-.+\.md$/.test(file);
+}
+// date 폴더 안 Page 파일 목록을 page-번호 순서로 정렬한 {number, file}
+export async function listPageFiles(dir) {
+    let entries = [];
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const pages = entries
+        .filter(isValidPageFile)
+        .map((file) => {
+        const match = /^page-(\d+)-(.+)\.md$/.exec(file);
+        return match ? { number: Number(match[1]), file, slug: match[2] } : null;
+    })
+        .filter((entry) => entry !== null);
+    pages.sort((a, b) => a.number - b.number);
+    return pages;
+}
+// 오늘 Session이 상태로 있는지 (session.json 존재)
+export async function sessionExists(dir) {
+    try {
+        await fs.access(path.join(dir, SESSION_META_FILE));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function readSessionMeta(dir) {
+    const file = path.join(dir, SESSION_META_FILE);
+    let raw;
+    try {
+        raw = await fs.readFile(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.date !== 'string')
+            throw new Error('date 누락');
+        const pages = Array.isArray(parsed.pages) ? parsed.pages : [];
+        return {
+            date: parsed.date,
+            status: parsed.status === 'finished' ? 'finished' : 'active',
+            currentPage: typeof parsed.currentPage === 'number' ? parsed.currentPage : null,
+            pages: pages.filter((page) => typeof page === 'object' &&
+                typeof page.number === 'number' &&
+                typeof page.agent === 'string' &&
+                typeof page.role === 'string' &&
+                typeof page.title === 'string' &&
+                typeof page.file === 'string'),
+        };
+    }
+    catch {
+        throw new Error(`session.json을 읽지 못했습니다(손상). 파일을 지우지 않고 중단합니다: ${file}`);
+    }
+}
+// 원자적 저장: 임시 파일에 쓴 뒤 이름을 바꾼다. 손상된 기존 파일은 덮어쓰지 않는다.
+export async function saveSessionMeta(dir, meta) {
+    await fs.mkdir(dir, { recursive: true });
+    const file = path.join(dir, SESSION_META_FILE);
+    const existing = await readSessionMeta(dir);
+    if (existing && existing.date !== meta.date) {
+        throw new Error(`session.json 날짜가 다릅니다. 병합하지 않습니다: ${file}`);
+    }
+    const tmp = path.join(dir, `${SESSION_META_FILE}.tmp`);
+    await fs.writeFile(tmp, `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
+    await fs.rename(tmp, file);
+}
+export function createInitialMeta(date) {
+    return { date, status: 'active', currentPage: null, pages: [] };
+}
+export function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+export function pageFileName(page) {
+    const agent = slugify(page.agent) || 'agent';
+    const title = slugify(page.title);
+    return `page-${pad2(page.number)}-${agent}${title ? `-${title}` : ''}.md`;
+}
+export function pageLabel(page) {
+    return `Page ${pad2(page.number)} — ${page.agent} / ${page.title}`;
+}
+export function parseFileNameTitle(file) {
+    // page-01-opencode-jutell-report-style.md → 부분 타이틀(slug)만 복원
+    const match = /^page-\d+-(.+?)\.md$/.exec(file);
+    return match ? match[1] : file;
+}
+// Page 파일 안의 작업 번호 목록 (중복 없이 최대값 + 1 반환)
+export function nextWorkNumber(content) {
+    const numbers = Array.from(content.matchAll(/^## 작업 (\d+)\s*$/gm), (match) => Number(match[1]));
+    return (numbers.length > 0 ? Math.max(...numbers) : 0) + 1;
+}
+// Page 01을 처음 만들었을 때 같이 넣는 작업 01 블록
+export function workTemplate(workNumber) {
+    const p = pad2(workNumber);
+    return [
+        `## 작업 ${p}`,
+        '',
+        '### ChatGPT',
+        '',
+        '-',
+        '',
+        '### Agent 답변',
+        '',
+        '-',
+        '',
+        '### 내 피드백',
+        '',
+        '좋았던 점',
+        '',
+        '-',
+        '',
+        '불편했던 점',
+        '',
+        '-',
+        '',
+        '나라면 이렇게 말할 것 같다',
+        '',
+        '-',
+        '',
+        'JuTell 개선 아이디어',
+        '',
+        '-',
+        '',
+        '오늘의 발견',
+        '',
+        '-',
+    ].join('\n');
+}
+export function pageTemplate(page, date) {
+    return [
+        `# ${pageLabel(page)}`,
+        '',
+        `- Date: ${date}`,
+        `- Agent: ${page.agent}`,
+        `- 역할: ${page.role}`,
+        '- 상태: 진행 중',
+        '',
+        '---',
+        '',
+        workTemplate(1),
+        '',
+    ].join('\n');
+}
+export function summaryTemplate(date, pages) {
+    const pageLines = pages.length > 0 ? pages.map((page) => `- ${pageLabel(page)}`) : ['- (Page 없음)'];
+    return [
+        '# Session Summary',
+        '',
+        `Date: ${date}`,
+        '',
+        '## 오늘 Page',
+        '',
+        ...pageLines,
+        '',
+        '## 오늘 가장 좋았던 점',
+        '',
+        '-',
+        '',
+        '## 오늘 가장 불편했던 점',
+        '',
+        '-',
+        '',
+        '## 오늘의 핵심 발견',
+        '',
+        '-',
+        '',
+        '## Agent별 차이',
+        '',
+        '-',
+        '',
+        '## JuTell에 반영할 후보',
+        '',
+        '-',
+        '',
+        '## 다음 Session에서 가장 먼저 할 일',
+        '',
+        '-',
+        '',
+    ].join('\n');
+}

package/dist/commands/session/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/status.js

@@ -0,0 +1,208 @@
+import { promises as fs } from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { assets, codexScopedPaths, packageRoot, safeLocation } from '../config/paths.js';
+import { claudeDetected, codexDetected, nodeMajorVersion, operatingSystem } from '../process/system.js';
+import { exists, parseSkillVersion, readBridgeConfig, readCodexRegistration, readText, readVersionInfo, FEATURE_IDS } from '../config/managed.js';
+import { setupCommand } from './lifecycle.js';
+import { hasJuTellAgentsBlock } from '../installer/agents.js';
+import { opencodeDetected, readOpenCodeRegistration } from '../installer/opencode.js';
+import { readClaudeRegistration } from '../installer/claude.js';
+import { probeMcpServer } from '../process/mcpProbe.js';
+async function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function adminState(paths) {
+    const marker = path.join(paths.dataRoot, 'dashboard.json');
+    const raw = await readText(marker);
+    if (!raw)
+        return '중지됨';
+    try {
+        const value = JSON.parse(raw);
+        if (typeof value.pid === 'number' && await processAlive(value.pid))
+            return '실행 중';
+        await fs.rm(marker, { force: true });
+    }
+    catch {
+        return '확인 필요';
+    }
+    return '중지됨';
+}
+export async function getStatus(paths) {
+    const config = await readBridgeConfig(paths);
+    // Codex only reads MCP servers from its global config, so status always
+    // checks that real file regardless of the invocation's scope (see
+    // codexScopedPaths) — otherwise a project-scope status could report
+    // "등록됨" for a file Codex never actually consumes.
+    const registration = await readCodexRegistration(codexScopedPaths(paths), packageRoot(), config.config.mcp?.enabled === true);
+    const versions = await readVersionInfo();
+    const skillInstalled = await exists(path.join(paths.skillRoot, 'SKILL.md'));
+    const installedSkillText = await readText(path.join(paths.skillRoot, 'SKILL.md'));
+    const agentsManaged = await hasJuTellAgentsBlock(paths.targetRoot);
+    const opencode = await readOpenCodeRegistration(paths, packageRoot(), false);
+    const claude = await readClaudeRegistration(paths, packageRoot(), false);
+    const codexPreparation = registration.conflict ? 'error' : !registration.registered ? 'not_registered' : registration.enabled ? 'enabled' : 'registered';
+    const opencodePreparation = opencode.conflict ? 'conflict' : !opencode.registered ? 'not_registered' : opencode.enabled ? 'enabled' : 'registered';
+    const claudePreparation = claude.conflict ? 'conflict' : !claude.registered ? 'not_registered' : claude.enabled ? 'enabled' : 'registered';
+    const anyProviderRegistered = registration.registered || opencode.registered || claude.registered;
+    const anyProviderEnabled = registration.enabled || opencode.enabled || claude.enabled;
+    const warnings = [];
+    if (!config.valid)
+        warnings.push('설정 파일을 읽지 못해 balanced 기본값을 사용 중입니다.');
+    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가 모두 있습니다. 자동 정리하지 않았습니다. 이전 항목 제거는 추후 안전한 마이그레이션에서 안내합니다.');
+    if (opencode.bothRegistered)
+        warnings.push('OpenCode에 canonical jutell과 legacy beginner_bridge MCP가 모두 있습니다. 자동 정리하지 않았습니다. 이전 항목 제거는 추후 안전한 마이그레이션에서 안내합니다.');
+    if (registration.legacyRegistered && !registration.canonicalRegistered)
+        warnings.push('Codex에 이전 beginner_bridge 항목만 있습니다. jutell use codex 를 실행하면 보존하면서 새 jutell 항목을 추가합니다.');
+    if (opencode.legacyRegistered && !opencode.canonicalRegistered)
+        warnings.push('OpenCode에 이전 beginner_bridge 항목만 있습니다. jutell use opencode 를 실행하면 보존하면서 새 jutell 항목을 추가합니다.');
+    if (config.config.mcp?.enabled && !anyProviderRegistered)
+        warnings.push('MCP 연결 정책은 켜져 있지만 Codex·OpenCode·Claude Code 어느 Provider에도 JuTell MCP가 등록되지 않았습니다. jutell use <agent> 를 실행해 주세요.');
+    if (config.config.mcp?.enabled && anyProviderRegistered && !anyProviderEnabled)
+        warnings.push('연결 정책(.jutell.json)은 켜져 있지만 새 세션에서 자동 시작할 활성 Provider 항목이 없습니다. jutell use <agent> 를 실행해 주세요.');
+    if (!config.config.mcp?.enabled && anyProviderEnabled)
+        warnings.push('연결 정책(.jutell.json)은 꺼져 있지만 Provider 자동 시작은 켜져 있습니다. 일치시키려면 jutell use <agent> 또는 jutell off을 실행해 주세요.');
+    return {
+        cliVersion: versions.cli,
+        skillVersion: skillInstalled ? (parseSkillVersion(installedSkillText) ?? versions.skill) : '설치되지 않음',
+        mcpVersion: versions.mcp,
+        adminVersion: versions.admin,
+        installationScope: paths.scope,
+        configExists: config.exists,
+        configValid: config.valid,
+        codexDetected: codexDetected(),
+        opencodeDetected: opencodeDetected(),
+        claudeDetected: claudeDetected(),
+        skillInstalled,
+        agentsManaged,
+        mcpRegistered: anyProviderRegistered,
+        mcpEnabled: config.config.mcp?.enabled === true,
+        codexPreparation,
+        opencodePreparation,
+        claudePreparation,
+        anyProviderRegistered,
+        anyProviderEnabled,
+        actualConnection: 'not_checked',
+        opencode: { registered: opencode.registered, conflict: opencode.conflict, enabled: opencode.enabled },
+        claude: { registered: claude.registered, conflict: claude.conflict, enabled: claude.enabled },
+        profile: config.config.profile,
+        activeFeatureCount: Object.values(config.config.features).filter(Boolean).length,
+        configLocation: config.source === 'legacy' ? '기존 설정(.beginner-bridge.json)' : safeLocation(paths.scope, 'config'),
+        localAdmin: await adminState(paths),
+        usageCountersEnabled: config.config.usageMeasurement?.localCountersEnabled === true,
+        telemetry: '비활성화',
+        externalTransmission: '없음',
+        warnings,
+    };
+}
+export async function statusCommand(paths, options, io) {
+    const status = await getStatus(paths);
+    if (options.json) {
+        io.write(JSON.stringify(status, null, 2));
+        return status;
+    }
+    const codexLabel = { not_registered: '미등록', registered: '등록됨', enabled: '활성화됨', error: '오류' }[status.codexPreparation];
+    const opencodeLabel = { not_registered: '미등록', registered: '등록됨', enabled: '활성화됨', conflict: '충돌' }[status.opencodePreparation];
+    const claudeLabel = { not_registered: '미등록', registered: '등록됨', enabled: '활성화됨', conflict: '충돌' }[status.claudePreparation];
+    const actual = { not_checked: '확인하지 않음', success: '마지막 확인 성공', failure: '마지막 확인 실패' }[status.actualConnection];
+    const codexDetectedLabel = status.codexDetected ? '감지됨' : '미감지';
+    const opencodeDetectedLabel = status.opencodeDetected ? '감지됨' : status.opencode.registered ? '설정 있음(명령 미감지)' : '미감지';
+    const claudeDetectedLabel = status.claudeDetected ? '감지됨' : status.claude.registered ? '설정 있음(명령 미감지)' : '미감지';
+    const claudeScopeNote = status.installationScope === 'global' ? '사용자 전역(user)' : '현재 프로젝트(local)';
+    io.write(`JuTell 상태\n\nCLI: ${status.cliVersion}\nSkill: ${status.skillInstalled ? '설치됨' : '설치되지 않음'}\nAGENTS.md: ${status.agentsManaged ? 'JuTell 블록 있음' : 'JuTell 블록 없음'}\nJuTell 연결 정책: ${status.mcpEnabled ? '켜짐' : '꺼짐'}\nCodex MCP (전역, Codex는 프로젝트 설정을 읽지 않음): ${codexLabel}${status.codexDetected ? ` (명령 ${codexDetectedLabel})` : ''}\nOpenCode MCP: ${opencodeLabel}${status.opencode.enabled ? ' (새 세션 자동 시작 켜짐)' : ''}${status.opencodeDetected ? '' : ` (명령 ${opencodeDetectedLabel})`}\nClaude Code MCP (${claudeScopeNote}): ${claudeLabel}${status.claudeDetected ? '' : ` (명령 ${claudeDetectedLabel})`}\nMCP 서버 응답: ${actual}\n현재 Agent 세션 적용: 직접 확인 필요\nProfile: ${status.profile}\n활성 Feature: ${status.activeFeatureCount}개\n설치 범위 (설정·Skill·AGENTS.md): ${status.installationScope === 'global' ? '사용자 전역' : '현재 프로젝트'}\n로컬 관리자: ${status.localAdmin}\n로컬 사용량 카운터: ${status.usageCountersEnabled ? '켜짐' : '꺼짐'}\nTelemetry: ${status.telemetry}\n외부 전송: ${status.externalTransmission}\n설정 위치: ${status.configLocation}`);
+    for (const warning of status.warnings)
+        io.write(`주의: ${warning}`);
+    return status;
+}
+async function portAvailable() {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', () => resolve(false));
+        server.listen(0, '127.0.0.1', () => server.close(() => resolve(true)));
+    });
+}
+async function writeCheck(paths) {
+    const directory = paths.dataRoot;
+    const file = path.join(directory, `.doctor-${process.pid}.tmp`);
+    try {
+        await fs.mkdir(directory, { recursive: true });
+        await fs.writeFile(file, 'ok', 'utf8');
+        await fs.rm(file, { force: true });
+        return true;
+    }
+    catch {
+        await fs.rm(file, { force: true });
+        return false;
+    }
+}
+export async function getDoctorResults(paths) {
+    const config = await readBridgeConfig(paths);
+    const codexPaths = codexScopedPaths(paths);
+    const registration = await readCodexRegistration(codexPaths, packageRoot(), config.config.mcp?.enabled === true);
+    const opencode = await readOpenCodeRegistration(paths, packageRoot(), false);
+    const claude = await readClaudeRegistration(paths, packageRoot(), false);
+    const skillFile = path.join(paths.skillRoot, 'SKILL.md');
+    const skillText = await readText(skillFile);
+    const mcpEntry = path.join(assets().mcpServer, 'index.js');
+    const adminEntry = path.join(assets().localAdmin, 'index.html');
+    const mcpText = await readText(mcpEntry) ?? '';
+    const checks = [];
+    checks.push({ name: 'Node 버전', status: nodeMajorVersion() >= 18 ? '정상' : '오류', detail: `현재 Node ${process.versions.node}` });
+    checks.push({ name: '운영체제', status: ['Windows', 'macOS', 'Linux'].includes(operatingSystem()) ? '정상' : '직접 확인 필요', detail: operatingSystem() });
+    const anyProviderDetectedOrConfigured = codexDetected() || opencodeDetected() || claudeDetected() || await exists(codexPaths.codexConfigFile) || await exists(paths.opencodeConfigFile) || claude.exists;
+    checks.push({ name: 'AI Agent Provider 설치 또는 설정', status: anyProviderDetectedOrConfigured ? '정상' : '직접 확인 필요', detail: anyProviderDetectedOrConfigured ? 'Provider 명령 또는 설정을 확인했습니다.' : 'Provider 명령과 설정을 모두 자동 확인하지 못했습니다.' });
+    checks.push({ name: 'OpenCode 명령 감지', status: opencodeDetected() ? '정상' : '직접 확인 필요', detail: opencodeDetected() ? 'opencode --version 명령을 확인했습니다.' : 'opencode 명령을 자동 확인하지 못했습니다. PATH·shell 실행 권한을 확인해 주세요.' });
+    checks.push({ name: 'Skill 파일', status: skillText?.includes('name: beginner-bridge') ? '정상' : '오류', detail: skillText ? 'Skill 파일을 확인했습니다.' : 'Skill 파일이 없습니다.' });
+    const skillVersion = parseSkillVersion(skillText);
+    const sourceSkillText = await readText(path.join(assets().skill, 'SKILL.md'));
+    const sourceVersion = parseSkillVersion(sourceSkillText);
+    const skillMatch = Boolean(skillText && sourceSkillText && skillText === sourceSkillText);
+    checks.push({ name: 'Skill 버전', status: skillMatch ? '정상' : skillVersion ? '주의' : '직접 확인 필요', detail: skillMatch ? `스킬 버전 ${sourceVersion ?? '(버전 기록 없음)'} (설치 사본 일치).` : skillVersion ? `설치 사본 버전 ${skillVersion}이 원본과 다릅니다. jutell use <agent> 로 재설치하세요.` : '설치된 Skill에 버전 기록이 없습니다.' });
+    checks.push({ name: '현재 Agent 세션 적용', status: '직접 확인 필요', detail: '실제로 Skill과 규칙을 읽었는지 여부는 해당 Agent 세션에서 직접 확인해야 합니다.' });
+    checks.push({ name: 'MCP 빌드 파일', status: await exists(mcpEntry) ? '정상' : '오류', detail: await exists(mcpEntry) ? '패키지에 포함되어 있습니다.' : 'MCP 빌드 파일이 없습니다.' });
+    checks.push({ name: 'Codex MCP', status: registration.conflict ? '오류' : registration.registered ? '정상' : '주의', detail: registration.conflict ? '관리되지 않는 동일 이름 설정이 있습니다.' : registration.registered ? `JuTell 관리 블록을 확인했습니다. 새 세션 자동 시작: ${registration.enabled ? '켜짐' : '꺼짐'}.` : '등록되지 않았습니다.' });
+    checks.push({ name: 'OpenCode MCP', status: opencode.conflict ? '오류' : opencode.registered ? (opencode.enabled ? '정상' : '주의') : '주의', detail: opencode.conflict ? '관리되지 않는 동일 이름 항목이 있습니다.' : opencode.registered ? `JuTell 관리 블록을 확인했습니다. 새 세션 자동 시작: ${opencode.enabled ? '켜짐' : '꺼짐'}.` : 'OpenCode MCP가 등록되지 않았습니다.' });
+    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;
+    checks.push({ name: '공식 Feature ID', status: featuresValid ? '정상' : '오류', detail: featuresValid ? '현재 공식 ID만 확인했습니다.' : '지원하지 않는 Feature ID가 있습니다.' });
+    checks.push({ name: 'limits', status: limitsValid ? '정상' : '오류', detail: 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: '로컬 상태 폴더에 임시 파일을 만들고 삭제했습니다.' });
+    const backupExists = await exists(`${codexPaths.codexConfigFile}.previous`);
+    checks.push({ name: '설정 백업 상태', status: !await exists(codexPaths.codexConfigFile) || backupExists ? '정상' : '주의', detail: !await exists(codexPaths.codexConfigFile) ? '아직 Provider 설정을 변경하지 않았습니다.' : backupExists ? '이전 설정 백업을 확인했습니다.' : '기존 Provider 설정 백업이 없습니다.' });
+    const externalCode = /(?:https?:\/\/(?!127\.0\.0\.1)|https?\.request|net\.connect)/i.test(mcpText);
+    checks.push({ name: '외부 전송 코드', status: externalCode ? '오류' : '정상', detail: externalCode ? 'MCP 빌드에서 외부 네트워크 관련 코드를 찾았습니다.' : 'MCP 빌드에 외부 전송 패턴이 없습니다.' });
+    const probe = await probeMcpServer(mcpEntry);
+    checks.push({ name: 'MCP 서버 실제 연결 (Stdio)', status: probe.ok ? '정상' : '오류', detail: probe.ok ? `${probe.serverName || 'JuTell'} 서버가 응답하고 ${probe.toolCount}개 도구를 제공합니다.` : `서버 응답 실패: ${probe.error ?? '알 수 없는 오류'}` });
+    return checks;
+}
+export async function doctorCommand(paths, options, io) {
+    let checks = await getDoctorResults(paths);
+    const fixableError = checks.some((check) => check.status === '오류' && check.name !== 'MCP 서버 실제 연결 (Stdio)');
+    if (options.fix && fixableError) {
+        await setupCommand(paths, { ...options, yes: true }, io);
+        checks = await getDoctorResults(paths);
+    }
+    if (options.json) {
+        io.write(JSON.stringify(checks, null, 2));
+        return checks;
+    }
+    io.write('JuTell 점검 결과');
+    for (const check of checks)
+        io.write(`${check.status}  ${check.name}: ${check.detail}`);
+    return checks;
+}

package/dist/commands/upgrade.js

@@ -0,0 +1,113 @@
+import { assets, codexScopedPaths, packageRoot } from '../config/paths.js';
+import { readBridgeConfig, snapshot, restore } from '../config/managed.js';
+import { ensureBridgeConfig } from '../installer/config.js';
+import { installSkill, recordSkillFiles, removeAddedSkillFiles } from '../installer/skill.js';
+import { agentsFile, ensureJuTellAgentsBlock } from '../installer/agents.js';
+import { readCodexRegistration, registerMcp } from '../config/managed.js';
+import { readOpenCodeRegistration, registerOpenCodeMcp } from '../installer/opencode.js';
+import { readClaudeRegistration, registerClaudeMcp } from '../installer/claude.js';
+export async function upgradeCommand(paths, options, io) {
+    const snapshots = [
+        await snapshot(paths.configFile),
+        await snapshot(paths.legacyConfigFile),
+        await snapshot(codexScopedPaths(paths).codexConfigFile),
+        await snapshot(paths.opencodeConfigFile),
+        await snapshot(paths.claudeConfigFile),
+    ];
+    if (paths.scope === 'project')
+        snapshots.push(await snapshot(agentsFile(paths.targetRoot)));
+    let changedSkill = [];
+    try {
+        // 1. Config — preserve profile, create canonical from legacy if needed (READ LEGACY, WRITE CANONICAL)
+        const beforeConfig = await readBridgeConfig(paths);
+        const ensured = await ensureBridgeConfig(paths, undefined);
+        const configCreated = !beforeConfig.exists && ensured.created;
+        const migratedConfig = beforeConfig.source === 'legacy' && ensured.config;
+        // 2. Skill — refresh to current assets
+        const skillResult = await installSkill(assets().skill, paths.skillRoot);
+        changedSkill = skillResult.changed;
+        // 3. AGENTS block — refresh
+        if (paths.scope === 'project')
+            await ensureJuTellAgentsBlock(paths.targetRoot);
+        // 4. Provider MCP — refresh canonical command/path, repair drift, keep legacy + unrelated
+        const mcpEnabled = ensured.config.mcp?.enabled === true;
+        const codexPaths = codexScopedPaths(paths);
+        const codexReg = await readCodexRegistration(codexPaths, packageRoot(), mcpEnabled);
+        const opencodeReg = await readOpenCodeRegistration(paths, packageRoot(), mcpEnabled);
+        const claudeReg = await readClaudeRegistration(paths, packageRoot(), mcpEnabled);
+        let codexRefreshed = false;
+        let opencodeRefreshed = false;
+        let claudeRefreshed = false;
+        // Codex: if any JuTell registration (canonical or legacy heuristic) exists, ensure canonical block is fresh
+        if (codexReg.registered || codexReg.legacyRegistered || codexReg.canonicalRegistered) {
+            // Force refresh by rewriting canonical block with current packageRoot/command
+            // Use registerMcp's forced path: remove canonical block then add fresh
+            const before = await readCodexRegistration(codexPaths, packageRoot(), mcpEnabled);
+            // registerMcp will handle backup + rewrite; we force by temporarily clearing enabled flag check via direct write if needed
+            // Simpler: call registerMcp — it will rewrite if command drift is detected via heuristic? Our heuristic already treats unmarked as registered,
+            // but registerMcp's early return checks canonicalRegistered + enabled ===. To force refresh when command is stale, we bypass by
+            // using internal write: if canonical block exists but command doesn't match current packageRoot, force.
+            const currentContent = before.content;
+            const expected = packageRoot();
+            const needsRefresh = !currentContent.includes(expected) && (before.canonicalRegistered || before.legacyRegistered);
+            if (needsRefresh || before.canonicalRegistered) {
+                await registerMcp(codexPaths, packageRoot(), mcpEnabled);
+                codexRefreshed = true;
+            }
+            else if (before.legacyRegistered && !before.canonicalRegistered) {
+                // legacy-only -> create canonical (READ LEGACY, WRITE CANONICAL, keep legacy)
+                await registerMcp(codexPaths, packageRoot(), mcpEnabled);
+                codexRefreshed = true;
+            }
+        }
+        // OpenCode: if registered, refresh via registerOpenCodeMcp (serializeWithManaged uses current packageRoot)
+        if (opencodeReg.registered || opencodeReg.canonicalRegistered || opencodeReg.legacyRegistered) {
+            await registerOpenCodeMcp(paths, packageRoot(), mcpEnabled);
+            opencodeRefreshed = true;
+        }
+        // Claude: if registered, ensure command matches current (registerClaudeMcp already checks commandMatches)
+        if (claudeReg.registered) {
+            await registerClaudeMcp(paths, packageRoot(), mcpEnabled);
+            claudeRefreshed = true;
+        }
+        await recordSkillFiles(paths, changedSkill);
+        // 5. Report — what changed / preserved / legacy / next
+        const parts = ['JuTell 업그레이드가 끝났습니다.'];
+        if (migratedConfig)
+            parts.push('- 설정: 이전 .beginner-bridge.json을 읽어 .jutell.json을 만들었습니다. 이전 파일은 보존했습니다.');
+        else if (configCreated)
+            parts.push('- 설정: 새 .jutell.json을 만들었습니다.');
+        else
+            parts.push('- 설정: 기존 .jutell.json을 유지했습니다.');
+        if (skillResult.conflicts.length)
+            parts.push(`- Skill: 기존 파일을 덮어쓰지 않았습니다 (${skillResult.conflicts.join(', ')}).`);
+        else if (changedSkill.length)
+            parts.push('- Skill: 최신 Skill로 새로고침했습니다.');
+        else
+            parts.push('- Skill: 최신 상태를 유지했습니다.');
+        parts.push('- AGENTS.md: JuTell 블록을 확인/새로고침했습니다.');
+        if (codexRefreshed || opencodeRefreshed || claudeRefreshed) {
+            const refreshed = [
+                codexRefreshed ? 'Codex' : null,
+                opencodeRefreshed ? 'OpenCode' : null,
+                claudeRefreshed ? 'Claude Code' : null,
+            ].filter(Boolean).join(', ');
+            parts.push(`- MCP: ${refreshed} canonical jutell 블록을 현재 패키지 경로로 새로고침했습니다. 관련 없는 설정은 보존했습니다.`);
+        }
+        else {
+            parts.push('- MCP: 등록된 Provider가 없어 MCP를 새로고침하지 않았습니다. jutell use <provider>로 연결하세요.');
+        }
+        const anyLegacy = codexReg.legacyRegistered || opencodeReg.legacyRegistered || beforeConfig.source === 'legacy';
+        if (anyLegacy)
+            parts.push('- 레거시: 이전 beginner_bridge 상태는 그대로 두었습니다. 정리하려면 jutell migrate --clean 을 실행하세요.');
+        parts.push('다음: jutell status / jutell doctor 로 확인하세요.');
+        io.write(parts.join('\n'));
+        return { cancelled: false };
+    }
+    catch (error) {
+        for (const s of snapshots)
+            await restore(s);
+        await removeAddedSkillFiles(paths.skillRoot, changedSkill);
+        throw error;
+    }
+}