elanous 0.2.36 → 0.2.38

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

@@ -6,6 +6,7 @@ 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';
+import { writeStdoutFully } from './stdout-flush.js';
 
 /**
  * CLI-ENTRY-LAZY — `tasks list`·`tasks show` 의 등록과 넥서스 조회 보조.
@@ -100,6 +101,7 @@ export function handleError(error: unknown, out: (line: string) => void): void {
 export interface TasksCliContext {
   deps: TasksCliDeps;
   out: (line: string) => void;
+  outFully: (line: string) => Promise<void>;
   authenticate: () => { baseUrl: string; token?: string };
   clearToken: () => void;
 }
@@ -107,9 +109,15 @@ export interface TasksCliContext {
 export function createTasksCliContext(deps: TasksCliDeps): TasksCliContext {
   let activeToken: string | undefined;
   const output = deps.output ?? console.log;
+  const maskToken = (line: string) => activeToken ? line.replaceAll(activeToken, '[redacted]') : line;
   return {
     deps,
-    out: (line: string) => output(activeToken ? line.replaceAll(activeToken, '[redacted]') : line),
+    out: (line: string) => output(maskToken(line)),
+    outFully: async (line: string) => {
+      const safeLine = maskToken(line);
+      if (deps.output) output(safeLine);
+      else await writeStdoutFully(safeLine);
+    },
     authenticate: () => {
       const auth = credentials(deps);
       activeToken = auth?.token;
@@ -126,7 +134,7 @@ export function registerTasksRoot(program: Command): Command {
 }
 
 export function registerTaskListCommand(tasks: Command, ctx: TasksCliContext): void {
-  const { deps, out, authenticate } = ctx;
+  const { deps, out, outFully, authenticate } = ctx;
   tasks.command('list')
     .description('우선순위와 생성 시각 순으로 태스크 보기')
     .option('--status <s>', '상태로 필터')
@@ -152,7 +160,7 @@ export function registerTaskListCommand(tasks: Command, ctx: TasksCliContext): v
           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));
+        if (opts.json) await outFully(JSON.stringify(rows));
         else {
           out('id\t우선순위\t상태\t승인\t출처\t제목');
           for (const row of rows) out(taskLine(row));
@@ -162,7 +170,7 @@ export function registerTaskListCommand(tasks: Command, ctx: TasksCliContext): v
 }
 
 export function registerTaskShowCommand(tasks: Command, ctx: TasksCliContext): void {
-  const { deps, out, authenticate } = ctx;
+  const { deps, out, outFully, authenticate } = ctx;
   tasks.command('show <id>')
     .description(`태스크 상세 보기 (id 가 \`${TASK_CARD_PREFIX}\` 로 시작하면 TASK-AGENT 과제 카드 ⊕ 다음 수)`)
     .option('--json', 'JSON 출력')
@@ -179,7 +187,7 @@ export function registerTaskShowCommand(tasks: Command, ctx: TasksCliContext): v
         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));
+        if (opts.json) await outFully(JSON.stringify(data));
         else {
           out(taskLine(data.task));
           out(JSON.stringify(data, null, 2));

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/context-now.ts

@@ -16,7 +16,7 @@ import { filterPublicDemoContext } from './context-now-public.js';
 
 export type ContextFact =
   | { kind: 'version'; version: string; source: string }
-  | { kind: 'cell'; version: string; id: string; title: string; status: string; owner: string | null; source: string }
+  | { kind: 'cell'; version: string; id: string; title: string; status: string; owner: string | null; source: string; priority?: string | null }
   | { kind: 'decision'; id: string; title: string; status: string; dueAt: string | null; source: string }
   | { kind: 'seat'; seat: string; at: string; status: string; id: string | null; title: string | null; source: string }
   | { kind: 'run'; goal: string; phase: string; elapsed: string; source: string; unreadable?: string }
@@ -157,7 +157,8 @@ export function contextNow(options: { topic?: string; limit?: number; audience?:
     for (const item of checklist.items) {
       if (item.status === 'done') continue;
       facts.push({ kind: 'cell', version: v, id: item.id, title: redactSecretText(item.title.split(/\r?\n/, 1)[0] ?? '').slice(0, 120),
-        status: item.status, owner: item.owner ?? null, source: `elanous://release/${v}/checklist#${encodeURIComponent(item.id)}` });
+        status: item.status, owner: item.owner ?? null, priority: item.priority ?? null,
+        source: `elanous://release/${v}/checklist#${encodeURIComponent(item.id)}` });
     }
   }
   for (const item of (deps.decisions ?? (() => new DecisionLedger().list({ status: 'open' })))()) {
@@ -218,6 +219,89 @@ export function contextNow(options: { topic?: string; limit?: number; audience?:
   return options.audience === 'public-demo' ? filterPublicDemoContext(answer, deps.brandCheck) : answer;
 }
 
+export type AskOpContextTopic = 'release' | 'required' | 'train' | 'incident' | 'decision' | 'general';
+export type AskOpContextBundle = {
+  queriedAt: string;
+  topic: AskOpContextTopic;
+  facts: Array<{ kind: string; summary: string; source: string; observedAt: string }>;
+  gaps: Array<{ kind: string; reason: string }>;
+};
+
+function askOpTopic(question: string): AskOpContextTopic {
+  const text = question.toLocaleLowerCase();
+  if (/열차|착지|병합|merge|train|pull request|\bpr\b/.test(text)) return 'train';
+  if (/사고|장애|incident|failure|실패|에러|오류/.test(text)) return 'incident';
+  if (/결정|승인|decision|approval/.test(text)) return 'decision';
+  if (/필수|p0|must|required|우선순위/.test(text)) return 'required';
+  if (/발행|출시|릴리스|release|컷|cut|게이트|gate|이번 판|다음 판|판 진도|\b\d+\.\d+\.\d+\b/.test(text)) return 'release';
+  return 'general';
+}
+
+/** A small evidence packet for an OP answer. A missing source stays a gap, never an inferred fact. */
+export function buildAskOpContextBundle(
+  question: string,
+  snapshot: ContextNowAnswer,
+  options: { audience?: 'operator' | 'public-demo'; limit?: number } = {},
+): AskOpContextBundle {
+  const answer = options.audience === 'public-demo' ? filterPublicDemoContext(snapshot) : snapshot;
+  const topic = askOpTopic(question);
+  const limit = typeof options.limit === 'number' && Number.isFinite(options.limit)
+    ? Math.max(1, Math.min(20, Math.floor(options.limit))) : 8;
+  const facts: AskOpContextBundle['facts'] = [];
+  const gaps: AskOpContextBundle['gaps'] = [];
+  const pushFact = (kind: string, summary: string, source: string, observedAt: string) => {
+    if (facts.length < limit) facts.push({ kind, summary: oneLine(summary), source, observedAt });
+  };
+  const relevant = (kind: ContextFact['kind']) => topic === 'general'
+    || (topic === 'release' && (kind === 'release' || kind === 'version'))
+    || (topic === 'required' && kind === 'cell')
+    || (topic === 'decision' && kind === 'decision')
+    || (topic === 'incident' && kind === 'run');
+  for (const fact of answer.facts) {
+    if (!relevant(fact.kind)) continue;
+    if ('unreadable' in fact && fact.unreadable) {
+      gaps.push({ kind: fact.kind, reason: fact.unreadable });
+      continue;
+    }
+    if (topic === 'required' && fact.kind === 'cell' && fact.priority !== 'P0') continue;
+    if (topic === 'incident' && fact.kind === 'run' && !/fail|error|timeout|실패|오류|정지|중단/i.test(`${fact.phase} ${fact.goal}`)) continue;
+    if (topic === 'train') continue;
+    const summary = fact.kind === 'version' ? `판 ${fact.version}`
+      : fact.kind === 'cell' ? `${fact.id} ${fact.status} ${fact.title}`
+      : fact.kind === 'decision' ? `${fact.id} ${fact.status} ${fact.title}`
+      : fact.kind === 'seat' ? `${fact.seat} ${fact.status} ${fact.id ?? ''}`
+      : fact.kind === 'run' ? `${fact.goal} ${fact.phase} ${fact.elapsed}`
+      : fact.kind === 'release' ? `${fact.version} ${fact.node} ${fact.status}`
+      : `${fact.count ?? '미관측'}건 ${fact.names.join(', ')}`;
+    pushFact(fact.kind, summary, fact.source, fact.kind === 'seat' ? fact.at : answer.at);
+  }
+  const eventMatches = (kind: string, summary: string) => topic === 'general'
+    || (topic === 'train' && /train|열차|착지|병합|merge|\bpr\b/i.test(`${kind} ${summary}`))
+    || (topic === 'incident' && /incident|사고|장애|failure|실패|에러|오류|timeout/i.test(`${kind} ${summary}`));
+  for (const event of answer.events) {
+    if (eventMatches(event.kind, event.summary)) pushFact(event.kind, event.summary, event.source, event.at);
+  }
+  if (topic === 'required' && !facts.length) {
+    const cells = answer.facts.filter(fact => fact.kind === 'cell');
+    if (cells.some(fact => fact.priority == null)) gaps.push({ kind: 'cell', reason: '우선순위 미관측' });
+    else if (cells.length) gaps.push({ kind: 'cell', reason: '조회 범위에서 일치하는 P0 없음' });
+  }
+  if (!facts.length && !gaps.length) gaps.push({ kind: topic, reason: '미관측' });
+  if (topic === 'release' && !answer.facts.some(fact => fact.kind === 'release' && !('unreadable' in fact && fact.unreadable))
+    && !gaps.some(gap => gap.kind === 'release')) gaps.push({ kind: 'release', reason: '미관측' });
+  return { queriedAt: answer.at, topic, facts, gaps: gaps.slice(0, 3) };
+}
+
+/** Worker scan keeps ledger IO away from the OP inbox turn; the packet itself is bounded. */
+export async function askOpContextBundle(
+  question: string,
+  options: { audience?: 'operator' | 'public-demo'; limit?: number } = {},
+  readSnapshot: () => Promise<ContextNowAnswer> = () => contextNowInWorker({ audience: 'operator', limit: 100 }),
+): Promise<AskOpContextBundle> {
+  try { return buildAskOpContextBundle(question, await readSnapshot(), { ...options, audience: options.audience ?? 'public-demo' }); }
+  catch { return { queriedAt: new Date().toISOString(), topic: askOpTopic(question), facts: [], gaps: [{ kind: 'context', reason: '조회 실패' }] }; }
+}
+
 const workerAnswers = new Map<string, { promise: Promise<ContextNowAnswer>; expiresAt: number }>();
 const WORKER_ANSWER_TTL_MS = 5_000;
 const WORKER_SCAN_TIMEOUT_MS = 60_000;

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

@@ -25,7 +25,7 @@ import { drainPendingUserInput } from '../session/pending-input.js';
 import type { StreamWithToolsHandlers } from '../llm.js';
 import { debug, redactSecretText, withAmbientSessionScope } from '../debug/log.js';
 import { applyDeferredTools } from '../session-runtime/tier-flip.js';
-import { resolveSessionSurfaceProfile } from '../session-runtime/index.js';
+import { buildResearchDateSystemMessage, resolveSessionSurfaceProfile } from '../session-runtime/index.js';
 import type {
   CoreTurnContext,
   CoreTurnResult,
@@ -239,12 +239,18 @@ export async function runCoreTurn(
   // 있으면 그 스코프의 deferred 툴을 active 로 선주입(ToolSearch 왕복 0).
   const recentUserText = extractRecentUserText(ctx.messages);
   const surfaceUserText = selectSurfaceUserText(ctx);
-  const surface = resolveSessionSurfaceProfile({ userText: surfaceUserText });
+  const surface = ctx.surfaceProfile ?? resolveSessionSurfaceProfile({ userText: surfaceUserText });
   const { messages, tools, stats } = applyDeferredTools(
     ctx.messages,
     ctx.tools,
     { enabled: deferredEnabled, ...(recentUserText ? { userText: recentUserText } : {}) },
   );
+  if (surface.id === 'research/agent' && !messages.some((message) =>
+    message.role === 'system' && typeof message.content === 'string'
+      && message.content.startsWith('Current local date:'))
+  ) {
+    messages.unshift(buildResearchDateSystemMessage());
+  }
   if (debug.enabled) {
     debug.log('llm.request', 'tools-tier', {
       sessionId: ctx.sessionId,
@@ -282,6 +288,7 @@ export async function runCoreTurn(
       handlers,
       {
         tools,
+        researchTurn: surface.id === 'research/agent',
         signal: ctx.signal,
         ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}),
         ...(ctx.maxToolTurns !== undefined ? { maxTurns: ctx.maxToolTurns } : {}),

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

@@ -185,7 +185,7 @@ export const GOAL_FINAL_ITERATION_NOTE =
   '[last iteration] 이번이 이 목표의 마지막 반복이다. 이번에 끝내지 못하면 답 끝에 최종 보고를 한 번 써라: 한 것 · 남은 것 · 확인한 증거.';
 
 /** 중간 답이 «최종 보고형»(미완 목록)인가 — 관측 전용(행동을 바꾸지 않는다). */
-const INTERIM_REPORT_SHAPED = /(?:보고할 수 없|하지 못했습니다|못했습니다|완료되지 않았|검증되지 않았|확인하지 못했|not (?:yet )?(?:verified|completed)|cannot report)/i;
+const INTERIM_REPORT_SHAPED = /(?:보고할 수 없|하지\s?못했습니다|못\s?했습니다|완료되지 않았|검증되지 않았|확인하지 못했|not (?:yet )?(?:verified|completed)|cannot report)/i;
 export function isInterimReportShaped(text: string): boolean {
   return INTERIM_REPORT_SHAPED.test(text);
 }
@@ -631,12 +631,15 @@ export async function runGoalLoop(
   const reinject = (content: string): void => {
     if (iterations >= maxIterations) return;
     const lastIteration = iterations === maxIterations - 1;
+    const reportShaped = isInterimReportShaped(lastResult.finalText);
     try {
       debug.log('goal.loop', 'interim-reply', {
         sessionId: ctx.sessionId, ...runAttribution, iteration: iterations, lastIteration,
-        reportShaped: isInterimReportShaped(lastResult.finalText), finalChars: lastResult.finalText.length,
+        reportShaped, finalChars: lastResult.finalText.length,
       }, { level: 'debug' });
     } catch { /* 관측 실패가 루프를 막지 않는다 */ }
+    // Only a real continuation is interim; terminal and last-iteration answers stay visible.
+    if (lastResult.finalText.trim()) ctx.callbacks?.onGoalInterim?.(lastResult.finalText, iterations);
     const nextIteration = iterations + 1;
     const toolBudget = ctx.maxToolTurns ?? TOOL_LOOP_MAX_TURNS_DEFAULT;
     const shouldAttachDelegateHint = shouldHintDelegate({

package/src/core-turn/types.ts

@@ -103,6 +103,8 @@ export interface CoreTurnCallbacks {
    *  persist this into their history store so the next user turn
    *  sees real tool evidence rather than a string summary. */
   onTurnComplete?(newMessages: LLMMessage[]): void;
+  /** A goal iteration has finished but the goal remains open. Display-only signal; never replaces the turn history. */
+  onGoalInterim?(text: string, iteration: number): void;
   /** Codex Responses API reasoning summary stream (gpt-5 family).
    *  `summary_part_added` marks a paragraph break between successive
    *  parts; `summary_delta` carries the streamed text. Only fires when
@@ -135,6 +137,9 @@ export interface CoreTurnContext {
   originSessionId?: string;
   /** Original human prompt for this turn, forwarded to tool dispatch. */
   userText?: string;
+  /** Caller-selected surface. ACP passes its one per-turn verdict through;
+   * direct callers can omit it and let core-turn resolve from userText. */
+  surfaceProfile?: import('../session-runtime/index.js').SessionSurfaceProfile;
   /** Full prompt (system + history + current user blocks). */
   messages: LLMMessage[];
   /** Tool catalog the model may call this turn. Empty array means

package/src/dashboard/chat/acp-chat.ts

@@ -89,6 +89,8 @@ export interface AcpChatHandlers {
   /** Append streamed assistant text. Caller accumulates + redraws.
    *  Receives each chunk exactly as the ACP agent emits it. */
   appendChunk: (delta: string) => void;
+  /** A goal iteration ended; fold only that interim reply in the visible pane. */
+  foldGoalInterim?: (text: string) => void;
   /** Called once per tool_call event with a rendered label like
    *  "→ tool: read_file(/tmp/foo)". Dashboard writes these into the
    *  log pane with a subdued style. */
@@ -430,6 +432,13 @@ export class DashboardAcpChat {
   private dispatchUpdate(update: SessionUpdate, handlers: AcpChatHandlers, sess: AcpChatSession): void {
     switch (update.sessionUpdate) {
       case 'agent_message_chunk': {
+        const interim = (update as typeof update & { _meta?: { goalInterim?: unknown } })._meta?.goalInterim;
+        if (typeof interim === 'string') {
+          this.closeStreamBuffer(sess, 'flush');
+          handlers.foldGoalInterim?.(interim);
+          handlers.redraw?.();
+          return;
+        }
         const c = update.content;
         if (c.type === 'text') {
           this.routeText(sess, c.text, handlers);