elanous 0.2.43 → 0.2.44

package/src/tool-runtime/elanous-linear-secretary-runtime.ts

@@ -1,57 +1,173 @@
 import { debug } from '../debug/log.js';
+import { fetchLinearIssueDescription, fetchLinearMissionIssueIdentity } from '../connectors/linear.js';
+import { DecisionLedger } from '../decisions/decision-ledger.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { getSecretAsync } from '../nexus/config/secrets/index.js';
+import { parseLinearSecretaryManifest, updateLinearSecretaryProgress, type LinearSecretaryCaptureInput } from '../intake-plane/linear-wish.js';
+import { submitIntakeWork, type SubmitIntakeWorkDeps } from '../intake-plane/submit-intake-work.js';
 import type { LLMToolSpec } from '../llm.js';
 import type { ToolRuntime, ToolRuntimeContext } from './types.js';
 
-export interface ElanousLinearSecretaryArgs { request: string }
+export type ElanousLinearSecretaryArgs =
+  | { action: 'create'; request: string }
+  | { action: 'progress'; teamKey: 'DEMO'; parentIssueId: string; taskIssueId: string; state: 'started' | 'completed' | 'comment'; summary: string; absorbText?: string; captureArtifact?: LinearSecretaryCaptureInput; workaround?: string }
+  | { action: 'approval'; teamKey: 'DEMO'; parentIssueId: string; title: string; context: string };
 export interface ElanousLinearSecretaryResult extends Record<string, unknown> { ok: boolean; output: string }
 
-type Runner = (request: string) => Promise<{ replyCard: string; parentIssueId: string; childIssueIds: string[] }>;
-const productionRunner: Runner = async request =>
+type CreateRunner = (request: string) => Promise<{ replyCard: string; parentIssueId: string; childIssueIds: string[] }>;
+const productionCreate: CreateRunner = async request =>
   (await import('../intake-plane/linear-secretary-runtime.js')).runLinearSecretaryRequest(request);
-let runner = productionRunner;
+let createRunner = productionCreate;
 
-export function setElanousLinearSecretaryRunnerForTest(next?: Runner): () => void {
-  if (runner !== productionRunner) throw new Error('Linear secretary runner already replaced');
-  runner = next ?? productionRunner;
-  const installed = runner;
-  return () => { if (runner === installed) runner = productionRunner; };
+export function setElanousLinearSecretaryRunnerForTest(next?: CreateRunner): () => void {
+  if (createRunner !== productionCreate) throw new Error('Linear secretary runner already replaced');
+  createRunner = next ?? productionCreate;
+  const installed = createRunner;
+  return () => { if (createRunner === installed) createRunner = productionCreate; };
 }
 
-export const elanousLinearSecretaryRuntime: ToolRuntime<ElanousLinearSecretaryArgs, ElanousLinearSecretaryResult> = {
-  id: 'elanous_linear_secretary',
-  surfaces: ['tui', 'mcp'],
+export interface ElanousLinearSecretaryRuntimeDeps {
+  create?: CreateRunner;
+  getApiKey?: () => Promise<string | undefined>;
+  fetch?: typeof fetch;
+  verifyParent?: typeof ensureDemoParent;
+  readChildManifest?: typeof readDemoChildManifest;
+  updateProgress?: typeof updateLinearSecretaryProgress;
+  intake?: SubmitIntakeWorkDeps;
+  ledger?: () => DecisionLedger;
+}
+
+async function ensureDemoParent(apiKey: string, parentIssueId: string, fetchFn: typeof fetch): Promise<void> {
+  const query = `query SecretaryDemoParent($id: String!) { issue(id: $id) { id team { key } } }`;
+  const response = await fetchFn('https://api.linear.app/graphql', { method: 'POST', headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ query, variables: { id: parentIssueId } }) });
+  if (!response.ok) throw new Error('Linear parent lookup failed');
+  const result = await response.json() as { errors?: unknown[]; data?: { issue?: { id?: string; team?: { key?: string } } | null } };
+  const issue = result.data?.issue;
+  if (result.errors?.length || !issue || issue.id !== parentIssueId || issue.team?.key !== 'DEMO') {
+    throw new Error('Linear secretary only accepts a parent issue in the DEMO team');
+  }
+}
+
+async function readDemoChildManifest(apiKey: string, parentIssueId: string, taskIssueId: string, fetchFn: typeof fetch) {
+  const identity = await fetchLinearMissionIssueIdentity({ apiKey, issueId: taskIssueId, fetch: fetchFn });
+  if (identity.teamKey !== 'DEMO' || identity.parentId !== parentIssueId) throw new Error('Linear secretary child is not listed in the DEMO parent manifest');
+  const description = await fetchLinearIssueDescription({ apiKey, issueId: taskIssueId, fetch: fetchFn });
+  const manifest = parseLinearSecretaryManifest(description, taskIssueId);
+  if (!manifest || manifest.parentIssueId !== parentIssueId) throw new Error('Linear secretary child is not listed in the DEMO parent manifest');
+  return manifest;
+}
+
+async function runProgress(args: Extract<ElanousLinearSecretaryArgs, { action: 'progress' }>, deps: ElanousLinearSecretaryRuntimeDeps) {
+  if (args.captureArtifact && (args.captureArtifact.externalShare !== true || args.captureArtifact.sensitivity !== 'public' ||
+      args.captureArtifact.linearIssueId !== args.parentIssueId || !args.captureArtifact.runId.trim() || !Number.isFinite(args.captureArtifact.createdAt))) {
+    return { ok: false, output: 'Linear 캡처는 현재 DEMO 부모에 대해 명시 승인된 공개 브라우저 증거여야 합니다.' };
+  }
+  const apiKey = await (deps.getApiKey?.() ?? getSecretAsync('connector.linear.apiKey'));
+  if (!apiKey?.trim()) throw new Error('Linear API key is missing; run elanous connector linear set-key');
+  const fetchFn = deps.fetch ?? globalThis.fetch;
+  await (deps.verifyParent ?? ensureDemoParent)(apiKey, args.parentIssueId, fetchFn);
+  const manifest = await (deps.readChildManifest ?? readDemoChildManifest)(apiKey, args.parentIssueId, args.taskIssueId, fetchFn);
+  const task = manifest.tasks.find(item => item.issueId === args.taskIssueId);
+  if (!task) throw new Error('Linear secretary child is not listed in the DEMO parent manifest');
+  const absorbed = args.absorbText?.trim() ? await (async text => {
+    const result = await submitIntakeWork({ text, track: 'absorb', origin: { kind: 'owner', ledgerSource: 'memo' } }, deps.intake);
+    return result.ok && result.track === 'absorb' ? { ok: true as const, ids: result.ids }
+      : { ok: false as const, reason: result.ok ? 'unexpected-intake-track' : result.reason };
+  })(args.absorbText.trim()) : undefined;
+  if (absorbed && (!absorbed.ok || !absorbed.ids.length)) throw new Error('흡수 근거를 intake 원장에 기록하지 못해 진행을 보류했습니다.');
+  const refs = absorbed?.ok ? absorbed.ids.map(id => `elanous:intake:${id}`) : [];
+  const summary = [args.summary.trim(), ...(refs.length ? [`흡수 근거: ${refs.join(' · ')}`] : [])].join('\n');
+  await (deps.updateProgress ?? updateLinearSecretaryProgress)({ apiKey, parentIssueId: args.parentIssueId, taskIssueId: task.issueId, taskTitle: task.title,
+    tasks: manifest.tasks, state: args.state, summary, ...(args.workaround ? { workaround: args.workaround } : {}),
+    ...(args.captureArtifact ? { captureArtifact: args.captureArtifact } : {}), fetch: fetchFn });
+  return { ok: true, output: `DEMO 하위 이슈 진행을 기록했습니다: ${task.issueId}`, parentIssueId: args.parentIssueId, taskIssueId: task.issueId, state: args.state,
+    ...(refs.length ? { evidenceRefs: refs } : {}) };
+}
+
+async function runApproval(args: Extract<ElanousLinearSecretaryArgs, { action: 'approval' }>, deps: ElanousLinearSecretaryRuntimeDeps) {
+  const apiKey = await (deps.getApiKey?.() ?? getSecretAsync('connector.linear.apiKey'));
+  if (!apiKey?.trim()) throw new Error('Linear API key is missing; run elanous connector linear set-key');
+  await (deps.verifyParent ?? ensureDemoParent)(apiKey, args.parentIssueId, deps.fetch ?? globalThis.fetch);
+  const refs = [args.parentIssueId];
+  const title = args.title.trim();
+  const context = args.context.trim();
+  if (!title || !context) throw new Error('Approval title and context are required');
+  const ledger = deps.ledger?.() ?? new DecisionLedger({ stateDir: elanousStateRoot() });
+  const ref = `linear-secretary-approval:${args.parentIssueId}`;
+  const entry = ledger.raiseOnce({ title, category: 'publish', scqa: { s: 'DEMO Linear 결과와 근거가 준비됐다.', c: context },
+    options: [{ key: 'a', label: '승인', consequence: '사람이 명시적으로 승인한 뒤 다음 동작을 진행한다' },
+      { key: 'b', label: '보류', consequence: '외부 공개를 멈춘다' }],
+    recommendation: { option: 'b', why: '승인 전에는 보류한다' }, raisedBy: { agent: 'OPT', track: 'OP' }, refs: [...refs, ref] }, ref);
+  // Local durable pending card only. No Telegram/card transport is invoked here.
+  const output = entry.status === 'open' ? `승인 대기 카드를 열었습니다: ${entry.id}` : `기존 승인 카드 ${entry.id}의 상태는 ${entry.status}입니다. 새 카드는 열지 않았습니다.`;
+  return { ok: true, output, decisionId: entry.id, status: entry.status };
+}
+
+export function createElanousLinearSecretaryRuntime(deps: ElanousLinearSecretaryRuntimeDeps = {}): ToolRuntime<ElanousLinearSecretaryArgs, ElanousLinearSecretaryResult> {
+return {
+  id: 'elanous_linear_secretary', surfaces: ['tui', 'mcp'],
   spec: {
     name: 'elanous_linear_secretary',
-    description: 'Ground a request in repository evidence and create a Linear parent issue with 3–5 assigned subtasks. Requires an explicit due date and verified evidence. Use configured project by default; team-only creation requires `projectless=true` and exactly one explicit `teamKey=<KEY>` token in the request.',
-    parameters: {
-      type: 'object',
-      properties: { request: { type: 'string', minLength: 1, description: 'The user request. Include an explicit YYYY-MM-DD due date.' } },
-      required: ['request'],
-      additionalProperties: false,
-    },
+    description: 'DEMO 팀 전용 grounded Linear secretary. create는 due date가 포함된 근거 기반 부모/하위 이슈를 만든다. progress는 intake 원문을 흡수한 ID와 명시 승인된 브라우저 캡처를 연결하고 하위 상태를 갱신한다. approval은 부모당 하나의 로컬 open 카드를 만든다. 같은 부모 재호출은 기존 카드 상태를 돌려주며 외부 발송은 없다.',
+    parameters: { type: 'object', properties: {
+      action: { type: 'string', enum: ['create', 'progress', 'approval'] },
+      request: { type: 'string', minLength: 1, description: 'create에 필수. 명시적 YYYY-MM-DD 날짜를 포함한다.' },
+      teamKey: { type: 'string', enum: ['DEMO'] }, parentIssueId: { type: 'string' }, taskIssueId: { type: 'string' },
+      state: { type: 'string', enum: ['started', 'completed', 'comment'] }, summary: { type: 'string' },
+      absorbText: { type: 'string', description: '흡수 원장에 실제 기록할 원문 또는 URL; 성공한 intake id만 진행 근거로 연결한다.' },
+      captureArtifact: { type: 'object', description: 'browser-runtime이 생성하고 Linear 공유가 명시 승인된 정확한 캡처 artifact',
+        properties: { path: { type: 'string' }, mimeType: { type: 'string', enum: ['image/png', 'image/jpeg', 'image/webp', 'image/gif'] },
+          runId: { type: 'string' }, linearIssueId: { type: 'string' }, externalShare: { type: 'boolean', enum: [true] },
+          sensitivity: { type: 'string', enum: ['public'] }, createdAt: { type: 'number' } },
+        required: ['path', 'mimeType', 'runId', 'linearIssueId', 'externalShare', 'sensitivity', 'createdAt'], additionalProperties: false },
+      workaround: { type: 'string' }, title: { type: 'string' }, context: { type: 'string' },
+    }, required: ['action'], additionalProperties: false },
   } satisfies LLMToolSpec,
-  async run(args: ElanousLinearSecretaryArgs, _ctx: ToolRuntimeContext): Promise<ElanousLinearSecretaryResult> {
-    const request = typeof args?.request === 'string' ? args.request.trim() : '';
-    if (!request) return { ok: false, output: 'Linear 비서 요청 내용이 필요합니다.' };
+  async run(args, _ctx): Promise<ElanousLinearSecretaryResult> {
     try {
-      const result = await runner(request);
-      debug.log('tool.linear-secretary', 'created', { childCount: result.childIssueIds.length });
-      return { ok: true, output: result.replyCard, parentIssueId: result.parentIssueId, childIssueIds: result.childIssueIds };
+      if (args?.action === 'create') {
+        const request = typeof args.request === 'string' ? args.request.trim() : '';
+        if (!request) return { ok: false, output: 'Linear 비서 요청 내용이 필요합니다.' };
+        const teamTokens = [...request.matchAll(/(?:^|\s)teamKey\s*=\s*([^\s]+)/gi)].map(match => match[1]);
+        const projectlessTokens = [...request.matchAll(/(?:^|\s)projectless\s*=\s*([^\s]+)/gi)].map(match => match[1]?.toLowerCase());
+        const declaredTeam = teamTokens[0];
+        if (teamTokens.length > 1 || (declaredTeam && declaredTeam.toUpperCase() !== 'DEMO') ||
+            projectlessTokens.length > 1 || projectlessTokens.some(token => token !== 'true') || (projectlessTokens.length === 1 && !declaredTeam)) {
+          return { ok: false, output: 'DEMO 팀만 지원합니다.' };
+        }
+        const normalizedRequest = request
+          .replace(/(^|\s)teamKey\s*=\s*[^\s]+/gi, '$1teamKey=DEMO')
+          .replace(/(^|\s)projectless\s*=\s*[^\s]+/gi, '$1projectless=true');
+        const scopedRequest = projectlessTokens.length === 1 ? normalizedRequest
+          : declaredTeam ? `projectless=true ${normalizedRequest}` : `projectless=true teamKey=DEMO ${request}`;
+        const result = await (deps.create ?? createRunner)(scopedRequest);
+        debug.log('tool.linear-secretary', 'created', { childCount: result.childIssueIds.length, teamKey: 'DEMO' });
+        return { ok: true, output: result.replyCard, parentIssueId: result.parentIssueId, childIssueIds: result.childIssueIds, teamKey: 'DEMO' };
+      }
+      if (args?.action === 'progress') {
+        if (args.teamKey !== 'DEMO' || !args.parentIssueId?.trim() || !args.taskIssueId?.trim() || !args.summary?.trim() || !args.state) return { ok: false, output: 'DEMO 진행 기록에는 팀·부모·하위 이슈·상태·요약이 필요합니다.' };
+        return await runProgress(args, deps);
+      }
+      if (args?.action === 'approval') {
+        if (args.teamKey !== 'DEMO' || !args.parentIssueId?.trim() || !args.title?.trim() || !args.context?.trim()) return { ok: false, output: 'DEMO 승인 카드에는 팀·부모 이슈·제목·맥락이 필요합니다.' };
+        return await runApproval(args, deps);
+      }
+      return { ok: false, output: '지원하지 않는 Linear secretary 작업입니다.' };
     } catch (error) {
-      // The existing secretary validates key, project, evidence and dates before creating issues.
       const message = error instanceof Error ? error.message : 'Linear 비서 실행 실패';
-      // Error.name is caller-controlled and may itself contain connector secrets.
-      debug.log('tool.linear-secretary', 'failed', { errorType: error instanceof Error ? 'Error' : 'unknown' });
-      const safeMessage = [
+      debug.log('tool.linear-secretary', 'failed', { action: args?.action ?? 'unknown', errorType: error instanceof Error ? 'Error' : 'unknown' });
+      const safeMessage = ['Linear secretary only accepts a parent issue in the DEMO team', 'Linear secretary child is not listed in the DEMO parent manifest',
         'Linear API key is missing; run elanous connector linear set-key',
         'Linear COO 프로젝트 설정이 없어 이슈 등록을 보류했습니다. 프로젝트를 지정해 주세요.',
-        'projectless=true requires an explicit teamKey=<KEY>',
-        '저장소 근거 검색 총 시간 제한(20초)을 초과했습니다.',
-        '저장소 근거 검색 도구를 실행하지 못해 근거 확인을 완료하지 못했습니다.',
-        '저장소·문서·기억에서 확인된 근거가 없어 등록을 보류했습니다.',
-        '요청에 마감일이 없어 등록을 보류했습니다. 요청에 YYYY-MM-DD 날짜를 넣어 주세요.',
-      ].find(known => message.includes(known));
-      return { ok: false, output: safeMessage ?? 'Linear 비서 작업을 진행하지 못했습니다. 키·프로젝트·요청 내용을 확인해 주세요.' };
+        '저장소 근거 검색 총 시간 제한(20초)을 초과했습니다.', '저장소 근거 검색 도구를 실행하지 못해 근거 확인을 완료하지 못했습니다.',
+        '저장소·문서·기억에서 확인된 근거가 없어 등록을 보류했습니다.', '요청에 마감일이 없어 등록을 보류했습니다. 요청에 YYYY-MM-DD 날짜를 넣어 주세요.',
+        '마감일이 없어 등록하지 않았습니다. 요청에 날짜를 넣어 주세요.', '흡수 근거를 intake 원장에 기록하지 못해 진행을 보류했습니다.']
+        .find(known => message.includes(known));
+      return { ok: false, output: safeMessage ?? 'Linear 비서 작업을 진행하지 못했습니다. 팀 키·이슈 ID·근거·권한을 확인해 주세요.' };
     }
   },
 };
+}
+
+export const elanousLinearSecretaryRuntime = createElanousLinearSecretaryRuntime();

package/src/tool-runtime/types.ts

@@ -52,6 +52,8 @@ export interface ToolRuntimeContext {
   /** MCP only — the connected client's `clientInfo.name` from `initialize`
    *  (e.g. `claude-code`, `codex-mcp-client`). Unset on other surfaces. */
   mcpClient?: string;
+  /** Optional caller-supplied MCP join key. Correlation only; never an authorization input. */
+  runId?: string;
   /** Cancellation — forwarded to underlying dispatcher when
    *  supported (e.g. streaming fetch, long-running agent calls). */
   signal?: AbortSignal;

package/src/tui/entry.ts

@@ -611,10 +611,21 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
             firstResponseSeen = true;
             dashboardRuntime.endTurnStartSegments(turnSessionId, 'stream-open');
           }
-          // The first model token is visible before the final JSONL frame. Keep only
-          // a bounded tail until session history becomes the canonical display.
-          streamingReply = replace ? delta.slice(-32_768) : (streamingReply + delta).slice(-32_768);
-          activity = streamReplyLines(streamingReply, process.stdout.columns || 80);
+          // The first model token is visible while the turn runs. Once the core
+          // replaces that provisional answer, let the persisted final message
+          // become canonical instead of showing the same answer in both layers.
+          if (replace) {
+            streamingReply = '';
+            activity = [];
+            if (streamRenderTimer !== null) clearTimeout(streamRenderTimer);
+            streamRenderTimer = null;
+            streamRenderAt = performance.now();
+            render();
+            return;
+          } else {
+            streamingReply = (streamingReply + delta).slice(-32_768);
+            activity = streamReplyLines(streamingReply, process.stdout.columns || 80);
+          }
           const now = performance.now();
           if (streamRenderAt === 0 || now - streamRenderAt >= 33) {
             streamRenderAt = now;
@@ -657,7 +668,6 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
         activity = [];
         streamingReply = '';
         busy = false;
-        reportTuiTurn('idle');
         turnAbort = null;
         scroll = 0;
         settle();
@@ -680,8 +690,17 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
         }
         const switchAfterTurn = pendingSidetabSwitch;
         pendingSidetabSwitch = null;
-        if (switchAfterTurn) await switchSidetabSession(switchAfterTurn);
-        render();
+        try {
+          if (switchAfterTurn) await switchSidetabSession(switchAfterTurn);
+        } finally {
+          try {
+            render();
+          } finally {
+            // Publish idle only after the canonical history has replaced the stream preview
+            // on screen. External PTY observers use this edge as their capture boundary.
+            reportTuiTurn('idle');
+          }
+        }
       });
   };
 
@@ -754,6 +773,7 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
         detach: () => { if (sidetabAttachments?.hasRemoteView()) sidetabAttachments.showMain(); else if (sidetabAttachments?.hasModal()) { sidetabAttachments.handleKey({ name: '\\', ctrl: true, shift: false, raw: '' }); sidetabAttachments.handleKey({ name: 'd', ctrl: false, shift: false, raw: 'd' }); } render(); return { ok: true, action: 'detach' }; },
         spawn: async (character) => { await ensureSidetabAttachments(); const ok = sidetabAttachments!.spawn(character); refreshSidetabRows(); render(); return { ok, action: 'new', character }; },
         runMission: async (agent, mission) => { await ensureSidetabAttachments(); const result = await sidetabAttachments!.runMission(agent, mission); refreshSidetabRows(); render(); return result; },
+        runMissionPair: async (agent, mission, parallelMission) => { await ensureSidetabAttachments(); const result = await sidetabAttachments!.runMissionPair(agent, mission, parallelMission); refreshSidetabRows(); render(); return result; },
         kill: async (row) => { await ensureSidetabAttachments(); const ok = sidetabAttachments!.kill(row); refreshSidetabRows(); render(); return { ok, action: 'kill', target: row.id }; },
       }));
       const gate = wakeup.gate;

package/src/tui/sidetab/attach.ts

@@ -8,6 +8,7 @@ import { getSessionCwd } from '../../session/working-dir.js';
 import { TerminalSessionRegistry, type TerminalSession } from '../../terminal/session-registry.js';
 import { requestRemotePtyControl } from '../../pty-shell/pty-control-ipc.js';
 import { runVisibleAgentMission, type VisibleMissionPty, type VisibleMissionResult } from '../../sidetab-core/visible-agent-mission.js';
+import { runVisibleAgentMissionPair } from '../../sidetab-core/visible-agent-mission-pair.js';
 import type { Key } from '../../tui.js';
 import type { SidetabRow } from './list.js';
 import { createHerdrSidetabPortal, herdrPaneIdFromSidetabRow, type HerdrSidetabPortal } from './herdr-portal.js';
@@ -20,6 +21,7 @@ export interface SidetabAttachmentController {
   showMain(): void;
   spawn(character: SidetabCharacter): boolean;
   runMission(agent: 'codex' | 'claude', mission: string): Promise<Awaited<ReturnType<typeof runVisibleAgentMission>>>;
+  runMissionPair(agent: 'codex' | 'claude', mission: string, parallelMission: string): Promise<unknown>;
   kill(row: SidetabRow): boolean;
   handleKey(key: Key): boolean;
   hasModal(): boolean;
@@ -342,6 +344,116 @@ export function createSidetabAttachmentController(deps: {
       deps.setStatus(result.ok ? `미션 결과 확인 · ${result.path}` : `미션 확인 실패 · ${result.promptReady ? agent : result.startupScreen ?? agent} · ${result.error}`);
       return result;
     },
+    async runMissionPair(agent, mission, parallelMission) {
+      const missionId = `duo-${randomUUID()}`;
+      const startedAt = Date.now();
+      const members = [agent, agent === 'codex' ? 'claude' : 'codex'] as const;
+      if (deps.detectAgentCli) {
+        const detections = await Promise.all(members.map(async (member) => {
+          try { return await deps.detectAgentCli!(member); }
+          catch (error) {
+            return { agent: member, installed: false, version: null, login: 'unknown' as const,
+              message: `${member} CLI 확인에 실패했습니다: ${error instanceof Error ? error.message : String(error)}` };
+          }
+        }));
+        const unavailable = detections.find(({ installed }) => !installed);
+        if (unavailable) {
+          const message = `${unavailable.message} · pair 미션은 두 CLI 모두 준비돼야 시작합니다`;
+          deps.setStatus(message);
+          return { ok: false, error: message, codex: null, claude: null };
+        }
+      }
+
+      const sessions = new Map<'codex' | 'claude', TerminalSession>();
+      const workspaces = new Map<'codex' | 'claude', string>();
+      const ptySessions = new Map<VisibleMissionPty, TerminalSession>();
+      const pair = await runVisibleAgentMissionPair({
+        spawn: (member) => {
+          lastSpawnedSession = null;
+          const injected = deps.createVisibleMissionPty?.(member);
+          if (injected) {
+            workspaces.set(member, injected.cwd);
+            return injected.pty;
+          }
+          const didSpawn = spawn(member);
+          const session = lastSpawnedSession as TerminalSession | null;
+          if (!didSpawn || !session) return null;
+          sessions.set(member, session);
+          workspaces.set(member, session.cwd);
+          const pty: VisibleMissionPty = {
+            snapshot: () => session.preview.renderForLLM(),
+            write: (bytes) => session.preview.write(bytes),
+            isAlive: () => session.preview.isAlive,
+          };
+          ptySessions.set(pty, session);
+          return pty;
+        },
+        dispose: (preview) => {
+          const session = ptySessions.get(preview);
+          if (session) registry.kill(session.id);
+        },
+        run: async (member, prompt, pty) => {
+          const outputPath = join(workspaces.get(member)!, '.elanous', 'mission-results', `sidetab-pair-${randomUUID()}-${member}.md`);
+          const backend = member === 'codex' ? codexBackend : claudeBackend;
+          const result = await (deps.visibleMissionRunner ?? runVisibleAgentMission)({
+            pty, agent: member, mission: prompt, outputPath,
+            onStartupScreen: (screen) => deps.logEvent?.('agent-mission.sidetab-pair', 'startup-screen', { agent: member, screen }),
+            handleTrust: (screen, write) => backend.handleTrust?.(screen, write) ?? false,
+          });
+          const failureLog = sidetabMissionFailureLog(member, result);
+          if (failureLog) deps.logEvent?.('agent-mission.sidetab-pair', failureLog.event, failureLog.data);
+          return result;
+        },
+      }, agent, mission, parallelMission);
+      if (pair.error) {
+        showMain();
+        deps.setStatus(pair.error);
+        return pair;
+      }
+      const codexWorkspace = workspaces.get('codex');
+      const claudeWorkspace = workspaces.get('claude');
+      if (!codexWorkspace || !claudeWorkspace || codexWorkspace !== claudeWorkspace) {
+        showMain();
+        const error = '두 사이드탭이 같은 작업 디렉터리를 쓰지 않아 pair 합성을 안전하게 저장할 수 없습니다';
+        deps.setStatus(error);
+        return { ...pair, ok: false, error };
+      }
+      const missionByAgent = new Map([ [agent, mission], [agent === 'codex' ? 'claude' : 'codex', parallelMission] ] as const);
+      const completion = await (await import('../../tui-client/next-dashboard-runtime.js')).completeNextTuiMissionPair({
+        taskId: missionId,
+        codex: {
+          missionId: `${missionId}-codex`, startedAt,
+          mission: missionByAgent.get('codex')!, workspaceDir: codexWorkspace, result: pair.codex!,
+        },
+        claude: {
+          missionId: `${missionId}-claude`, startedAt,
+          mission: missionByAgent.get('claude')!, workspaceDir: claudeWorkspace, result: pair.claude!,
+        },
+      });
+      const notification = completion.notification;
+      const finalFile = notification?.resultPath;
+      deps.logEvent?.('agent-mission.sidetab-pair', 'synthesis-result', {
+        missionId, codexOk: pair.codex?.ok ?? false, claudeOk: pair.claude?.ok ?? false,
+        synthesisOk: Boolean(finalFile), status: completion.status,
+      });
+      showMain();
+      deps.setStatus(finalFile
+        ? `그래프 두 갈래·비교 합성 완료 · ${finalFile}`
+        : '그래프 두 갈래 완료 · 기존 pair 합성 파일 저장 실패');
+      return {
+        ...pair,
+        ok: pair.ok && completion.status === 'done' && Boolean(finalFile),
+        pair: 'codex+claude',
+        graph: [
+          { id: 'plan', state: 'complete', task: `${mission} ⊕ ${parallelMission}` },
+          { id: 'codex', state: pair.codex?.ok ? 'complete' : 'failed', task: missionByAgent.get('codex'), resultFile: pair.codex?.path },
+          { id: 'claude', state: pair.claude?.ok ? 'complete' : 'failed', task: missionByAgent.get('claude'), resultFile: pair.claude?.path },
+          { id: 'synthesis', state: finalFile ? 'complete' : 'failed', resultFile: finalFile },
+        ],
+        finalFile,
+        summary: notification?.output,
+      };
+    },
     kill(row) {
       if (row.currentProcess) {
         deps.setStatus('현재 TUI 세션은 사이드탭에서 종료할 수 없습니다');

package/src/tui/sidetab/list.ts

@@ -4,6 +4,7 @@ import {
   formatSidetabLines as formatCoreSidetabLines,
   loadSidetabRows as loadCoreSidetabRows,
   type SidetabRow,
+  type SidetabScope,
 } from '../../sidetab-core/model.js';
 import { listPtyManifestRows } from '../../pty-shell/pty-manifest.js';
 import { formatSidetabPeekLines } from './peek.js';
@@ -11,9 +12,9 @@ import { formatSidetabPeekLines } from './peek.js';
 type PreviewSidetabRow = SidetabRow & { readonly previewSource?: string };
 
 /** Attach the latest manifest snapshot without changing the shared row contract. */
-export function loadSidetabRows(all = false, currentSessionId?: string): SidetabRow[] {
+export function loadSidetabRows(all = false, currentSessionId?: string, scopeOverrides?: Partial<SidetabScope>): SidetabRow[] {
   const snapshots = new Map<string, string>(listPtyManifestRows().map((row) => [row.id, row.snapshot || row.frame] as const));
-  return loadCoreSidetabRows(all, currentSessionId).map((row) => ({
+  return loadCoreSidetabRows(all, currentSessionId, scopeOverrides).map((row) => ({
     ...row,
     previewSource: snapshots.get(row.id) ?? '',
   }));

package/src/tui-client/next-dashboard-runtime.ts

@@ -1,4 +1,56 @@
 /** Dashboard integrations used by next TUI, loaded only after that surface is opened. */
+import type { PendingTaskNotification } from '../agent/task-notification.js';
+import type { VisibleMissionResult } from '../sidetab-core/visible-agent-mission.js';
+
+export interface NextTuiMissionPairMember {
+  missionId: string;
+  mission: string;
+  workspaceDir: string;
+  startedAt: number;
+  result: VisibleMissionResult;
+}
+
+export interface NextTuiMissionPairCompletionInput {
+  taskId: string;
+  codex: NextTuiMissionPairMember;
+  claude: NextTuiMissionPairMember;
+}
+
+export interface NextTuiMissionPairCompletionResult {
+  status: 'done' | 'error';
+  notification?: PendingTaskNotification;
+}
+
+/** Keep the next-TUI sidetab controller on the dashboard facade, not dashboard internals. */
+export async function completeNextTuiMissionPair(
+  input: NextTuiMissionPairCompletionInput,
+): Promise<NextTuiMissionPairCompletionResult> {
+  const { enqueueClassicSidetabMissionPairCompletion } = await import('../dashboard/classic-sidetab-mission-job.js');
+  const asClassicResult = (result: VisibleMissionResult) => ({
+    ok: result.ok,
+    status: result.ok ? 'completed' as const : 'failed' as const,
+    ...(result.path ? { path: result.path } : {}),
+    ...(result.content !== undefined ? { content: result.content } : {}),
+    ...(result.error ? { error: result.error } : {}),
+    ...(result.failureStage ? { failureStage: result.failureStage } : {}),
+    ...(result.failureScreen ? { failureScreen: result.failureScreen } : {}),
+  });
+  let notification: PendingTaskNotification | undefined;
+  const completion = await enqueueClassicSidetabMissionPairCompletion({
+    codex: {
+      missionId: input.codex.missionId, taskId: input.taskId, startedAt: input.codex.startedAt,
+      mission: input.codex.mission, workspaceDir: input.codex.workspaceDir,
+      completion: Promise.resolve(asClassicResult(input.codex.result)),
+    },
+    claude: {
+      missionId: input.claude.missionId, taskId: input.taskId, startedAt: input.claude.startedAt,
+      mission: input.claude.mission, workspaceDir: input.claude.workspaceDir,
+      completion: Promise.resolve(asClassicResult(input.claude.result)),
+    },
+  }, item => { notification = item; });
+  return { status: completion.status, ...(notification ? { notification } : {}) };
+}
+
 export async function loadNextTuiDashboardRuntime() {
   const [segments, goalContinue] = await Promise.all([
     import('../dashboard/turn-start-segments.js'),

package/src/ux-sim/draft-inventory-builder.ts

@@ -56,6 +56,7 @@ function makeCase(scenario: DraftInventoryScenario, index: number): DraftInvento
   };
   const input: DraftTriageInput = {
     draft,
+    now: new Date(fixedNow),
     runStatus: 'self-implement.result final',
     mergedTwins: [],
     openDrafts: [],
@@ -190,7 +191,7 @@ export function assessDraftInventory(cases = buildDraftInventory()): {
     if ((item.scenario === 'protected-label' || item.scenario === 'running') && decision.action === 'close') {
       protectedOrRunningClosed += 1;
     }
-    if (item.scenario === 'running' && draftClaimState(item.input.draft, new Date(fixedNow)) !== 'claimed') {
+    if (item.scenario === 'running' && draftClaimState({ labels: item.input.draft.labels ?? [], updatedAt: item.input.draft.updatedAt }, new Date(fixedNow)) !== 'claimed') {
       mismatches.push(`${index}:running:draftClaimState expected=claimed`);
     }
   });

package/src/ux-sim/linear-secretary.ts

@@ -7,7 +7,7 @@ import { createTelegramAmbientMessageHandler } from '../intake-plane/adapters/te
 import { createLinearSecretaryBreakdown, updateLinearSecretaryProgress, type LinearSecretaryPlan } from '../intake-plane/linear-wish.js';
 import { submitIntakeWork } from '../intake-plane/submit-intake-work.js';
 import { DecisionLedger } from '../decisions/decision-ledger.js';
-import { DecisionCardService, type CardRef, type CardTransport, type CardView } from '../decisions/decision-cards.js';
+import { renderCard, type CardView } from '../decisions/decision-cards.js';
 import { LogStore } from '../mss/logging/log-store.js';
 import { simBrowserHand } from './browser-hand.js';
 
@@ -174,20 +174,12 @@ export async function simLinearSecretary(): Promise<LinearSecretarySimulationRes
         options: [{ key: 'a', label: '승인', consequence: '공개를 진행한다' }, { key: 'b', label: '보류', consequence: '외부 공개를 멈춘다' }],
         recommendation: { option: 'b', why: '이 장치는 승인 전 경계까지만 재현한다' }, raisedBy: { agent: 'OPT', track: 'O' },
         refs: [parentIssueId, ...childIssueIds] });
-      const sent: Array<{ view: CardView }> = [];
-      const transport: CardTransport = {
-        platform: 'telegram', async ownerChats() { return ['fake-owner']; },
-        async send(_chat: string, view: CardView): Promise<CardRef> { sent.push({ view }); return { chat: 'fake-owner', message: String(sent.length) }; },
-        async edit() {}, async notify() {},
-      };
-      await new DecisionCardService({ transport, ownerIds: ['fake-owner'], ledger, now: () => NOW }).tick();
-      const card = sent.find(item => item.view.text.includes(decision.id));
-      if (!card) throw new Error('approval card did not reach the fake owner transport');
+      const card = renderCard(ledger.show(decision.id));
       approvalDecisionId = decision.id;
-      approvalCard = { id: decision.id, text: card.view.text, buttons: card.view.buttons };
+      approvalCard = { id: decision.id, text: card.text, buttons: card.buttons };
       approvalCardStatus = ledger.show(decision.id).status;
       if (approvalCardStatus !== 'open') throw new Error(`approval card was not left open: ${approvalCardStatus}`);
-      event('approval-card-opened', { decisionId: decision.id, status: approvalCardStatus });
+      event('approval-card-opened', { decisionId: decision.id, status: approvalCardStatus, localOnly: true });
       return { replyCard: result.replyCard };
       } catch (error) {
         failure = error instanceof Error ? error.message : String(error);