elanous 0.2.12 → 0.2.13

package/skills/omni-digest/src/media.ts

@@ -8,11 +8,11 @@
  * X 는 media.variants 로 MP4 직링크를 주므로 yt-dlp 없이 curl 로 바로 받는다.
  */
 
-import { execFile as execFileCb, execFileSync } from 'node:child_process';
+import { execFile as execFileCb } from 'node:child_process';
 import { mkdir, readdir, readFile, rm } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
+import { accessSync, constants, existsSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { join, delimiter } from 'node:path';
 import { promisify } from 'node:util';
 import { env } from './env.js';
 import type { TweetMedia } from './types.js';
@@ -25,10 +25,22 @@ const MAX_DURATION_MS = Number(env('OMNI_DIGEST_MEDIA_MAX_MS', String(20 * 60 *
 const CHUNK_SECONDS = 600;
 
 function has(bin: string): boolean {
-  try {
-    execFileSync('which', [bin], { stdio: 'ignore' });
-    return true;
-  } catch { return false; }
+  for (const dir of (process.env.PATH ?? '').split(delimiter).filter(Boolean)) {
+    try { accessSync(join(dir, bin), constants.X_OK); return true; } catch { /* try next directory */ }
+  }
+  return false;
+}
+
+const missingEngines = new Set<string>();
+
+export function mediaEngineAvailable(engine: 'ffmpeg' | 'whisper'): boolean {
+  if (has(engine)) return true;
+  if (!missingEngines.has(engine)) {
+    missingEngines.add(engine);
+    if (engine === 'ffmpeg') console.error('ffmpeg 없음 — 영상 오디오 추출·전사 빠짐 · 설치하면 영상 전사 켜짐');
+    else console.error('whisper 없음 — 로컬 음성 전사 빠짐 · 설치하면 오프라인 전사 켜짐 (youtube-master 폴백은 계속)');
+  }
+  return false;
 }
 
 async function run(bin: string, args: string[]): Promise<string> {
@@ -47,7 +59,7 @@ export async function downloadVideo(url: string, outdir: string): Promise<string
 
 /** 영상에서 16kHz 모노 mp3 를 추출한다 (STT 엔진 공통 입력 규격). */
 export async function extractAudio(videoPath: string, outdir: string): Promise<string> {
-  if (!has('ffmpeg')) throw new Error('ffmpeg 가 필요합니다 (brew install ffmpeg)');
+  if (!mediaEngineAvailable('ffmpeg')) throw new Error('ffmpeg 가 필요합니다 (brew install ffmpeg)');
   const out = join(outdir, 'audio.mp3');
   await run('ffmpeg', [
     '-hide_banner', '-loglevel', 'error', '-y',
@@ -61,7 +73,7 @@ export async function extractAudio(videoPath: string, outdir: string): Promise<s
 
 /** 로컬 whisper CLI 전사. 미설치면 null 을 반환해 폴백을 유도한다. */
 async function transcribeLocalWhisper(audioPath: string, outdir: string, lang: string): Promise<string | null> {
-  if (!has('whisper')) return null;
+  if (!mediaEngineAvailable('whisper')) return null;
   const model = env('OMNI_DIGEST_WHISPER_MODEL', 'small');
   try {
     await run('whisper', [
@@ -81,11 +93,12 @@ async function transcribeLocalWhisper(audioPath: string, outdir: string, lang: s
 }
 
 /** youtube-master 의 STT 체인(ElevenLabs → OpenAI → Gemini)으로 폴백. */
-async function transcribeViaYoutubeMaster(audioPath: string, outdir: string): Promise<string | null> {
+export async function transcribeViaYoutubeMaster(audioPath: string, outdir: string): Promise<string | null> {
   const skillRoot = env('YOUTUBE_MASTER_ROOT', join(process.env.HOME || '', '.claude/skills/youtube-master'));
   const script = join(skillRoot, 'scripts/transcribe-local.ts');
   if (!existsSync(script)) return null;
 
+  if (!mediaEngineAvailable('ffmpeg')) return null;
   // transcribe-local.ts 는 chunk_%03d.mp3 가 든 디렉터리를 입력으로 받는다
   const chunksDir = join(outdir, 'chunks');
   await mkdir(chunksDir, { recursive: true });
@@ -98,7 +111,7 @@ async function transcribeViaYoutubeMaster(audioPath: string, outdir: string): Pr
 
   const outFile = join(outdir, 'transcript.txt');
   try {
-    await run('npx', ['tsx', script, chunksDir, outFile]);
+    await run(process.execPath, [script, chunksDir, outFile]);
     const text = (await readFile(outFile, 'utf-8')).trim();
     return text || null;
   } catch {
@@ -137,6 +150,7 @@ export async function transcribeTweetMedia(
     console.log(`  영상 ${Math.round(video.durationMs / 1000)}s — 상한(${Math.round(MAX_DURATION_MS / 1000)}s) 초과로 전사 생략`);
     return null;
   }
+  if (!mediaEngineAvailable('ffmpeg')) return null;
 
   const workdir = join(tmpdir(), `omni-digest-media-${video.mediaKey}`);
   try {

package/skills/omni-digest/src/visual.ts

@@ -13,7 +13,7 @@ import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'n
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { env, requireEnv } from './env.js';
-import { downloadVideo } from './media.js';
+import { downloadVideo, mediaEngineAvailable } from './media.js';
 import type { TweetMedia } from './types.js';
 
 const MAX_FRAMES = 8;
@@ -101,7 +101,8 @@ export async function absorbTweetVisuals(media: TweetMedia[], opts: { tweetId: s
       } catch (e) { log(`  [시각] 이미지 ${i + 1} 실패: ${String(e).slice(0, 120)}`); }
     }
     const videos = media.filter((m) => (m.type === 'video' || m.type === 'animated_gif') && (m.bestMp4Url || m.sttMp4Url));
-    for (const [i, v] of videos.entries()) {
+    const canExtractFrames = !videos.length || mediaEngineAvailable('ffmpeg');
+    for (const [i, v] of (canExtractFrames ? videos : []).entries()) {
       if (v.durationMs && v.durationMs > MAX_VIDEO_MS_FOR_FRAMES) { log(`  [시각] 영상 ${i + 1} 길어서 프레임 생략`); continue; }
       try {
         const dir = join(work, `v${i + 1}`);

package/skills/omni-market/scripts/main.ts

@@ -5,7 +5,7 @@ import { resolveDateRange } from '../src/date.js';
 import { route, listProviders } from '../src/router.js';
 import { render } from '../src/render.js';
 import type { Command } from '../src/types.js';
-import { writeStdoutJson } from '../../../src/cli/stdout-json.ts';
+import { writeStdoutJson } from './stdout-json.js';
 
 initEnv();
 

package/skills/omni-market/scripts/stdout-json.ts

@@ -0,0 +1,4 @@
+/** Write JSON output completely before the process can exit. (Kept inside the skill so the skill runs outside this repository — public pack and lite Pod.) */
+export async function writeStdoutJson(text: string): Promise<void> {
+  await new Promise<void>((resolve, reject) => process.stdout.write(text, error => error ? reject(error) : resolve()));
+}

package/src/agent/identity-env.ts

@@ -21,6 +21,17 @@
 import { debug } from '../debug/log.js';
 import { getCapturedEnv, capturedEnvAvailable } from '../shell-env-bootstrap.js';
 import { resolveCurrentInstance } from '../instance/current.js';
+import { treeDerivedRootFor } from '../instance/resolve.js';
+
+/** Pin a child state root together with its origin; only reuse a parent's tag for the same root. */
+export function stateDirSourceForChild(root: string, env: NodeJS.ProcessEnv = process.env): string {
+  if (env.ELANOUS_STATE_DIR === root && env.ELANOUS_STATE_DIR_SOURCE?.trim()) {
+    return env.ELANOUS_STATE_DIR_SOURCE;
+  }
+  const current = resolveCurrentInstance();
+  return root === treeDerivedRootFor(process.cwd()) || (current.root === root && current.layer === 'default')
+    ? 'derived' : 'explicit';
+}
 
 // ── 전파 allowlist ─────────────────────────────────────────────────────────
 //

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;
@@ -2216,8 +2221,8 @@ 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,
+    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})` : 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/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();
     }