elanous 0.2.35 → 0.2.37

package/src/cli/tasks-read-cli.ts

@@ -0,0 +1,197 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Command } from 'commander';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { readNexusRuntime } from '../nexus/runtime.js';
+import { TASK_CARD_PREFIX } from '../task-agent/task-card-prefix.js';
+import type { Task } from '../task-orchestrator/types.js';
+import type { TasksCliDeps } from './tasks-cli.js';
+
+/**
+ * CLI-ENTRY-LAZY — `tasks list`·`tasks show` 의 등록과 넥서스 조회 보조.
+ * ⛔ 이 파일은 task-agent 의 board·shadow·mission 클러스터(·dashboard)를 «정적으로» 싣지 않는다 — 가벼운 진입(`light-cli.ts`)이
+ * `tasks-cli.ts` 전체 대신 이것만 등록한다. 과제 카드(`ta-…`) 상세는 `tasks-card-show.ts` 를 그때 싣는다.
+ * 같은 등록 함수를 `tasks-cli.ts` 가 부르므로 전체 진입과 출력 계약이 한 코드다.
+ */
+
+type TaskRow = Pick<Task, 'id' | 'title' | 'priority' | 'status' | 'createdAt' | 'approval' | 'generatedBy'>;
+
+/** `tasks hand`·`show` 가 남기는 `task-agent` 관측의 logs.db surface 라벨. */
+export const TASK_AGENT_SINK_SURFACE = 'task-agent';
+
+/**
+ * 독립 CLI 프로세스는 데몬의 logs.db 싱크를 상속하지 않는다 — 등록하지 않으면 `debug.log('task-agent', …)` 가
+ * 파일 트레일에만 남고 `elanous logs --category task-agent` 에 0건으로 보인다(10-06 실측: 카드 3장 · 이벤트 0).
+ * fail-open — 등록 실패가 과제 넘기기를 막지 않는다.
+ */
+export async function registerTaskAgentSink(register?: (surface: string) => Promise<unknown>): Promise<void> {
+  try {
+    const fn = register ?? (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink;
+    await fn(TASK_AGENT_SINK_SURFACE);
+  } catch { /* fail-open — 파일 트레일이 진실원 */ }
+}
+
+const PRIORITY_RANK: Record<Task['priority'], number> = { urgent: 0, high: 1, medium: 2, low: 3 };
+export const NEXUS_DOWN = '넥서스가 안 떠 있다 — `elanous nexus run`';
+
+function taskOrder(a: TaskRow, b: TaskRow): number {
+  return PRIORITY_RANK[a.priority] - PRIORITY_RANK[b.priority]
+    || a.createdAt - b.createdAt || a.id.localeCompare(b.id);
+}
+
+function taskSource(task: TaskRow): string {
+  return task.generatedBy?.kind === 'external'
+    ? `${task.generatedBy.provider}:${task.generatedBy.ref}` : '-';
+}
+
+function taskLine(task: TaskRow): string {
+  return [task.id, task.priority, task.status, task.approval?.state ?? '-', taskSource(task), task.title].join('\t');
+}
+
+export function credentials(deps: TasksCliDeps): { baseUrl: string; token?: string } | null {
+  const port = deps.baseUrl !== undefined ? undefined : readNexusRuntime()?.httpPort;
+  const baseUrl = deps.baseUrl ?? (port ? `http://127.0.0.1:${port}` : undefined);
+  if (!baseUrl) return null;
+  // Same as `connector linear sync`: an isolated (--test) universe has no acp-token and its
+  // daemon accepts loopback callers without one — send the bearer only when there is one.
+  let token = deps.bearerToken;
+  if (token === undefined) {
+    try { token = readFileSync(join(getElanousConfigDir(), 'acp-token'), 'utf8').trim() || undefined; }
+    catch { token = undefined; }
+  }
+  return { baseUrl, ...(token ? { token } : {}) };
+}
+
+export class NexusUnavailable extends Error {}
+
+export async function request(deps: TasksCliDeps, auth: { baseUrl: string; token?: string }, path: string, method = 'GET'): Promise<Response> {
+  try {
+    return await (deps.fetch ?? fetch)(`${auth.baseUrl}${path}`, {
+      method,
+      headers: auth.token ? { Authorization: `Bearer ${auth.token}` } : {},
+    });
+  } catch {
+    // Fetch exceptions can include the URL or credentials; never forward their text.
+    throw new NexusUnavailable();
+  }
+}
+
+export async function responseJson(response: Response): Promise<unknown> {
+  try { return await response.json(); }
+  catch { throw new Error('넥서스 응답 JSON이 유효하지 않다'); }
+}
+
+function httpError(response: Response): Error {
+  // Do not echo server-supplied error bodies: they may contain credentials.
+  return new Error(`HTTP ${response.status}`);
+}
+
+export function handleError(error: unknown, out: (line: string) => void): void {
+  if (error instanceof NexusUnavailable) {
+    out(NEXUS_DOWN);
+    process.exitCode = 2;
+  } else {
+    out(error instanceof Error ? error.message : '태스크 요청 실패');
+    process.exitCode = 1;
+  }
+}
+
+/** `tasks` 하위 명령들이 함께 쓰는 출력·인증 문맥 — 응답 출력에서 쓰인 토큰을 가린다. */
+export interface TasksCliContext {
+  deps: TasksCliDeps;
+  out: (line: string) => void;
+  authenticate: () => { baseUrl: string; token?: string };
+  clearToken: () => void;
+}
+
+export function createTasksCliContext(deps: TasksCliDeps): TasksCliContext {
+  let activeToken: string | undefined;
+  const output = deps.output ?? console.log;
+  return {
+    deps,
+    out: (line: string) => output(activeToken ? line.replaceAll(activeToken, '[redacted]') : line),
+    authenticate: () => {
+      const auth = credentials(deps);
+      activeToken = auth?.token;
+      if (!auth) throw new NexusUnavailable();
+      return auth;
+    },
+    clearToken: () => { activeToken = undefined; },
+  };
+}
+
+/** `tasks` 뿌리 명령(별칭 `task`) — 전체·가벼운 등록이 같은 뿌리를 쓴다. */
+export function registerTasksRoot(program: Command): Command {
+  return program.command('tasks').alias('task').description('TOX 태스크 조회 및 승인 · TASK-AGENT 과제 넘기기(hand)');
+}
+
+export function registerTaskListCommand(tasks: Command, ctx: TasksCliContext): void {
+  const { deps, out, authenticate } = ctx;
+  tasks.command('list')
+    .description('우선순위와 생성 시각 순으로 태스크 보기')
+    .option('--status <s>', '상태로 필터')
+    .option('--provider <p>', '외부 출처로 필터')
+    .option('--json', 'JSON 출력')
+    .action(async (opts: { status?: string; provider?: string; json?: boolean }) => {
+      try {
+        ctx.clearToken();
+        const auth = authenticate();
+        const response = await request(deps, auth, '/v1/tasks');
+        if (!response.ok) throw httpError(response);
+        const body = await responseJson(response) as { tasks?: Array<Pick<TaskRow, 'id' | 'status'>> };
+        if (!Array.isArray(body?.tasks)) throw new Error('넥서스 태스크 목록 형식이 유효하지 않다');
+        const cards = body.tasks.filter((task) => !opts.status || task.status === opts.status);
+        // The list endpoint returns board cards without approval or provenance.
+        // Obtain those fields from the detail endpoint rather than displaying guesses.
+        const rows: TaskRow[] = [];
+        for (const card of cards) {
+          const detail = await request(deps, auth, `/v1/tasks/${encodeURIComponent(card.id)}`);
+          if (!detail.ok) throw httpError(detail);
+          const data = await responseJson(detail) as { task?: TaskRow };
+          if (!data?.task || data.task.id !== card.id) throw new Error('넥서스 태스크 상세 형식이 유효하지 않다');
+          if (!opts.provider || (data.task.generatedBy?.kind === 'external' && data.task.generatedBy.provider === opts.provider)) rows.push(data.task);
+        }
+        rows.sort(taskOrder);
+        if (opts.json) out(JSON.stringify(rows));
+        else {
+          out('id\t우선순위\t상태\t승인\t출처\t제목');
+          for (const row of rows) out(taskLine(row));
+        }
+      } catch (error) { handleError(error, out); }
+    });
+}
+
+export function registerTaskShowCommand(tasks: Command, ctx: TasksCliContext): void {
+  const { deps, out, authenticate } = ctx;
+  tasks.command('show <id>')
+    .description(`태스크 상세 보기 (id 가 \`${TASK_CARD_PREFIX}\` 로 시작하면 TASK-AGENT 과제 카드 ⊕ 다음 수)`)
+    .option('--json', 'JSON 출력')
+    .action(async (id: string, opts: { json?: boolean }) => {
+      if (id.startsWith(TASK_CARD_PREFIX)) {
+        const { showTaskCard } = await import('./tasks-card-show.js');
+        await showTaskCard(id, opts, deps, out);
+        return;
+      }
+      try {
+        ctx.clearToken();
+        const auth = authenticate();
+        const response = await request(deps, auth, `/v1/tasks/${encodeURIComponent(id)}`);
+        if (!response.ok) throw httpError(response);
+        const data = await responseJson(response) as { task?: TaskRow };
+        if (!data?.task) throw new Error('넥서스 태스크 상세 형식이 유효하지 않다');
+        if (opts.json) out(JSON.stringify(data));
+        else {
+          out(taskLine(data.task));
+          out(JSON.stringify(data, null, 2));
+        }
+      } catch (error) { handleError(error, out); }
+    });
+}
+
+/** 가벼운 진입 전용 — `tasks list`·`tasks show` 만 등록한다(전체 레지스트리 `registerTasksCommands` 를 싣지 않는다). */
+export function registerTaskReadCommands(program: Command, deps: TasksCliDeps = {}): void {
+  const ctx = createTasksCliContext(deps);
+  const tasks = registerTasksRoot(program);
+  registerTaskListCommand(tasks, ctx);
+  registerTaskShowCommand(tasks, ctx);
+}

package/src/cli/usage-cli.ts

@@ -75,13 +75,14 @@ function configuredUsageHosts(): { local: string; remote: string[] } {
   return { local, remote: [...new Set(entries.map((entry) => entry.host?.trim()).filter((host): host is string => !!host && host !== local))] };
 }
 
-type UsageAxis = 'stage' | 'phase' | 'model' | 'account';
+type UsageAxis = 'stage' | 'phase' | 'model' | 'account' | 'job';
 type ExtendedRunUsageInput = RunUsageInput & { stage?: string | null; account?: string | null; origin?: string; podJob?: string; job?: string; measured?: boolean };
 type AxisUsageRow = {
   stage?: string;
   phase?: string;
   model?: string;
   account?: string;
+  job?: string;
   hostIds: string[];
   calls: number;
   inputTokens: number;
@@ -98,7 +99,7 @@ type AxisUsageRow = {
 };
 
 type FederatedUsageRow = {
-  runId?: string; role?: string; site?: string; stage?: string; phase?: string; model?: string; account?: string;
+  runId?: string; role?: string; site?: string; stage?: string; phase?: string; model?: string; account?: string; job?: string;
   billingProvider?: string; billing?: string; hostIds: string[]; rankUsd?: number;
   calls: number; inputTokens: number; outputTokens: number; cacheReadInputTokens: number;
   cacheCreationInputTokens: number; reasoningOutputTokens: number; usdKnown: number;
@@ -123,7 +124,7 @@ function validUsageRows(value: unknown, axis: 'run' | 'role' | UsageAxis): value
         const number = row[field];
         return typeof number === 'number' && Number.isFinite(number) && number >= 0;
       })
-      && (axis !== 'stage' && axis !== 'phase' && axis !== 'model' && axis !== 'account'
+      && (axis !== 'stage' && axis !== 'phase' && axis !== 'model' && axis !== 'account' && axis !== 'job'
         || typeof row.rankUsd === 'number' && Number.isFinite(row.rankUsd));
   });
 }
@@ -138,7 +139,7 @@ function mergeUsageRows(groups: readonly FederatedUsageRow[][], axis: 'run' | 'r
     if (!previous) { merged.set(key, { ...row, hostIds: [...row.hostIds] }); continue; }
     for (const field of SUM_FIELDS) previous[field] += row[field];
     previous.hostIds = [...new Set([...previous.hostIds, ...row.hostIds])];
-    if (axis === 'stage' || axis === 'phase' || axis === 'model' || axis === 'account') previous.rankUsd = previous.usdKnown + previous.apiEquivalentUsd;
+    if (axis === 'stage' || axis === 'phase' || axis === 'model' || axis === 'account' || axis === 'job') previous.rankUsd = previous.usdKnown + previous.apiEquivalentUsd;
   }
   return [...merged.values()];
 }
@@ -188,6 +189,7 @@ function rollupByAxis(inputs: readonly ExtendedRunUsageInput[], axis: UsageAxis)
   for (const data of inputs) {
     const value = axis === 'stage' ? stageForUsage(data)
       : axis === 'phase' ? (typeof data.phase === 'string' && data.phase.length > 0 ? data.phase : '(none)')
+      : axis === 'job' ? (typeof data.jobKind === 'string' && data.jobKind.length > 0 ? data.jobKind : '(none)')
       : axis === 'model' ? (data.model || '(none)')
         : (data.account || '(none)');
     const group = groups.get(value) ?? [];
@@ -218,7 +220,7 @@ function rollupByAxis(inputs: readonly ExtendedRunUsageInput[], axis: UsageAxis)
 }
 
 function isUsageAxis(value: string): value is 'run' | 'role' | UsageAxis {
-  return value === 'run' || value === 'role' || value === 'stage' || value === 'phase' || value === 'model' || value === 'account';
+  return value === 'run' || value === 'role' || value === 'stage' || value === 'phase' || value === 'model' || value === 'account' || value === 'job';
 }
 
 function formatAxisUsage(row: AxisUsageRow, axis: UsageAxis): string {
@@ -260,7 +262,7 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
     .action((opts: { run?: string; by: string; since?: string; hosts?: string; json?: boolean }, command: Command) => {
       const json = opts.json || command.optsWithGlobals<{ json?: boolean }>().json;
       if (!isUsageAxis(opts.by)) {
-        out.log('⛔ --by 는 run | role | stage | model | account');
+        out.log('⛔ --by 는 run | role | stage | phase | model | account | job');
         exit(2);
         return;
       }
@@ -300,14 +302,14 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
         const complete = !rosterReason && hosts.every((host) => host.status === 'ok');
         const rows = mergeUsageRows(parts, opts.by as 'run' | 'role' | UsageAxis);
         if (opts.by === 'role') rows.sort((a, b) => b.calls - a.calls);
-        if (opts.by === 'stage' || opts.by === 'phase' || opts.by === 'model' || opts.by === 'account') rows.sort((a, b) => (b.rankUsd ?? 0) - (a.rankUsd ?? 0) || b.calls - a.calls);
+        if (opts.by === 'stage' || opts.by === 'phase' || opts.by === 'model' || opts.by === 'account' || opts.by === 'job') rows.sort((a, b) => (b.rankUsd ?? 0) - (a.rankUsd ?? 0) || b.calls - a.calls);
         if (json) { out.log(JSON.stringify({ rows, hosts, complete, ...(rosterReason ? { reason: rosterReason } : {}) }, null, 2)); return; }
         out.log(`호스트 ${hosts.filter((host) => host.status === 'ok').length}/${hosts.length} 측정 · ${complete ? '완결' : '부분 합계'}`);
         if (rosterReason) out.log(`호스트 목록: 못 잼 (${rosterReason})`);
         for (const host of hosts) if (host.status === 'unmeasured') out.log(`${host.host}: 못 잼 (${host.reason})`);
         if (rows.length === 0) { out.log('(일치하는 런 사용량 없음)'); return; }
         for (const row of rows) {
-          if (opts.by === 'stage' || opts.by === 'phase' || opts.by === 'model' || opts.by === 'account') out.log(formatAxisUsage(row as AxisUsageRow, opts.by));
+          if (opts.by === 'stage' || opts.by === 'phase' || opts.by === 'model' || opts.by === 'account' || opts.by === 'job') out.log(formatAxisUsage(row as AxisUsageRow, opts.by));
           else if (opts.by === 'role') out.log(`${row.role}  ${row.site}  ${row.model}  ${row.billingProvider}/${row.billing}  calls=${row.calls}  input=${row.inputTokens}  output=${row.outputTokens}  usdKnown=${row.usdKnown}  unknownCostCalls=${row.unknownCostCalls}  includedCalls=${row.includedCalls}  apiEquivalentUsd=${row.apiEquivalentUsd}`);
           else out.log(`${row.runId}  ${row.model}  ${row.billingProvider}/${row.billing}  hosts=${row.hostIds.join(',') || '(none)'}  calls=${row.calls}  input=${row.inputTokens}  output=${row.outputTokens}  cacheRead=${row.cacheReadInputTokens}  cacheCreation=${row.cacheCreationInputTokens}  reasoning=${row.reasoningOutputTokens}  usdKnown=${row.usdKnown}  unknownCostCalls=${row.unknownCostCalls}  includedCalls=${row.includedCalls}  apiEquivalentUsd=${row.apiEquivalentUsd}`);
         }
@@ -325,14 +327,14 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
           localFailure = '로컬 logs.db 조회 실패';
         }
       }
-      const unwrapPod = opts.by === 'stage' || opts.by === 'phase' || opts.by === 'model' || opts.by === 'account';
+      const unwrapPod = opts.by === 'stage' || opts.by === 'phase' || opts.by === 'model' || opts.by === 'account' || opts.by === 'job';
       // ⭐ METER-POD-ROLLUP-GAP-2 — Pod 사용량 재방출 행(podRollupKey)은 «더 완전한 한 행»만 센다(키 없는 행은 그대로).
       const selected = rows.map((row) => usageData(row, unwrapPod))
         .filter((data): data is ExtendedRunUsageInput => data !== null)
         .filter((data) => opts.run === undefined || data.runId === opts.run);
       // A returned Pod raw row and its host rollup describe the same usage. Keep raw rows when no measured rollup exists.
       const inputs = dedupePodRollupRows(unwrapPod ? excludeCoveredPodRawRows(selected) : selected);
-      if (opts.by === 'stage' || opts.by === 'phase' || opts.by === 'model' || opts.by === 'account') {
+      if (opts.by === 'stage' || opts.by === 'phase' || opts.by === 'model' || opts.by === 'account' || opts.by === 'job') {
         const report = rollupByAxis(inputs, opts.by);
         if (opts.hosts === 'all') { emitFederated(report, localFailure); return; }
         if (json) {

package/src/context-bus/claude-memory-import.ts

@@ -0,0 +1,99 @@
+/**
+ * Claude 자동 기억(`~/.claude/projects/<project>/memory/*.md`) → 엘라누스 장기 기억 저장소
+ * (MEMORY-IMPORT-CLAUDE · 대표 10-12). 변환은 `long-term-memory.ts` 의 순수 함수가 맡고, 여기는
+ * «파일 읽기 ⊕ 저장(name 중복이면 덮어쓰기)» 만 둔다 — 생산 호출자는 `elanous memory import-claude`
+ * (`src/cli/memory-cli.ts`) 다.
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import {
+  importClaudeMemories,
+  type ClaudeMemoryFile, type ClaudeMemoryImport, type ClaudeMemoryItem, type ClaudeMemoryType,
+} from './long-term-memory.js';
+
+/** 저장소에 쓸 레코드 — 큐레이션 기억 파일 하나로 떨어진다. */
+export interface ClaudeMemorySaveRecord {
+  /** 같은 name 이 이미 있으면 그 id 로 덮어쓴다. */
+  id?: string;
+  type: ClaudeMemoryType;
+  name: string;
+  description: string;
+  /** 낡음 표시 ⊕ 본문 ⊕ 출처 링크. */
+  body: string;
+}
+
+export interface ClaudeMemoryStoreDeps {
+  /** 저장소의 현재 기억 목록 — name 중복 판정용. */
+  list: () => Array<{ id: string; name: string }>;
+  /** 장기 기억 쓰기(생산 구현 = `saveMemory`). */
+  save: (record: ClaudeMemorySaveRecord) => void;
+}
+
+export interface ClaudeMemoryApplyResult extends ClaudeMemoryImport {
+  /** 새로 만든 수 */
+  saved: number;
+  /** 같은 name 을 덮어쓴 수 */
+  updated: number;
+}
+
+/** 기본 뿌리 — `~/.claude/projects`(프로젝트별 `memory/` 를 훑는다). */
+export function claudeMemoryRoot(): string {
+  return join(homedir(), '.claude', 'projects');
+}
+
+/** 가져온 레코드 → 저장소 레코드. 낡음 표시가 본문에 남아 화면·주입에서 바로 보인다. */
+export function claudeMemoryStoreRecord(item: ClaudeMemoryItem, id?: string): ClaudeMemorySaveRecord {
+  return {
+    id,
+    type: item.type,
+    name: item.name,
+    description: item.description,
+    body: [item.summary, item.body, `source: ${item.source}`, `updated: ${item.updatedAt}`]
+      .filter(Boolean).join('\n\n'),
+  };
+}
+
+/**
+ * `root` 아래 Claude 기억 파일을 모두 읽는다. `root` 가 `~/.claude/projects` 여도 되고
+ * `.../memory` 디렉터리 자체여도 된다. 색인 파일(`MEMORY.md`)은 기억이 아니므로 뺀다.
+ */
+export function collectClaudeMemoryFiles(root: string = claudeMemoryRoot()): ClaudeMemoryFile[] {
+  if (!existsSync(root)) return [];
+  const dirs = new Set<string>();
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      const memoryDir = join(root, entry.name, 'memory');
+      if (existsSync(memoryDir)) dirs.add(memoryDir);
+    } else if (basename(root) === 'memory' && entry.isFile() && entry.name.endsWith('.md')) {
+      dirs.add(root);
+    }
+  }
+  const files: ClaudeMemoryFile[] = [];
+  for (const dir of [...dirs].sort()) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith('.md') || entry.name === 'MEMORY.md') continue;
+      const path = join(dir, entry.name);
+      files.push({ path, text: readFileSync(path, 'utf8') });
+    }
+  }
+  return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+
+/** 파일들 → 장기 기억. 같은 name 이 저장소에 이미 있으면 그 id 로 덮어쓴다(새 파일을 만들지 않는다). */
+export function applyClaudeMemoryImport(
+  files: readonly ClaudeMemoryFile[],
+  options: { asOf: string },
+  deps: ClaudeMemoryStoreDeps,
+): ClaudeMemoryApplyResult {
+  const imported = importClaudeMemories(files, options);
+  const existing = new Map(deps.list().map(entry => [entry.name, entry.id]));
+  let saved = 0;
+  let updated = 0;
+  for (const item of imported.items) {
+    const id = existing.get(item.name);
+    deps.save(claudeMemoryStoreRecord(item, id));
+    if (id) updated += 1; else saved += 1;
+  }
+  return { ...imported, saved, updated };
+}

package/src/context-bus/long-term-memory.ts

@@ -302,3 +302,128 @@ export async function condenseContextWindowWithReport(
   catch { /* Observation must not stop condensation. */ }
   return { cards, skipped, folded, droppedHarnessChild, funnel };
 }
+
+// ─── Claude 자동 기억 가져오기 (MEMORY-IMPORT-CLAUDE · 대표 10-12) ──────────────────────────────
+// `~/.claude/projects/<project>/memory/*.md` 의 frontmatter(name·description·type)를 엘라누스
+// 장기 기억 레코드로 옮긴다. 파일 읽기·저장은 호출자 몫 — 여기는 순수 변환만 둔다(에이전트 무관).
+
+/** Claude 기억 파일 frontmatter 의 type 값 — 큐레이션 기억 type 어휘와 같다. */
+export type ClaudeMemoryType = 'user' | 'feedback' | 'project' | 'reference';
+
+/** 가져온 기억이 앉는 신뢰 사다리 맨 아래 칸 — 승격된 카드·결정을 덮지 않는다. */
+export const CLAUDE_MEMORY_TRUST = 'memory';
+
+/** 가져온 기억의 seat 표식 — 어떤 에이전트(codex·elanous TUI)든 같은 자리에서 읽는다. */
+export const CLAUDE_MEMORY_SEAT = 'claude-memory';
+
+/** 디스크에서 읽은 Claude 기억 파일 하나(경로 ⊕ 원문). */
+export interface ClaudeMemoryFile { path: string; text: string }
+
+/** MemoryItem 계약에 파일 자신의 이름 3종(name·description·type)을 그대로 얹은 레코드. */
+export interface ClaudeMemoryItem extends MemoryItem {
+  name: string;
+  description: string;
+  type: ClaudeMemoryType;
+  body: string;
+  trust: typeof CLAUDE_MEMORY_TRUST;
+}
+
+export type ClaudeMemorySkipReason = 'no-frontmatter' | 'no-name' | 'no-description' | 'unknown-type';
+
+export interface ClaudeMemoryImport {
+  items: ClaudeMemoryItem[];
+  /** 같은 name 이 두 번 나오면 뒤 파일이 이긴다(덮어쓰기). */
+  overwritten: number;
+  skipped: Partial<Record<ClaudeMemorySkipReason, number>>;
+}
+
+const CLAUDE_MEMORY_TYPES: readonly ClaudeMemoryType[] = ['user', 'feedback', 'project', 'reference'];
+
+/** 출처 표시 — 원장의 `^(https?://|elanous://)` 링크 계약을 넓히지 않고 그대로 만족한다. */
+export function claudeMemorySource(name: string): string {
+  return `elanous://claude-memory/${encodeURIComponent(name.trim())}`;
+}
+
+/** 낡음 표시 — «10-14 기준» 처럼 기준일의 월-일을 남긴다. */
+export function claudeMemoryStalenessNote(asOf: string): string {
+  return `«${claudeMemoryInstant(asOf).slice(5, 10)} 기준»`;
+}
+
+function claudeMemoryInstant(asOf: string): string {
+  const ms = Date.parse(asOf);
+  if (!Number.isFinite(ms)) throw new Error(`claude memory asOf is not a date: ${asOf}`);
+  return new Date(ms).toISOString();
+}
+
+function claudeFrontmatter(text: string): { fields: Record<string, string>; body: string } | undefined {
+  const normalized = text.replace(/^\uFEFF/, '').replace(/\r\n?/g, '\n');
+  if (!normalized.startsWith('---\n')) return undefined;
+  const close = normalized.indexOf('\n---', 3);
+  if (close < 0) return undefined;
+  const fields: Record<string, string> = {};
+  for (const line of normalized.slice(4, close).split('\n')) {
+    const match = /^([A-Za-z][\w-]*)\s*:\s*(.*)$/.exec(line);
+    if (match) fields[match[1]] = match[2].replace(/^(['"])([\s\S]*)\1$/, '$2').trim();
+  }
+  return { fields, body: normalized.slice(close + 4).replace(/^\n+/, '').trim() };
+}
+
+function claudeMemoryProject(path: string): string {
+  const parts = path.split(/[\\/]/).filter(Boolean);
+  const projectsAt = parts.indexOf('projects');
+  if (projectsAt >= 0 && parts[projectsAt + 2] === 'memory') return parts[projectsAt + 1];
+  const memoryAt = parts.lastIndexOf('memory');
+  return memoryAt > 0 ? parts[memoryAt - 1] : '(unknown)';
+}
+
+/**
+ * Claude 기억 파일 하나 → 장기 기억 레코드. 형식이 안 맞으면 이유와 함께 건너뛴다.
+ * claim 이 없는 레코드지만 source 가 `elanous://claude-memory/<name>` 링크라 원장 계약을 지킨다.
+ */
+export function importClaudeMemory(
+  file: ClaudeMemoryFile,
+  options: { asOf: string },
+): { ok: true; item: ClaudeMemoryItem } | { ok: false; reason: ClaudeMemorySkipReason } {
+  const parsed = claudeFrontmatter(file.text);
+  if (!parsed) return { ok: false, reason: 'no-frontmatter' };
+  const name = (parsed.fields.name ?? '').trim();
+  if (!name) return { ok: false, reason: 'no-name' };
+  const description = (parsed.fields.description ?? '').trim();
+  if (!description) return { ok: false, reason: 'no-description' };
+  const type = (parsed.fields.type ?? '').trim().toLowerCase();
+  if (!CLAUDE_MEMORY_TYPES.includes(type as ClaudeMemoryType)) return { ok: false, reason: 'unknown-type' };
+  return { ok: true, item: {
+    project: claudeMemoryProject(file.path),
+    seat: CLAUDE_MEMORY_SEAT,
+    topic: name,
+    summary: `${claudeMemoryStalenessNote(options.asOf)} ${description}`,
+    source: claudeMemorySource(name),
+    updatedAt: claudeMemoryInstant(options.asOf),
+    status: 'active',
+    name,
+    description,
+    type: type as ClaudeMemoryType,
+    body: parsed.body,
+    trust: CLAUDE_MEMORY_TRUST,
+  } };
+}
+
+/** 여러 파일을 한 번에 — name 이 겹치면 뒤 파일이 이긴다(덮어쓰기). */
+export function importClaudeMemories(
+  files: readonly ClaudeMemoryFile[],
+  options: { asOf: string },
+): ClaudeMemoryImport {
+  const byName = new Map<string, ClaudeMemoryItem>();
+  const skipped: Partial<Record<ClaudeMemorySkipReason, number>> = {};
+  let overwritten = 0;
+  for (const file of files) {
+    const outcome = importClaudeMemory(file, options);
+    if (!outcome.ok) {
+      skipped[outcome.reason] = (skipped[outcome.reason] ?? 0) + 1;
+      continue;
+    }
+    if (byName.has(outcome.item.name)) overwritten += 1;
+    byName.set(outcome.item.name, outcome.item);
+  }
+  return { items: [...byName.values()], overwritten, skipped };
+}

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

@@ -256,7 +256,7 @@ export async function runCoreTurn(
       mode: deferredEnabled ? 'always' : 'off',
     });
   }
-  debug.log('capability.resolve', 'tier-split', {
+  debug.log('capability.resolve', 'tool-tier-split', {
     sessionId: ctx.sessionId,
     surfaceId: surface.id,
     surfaceSelectionReason: surface.selectionReason,
@@ -285,7 +285,9 @@ export async function runCoreTurn(
         signal: ctx.signal,
         ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}),
         ...(ctx.maxToolTurns !== undefined ? { maxTurns: ctx.maxToolTurns } : {}),
-        ...(ctx.modelOverride !== undefined ? { model: ctx.modelOverride } : {}),
+        ...(ctx.initialProvider !== undefined
+          ? { initialProvider: ctx.initialProvider, ...(ctx.skipProviders ? { skipProviders: ctx.skipProviders } : {}) }
+          : ctx.modelOverride !== undefined ? { model: ctx.modelOverride } : {}),
         ...(ctx.callbacks?.onResolvedProvider !== undefined ? { onResolvedProvider: ctx.callbacks.onResolvedProvider } : {}),
         ...(ctx.budgetGrant !== undefined ? { budgetGrant: ctx.budgetGrant } : {}),
         ...(ctx.terminalToolNames !== undefined ? { terminalToolNames: ctx.terminalToolNames } : {}),