elanous 0.2.12 → 0.2.14

package/src/agent-mission/driver.ts

@@ -491,6 +491,8 @@ export interface AgentMissionSpec {
   memory?: boolean;
   /** PTY 닉네임(휴먼 리더블·goto 로 나중 접근). 기본 branch. */
   nickname?: string;
+  /** Concurrent missions may share one decision stream alias without sharing a PTY or worktree. */
+  decisionMissionId?: string;
   /** ⭐⭐ 그 브랜치를 이미 쥔 «소유» 워크트리가 있으면 지우지 말고 그대로 재사용하라고 요청한다
    *  (`createWorktree` 의 같은 이름 인자로 그대로 내려간다 · 판정은 거기 `gateWorktreeReuse` 가 한다).
    *
@@ -513,11 +515,14 @@ export interface AgentMissionResult {
   paths?: string[];
   rounds: number;
   evidencePath: string | null;
+  /** The evidence check outcome, independent of the final mission and DRIVE-OK verdicts. */
+  evidenceSatisfied?: boolean;
   committed: boolean;
   usedOmniCrawl: boolean;
   detail: string;
   ptyId?: string;
   webUrl?: string | null;
+  driveVerdict?: ReturnType<typeof verdictForFinalPtyScreen>['kind'];
 }
 /** @deprecated codex 특정 이름 — AgentMissionResult 을 쓰라. */
 export type CodexMissionResult = AgentMissionResult;
@@ -1609,7 +1614,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     const finalEv = verifyEvidence(wt.path, spec.evidence);
     if (!finalEv.ok) return {
       ok: false, worktree: wt.path, branch: wt.branch, rounds: result.numTurns ?? 0,
-      evidencePath: null, committed: false, usedOmniCrawl: false,
+      evidencePath: null, evidenceSatisfied: false, committed: false, usedOmniCrawl: false,
       detail: `미완(증거 부족): ${finalEv.retry ?? '증거가 아직 부족하다.'}`,
     };
     if (checklist.length) {
@@ -1627,13 +1632,13 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       if (!c.ok) {
         debug.log('agent-mission', 'result', { ok: false, rounds: result.numTurns ?? 0, evidencePath: finalEv.path, committed: false, usedOmni: false });
         return { ok: false, worktree: wt.path, branch: wt.branch, rounds: result.numTurns ?? 0,
-          evidencePath: finalEv.path, committed: false, usedOmniCrawl: false,
+          evidencePath: finalEv.path, evidenceSatisfied: true, committed: false, usedOmniCrawl: false,
           detail: `미완(자동 커밋 실패): ${c.out.slice(0, 120)}` };
       }
     }
     debug.log('agent-mission', 'result', { ok: true, rounds: result.numTurns ?? 0, evidencePath: finalEv.path, committed, usedOmni: false });
     return { ok: true, worktree: wt.path, branch: wt.branch, rounds: result.numTurns ?? 0,
-      evidencePath: finalEv.path, committed, usedOmniCrawl: false, detail: '완료(증거 충족)' };
+      evidencePath: finalEv.path, evidenceSatisfied: true, committed, usedOmniCrawl: false, detail: '완료(증거 충족)' };
   }
   env.TERM = 'xterm-256color';
   // ⭐run-identity — runId was resolved before either headless or PTY spawn.
@@ -1713,7 +1718,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   process.stderr.write(`[agent-mission] pty=${h.id} watch=${webAddress.webUrl ?? `(web unavailable: ${webAddress.pwaUnavailableReason ?? 'not-resolved'})`}\n`);
   debug.log('agent-mission', 'pty-link', { id: h.id, webUrl: webAddress.webUrl, webUrlSource: webAddress.webUrlSource });
 
-  const decisionIdentity = { missionId: runId, sessionId: runId, terminalId: h.id, agent: backend.name };
+  const decisionIdentity = { missionId: spec.decisionMissionId ?? runId, sessionId: runId, terminalId: h.id, agent: backend.name };
   const decisionEvent = (event: Omit<DecisionInput, keyof typeof decisionIdentity>): void => {
     try { (deps.emitPtyDecision ?? emitPtyDecision)({ ...decisionIdentity, ...event } as DecisionInput); }
     catch { /* Observation must not change mission control or handoff. */ }
@@ -2142,7 +2147,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     try { h.kill(); } catch { /* noop */ }
     return { ok: true, worktree: wt.path, branch: wt.branch, rounds: control.steps, evidencePath: wt.path, committed: true, usedOmniCrawl: usedOmni,
       ...(handoffPrSkipped ? { pr: 'skipped' as const, reason: 'origin-not-github' as const } : {}),
-      detail: handoffPrSkipped ? '완료(증거 게이트·push·PR 생략)' : '완료(증거 게이트·PR)' };
+      evidenceSatisfied: true, detail: handoffPrSkipped ? '완료(증거 게이트·push·PR 생략)' : '완료(증거 게이트·PR)' };
   }
   const done = control.termination.kind === 'success';
   const round = control.steps;
@@ -2197,8 +2202,8 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     rounds: round, evidencePath: null, committed: false, usedOmniCrawl: usedOmni, detail: 'aborted' };
   const finalEv = verifyEvidence(wt.path, spec.evidence);
   const finalScreen = await h.renderScreen();
-  const driveVerdict = verdictForFinalPtyScreen({ screen: finalScreen, inputHistory: submittedInputs, exitCode: h.exitCode ?? null });
-  debug.log('agent-mission', 'drive-verdict', { kind: driveVerdict.kind, reason: driveVerdict.reason.slice(0, 200) });
+  const driveVerdict = verdictForFinalPtyScreen({ screen: finalScreen, inputHistory: submittedInputs, exitCode: h.exitCode ?? null, artifactEvidence: finalEv.ok });
+  debug.log('agent-mission', 'drive-ok', { verdict: driveVerdict.kind, reason: driveVerdict.reason.slice(0, 200), evidence: finalEv.ok });
   const recoverExhausted = control.termination.kind === 'stuck' && control.termination.reason.startsWith('사람 필요');
   const accepted = finalEv.ok && !recoverExhausted && driveVerdict.kind !== 'done-but-failed';
   const evidencePath = accepted ? finalEv.path : null;
@@ -2216,9 +2221,9 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
 
   return {
     ok: accepted, worktree: wt.path, branch: wt.branch, rounds: round,
-    evidencePath, committed, usedOmniCrawl: usedOmni,
-    ptyId: h.id, webUrl: webAddress.webUrl,
-    detail: recoverExhausted ? control.termination.reason : driveVerdict.kind === 'done-but-failed' ? `미완(DRIVE-OK: ${driveVerdict.reason})` : done ? '완료(증거 충족)' : (finalEv.ok ? '증거 충족(루프 종료)' : '미완(증거 부족)'),
+    evidencePath, evidenceSatisfied: finalEv.ok, committed, usedOmniCrawl: usedOmni,
+    ptyId: h.id, webUrl: webAddress.webUrl, driveVerdict: driveVerdict.kind,
+    detail: recoverExhausted ? control.termination.reason : driveVerdict.kind === 'done-but-failed' ? `미완(DRIVE-OK: ${driveVerdict.reason})` : driveVerdict.kind === 'success-unverified' && finalEv.ok ? '완료(증거)' : done ? '완료(증거 충족)' : (finalEv.ok ? '증거 충족(루프 종료)' : '미완(증거 부족)'),
   };
   } finally { stopLive(); finishContext(false); }
 }

package/src/agent-mission/duo.ts

@@ -0,0 +1,94 @@
+import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { runAgentMission, resolveBackend, type AgentBackend, type AgentMissionResult, type AgentMissionSpec, type EvidenceMode } from './driver.js';
+
+export interface DuoOptions {
+  left: string;
+  right: string;
+  branch: string;
+  base?: string;
+  missionFile?: string;
+  evidence?: string;
+  docDir?: string;
+  docGlob?: string;
+  testPath?: string;
+  file?: string;
+  maxRounds?: string;
+  commit?: boolean;
+}
+
+export interface DuoSide {
+  side: 'left' | 'right';
+  backend: string;
+  branch: string;
+  finished: number;
+  result?: AgentMissionResult;
+  error?: string;
+}
+
+export interface DuoResult {
+  missionId: string;
+  sides: [DuoSide, DuoSide];
+  lines: [string, string];
+  exitCode: number;
+}
+
+export interface DuoDeps {
+  resolveBackend?: typeof resolveBackend;
+  runMission?: typeof runAgentMission;
+  readFile?: (path: string) => string;
+  id?: () => string;
+}
+
+function evidenceFor(opts: DuoOptions): EvidenceMode {
+  if (opts.evidence === 'doc') return { kind: 'doc', dirRel: opts.docDir ?? 'docs/plans', glob: new RegExp(opts.docGlob ?? '^PLAN-.*[.]md$', 'i') };
+  if (opts.evidence === 'test') {
+    if (!opts.testPath) throw new Error('test 모드엔 --test-path 필요');
+    return { kind: 'test', testPath: opts.testPath, ...(opts.file ? { fileRel: opts.file } : {}) };
+  }
+  if (opts.evidence === undefined || opts.evidence === 'tsc') return { kind: 'tsc' };
+  throw new Error('--evidence 는 doc|tsc|test 여야 합니다');
+}
+
+function render(side: DuoSide, first: DuoSide | undefined): string {
+  const evidence = side.result?.evidenceSatisfied === true
+    ? side.result.evidencePath ? `충족(${side.result.evidencePath})` : '충족'
+    : side.result?.evidenceSatisfied === false ? '미충족' : '미측정';
+  const drive = side.result?.driveVerdict ?? '미측정';
+  const detail = side.error ?? (!side.result?.ok ? side.result?.detail : undefined);
+  return `${side.side} ${side.backend} · branch=${side.branch} · terminalId=${side.result?.ptyId ?? '없음'} · ${first === side ? '먼저' : '나중'} · 증거 ${evidence} · DRIVE-OK ${drive} · ${side.result?.ok ? '완료' : '실패'}${detail ? ` (${detail})` : ''}`;
+}
+
+/** Run two independent existing agent missions; neither branch waits for or cancels its peer. */
+export async function runAgentMissionDuo(textParts: string[], opts: DuoOptions, deps: DuoDeps = {}): Promise<DuoResult> {
+  if (!opts.branch?.trim()) throw new Error('--branch 필요');
+  if (opts.left !== 'codex' && opts.left !== 'claude') throw new Error('--left 는 codex|claude 여야 합니다');
+  if (opts.right !== 'codex' && opts.right !== 'claude') throw new Error('--right 는 codex|claude 여야 합니다');
+  if (opts.left === opts.right) throw new Error('duo 에는 서로 다른 backend 둘이 필요합니다');
+  const mission = opts.missionFile ? (deps.readFile ?? ((path) => readFileSync(path, 'utf8')))(opts.missionFile) : textParts.join(' ');
+  if (!mission.trim()) throw new Error('미션 텍스트가 비었다 — <text...> 또는 --mission-file 필요');
+  const evidence = evidenceFor(opts);
+  const rounds = opts.maxRounds === undefined ? 16 : Number(opts.maxRounds);
+  if (!Number.isSafeInteger(rounds) || rounds <= 0) throw new Error('--max-rounds 는 양의 정수여야 합니다');
+  const resolve = deps.resolveBackend ?? resolveBackend;
+  const backends: [AgentBackend, AgentBackend] = [resolve(opts.left), resolve(opts.right)];
+  if (backends[0].name !== opts.left || backends[1].name !== opts.right) throw new Error('backend 선택이 요청과 다릅니다');
+  const id = `duo-${(deps.id ?? randomUUID)()}`;
+  const run = deps.runMission ?? runAgentMission;
+  let completed = 0;
+  const branches = [`${opts.branch}-${opts.left}`, `${opts.branch}-${opts.right}`] as const;
+  const tasks = backends.map(async (backend, index): Promise<DuoSide> => {
+    const side = index === 0 ? 'left' : 'right';
+    const branch = branches[index]!;
+    const spec: AgentMissionSpec = {
+      mission, branch, agent: backend, decisionMissionId: id, evidence, maxRounds: rounds,
+      ...(opts.base ? { base: opts.base } : {}), commit: opts.commit !== false,
+      enhance: false, memory: false, resources: 'off', entry: 'external-verbatim',
+    };
+    try { return { side, backend: backend.name, branch, result: await run(spec), finished: ++completed }; }
+    catch (error) { return { side, backend: backend.name, branch, error: error instanceof Error ? error.message : String(error), finished: ++completed }; }
+  });
+  const sides = await Promise.all(tasks) as [DuoSide, DuoSide];
+  const first = sides[0].finished <= sides[1].finished ? sides[0] : sides[1];
+  return { missionId: id, sides, lines: [render(sides[0], first), render(sides[1], first)], exitCode: sides.every((s) => s.result?.ok) ? 0 : 2 };
+}

package/src/agent-mission/pty-decision.ts

@@ -44,7 +44,7 @@ function safe(value: string): string {
 export function emitPtyDecision(input: DecisionInput, log: typeof debug.log = (category, event, data) => debug.log(category, event, data)): PtyDecision {
   let stream = missionStreams.get(input.missionId);
   if (!stream) {
-    stream = { alias: `mission-${missionStreams.size + 1}`, seq: -1 };
+    stream = { alias: `${input.missionId.startsWith('duo-') ? 'duo' : 'mission'}-${missionStreams.size + 1}`, seq: -1 };
     missionStreams.set(input.missionId, stream);
   }
   stream.seq += 1;

package/src/autopilot/build/llm-conflict-merge.ts

@@ -10,6 +10,9 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { runGitCommand } from '../../git-fs/runner.js';
 import { countTestDeclarations } from '../../self-implement/test-declarations.js';
 import { NEXT_MD_PATH, resolveNextMdConflict } from '../../release-loop/next-md-merge.js';
+import { getUserConfig } from '../../user-config.js';
+import { debug } from '../../debug/log.js';
+import { collectMergeIntent, defaultIntentGit, type IntentGit } from './merge-intent.js';
 
 function deterministicNextMd(git: MergeGitSeam, worktreePath: string, file: string): string | null {
   try {
@@ -328,27 +331,61 @@ export function defaultGitMergeSeam(): MergeGitSeam {
 }
 
 /** 실 LLM 충돌 해결 어댑터(streamLLM·sol). 코드펜스/설명 제거해 완결 파일만. */
-export async function defaultLlmResolve(filePath: string, conflicted: string, mergeTarget: string): Promise<string> {
-  const { streamLLM } = await import('../../llm.js');
-  const out = await streamLLM([{ role: 'user', content: conflictResolvePrompt(filePath, conflicted, mergeTarget) }], () => {}, { model: process.env.ELANOUS_CONFLICT_MODEL || tierModel('better'), reasoningEffort: 'medium' });
-  // ⛔ 라우터는 공급자가 전부 막히면 던지지 않고 오류 문구를 돌려준다 — 그것은 파일 내용이 아니다. 던져서 «LLM 예외 → base 유지» 로 보낸다.
-  if (PROVIDER_FAILURE_TEXT.test(out)) throw new Error(`conflict resolve: LLM provider failure for ${filePath}`);
-  return `${out.replace(/^```[\w.-]*\n?/, '').replace(/\n?```\s*$/, '').trimEnd()}\n`;
+export async function defaultLlmResolve(
+  filePath: string, conflicted: string, mergeTarget: string,
+  options: { worktreePath?: string; mode?: 'off' | 'shadow' | 'on'; git?: IntentGit; stream?: typeof import('../../llm.js')['streamLLM'] } = {},
+): Promise<string> {
+  let rawMode: unknown = options.mode;
+  if (rawMode === undefined) {
+    try { rawMode = (getUserConfig().raw.selfImplement as { mergeIntent?: unknown } | undefined)?.mergeIntent; }
+    catch { /* unreadable config keeps the old resolver */ }
+  }
+  const mode = rawMode === 'shadow' || rawMode === 'on' ? rawMode : 'off';
+  const streamLLM = options.stream ?? (await import('../../llm.js')).streamLLM;
+  const resolve = async (intent?: { ours: string | null; theirs: string[] }): Promise<string> => {
+    const out = await streamLLM([{ role: 'user', content: conflictResolvePrompt(filePath, conflicted, mergeTarget, intent) }], () => {}, { model: process.env.ELANOUS_CONFLICT_MODEL || tierModel('better'), reasoningEffort: 'medium' });
+    // ⛔ 라우터는 공급자가 전부 막히면 던지지 않고 오류 문구를 돌려준다 — 그것은 파일 내용이 아니다.
+    if (PROVIDER_FAILURE_TEXT.test(out)) throw new Error(`conflict resolve: LLM provider failure for ${filePath}`);
+    return `${out.replace(/^```[\w.-]*\n?/, '').replace(/\n?```\s*$/, '').trimEnd()}\n`;
+  };
+  if (mode === 'off') return resolve();
+  const collect = () => collectMergeIntent({ worktreePath: options.worktreePath ?? process.cwd(), filePath, mergeTarget, git: options.git ?? defaultIntentGit });
+  if (mode === 'on') return resolve(collect());
+  const plain = await resolve();
+  try {
+    const intent = collect();
+    const withIntent = await resolve(intent);
+    debug.log('self-dev.merge', 'intent-shadow', {
+      file: filePath, same: plain === withIntent,
+      plainMarkers: hasConflictMarkers(plain), intentMarkers: hasConflictMarkers(withIntent),
+      plainLines: lineCount(plain), intentLines: lineCount(withIntent),
+      oursIntent: intent.ours !== null, theirsCount: intent.theirs.length,
+    });
+  } catch (error) {
+    try { debug.log('self-dev.merge', 'intent-shadow-failed', { file: filePath, error: String(error) }); }
+    catch { /* shadow observation must not affect the adopted result */ }
+  }
+  return plain;
 }
 
 /** 편의 — 실 git+LLM 으로 호출부가 해석한 ref를 worktree 에 지능 정합한다. */
 export async function mergeMainIntoWorktreeWithLlm(worktreePath: string, mergeTarget: string): Promise<LlmMergeOutcome> {
-  return mergeMainWithLlmResolve(worktreePath, mergeTarget, (filePath, conflicted) => defaultLlmResolve(filePath, conflicted, mergeTarget), defaultGitMergeSeam());
+  return mergeMainWithLlmResolve(worktreePath, mergeTarget, (filePath, conflicted) => defaultLlmResolve(filePath, conflicted, mergeTarget, { worktreePath }), defaultGitMergeSeam());
 }
 
 /** LLM 충돌 해결 프롬프트(순수·테스트) — ours(walker)·theirs(호출자가 전달한 정합 대상) 종합 지시. */
-export function conflictResolvePrompt(filePath: string, conflictedContent: string, mergeTarget: string): string {
+export function conflictResolvePrompt(filePath: string, conflictedContent: string, mergeTarget: string, intent?: { ours: string | null; theirs: string[] }): string {
   return [
     '너는 git merge 충돌을 지능적으로 해결하는 엔지니어다. 아래 파일은 3-way merge 충돌 마커를 포함한다:',
     '  <<<<<<< ours   = 현재 브랜치(walker 가 이 미션에서 만든 산출물)',
     '  ======= 사이   = 양쪽 버전',
     `  >>>>>>> theirs = ${mergeTarget}(호출자가 해석해 전달한 정합 대상)`,
     '',
+    ...(intent ? [
+      `ours 의 의도: ${intent.ours ?? '(확인 불가)'}`,
+      `theirs 에 먼저 착지한 변경: ${intent.theirs.length ? intent.theirs.join(' · ') : '(확인 불가)'}`,
+      '',
+    ] : []),
     '해결 원칙:',
     '- 양쪽의 의도를 **모두 보존**하며 종합한다(한쪽을 통째로 버리지 않는다).',
     `- 같은 목적의 중복(예: 같은 테스트·같은 함수)은 **theirs(${mergeTarget}) 버전을 채택**하고 ours 의 중복은 제거.`,

package/src/autopilot/build/merge-intent.ts

@@ -0,0 +1,53 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { runGitCommand } from '../../git-fs/runner.js';
+
+export interface MergeIntent {
+  ours: string | null;
+  theirs: string[];
+}
+
+export type IntentGit = (worktreePath: string, args: string[]) => { status: number | null; stdout: string };
+
+export const defaultIntentGit: IntentGit = (worktreePath, args) => {
+  const result = runGitCommand(worktreePath, args, { encoding: 'utf8' });
+  return { status: result.status, stdout: result.stdout ?? '' };
+};
+
+/** Read only commits introduced on each side of the merge base; a missing ref/document never blocks resolution. */
+export function collectMergeIntent({ worktreePath, filePath, mergeTarget, git }: {
+  worktreePath: string;
+  filePath: string;
+  mergeTarget: string;
+  git: IntentGit;
+}): MergeIntent {
+  const read = (...args: string[]): string | null => {
+    try {
+      const result = git(worktreePath, args);
+      return result.status === 0 ? result.stdout.trim() : null;
+    } catch { return null; }
+  };
+  const base = read('merge-base', 'HEAD', mergeTarget);
+  if (!base) return { ours: null, theirs: [] };
+
+  let ours: string | null = null;
+  const added = read('log', '--reverse', '--diff-filter=A', '--format=', '--name-only', '-z', `${base}..HEAD`, '--', 'docs/goals/');
+  for (const goal of added?.split('\0').map((file) => file.trim()).filter((file) => /^docs\/goals\/[^/]+$/.test(file)) ?? []) {
+    try {
+      const content = readFileSync(join(worktreePath, goal), 'utf8');
+      const lines = content.split(/\r?\n/);
+      const title = lines.find((line) => /^#\s+\S/.test(line))?.replace(/^#\s+/, '').trim()
+        ?? lines.find((line) => line.trim().length > 0)?.trim();
+      const situation = lines.find((line) => /^Situation:/.test(line))?.trim();
+      const complication = lines.find((line) => /^Complication:/.test(line))?.trim();
+      ours = [title, situation, complication].filter(Boolean).join('\n') || null;
+      if (ours) break;
+    } catch { /* missing goal: try the next added document */ }
+  }
+  if (!ours) {
+    const subjects = read('log', '-3', '--format=%s', `${base}..HEAD`);
+    ours = subjects || null;
+  }
+  const subjects = read('log', '-5', '--format=%s', `${base}..${mergeTarget}`, '--', filePath);
+  return { ours, theirs: subjects ? subjects.split('\n') : [] };
+}

package/src/autopilot/track-agent-shadow.ts

@@ -2,6 +2,7 @@ import { execFile } from 'node:child_process';
 import { appendFileSync, mkdirSync, readFileSync, rmdirSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
+import { stateDirSourceForChild } from '../agent/identity-env.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import type { TrackAgentDecision, TrackAgentInput, TrackAgentResult } from './track-agent.js';
 
@@ -127,7 +128,7 @@ export async function launchTrackAgentShadow(input: TrackAgentInput, options: Sh
       const instanceRoot = effectiveInstanceRoot();
       const { stdout } = await exec('bun', ['bin/elanous.mjs', '--config-dir', instanceRoot, ...values], {
         cwd: process.env.ELANOUS_TOOL_CWD?.trim() || resolve(import.meta.dir, '../..'),
-        env: { ...process.env, ELANOUS_STATE_DIR: instanceRoot },
+        env: { ...process.env, ELANOUS_STATE_DIR: instanceRoot, ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(instanceRoot) },
         encoding: 'utf8', maxBuffer: 1024 * 1024,
       });
       return { stdout };

package/src/autopilot/track-agent.ts

@@ -2,6 +2,7 @@ import { execFile, spawn } from 'node:child_process';
 import { readdirSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { promisify } from 'node:util';
+import { stateDirSourceForChild } from '../agent/identity-env.js';
 import { debug, redactSecretText } from '../debug/log.js';
 import { getOrCreatePersonaSession } from '../session/index.js';
 import { getUserConfig } from '../user-config.js';
@@ -38,7 +39,9 @@ const log = (event: string, data: Record<string, unknown>) => {
 };
 /** The daemon's own universe, resolved once and pinned on the child (config ⊕ state) — the harness isolates its own workers. */
 export function universeLaunch(args: readonly string[], root: string = effectiveInstanceRoot()): { argv: string[]; env: NodeJS.ProcessEnv } {
-  return { argv: ['bin/elanous.mjs', '--config-dir', root, ...args], env: { ...process.env, ELANOUS_STATE_DIR: root } };
+  return { argv: ['bin/elanous.mjs', '--config-dir', root, ...args], env: {
+    ...process.env, ELANOUS_STATE_DIR: root, ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(root),
+  } };
 }
 const runCli = async (args: string[]): Promise<{ stdout: string }> => {
   const { argv, env } = universeLaunch(args);

package/src/boot/daemon-prompt-request.ts

@@ -38,6 +38,7 @@ export interface DaemonPromptBody {
    *  (`none` · `readonly` · `chat` · `webterm`); invalid values reject
    *  the request rather than silently falling back. */
   tools?: DaemonToolSurfaceKind;
+  personaId?: string;
 }
 
 export interface DaemonPromptRequest {
@@ -53,6 +54,7 @@ export interface DaemonPromptRequest {
    *  not opt in; the caller-side (`handlePromptStreamPost`) interprets
    *  null as "use the daemon's boot-time surface". */
   tools: DaemonToolSurfaceKind | null;
+  personaId?: string;
 }
 
 export type DaemonPromptRequestParseResult =
@@ -117,6 +119,7 @@ export function parseDaemonPromptBody(
         body.source ? writeInputSourceMeta(body.source) : undefined,
       ),
       tools: body.tools ?? null,
+      ...(typeof body.personaId === 'string' && body.personaId.trim() ? { personaId: body.personaId } : {}),
     },
   };
 }

package/src/boot/daemon-prompt-turn.ts

@@ -10,7 +10,7 @@ import {
   appendUserPromptBlocksAndBuildMessages,
 } from './daemon-history-helper.js';
 import type { ContentBlock as AcpContentBlock } from '@agentclientprotocol/sdk';
-import type { DaemonSessionHistory } from './daemon-runtime.js';
+import { personaPromptForChat, type DaemonSessionHistory } from './daemon-runtime.js';
 import type { DaemonPromptRequest } from './daemon-prompt-request.js';
 import type { DaemonToolSurface } from './daemon-tools/types.js';
 import type { ConfirmChannel } from '../hitl/confirm.js';
@@ -199,8 +199,9 @@ export async function runDaemonPromptTurn(opts: {
   // …" + active terminals) to the system prompt so the LLM has the
   // session id + terminal ids without an extra discovery call. Helper
   // returns the original prompt unchanged when there's nothing to add.
+  const personaPrompt = await personaPromptForChat(request.personaId);
   const augmentedSystemPrompt = appendWebtermContext(
-    request.effectiveSystemPrompt,
+    personaPrompt ? [personaPrompt, request.effectiveSystemPrompt].filter(Boolean).join('\n\n') : request.effectiveSystemPrompt,
     request.sessionId,
     activeToolSurface,
   );
@@ -291,6 +292,9 @@ export async function runDaemonPromptTurn(opts: {
   if (!isFirstTurn && opts.projectInstructions) {
     messages.unshift({ role: 'system', content: opts.projectInstructions });
   }
+  if (!isFirstTurn && personaPrompt) {
+    messages.unshift({ role: 'system', content: personaPrompt });
+  }
   const result = await runCoreTurn({
     sessionId: request.sessionId,
     userText: request.userText,

package/src/boot/daemon-runtime.ts

@@ -55,6 +55,33 @@ import { elanousSelfAccessPrompt } from '../agent/self-ambient.js';
 import { createToolCwdResolver, type ToolCwdResolver } from './tool-cwd.js';
 import { resolveSessionProjectContext } from '../project/session-context.js';
 import { debug } from '../debug/log.js';
+import { resolvePersonaAddress } from '../intake-plane/persona-answer.js';
+import { awaitGlobalPersonaLoad, getGlobalPersonaRegistry } from '../persona/global-registry.js';
+
+const turnPersonaPrompt = new AsyncLocalStorage<string | undefined>();
+
+export function withChatPersonaPrompt<T>(prompt: string | undefined, run: () => T): T {
+  return turnPersonaPrompt.run(prompt, run);
+}
+
+export function prependChatPersonaOnLaterTurn(
+  messages: LLMMessage[], isFirstTurn: boolean,
+): LLMMessage[] {
+  const prompt = turnPersonaPrompt.getStore();
+  if (!isFirstTurn && prompt) messages.unshift({ role: 'system', content: prompt });
+  return messages;
+}
+
+export async function personaPromptForChat(
+  id: unknown,
+  deps: { load: () => Promise<unknown>; registry: () => Parameters<typeof resolvePersonaAddress>[1] } = {
+    load: awaitGlobalPersonaLoad, registry: getGlobalPersonaRegistry,
+  },
+): Promise<string | undefined> {
+  if (typeof id !== 'string' || !id.trim()) return undefined;
+  await deps.load();
+  return resolvePersonaAddress(id, deps.registry())?.systemPrompt;
+}
 
 /** C4 (2026-07-12) — arm the non-detached-PTY kill ONCE per turn signal.
  *  Multiple tool calls in one turn share the same AbortSignal instance;
@@ -135,7 +162,7 @@ export function composeDaemonSystemPrompt(
   promptMeta: Readonly<Record<string, unknown>> | undefined,
   sessionId?: string,
 ): string {
-  return [basePrompt, buildDaemonInputSourceLine(promptMeta), elanousSelfAccessPrompt(sessionId)]
+  return [turnPersonaPrompt.getStore(), basePrompt, buildDaemonInputSourceLine(promptMeta), elanousSelfAccessPrompt(sessionId)]
     .filter((part): part is string => typeof part === 'string' && part.trim().length > 0)
     .join('\n\n');
 }
@@ -604,12 +631,11 @@ export function createDaemonRunTurn(
       const hasNonTextBlock = !!promptBlocks?.some(
         (b) => (b as { type?: string }).type !== 'text',
       );
-      if (hasNonTextBlock) {
-        return appendUserPromptBlocksAndBuildMessages(
-          history, sessionId, promptBlocks!, systemPrompt,
-        );
-      }
-      return appendUserAndBuildMessages(history, sessionId, userText, systemPrompt);
+      const isFirstTurn = history.get(sessionId).length === 0;
+      const messages = hasNonTextBlock
+        ? appendUserPromptBlocksAndBuildMessages(history, sessionId, promptBlocks!, systemPrompt)
+        : appendUserAndBuildMessages(history, sessionId, userText, systemPrompt);
+      return prependChatPersonaOnLaterTurn(messages, isFirstTurn);
     },
     getTools: () => surface.specs,
     dispatchTool: terminalCapableDispatch(surfaceHasPtyShell, async (name, args, ctx) => {
@@ -723,15 +749,21 @@ export function createDaemonRunTurn(
         });
         debugBridge.activate();
       }
-      const projectCwd = resolveSessionProjectContext(turnCtx.sessionId)?.cwd;
-      if (projectCwd || opts.acpSessionCwd) {
-        // An ACP session's explicit cwd wins; the project folder is only the default when none was given (IA3 review).
-        const explicitCwd = opts.acpSessionCwd && turnCtx.cwd ? turnCtx.cwd : undefined;
-        const resolver = createToolCwdResolver({ tools: opts.tools ?? 'none', toolCwd: explicitCwd ?? projectCwd ?? turnCtx.cwd });
-        await turnToolCwd.run(resolver, () => inner(turnCtx));
-      } else {
-        await inner(turnCtx);
-      }
+      const elanousMeta = turnCtx.promptMeta?.elanous;
+      const personaId = elanousMeta && typeof elanousMeta === 'object' && !Array.isArray(elanousMeta)
+        && 'pwaPersonaId' in elanousMeta ? elanousMeta.pwaPersonaId : undefined;
+      const personaPrompt = await personaPromptForChat(personaId);
+      await withChatPersonaPrompt(personaPrompt, async () => {
+        const projectCwd = resolveSessionProjectContext(turnCtx.sessionId)?.cwd;
+        if (projectCwd || opts.acpSessionCwd) {
+          // An ACP session's explicit cwd wins; the project folder is only the default when none was given (IA3 review).
+          const explicitCwd = opts.acpSessionCwd && turnCtx.cwd ? turnCtx.cwd : undefined;
+          const resolver = createToolCwdResolver({ tools: opts.tools ?? 'none', toolCwd: explicitCwd ?? projectCwd ?? turnCtx.cwd });
+          await turnToolCwd.run(resolver, () => inner(turnCtx));
+        } else {
+          await inner(turnCtx);
+        }
+      });
     } finally {
       debugBridge?.dispose();
     }

package/src/chat/index.ts

@@ -452,6 +452,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'reasoning', aliases: ['r', 'think'],  description: 'Reasoning level (codex effort + summary, anthropic extended-thinking budget) — /reasoning [off|low|medium|high|xhigh] (cycle when no arg · xhigh 는 모델 상한이 xhigh 이상일 때만 wire 에 실린다, 아니면 high 로 깎인다)', subcommands: ['off', 'low', 'medium', 'high', 'xhigh'] },
   { name: 'local',     aliases: ['ll'],         description: 'Local OpenAI-compatible LLM — ping / models / test / use', subcommands: ['ping', 'models', 'test', 'use', 'status'] },
   { name: 'session',   aliases: ['sess'],       description: 'Session resume — list / load / sync / new (handoff from mobile)', subcommands: ['list', 'load', 'sync', 'new'] },
+  { name: 'persona', aliases: [], description: '이 대화의 페르소나 보기·고르기·빼기 — /persona [이름|-]', subcommands: ['-'] },
   { name: 'fork',      aliases: [],             description: 'Copy this session into a new one' },
   { name: 'rewind',    aliases: [],             description: 'Rewind — 과거 user 턴 픽커로 되감기 (원본 보존 · 새 세션 분기 · /rewind <n> 숏컷)' },
   // TUI 부활 C-a (2026-07-12): autopilot 미션 TUI 표면 — CLI 동등 단일 창구 소비.
@@ -463,6 +464,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'plugin', aliases: ['plugins'], description: 'Manage plugins', subcommands: ['list', 'activate', 'deactivate', 'reload'] },
   { name: 'widget', aliases: ['widgets'], description: 'Manage widgets', subcommands: ['list', 'reload', 'instances'] },
   { name: 'log',   aliases: [],             description: 'Chat Log controls — size / clear / filter / search / freeze / solo / turn / fold / help', subcommands: ['size', 'clear', 'filter', 'search', 'freeze', 'solo', 'turn', 'fold', 'help'] },
+  { name: 'loops', aliases: [], description: '루프와 크론 상태 표 — /loops [owner]' },
   { name: 'memory', aliases: ['mem'], description: 'Memory ops — list / show / search / add / delete (see `elanous memory --help`)', subcommands: ['list', 'show', 'search', 'add', 'delete', 'index'] },
   { name: 'export', aliases: [], description: 'Export this conversation transcript to a markdown file — /export [path] (default ~/temp/elanous-transcript-<stamp>.md)' },
   { name: 'delta', aliases: ['diffs'], description: 'Source delta browser — open the latest turn-scoped file diff popup', subcommands: ['open', 'help'] },