jutell 0.3.0

package/dist/commands/provider.js

@@ -0,0 +1,135 @@
+import { readBridgeConfig, readCodexRegistration } from '../config/managed.js';
+import { AGENT_PROVIDERS, findProvider } from '../installer/providers.js';
+import { opencodeDetected, readOpenCodeRegistration, registerOpenCodeMcp, setOpenCodeEnabled } from '../installer/opencode.js';
+import { readClaudeRegistration } from '../installer/claude.js';
+import { setMcpDisabled, setMcpEnabled } from '../installer/config.js';
+import { claudeDetected, codexDetected } from '../process/system.js';
+import { codexScopedPaths, packageRoot } from '../config/paths.js';
+export async function readProviderStatuses(paths) {
+    // Codex only reads its global config (see codexScopedPaths), regardless
+    // of this invocation's --project/--global scope.
+    const codex = await readCodexRegistration(codexScopedPaths(paths), packageRoot(), false);
+    const opencode = await readOpenCodeRegistration(paths, packageRoot(), false);
+    const claude = await readClaudeRegistration(paths, packageRoot(), false);
+    return AGENT_PROVIDERS.map((provider) => {
+        if (provider.status === 'planned')
+            return { provider, detected: false, registered: false, conflict: false, enabled: false };
+        if (provider.id === 'codex')
+            return { provider, detected: codexDetected(), registered: codex.registered, conflict: codex.conflict, enabled: codex.enabled };
+        if (provider.id === 'claude-code')
+            return { provider, detected: claudeDetected(), registered: claude.registered, conflict: claude.conflict, enabled: claude.enabled };
+        return { provider, detected: opencodeDetected(), registered: opencode.registered, conflict: opencode.conflict, enabled: opencode.enabled };
+    });
+}
+function providerLabel(id) {
+    const provider = findProvider(id);
+    return provider ? `${provider.label} (${provider.status === 'supported' ? '현재 지원' : provider.status === 'beta' ? '베타' : '확장 준비'})` : id;
+}
+function openCodeScopeLabel(paths) {
+    return paths.scope === 'global' ? '사용자 OpenCode 설정' : '현재 프로젝트/opencode.json';
+}
+function claudeScopeLabel(paths) {
+    return paths.scope === 'global' ? '사용자 전역 Claude 설정 (user)' : '현재 프로젝트 Claude 설정 (local, 공유되지 않음)';
+}
+async function listCommand(io) {
+    io.write('JuTell AI Agent Provider 목록');
+    for (const provider of AGENT_PROVIDERS) {
+        const state = provider.status === 'supported' ? '현재 지원' : provider.status === 'beta' ? '베타' : '확장 준비';
+        io.write(`${provider.label.padEnd(10)} ${state}`);
+    }
+}
+async function summaryCommand(paths, io) {
+    const statuses = await readProviderStatuses(paths);
+    const config = await readBridgeConfig(paths);
+    const active = statuses.filter((item) => item.registered && item.enabled).map((item) => item.provider.label);
+    io.write('JuTell Agent 연결 상태\n');
+    for (const item of statuses) {
+        const state = item.provider.status === 'planned' ? '준비 중' : item.conflict ? '설정 충돌' : item.registered ? (item.enabled ? '연결됨 · 활성' : '연결됨 · 비활성') : '연결 안 됨';
+        io.write(`${item.provider.label.padEnd(12)} ${state}`);
+    }
+    io.write(`\n현재 권장 Agent: ${active.length ? active.join(', ') : '없음'}`);
+    io.write(`JuTell 자동 적용: ${config.config.mcp?.enabled ? '켜짐' : '꺼짐'}`);
+    if (config.config.mcp?.enabled && active.length === 0)
+        io.write('주의: 연결 정책은 켜져 있지만 자동 시작할 활성 Provider 항목이 없습니다. jutell use <agent> 를 실행하거나 provider enable 을 사용해 주세요.');
+    else if (!config.config.mcp?.enabled && active.length > 0)
+        io.write('주의: 연결 정책은 꺼져 있지만 Provider 자동 시작이 켜져 있습니다. 일치시키려면 jutell use <agent> 또는 jutell off 을 실행해 주세요.');
+}
+async function statusCommand(paths, io) {
+    const codex = await readCodexRegistration(codexScopedPaths(paths), packageRoot(), false);
+    const opencode = await readOpenCodeRegistration(paths, packageRoot(), false);
+    const claude = await readClaudeRegistration(paths, packageRoot(), false);
+    io.write(`JuTell AI Agent Provider 상태
+
+${providerLabel('codex')}
+  감지: ${codexDetected() ? '예' : '직접 확인 필요'}
+  설정 파일: 사용자 전역 Codex 설정 (Codex는 프로젝트 설정을 읽지 않음)
+  MCP 등록: ${codex.registered ? '등록됨' : codex.conflict ? '충돌 확인 필요' : '등록되지 않음'}
+  활성화: ${codex.registered ? (codex.enabled ? '예' : '아니오') : '등록되지 않음'}
+
+${providerLabel('opencode')}
+  감지: ${opencodeDetected() ? '예' : '직접 확인 필요'}
+  설정 파일: ${openCodeScopeLabel(paths)}
+  MCP 등록: ${opencode.registered ? '등록됨' : opencode.conflict ? '충돌 확인 필요' : '등록되지 않음'}
+  활성화: ${opencode.registered ? (opencode.enabled ? '예' : '아니오') : '등록되지 않음'}
+
+${providerLabel('claude-code')}
+  감지: ${claudeDetected() ? '예' : '직접 확인 필요'}
+  설정 파일: ${claudeScopeLabel(paths)}
+  MCP 등록: ${claude.registered ? '등록됨' : '등록되지 않음'}
+  활성화: ${claude.registered ? '예' : '등록되지 않음'}`);
+}
+function requireTarget(args) {
+    const target = args[1];
+    if (!target)
+        throw new Error('설정할 Provider 이름이 필요합니다. 예: jutell provider setup opencode');
+    if (target === 'codex')
+        throw new Error('Codex는 기존 jutell setup / on / off 또는 jutell use codex 명령을 사용하세요.');
+    if (target === 'claude' || target === 'claude-code')
+        throw new Error('Claude Code는 jutell use claude 명령을 사용하세요.');
+    if (target !== 'opencode')
+        throw new Error('provider 설정 명령은 opencode만 지원합니다. 일반 연결은 jutell use <agent> 를 사용하세요.');
+}
+export async function providerCommand(paths, options, io, args) {
+    const sub = args[0];
+    if (!sub)
+        return summaryCommand(paths, io);
+    if (sub === 'list')
+        return listCommand(io);
+    if (sub === 'status')
+        return statusCommand(paths, io);
+    if (sub === 'setup') {
+        requireTarget(args);
+        const policy = (await readBridgeConfig(paths)).config.mcp?.enabled === true;
+        const current = await readOpenCodeRegistration(paths, packageRoot(), policy);
+        if (current.conflict)
+            throw new Error('OpenCode 설정에 같은 이름의 관리되지 않는 MCP 항목이 있어 자동 변경하지 않았습니다.');
+        io.write(`JuTell OpenCode 연결 설정 미리보기\n\n설정 파일: ${openCodeScopeLabel(paths)}\n상태: ${current.registered ? '이미 등록됨 (최신 설정으로 갱신)' : '새로 등록'}\n새 세션 자동 시작: 연결 정책(.jutell.json) 기준 (현재 ${policy ? '켜짐' : '꺼짐'})\n\n${current.preview}`);
+        if (!options.yes && !(await io.ask('위 변경을 진행할까요?')))
+            return { cancelled: true };
+        await registerOpenCodeMcp(paths, packageRoot(), policy);
+        io.write('OpenCode 연결 설정을 등록했습니다. 기존 설정은 보존했고 JuTell 관리 블록만 추가했습니다.');
+        return { cancelled: false };
+    }
+    if (sub === 'enable') {
+        requireTarget(args);
+        await registerOpenCodeMcp(paths, packageRoot(), true);
+        await setMcpEnabled(paths, true);
+        io.write('OpenCode JuTell MCP를 활성화했습니다. 연결 정책을 켜고 새 OpenCode 세션부터 자동으로 사용할 수 있습니다.');
+        return { cancelled: false };
+    }
+    if (sub === 'disable') {
+        requireTarget(args);
+        const current = await readOpenCodeRegistration(paths, packageRoot(), false);
+        if (!current.registered) {
+            io.write('등록된 OpenCode JuTell 관리 블록이 없습니다. 먼저 jutell provider setup opencode 를 실행하세요.');
+            return { cancelled: false };
+        }
+        await setOpenCodeEnabled(paths, packageRoot(), false);
+        const codex = await readCodexRegistration(codexScopedPaths(paths), packageRoot(), false);
+        if (!codex.enabled)
+            await setMcpDisabled(paths);
+        io.write('OpenCode JuTell MCP를 비활성화했습니다. 설정 항목은 유지됩니다.');
+        return { cancelled: false };
+    }
+    throw new Error('provider 하위 명령: list, status, setup, enable, disable');
+}

package/dist/commands/session/add-work.js

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { todayStamp, readSessionMeta, nextWorkNumber, workTemplate, pageLabel, listPageFiles, pad2, } from './storage.js';
+import { resolveSessionRoot } from './operator-storage.js';
+import { arrowList } from './prompt.js';
+export async function addWorkCommand(paths, options, io) {
+    const { root } = await resolveSessionRoot(paths);
+    const stamp = todayStamp();
+    const dir = path.join(root, stamp);
+    const meta = await readSessionMeta(dir);
+    if (!meta)
+        throw new Error('오늘 Session이 없습니다. `jutell session new`로 시작하세요.');
+    let page = meta.pages.find((p) => p.number === (options.page ?? meta.currentPage));
+    if (!page) {
+        if (meta.pages.length === 0)
+            throw new Error('Page가 없습니다. `jutell session page`로 먼저 만들거나 `--page <번호>`를 지정하세요.');
+        if (options.page)
+            throw new Error(`Page ${options.page}을(를) 찾지 못했습니다.`);
+        const files = await listPageFiles(dir);
+        const picks = files.map((f, index) => ({
+            label: `${pageLabel(meta.pages[index] ?? f)} — ${f.number}`,
+        }));
+        const picked = await arrowList('작업을 추가할 Page 선택:', picks.map((p) => p.label), Math.max(0, (meta.currentPage ?? 1) - 1));
+        if (picked === null || picked === -1)
+            throw new Error('Page 선택이 필요합니다.');
+        page = meta.pages[picked] ?? null;
+        if (!page)
+            throw new Error('Page 목록을 읽지 못했습니다.');
+    }
+    const filePath = path.join(dir, page.file);
+    let content;
+    try {
+        content = await fs.readFile(filePath, 'utf8');
+    }
+    catch {
+        throw new Error(`Page 파일을 읽지 못했습니다: ${page.file}`);
+    }
+    const workNumber = nextWorkNumber(content);
+    content = `${content.replace(/\s+$/, '')}\n\n${workTemplate(workNumber)}\n`;
+    await fs.writeFile(filePath, content, 'utf8');
+    io.write(`작업 ${pad2(workNumber)} 추가 완료: ${pageLabel(page)} (작업 번호는 Page마다 독립)`);
+    return 0;
+}

package/dist/commands/session/create-page.js

@@ -0,0 +1,53 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { todayStamp, readSessionMeta, saveSessionMeta, pageFileName, pageTemplate, pageLabel, } from './storage.js';
+import { resolveSessionRoot } from './operator-storage.js';
+import { askText, arrowList } from './prompt.js';
+const AGENT_CHOICES = ['OpenCode', 'Codex', 'Claude Code', 'Cline'];
+export async function createPageCommand(paths, options, io) {
+    const { root } = await resolveSessionRoot(paths);
+    const stamp = todayStamp();
+    const dir = path.join(root, stamp);
+    const meta = await readSessionMeta(dir);
+    if (!meta) {
+        throw new Error('오늘 Session이 없습니다. `jutell session new`로 시작하세요.');
+    }
+    if (meta.status === 'finished') {
+        throw new Error('오늘 Session은 마감되었습니다. Page는 더 추가하지 않습니다.');
+    }
+    let agent = options.agent;
+    if (!agent) {
+        const picked = await arrowList('사용 Agent 선택:', AGENT_CHOICES);
+        if (picked === null || picked === -1)
+            throw new Error('Agent 선택이 필요합니다. `--agent <이름>`을 지정할 수도 있습니다.');
+        agent = AGENT_CHOICES[picked];
+    }
+    let role = options.role ?? (await askText('집중할 역할:'));
+    if (!role)
+        throw new Error('역할 입력이 필요합니다. `--role <역할>`을 지정할 수도 있습니다.');
+    let title = options.title ?? (await askText('Page 제목:'));
+    if (!title)
+        throw new Error('제목 입력이 필요합니다. `--title <제목>`을 지정할 수도 있습니다.');
+    const number = (meta.pages.reduce((max, page) => Math.max(max, page.number), 0)) + 1;
+    const page = { number, agent, role, title, file: pageFileName({ number, agent, title }) };
+    const filePath = path.join(dir, page.file);
+    if (await exists(filePath)) {
+        throw new Error(`Page 파일이 이미 있습니다. 덮어쓰지 않습니다: ${page.file}`);
+    }
+    await fs.writeFile(filePath, pageTemplate(page, stamp), 'utf8');
+    meta.pages.push(page);
+    meta.currentPage = number;
+    await saveSessionMeta(dir, meta);
+    io.write(`Page 추가 완료: ${pageLabel(page)}`);
+    io.write(`파일: ${page.file} (작업 01이 함께 생성됩니다)`);
+    return 0;
+}
+async function exists(file) {
+    try {
+        await fs.access(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/session/finish-session.js

@@ -0,0 +1,28 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { todayStamp, readSessionMeta, saveSessionMeta, summaryTemplate, SESSION_SUMMARY_FILE } from './storage.js';
+import { resolveSessionRoot } from './operator-storage.js';
+export async function finishSessionCommand(paths, io) {
+    const { root } = await resolveSessionRoot(paths);
+    const stamp = todayStamp();
+    const dir = path.join(root, stamp);
+    const meta = await readSessionMeta(dir);
+    if (!meta)
+        throw new Error('오늘 Session이 없습니다. `jutell session new`로 시작하세요.');
+    if (meta.status === 'finished') {
+        io.write('오늘 Session은 이미 마감되어 있습니다. SESSION_SUMMARY.md를 다시 만들지 않았습니다.');
+        return 0;
+    }
+    const summaryPath = path.join(dir, SESSION_SUMMARY_FILE);
+    try {
+        await fs.access(summaryPath);
+        io.write('SESSION_SUMMARY.md가 이미 있습니다. 덮어쓰지 않았습니다.');
+    }
+    catch {
+        await fs.writeFile(summaryPath, `${summaryTemplate(stamp, meta.pages)}\n`, 'utf8');
+    }
+    meta.status = 'finished';
+    await saveSessionMeta(dir, meta);
+    io.write(`Session 마감 완료: ${stamp} → SESSION_SUMMARY.md 생성`);
+    return 0;
+}

package/dist/commands/session/index.js

@@ -0,0 +1,76 @@
+import path from 'node:path';
+import { todayStamp, readSessionMeta, listLegacyFlatFiles, pageLabel } from './storage.js';
+import { resolveSessionRoot } from './operator-storage.js';
+import { createSessionCommand } from './new-session.js';
+import { createPageCommand } from './create-page.js';
+import { addWorkCommand } from './add-work.js';
+import { movePageCommand } from './move-page.js';
+import { finishSessionCommand } from './finish-session.js';
+import { storageCommand } from './storage-command.js';
+export async function sessionStatusCommand(paths, io) {
+    const { root } = await resolveSessionRoot(paths);
+    const stamp = todayStamp();
+    const meta = await readSessionMeta(path.join(root, stamp));
+    if (!meta) {
+        const legacy = await listLegacyFlatFiles(root, stamp);
+        if (legacy.length > 0) {
+            io.write(`오늘 Session 폴더가 아직 없습니다. (레거시 단일 파일 ${legacy.length}개는 그대로 두고 있습니다.)`);
+        }
+        else {
+            io.write('오늘 Session이 없습니다. `jutell session new`로 시작하세요.');
+        }
+        return 0;
+    }
+    const current = meta.pages.find((page) => page.number === meta.currentPage) ?? null;
+    io.write(`Session: ${meta.date} — ${meta.status === 'finished' ? '마감됨' : '진행 중'}`);
+    io.write(`현재 Page: ${current ? pageLabel(current) : '(없음)'}`);
+    if (meta.pages.length === 0) {
+        io.write('Page가 아직 없습니다. `jutell session page`로 첫 Page를 추가하세요.');
+        return 0;
+    }
+    for (const page of meta.pages) {
+        const marker = page.number === meta.currentPage ? ' (현재)' : '';
+        io.write(`- ${pageLabel(page)}${marker}`);
+    }
+    return 0;
+}
+export async function sessionHelpCommand(io) {
+    io.write(`Session은 하루 작업 기록을 담는 폴더입니다.
+Page는 Agent·역할별 파일, Work는 Page 안의 작업입니다.
+
+하루 기록 명령
+
+  jutell session         오늘 기록 상태를 봅니다.
+  jutell session new     오늘 Session 폴더를 만듭니다.
+  jutell session page    Agent·역할별 Page 파일을 만듭니다.
+  jutell session work    현재 Page에 다음 번호 작업을 추가합니다.
+  jutell session move    작업할 Page를 이동합니다.
+  jutell session finish  SESSION_SUMMARY.md로 하루를 마감합니다.
+
+운영자용 (보통 사용할 필요가 없습니다)
+
+  jutell session storage                 Session 저장 위치 상태를 확인합니다.
+  jutell session storage set <절대 경로>  Session 저장 위치를 운영자 지정으로 바꿉니다.
+  jutell session storage reset            운영자 지정을 제거하고 기본 위치로 돌아갑니다.`);
+    return 0;
+}
+export async function sessionCommand(paths, options, io, extraArgs) {
+    const sub = extraArgs[0] ?? '';
+    if (sub === 'new')
+        return createSessionCommand(paths, io);
+    if (sub === 'page')
+        return createPageCommand(paths, options, io);
+    if (sub === 'work')
+        return addWorkCommand(paths, options, io);
+    if (sub === 'move')
+        return movePageCommand(paths, options, io);
+    if (sub === 'finish')
+        return finishSessionCommand(paths, io);
+    if (sub === 'storage')
+        return storageCommand(paths, options, io, extraArgs.slice(1));
+    if (sub === 'help' || sub === '-h' || sub === '--help')
+        return sessionHelpCommand(io);
+    if (sub === '')
+        return sessionStatusCommand(paths, io);
+    throw new Error(`알 수 없는 session 하위 명령입니다: ${sub}\n` + `가능한 명령: ${sub} help를 실행해 확인하세요.`);
+}

package/dist/commands/session/move-page.js

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import { todayStamp, readSessionMeta, saveSessionMeta, pageLabel, listPageFiles, } from './storage.js';
+import { resolveSessionRoot } from './operator-storage.js';
+import { arrowList } from './prompt.js';
+export async function movePageCommand(paths, options, io) {
+    const { root } = await resolveSessionRoot(paths);
+    const stamp = todayStamp();
+    const dir = path.join(root, stamp);
+    const meta = await readSessionMeta(dir);
+    if (!meta)
+        throw new Error('오늘 Session이 없습니다. `jutell session new`로 시작하세요.');
+    if (meta.pages.length === 0)
+        throw new Error('Page가 없습니다. `jutell session page`로 먼저 만들세요.`');
+    const files = await listPageFiles(dir);
+    if (options.page) {
+        const target = meta.pages.find((p) => p.number === options.page);
+        if (!target)
+            throw new Error(`Page ${options.page}을(를) 찾지 못했습니다.`);
+        meta.currentPage = options.page;
+        await saveSessionMeta(dir, meta);
+        io.write(`현재 Page 변경: ${pageLabel(target)}`);
+        return 0;
+    }
+    const labels = files.map((f, index) => pageLabel(meta.pages[index] ?? f));
+    const defaultIndex = Math.max(0, (meta.currentPage ?? 1) - 1);
+    const picked = await arrowList('이동할 Page 선택:', labels, defaultIndex);
+    if (picked === null || picked === -1) {
+        throw new Error('Page 선택이 필요합니다. `--page <번호>`를 지정할 수도 있습니다.');
+    }
+    const target = meta.pages[picked] ?? null;
+    if (!target)
+        throw new Error('Page 목록을 읽지 못했습니다.');
+    meta.currentPage = target.number;
+    await saveSessionMeta(dir, meta);
+    io.write(`Page 이동 완료: ${pageLabel(target)}`);
+    return 0;
+}

package/dist/commands/session/new-session.js

@@ -0,0 +1,24 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { todayStamp, readSessionMeta, createInitialMeta, saveSessionMeta, listLegacyFlatFiles } from './storage.js';
+import { resolveSessionRoot } from './operator-storage.js';
+export async function createSessionCommand(paths, io) {
+    const { root } = await resolveSessionRoot(paths);
+    const stamp = todayStamp();
+    const dir = path.join(root, stamp);
+    const meta = await readSessionMeta(dir);
+    if (meta) {
+        io.write(`오늘 Session이 이미 있습니다: ${stamp} — ${meta.status === 'finished' ? '마감됨' : '진행 중'}`);
+        io.write('기존 Session을 이어서 사용하세요.');
+        return 0;
+    }
+    await fs.mkdir(dir, { recursive: true });
+    await saveSessionMeta(dir, createInitialMeta(stamp));
+    const legacy = await listLegacyFlatFiles(root, stamp);
+    if (legacy.length > 0) {
+        io.write(`레거시 단일 파일 ${legacy.length}개를 발견했지만 자동 변환하지 않고 그대로 둡니다.`);
+    }
+    io.write(`Session 생성 완료: ${stamp}`);
+    io.write('첫 Page를 추가하려면 `jutell session page`를 실행하세요.');
+    return 0;
+}

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

@@ -0,0 +1,126 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { sessionRoot } from './storage.js';
+// 운영자 로컬 설정 파일. 공개 Git에 포함되지 않으며(.gitignore),
+// Review Bundle·check:public에서도 제외·탐지 대상이다.
+export const OPERATOR_STORAGE_CONFIG_FILE = '.jutell-operator.local.json';
+// 경로가 잘못되었을 때 사용자에게 보여주는 안내. 절대 경로를 포함하지 않는다.
+export const OPERATOR_STORAGE_ERROR = '운영자 Session 저장 위치를 사용할 수 없습니다.\n' +
+    '설정을 확인하거나 제거하면 기본 로컬 저장 위치를 사용할 수 있습니다.';
+export function operatorStorageConfigFile(targetRoot) {
+    return path.join(targetRoot, OPERATOR_STORAGE_CONFIG_FILE);
+}
+// 설정 파일을 읽고 sessionStoragePath를 돌려준다.
+// - 파일이 없으면 undefined (기본 저장 사용)
+// - JSON이 손상되었거나 형식이 틀리면 OPERATOR_STORAGE_ERROR를 던진다
+// - sessionStoragePath가 없으면 undefined
+// - sessionStoragePath가 있지만 올바른 절대 경로가 아니면 OPERATOR_STORAGE_ERROR를 던진다
+//   (잘못된 경로를 기본 저장으로 조용히 대체하지 않는다)
+export async function readOperatorStoragePath(targetRoot) {
+    const file = operatorStorageConfigFile(targetRoot);
+    let raw;
+    try {
+        raw = await fs.readFile(file, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(OPERATOR_STORAGE_ERROR);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(OPERATOR_STORAGE_ERROR);
+    }
+    const value = parsed.sessionStoragePath;
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new Error(OPERATOR_STORAGE_ERROR);
+    const candidate = value.trim();
+    if (!path.isAbsolute(candidate))
+        throw new Error(OPERATOR_STORAGE_ERROR);
+    return candidate;
+}
+// Session 명령이 실제 사용할 저장 루트를 결정한다. 폴더를 만들지 않는다.
+// 운영자 설정이 있고 사용 가능하면 그 경로를, 없으면 기본 .jutell-local 경로를 돌려준다.
+// 설정된 경로가 폴더가 아니거나 접근할 수 없으면 중단한다 (fallback 없음).
+export async function resolveSessionRoot(paths) {
+    const custom = await readOperatorStoragePath(paths.targetRoot);
+    if (custom === undefined) {
+        return { kind: 'default', root: sessionRoot(paths.dataRoot) };
+    }
+    const problem = await inspectDir(custom);
+    if (problem !== undefined)
+        throw new Error(OPERATOR_STORAGE_ERROR);
+    return { kind: 'custom', root: custom };
+}
+// 대상이 폴더인지 확인한다. 없으면(ENOENT) 나중에 만들 수 있는 상태로 통과시킨다.
+async function inspectDir(dir) {
+    try {
+        const stat = await fs.stat(dir);
+        if (!stat.isDirectory())
+            return OPERATOR_STORAGE_ERROR;
+        return undefined;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT')
+            return undefined;
+        return OPERATOR_STORAGE_ERROR;
+    }
+}
+// storage set에서 사용: 후보 경로가 절대 경로인지 확인하고, 없으면 폴더를 만든다.
+// 접근 불가·폴더가 아닌 경우에는 오류를 던진다. 절대 경로를 오류 문구에 넣지 않는다.
+export async function ensureOperatorStorageDir(candidate) {
+    const target = candidate.trim();
+    if (!path.isAbsolute(target)) {
+        throw new Error('Session 저장 위치는 절대 경로로 입력해야 합니다.');
+    }
+    try {
+        const stat = await fs.stat(target);
+        if (!stat.isDirectory()) {
+            throw new Error('Session 저장 위치를 사용할 수 없습니다. 폴더가 아닙니다.');
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('폴더가 아닙니다'))
+            throw error;
+        const code = error.code;
+        if (code !== 'ENOENT') {
+            throw new Error('Session 저장 위치를 사용할 수 없습니다. 접근할 수 없습니다.');
+        }
+    }
+    try {
+        await fs.mkdir(target, { recursive: true });
+    }
+    catch {
+        throw new Error('Session 저장 위치를 사용할 수 없습니다. 폴더를 만들 수 없습니다.');
+    }
+}
+export async function writeOperatorStoragePath(targetRoot, storagePath) {
+    const file = operatorStorageConfigFile(targetRoot);
+    const content = `${JSON.stringify({ sessionStoragePath: storagePath }, null, 2)}\n`;
+    await fs.writeFile(file, content, 'utf8');
+}
+export async function hasOperatorStorageConfig(targetRoot) {
+    try {
+        await fs.access(operatorStorageConfigFile(targetRoot));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// 설정 파일만 제거한다. Session 기록 파일은 건드리지 않는다.
+export async function removeOperatorStorageConfig(targetRoot) {
+    try {
+        await fs.unlink(operatorStorageConfigFile(targetRoot));
+    }
+    catch {
+        // 이미 없는 경우 무시
+    }
+}

package/dist/commands/session/prompt.js

@@ -0,0 +1,77 @@
+import readline from 'node:readline/promises';
+import { emitKeypressEvents } from 'node:readline';
+import { stdin as input, stdout as output } from 'node:process';
+// 플래그(--agent 등) 없이 실행했을 때만 대화형으로 값을 묻습니다.
+// 비대화형(파이프)에서는 null을 돌려주어 명령 쪽에서 오류를 내게 합니다.
+export async function askText(message) {
+    if (!input.isTTY)
+        return null;
+    const rl = readline.createInterface({ input, output });
+    try {
+        const answer = await rl.question(`${message} `);
+        const trimmed = answer.trim();
+        return trimmed || null;
+    }
+    finally {
+        rl.close();
+    }
+}
+// 방향키(↑/↓) + Enter, 숫자 직접 입력을 지원하는 목록 선택.
+// TTY가 아니면 null을 돌려줘서 호출부가 번호 선택 폴백으로 넘어가게 합니다.
+export function arrowList(message, choices, defaultIndex = 0) {
+    if (!input.isTTY)
+        return Promise.resolve(null);
+    return new Promise((resolve) => {
+        let selected = Math.min(Math.max(defaultIndex, 0), Math.max(choices.length - 1, 0));
+        emitKeypressEvents(input);
+        let rawMode = false;
+        const render = () => {
+            output.write(`${message}\n`);
+            choices.forEach((choice, index) => {
+                output.write(`${index === selected ? '> ' : '  '}${index + 1}. ${choice}\n`);
+            });
+            output.write('↑/↓ 이동, Enter 확인, 번호 직접 입력, Ctrl+C 종료\n');
+        };
+        const cleanup = (value) => {
+            if (rawMode && input.setRawMode) {
+                try {
+                    input.setRawMode(false);
+                }
+                catch { /* noop */ }
+            }
+            input.off('keypress', onKeypress);
+            process.stdin.pause();
+            resolve(value);
+        };
+        const onKeypress = (str, key) => {
+            if (key.name === 'up') {
+                selected = (selected - 1 + choices.length) % choices.length;
+                render();
+            }
+            else if (key.name === 'down') {
+                selected = (selected + 1) % choices.length;
+                render();
+            }
+            else if (key.name === 'return')
+                cleanup(selected);
+            else if (key.name === 'escape')
+                cleanup(-1);
+            else if (key.ctrl && key.name === 'c')
+                cleanup(-1);
+            else if (str && /^\d$/.test(str)) {
+                const number = Number(str);
+                if (number >= 1 && number <= choices.length)
+                    cleanup(number - 1);
+            }
+        };
+        input.on('keypress', onKeypress);
+        if (input.setRawMode) {
+            try {
+                input.setRawMode(true);
+                rawMode = true;
+            }
+            catch { /* noop */ }
+        }
+        render();
+    });
+}