elanous 0.2.42 → 0.2.43

package/scripts/rhythm/linear-progress-sync.ts

@@ -0,0 +1,298 @@
+import { createHash } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { getSecretAsync } from '../../src/nexus/config/secrets/index.js';
+import { commentLinearIssue } from '../../src/connectors/linear.js';
+import { listChecklist, type Checklist, type ChecklistItem } from '../../src/release-loop/checklist.js';
+import { DecisionLedger, type DecisionEntry } from '../../src/decisions/decision-ledger.js';
+import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
+import { debug } from '../../src/debug/log.js';
+import { acquireLockAsync } from '../../src/storage/file-lock.js';
+
+export type ProgressIssue = {
+  id: string; identifier: string; title: string; url: string; description: string; state: string;
+};
+export type ProgressLink = { issue: ProgressIssue; cells: ChecklistItem[]; decisions: DecisionEntry[]; sources: Array<{ cellId: string; field: string }> };
+export type ProgressPreview = { identifier: string; body: string; sources: Array<{ cellId: string; field: string }> };
+export type ProgressSyncResult = {
+  day: string; candidates: ProgressPreview[]; posted: string[]; alreadyPresent: string[];
+  skipped: string[]; failures: Array<{ identifier: string; reason: string }>;
+};
+
+const kstDay = (date: Date) => new Date(date.getTime() + 9 * 3_600_000).toISOString().slice(0, 10);
+const escapeRegExp = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+function exactReference(source: string, token: string): boolean {
+  return new RegExp(`(^|[^A-Z0-9_-])${escapeRegExp(token)}($|[^A-Z0-9_-])`).test(source);
+}
+
+function declaredIssueRefs(source: string): string[] {
+  const refs: string[] = [];
+  for (const declaration of source.matchAll(/\blinear-ref\s*[:=]\s*([^\r\n]+)/gi)) {
+    refs.push(...[...(declaration[1] ?? '').matchAll(/\b[A-Z]{2,8}-\d+\b/g)].map(match => match[0]!));
+  }
+  return [...new Set(refs)];
+}
+
+/** Only `linear-ref:` declarations in checklist fields and exact checklist IDs in issue descriptions create a link. */
+export function resolveExplicitProgressLinks(issues: readonly ProgressIssue[], checklist: Checklist, decisions: readonly DecisionEntry[] = []): ProgressLink[] {
+  const links: ProgressLink[] = [];
+  for (const issue of issues) {
+    const cells = new Map<string, ChecklistItem>();
+    const sources: Array<{ cellId: string; field: string }> = [];
+    for (const cell of checklist.items) {
+      const declared: Array<[string, string]> = [
+        ['title', cell.title], ['evidence', cell.evidence ?? ''], ['refs', (cell.refs ?? []).join('\n')],
+      ];
+      for (const [field, value] of declared) {
+        if (declaredIssueRefs(value).includes(issue.identifier)) {
+          cells.set(cell.id, cell);
+          sources.push({ cellId: cell.id, field: `checklist.${field}` });
+        }
+      }
+      if (exactReference(issue.description, cell.id)) {
+        cells.set(cell.id, cell);
+        sources.push({ cellId: cell.id, field: 'issue.description' });
+      }
+    }
+    const linkedDecisions = decisions.filter(decision => decision.refs?.some(ref => ref === issue.identifier || ref === issue.url));
+    for (const decision of linkedDecisions) sources.push({ cellId: decision.id, field: 'decision.refs' });
+    if (cells.size || linkedDecisions.length) links.push({ issue, cells: [...cells.values()], decisions: linkedDecisions, sources });
+  }
+  return links;
+}
+
+function changedStatuses(checklist: Checklist, cellIds: ReadonlySet<string>, day: string): Array<{ id: string; from: string; to: string }> {
+  return checklist.history.flatMap(entry => {
+    if (!cellIds.has(entry.id) || entry.field !== 'status' || !entry.at || kstDay(new Date(entry.at)) !== day) return [];
+    return [{ id: entry.id, from: String(entry.from ?? 'unknown'), to: String(entry.to ?? 'unknown') }];
+  });
+}
+
+export function renderProgressPreview(link: ProgressLink, checklist: Checklist, day: string): ProgressPreview {
+  const ids = new Set(link.cells.map(cell => cell.id));
+  const transitions = changedStatuses(checklist, ids, day);
+  const statusLines = link.cells.map(cell => {
+    const evidence = cell.evidence ?? '';
+    const simulated = cell.status === 'green' && /green\(sim\)/i.test(evidence);
+    const e4Pending = simulated && /(?:설치본|installed)(?: CLI)?[^\n.]{0,24}E4[^\n.]{0,24}(?:미완|incomplete|not complete|not done)/i.test(evidence);
+    return `- 연결 칸: ${cell.id} — ${simulated ? `green(sim)${e4Pending ? ' · 설치본 E4 미완' : ''}` : cell.status}`;
+  });
+  const transitionLines = transitions.map(change => `- 오늘 상태 변화: ${change.id} ${change.from} → ${change.to}`);
+  const decisionLines = link.decisions.filter(decision => {
+    const timestamp = decision.decidedAt ?? decision.withdrawnAt ?? decision.raisedAt;
+    return !!timestamp && kstDay(new Date(timestamp)) === day;
+  })
+    .map(decision => `- 연결 결정: ${decision.id} — ${decision.status}`);
+  const landedPrs = [...new Set(link.cells.flatMap(cell => {
+    const text = cell.evidence ?? '';
+    return [...text.matchAll(/\bPR\s*#(\d+)\b[^\n]{0,120}\bmerged\b/gi)].map(match => `#${match[1]}`);
+  }))];
+  const nextCell = link.cells.find(cell => cell.status !== 'green' && cell.status !== 'done');
+  const simulatedCell = link.cells.find(cell => cell.status === 'green' && /green\(sim\)/i.test(cell.evidence ?? ''));
+  const simulatedEvidence = simulatedCell?.evidence ?? '';
+  const simulatedE4Pending = !!simulatedCell && /(?:설치본|installed)(?: CLI)?[^\n.]{0,24}E4[^\n.]{0,24}(?:미완|incomplete|not complete|not done)/i.test(simulatedEvidence);
+  const next = nextCell ? `연결 칸 ${nextCell.id}의 남은 완료 경계 진행`
+    : simulatedCell ? `연결 칸 ${simulatedCell.id}의 ${simulatedE4Pending ? '설치본 E4 실물 증거 확보' : '설치본 실물 증거 확인'}` : '연결된 칸은 현재 green/done';
+  const body = [
+    `${day} 진행 요약`,
+    `- 상태: ${link.issue.state} — ${link.issue.url}`,
+    ...statusLines,
+    ...transitionLines,
+    ...decisionLines,
+    ...(landedPrs.length ? [`- 연결 착지 PR: ${landedPrs.join(', ')}`] : []),
+    `- 다음: ${next}`,
+    `<!-- elanous-linear-progress:${day}:${link.issue.identifier} -->`,
+  ].join('\n');
+  return { identifier: link.issue.identifier, body, sources: link.sources };
+}
+
+async function fetchTeamIssues(apiKey: string, teamKey: string): Promise<ProgressIssue[]> {
+  const query = `query LinearProgressIssues($teamKey: String!, $after: String) {
+    issues(filter: { team: { key: { eq: $teamKey } } }, first: 100, after: $after) {
+      nodes { id identifier title url description state { name } }
+      pageInfo { hasNextPage endCursor }
+    }
+  }`;
+  const issues: ProgressIssue[] = [];
+  const cursors = new Set<string>();
+  let after: string | null = null;
+  do {
+    const response = await fetch('https://api.linear.app/graphql', {
+      method: 'POST', headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query, variables: { teamKey, after } }),
+    });
+    if (!response.ok) throw new Error(`Linear GraphQL HTTP ${response.status}`);
+    const result = await response.json() as { errors?: unknown[]; data?: { issues?: { nodes?: Array<Record<string, unknown>>; pageInfo?: { hasNextPage: boolean; endCursor: string | null } } } };
+    const page = result.data?.issues;
+    if (result.errors?.length || !Array.isArray(page?.nodes)) throw new Error(`Linear ${teamKey} issue query failed`);
+    for (const node of page.nodes) {
+      if (typeof node.id !== 'string' || typeof node.identifier !== 'string' || typeof node.title !== 'string' || typeof node.url !== 'string') continue;
+      const state = node.state && typeof node.state === 'object' ? (node.state as { name?: unknown }).name : undefined;
+      issues.push({ id: node.id, identifier: node.identifier, title: node.title, url: node.url,
+        description: typeof node.description === 'string' ? node.description : '', state: typeof state === 'string' ? state : 'unknown' });
+    }
+    const info = page.pageInfo;
+    if (info?.hasNextPage && (!info.endCursor || cursors.has(info.endCursor))) throw new Error(`Linear ${teamKey} cursor missing or repeated`);
+    after = info?.hasNextPage ? info.endCursor : null;
+    if (after) cursors.add(after);
+  } while (after);
+  return issues;
+}
+
+async function fetchAllowlistedIssue(apiKey: string, identifier: string): Promise<ProgressIssue | null> {
+  const query = `query LinearAllowlistedProgressIssue($identifier: String!) {
+    issue(id: $identifier) { id identifier title url description state { name } }
+  }`;
+  const response = await fetch('https://api.linear.app/graphql', {
+    method: 'POST', headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ query, variables: { identifier } }),
+  });
+  if (!response.ok) throw new Error(`Linear ${identifier} lookup HTTP ${response.status}`);
+  const result = await response.json() as { errors?: unknown[]; data?: { issue?: Record<string, unknown> | null } };
+  const node = result.data?.issue;
+  if (result.errors?.length) throw new Error(`Linear ${identifier} lookup failed`);
+  if (!node || typeof node.id !== 'string' || typeof node.identifier !== 'string' || typeof node.title !== 'string' || typeof node.url !== 'string') return null;
+  const state = node.state && typeof node.state === 'object' ? (node.state as { name?: unknown }).name : undefined;
+  return { id: node.id, identifier: node.identifier, title: node.title, url: node.url,
+    description: typeof node.description === 'string' ? node.description : '', state: typeof state === 'string' ? state : 'unknown' };
+}
+
+async function countMarker(apiKey: string, issueId: string, marker: string): Promise<number> {
+  const query = `query LinearProgressComments($id: String!, $after: String) {
+    issue(id: $id) { comments(first: 100, after: $after) { nodes { body } pageInfo { hasNextPage endCursor } } }
+  }`;
+  const cursors = new Set<string>();
+  let after: string | null = null;
+  let count = 0;
+  do {
+    const response = await fetch('https://api.linear.app/graphql', {
+      method: 'POST', headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query, variables: { id: issueId, after } }),
+    });
+    if (!response.ok) throw new Error(`Linear comment lookup HTTP ${response.status}`);
+    const result = await response.json() as { errors?: unknown[]; data?: { issue?: { comments?: { nodes?: Array<{ body?: unknown }>; pageInfo?: { hasNextPage: boolean; endCursor: string | null } } } } };
+    const comments = result.data?.issue?.comments;
+    if (result.errors?.length || !Array.isArray(comments?.nodes)) throw new Error('Linear comment lookup failed');
+    count += comments.nodes.filter(comment => typeof comment.body === 'string' && comment.body.includes(marker)).length;
+    const info = comments.pageInfo;
+    if (info?.hasNextPage && (!info.endCursor || cursors.has(info.endCursor))) throw new Error('Linear comment cursor missing or repeated');
+    after = info?.hasNextPage ? info.endCursor : null;
+    if (after) cursors.add(after);
+  } while (after);
+  return count;
+}
+
+export async function runLinearProgressSync(options: {
+  version: string; now?: Date; root?: string; apply?: boolean;
+  allowIssueIdentifiers?: readonly string[];
+  checklist?: Checklist; issues?: readonly ProgressIssue[]; decisions?: readonly DecisionEntry[];
+  getApiKey?: (id: string) => Promise<string | undefined>;
+  countMarker?: (issue: ProgressIssue, marker: string) => Promise<number>;
+  postComment?: (issue: ProgressIssue, body: string) => Promise<void>;
+  log?: (event: string, data: Record<string, unknown>) => void;
+}): Promise<ProgressSyncResult> {
+  const now = options.now ?? new Date();
+  const day = kstDay(now);
+  const root = options.root ?? effectiveInstanceRoot();
+  const checklist = options.checklist ?? listChecklist(options.version, root);
+  const decisions = options.decisions ?? new DecisionLedger({ stateDir: root }).list({ status: 'all' });
+  const apiKey = (options.getApiKey ?? getSecretAsync)('connector.linear.apiKey');
+  const resolvedKey = await apiKey;
+  if (!resolvedKey) throw new Error('connector.linear.apiKey missing');
+  const allowedIdentifiers = [...new Set(options.allowIssueIdentifiers ?? [])];
+  const lookupFailures: Array<{ identifier: string; reason: string }> = [];
+  let issues: ProgressIssue[];
+  if (options.issues) issues = [...options.issues];
+  else if (options.apply) {
+    const lookups = await Promise.all(allowedIdentifiers.map(async identifier => {
+      try {
+        const issue = await fetchAllowlistedIssue(resolvedKey, identifier);
+        if (!issue) lookupFailures.push({ identifier, reason: 'allowlisted issue not found' });
+        return issue;
+      } catch (error) {
+        lookupFailures.push({ identifier, reason: (error instanceof Error ? error.message : String(error)).slice(0, 200) });
+        return null;
+      }
+    }));
+    issues = lookups.filter((issue): issue is ProgressIssue => issue !== null);
+  } else issues = (await Promise.all(['ELA', 'DEMO'].map(key => fetchTeamIssues(resolvedKey, key)))).flat();
+  const links = resolveExplicitProgressLinks(issues, checklist, decisions);
+  const previews = links.map(link => renderProgressPreview(link, checklist, day));
+  const linkedIdentifiers = new Set(links.map(link => link.issue.identifier));
+  const fetchedIdentifiers = new Set(issues.map(issue => issue.identifier));
+  const lookupFailureIdentifiers = new Set(lookupFailures.map(failure => failure.identifier));
+  const missingApproved = options.apply ? allowedIdentifiers.filter(identifier => !fetchedIdentifiers.has(identifier) && !lookupFailureIdentifiers.has(identifier))
+    .map(identifier => ({ identifier, reason: 'allowlisted issue not found' })) : [];
+  const unlinkedApproved = options.apply ? allowedIdentifiers.filter(identifier => issues.some(issue => issue.identifier === identifier) && !linkedIdentifiers.has(identifier))
+    .map(identifier => ({ identifier, reason: 'allowlisted issue has no explicit checklist/decision link' })) : [];
+  const unresolvedApproved = [...lookupFailures, ...missingApproved, ...unlinkedApproved];
+  const result: ProgressSyncResult = { day, candidates: previews, posted: [], alreadyPresent: [], skipped: [], failures: unresolvedApproved };
+  const log = (event: string, data: Record<string, unknown>) => {
+    const enriched = { day, ...data };
+    if (options.log) options.log(event, enriched);
+    else debug.log('loop.rhythm-daily.linear-progress', event, enriched);
+  };
+  const check = options.countMarker ?? ((issue: ProgressIssue, marker: string) => countMarker(resolvedKey, issue.id, marker));
+  const post = options.postComment ?? ((issue: ProgressIssue, body: string) => commentLinearIssue({ apiKey: resolvedKey, issueId: issue.id, body }));
+  for (const failure of unresolvedApproved) log('approved-issue-unresolved', failure);
+  for (const preview of previews) {
+    const issue = links.find(link => link.issue.identifier === preview.identifier)!.issue;
+    const marker = `<!-- elanous-linear-progress:${day}:${issue.identifier} -->`;
+    let release: (() => void) | undefined;
+    let stillHeld: (() => boolean) | undefined;
+    try {
+      if (options.apply && !options.allowIssueIdentifiers?.includes(issue.identifier)) {
+        result.skipped.push(issue.identifier);
+        log('not-approved', { identifier: issue.identifier, sources: preview.sources });
+        continue;
+      }
+      if (options.apply) {
+        const lockDir = join(root, 'rhythm', 'linear-progress-sync');
+        mkdirSync(lockDir, { recursive: true, mode: 0o700 });
+        const lockName = createHash('sha256').update(`${day}:${issue.id}`).digest('hex');
+        const lock = await acquireLockAsync(join(lockDir, `${lockName}.lock`), { staleMs: 120_000, maxTries: 240 });
+        release = lock.release;
+        stillHeld = lock.stillHeld;
+        if (!stillHeld()) throw new Error('Linear progress lock lost before marker check');
+      }
+      const existing = await check(issue, marker);
+      if (existing > 1) {
+        result.failures.push({ identifier: issue.identifier, reason: `duplicate-marker-count=${existing}` });
+        log('duplicate-marker', { identifier: issue.identifier, markerCount: existing, sources: preview.sources });
+        continue;
+      }
+      if (existing === 1) {
+        result.alreadyPresent.push(issue.identifier);
+        log('already-present', { identifier: issue.identifier, markerCount: 1, sources: preview.sources });
+        continue;
+      }
+      if (!options.apply) {
+        result.skipped.push(issue.identifier);
+        log('dry-run', { identifier: issue.identifier, markerCount: 0, sources: preview.sources });
+        continue;
+      }
+      if (!release || !stillHeld?.()) throw new Error('Linear progress write lock unavailable or lost');
+      await post(issue, preview.body);
+      const verified = await check(issue, marker);
+      if (verified !== 1) throw new Error(`post-verification-marker-count=${verified}`);
+      result.posted.push(issue.identifier);
+      log('posted', { identifier: issue.identifier, markerCount: verified, sources: preview.sources });
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      result.failures.push({ identifier: issue.identifier, reason: reason.slice(0, 200) });
+      log('failed', { identifier: issue.identifier, reason: reason.slice(0, 200), sources: preview.sources });
+    } finally {
+      release?.();
+    }
+  }
+  return result;
+}
+
+if (import.meta.main) {
+  const version = process.argv.find((arg, index) => process.argv[index - 1] === '--version');
+  if (!version) throw new Error('--version required');
+  if (process.argv.includes('--apply')) throw new Error('live posting requires the approved scheduled daily path');
+  const result = await runLinearProgressSync({ version, apply: false });
+  console.log(JSON.stringify(result));
+}

package/scripts/video-pipeline.ts

@@ -1092,7 +1092,15 @@ async function plan() {
         ovSelections = sel.selections.map((x) => ({ overlayId: x.overlayId, verdict: x.verdict, detail: x.detail }));
         if (sel.applied.length > 0) {
           const applied = applyGraphOverlays(decl.template, sel.applied);
-          if (applied.ok) ovPatches = applied.patches.map((x) => ({ overlayId: x.overlayId, node: x.node, field: x.field, before: (x as { before: unknown }).before, after: (x as { after: unknown }).after }));
+          if (applied.ok) ovPatches = applied.patches.map((x) => {
+            if (x.field === 'edge-rerouted') return {
+              overlayId: x.overlayId, node: x.from, field: x.field, before: x.was, after: x.to,
+            };
+            if (x.field === 'node-added') return {
+              overlayId: x.overlayId, node: x.node, field: x.field, before: null, after: x.kind,
+            };
+            return { overlayId: x.overlayId, node: x.node, field: x.field, before: x.before, after: x.after };
+          });
           else ovError = `얹다가 거절됐다 — ${applied.rejections.map((r) => r.kind).join(', ')}`;
         }
       }

package/scripts/warm-pool-provider-config.ts

@@ -4,6 +4,7 @@ import { dirname, isAbsolute, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { userConfigPath } from '../src/user-config.js';
+import type { WarmWorkerCandidate } from '../src/task-orchestrator/surfaces/pod-warm-worker-provider.js';
 
 const TOKEN = /^[a-f0-9]{64}$/;
 const SHA = /^[a-f0-9]{40}$/;
@@ -14,7 +15,7 @@ const TIERS = new Set(['lite', 'standard']);
 type JsonObject = Record<string, unknown>;
 
 export interface WarmPoolProviderConfig {
-  candidates: [];
+  candidates: WarmWorkerCandidate[];
   poolTemplates: Array<{
     host: string;
     tier: 'lite' | 'standard';
@@ -47,6 +48,25 @@ export interface AssembleWarmPoolProviderConfigInput {
   machineTokens: Record<string, string>;
 }
 
+/** Keep a deployment canary to one explicit worker instead of expanding its profile quota. */
+export function selectSingleWarmPoolCandidate(config: WarmPoolProviderConfig, selection: string): WarmPoolProviderConfig {
+  const match = /^([a-zA-Z0-9][a-zA-Z0-9._-]*)\/(lite|standard)$/.exec(selection);
+  if (!match) throw new Error('--single-candidate must be HOST/lite or HOST/standard');
+  const [, host, tier] = match;
+  const template = config.poolTemplates.find(candidate => candidate.host === host && candidate.tier === tier);
+  if (!template) throw new Error(`warm pool template not found: ${host}/${tier}`);
+  const index = 1;
+  return {
+    ...config,
+    candidates: [{ host, tier: tier as 'lite' | 'standard', spec: {
+      ...template.spec,
+      name: `warm-${host}-${tier}-${index}`,
+      workerId: `${template.spec.workerId}-${tier}-${index}`,
+    } }],
+    poolTemplates: [],
+  };
+}
+
 function object(value: unknown, label: string): JsonObject {
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`${label} is required`);
   return value as JsonObject;
@@ -183,11 +203,12 @@ interface CliOptions {
   output: string;
   dryRun: boolean;
   serve: boolean;
+  singleCandidate?: string;
 }
 
 function parseArgs(argv: readonly string[]): CliOptions {
   let configPath = userConfigPath(), controlUrl = '', memberTokenFile = '', output = '';
-  let dryRun = false, serve = false;
+  let dryRun = false, serve = false, singleCandidate: string | undefined;
   const machineTokenFiles: Record<string, string> = {};
   for (let index = 0; index < argv.length; index++) {
     const arg = argv[index];
@@ -206,14 +227,15 @@ function parseArgs(argv: readonly string[]): CliOptions {
     } else if (arg === '--output') output = next();
     else if (arg === '--dry-run') dryRun = true;
     else if (arg === '--serve') serve = true;
+    else if (arg === '--single-candidate') singleCandidate = next();
     else throw new Error(`unknown argument: ${arg}`);
   }
   if (!isAbsolute(configPath) || !controlUrl || !isAbsolute(memberTokenFile))
-    throw new Error('usage: --config ABSOLUTE --control-url URL --member-token-file ABSOLUTE --machine-token HOST=ABSOLUTE [--output ABSOLUTE] [--dry-run|--serve]');
+    throw new Error('usage: --config ABSOLUTE --control-url URL --member-token-file ABSOLUTE --machine-token HOST=ABSOLUTE [--output ABSOLUTE] [--single-candidate HOST/TIER] [--dry-run|--serve]');
   if (Object.values(machineTokenFiles).some(file => !isAbsolute(file))) throw new Error('machine token files must be absolute');
   if (dryRun && serve) throw new Error('--dry-run and --serve cannot be combined');
   return { configPath, controlUrl, memberTokenFile, machineTokenFiles,
-    output: output || join(dirname(configPath), 'warm-pod-provider.json'), dryRun, serve };
+    output: output || join(dirname(configPath), 'warm-pod-provider.json'), dryRun, serve, singleCandidate };
 }
 
 function readPrivateToken(path: string, label: string): string {
@@ -228,8 +250,9 @@ export async function runWarmPoolProviderConfig(argv: readonly string[]): Promis
     .map(([host, path]) => [host, readPrivateToken(path, `machine token for ${host}`)]));
   const assembled = assembleWarmPoolProviderConfig({ config, controlUrl: options.controlUrl,
     memberToken: readPrivateToken(options.memberTokenFile, 'member token'), machineTokens });
-  if (!options.dryRun) writeWarmPoolProviderConfig(options.output, assembled);
-  process.stdout.write(`${JSON.stringify({ output: options.output, config: redact(assembled),
+  const selected = options.singleCandidate ? selectSingleWarmPoolCandidate(assembled, options.singleCandidate) : assembled;
+  if (!options.dryRun) writeWarmPoolProviderConfig(options.output, selected);
+  process.stdout.write(`${JSON.stringify({ output: options.output, config: redact(selected),
     ...(options.serve ? { serve: { command: `ELANOUS_WARM_POD_PROVIDER_CONFIG=${shellQuote(options.output)} bun src/task-orchestrator/surfaces/pod-warm-worker-provider.ts --serve` } } : {}) })}\n`);
   if (!options.serve) return;
   const provider = fileURLToPath(new URL('../src/task-orchestrator/surfaces/pod-warm-worker-provider.ts', import.meta.url));

package/src/acp/agent-manager.ts

@@ -76,6 +76,7 @@ export class AcpAgentManager {
       agent = new CodexAppServerAgent({
         backendId,
         ...opts,
+        remoteSocketPath: process.env.ELANOUS_CODEX_REMOTE_SIDETAB_SOCKET || undefined,
         elicitationHandler: createAskUserElicitationHandler(),
       }) as unknown as AcpAgent;
     } else {

package/src/acp/codex-app-server-agent.ts

@@ -31,6 +31,7 @@
 import {
   CodexAppServerClient,
   spawnCodexAppServer,
+  spawnCodexRemoteTui,
   type SpawnCodexAppServerOpts,
   type SpawnedCodexAppServer,
 } from './codex-app-server-client.js';
@@ -713,6 +714,8 @@ export interface CodexAppServerAgentOpts {
   readonly codexBinary?: string;
   /** Session-scoped argv forwarded to `spawnCodexAppServer`. */
   readonly codexArgs?: readonly string[];
+  /** Explicit opt-in Codex remote side-tab Unix socket path. */
+  readonly remoteSocketPath?: string;
   readonly env?: Record<string, string>;
   readonly log?: (msg: string) => void;
   /** Called after a successful initialize with this backend's advertised capabilities.
@@ -770,6 +773,7 @@ export interface CodexAppServerAgentOpts {
   readonly _spawnFactory?: (
     opts: SpawnCodexAppServerOpts,
   ) => SpawnedCodexAppServer;
+  readonly _remoteTuiSpawnForTesting?: typeof spawnCodexRemoteTui;
 }
 
 export class CodexAppServerAgent {
@@ -777,12 +781,14 @@ export class CodexAppServerAgent {
   private readonly cwd?: string;
   private readonly codexBinary?: string;
   private readonly codexArgs?: readonly string[];
+  private readonly remoteSocketPath?: string;
   private readonly env?: Record<string, string>;
   private readonly log: (msg: string) => void;
   private readonly onCapabilities: ((capabilities: ElanousCapabilities) => void) | undefined;
 
   private client: CodexAppServerClient | null;
   private child: SpawnedCodexAppServer['child'] | null = null;
+  private remoteTuiChild: ReturnType<typeof spawnCodexRemoteTui> | null = null;
   private initialized = false;
 
   private readonly approvalAdapter: CodexApprovalAdapter;
@@ -877,12 +883,14 @@ export class CodexAppServerAgent {
   private readonly _spawnFactory:
     | ((opts: SpawnCodexAppServerOpts) => SpawnedCodexAppServer)
     | undefined;
+  private readonly _remoteTuiSpawnForTesting: typeof spawnCodexRemoteTui | undefined;
 
   constructor(opts: CodexAppServerAgentOpts) {
     this.backendId = opts.backendId;
     this.cwd = opts.cwd;
     this.codexBinary = opts.codexBinary;
     this.codexArgs = opts.codexArgs ? [...opts.codexArgs] : undefined;
+    this.remoteSocketPath = opts.remoteSocketPath;
     this.env = opts.env;
     this.log = opts.log ?? ((msg) => debug.log('acp.cxn.appserver.agent', msg));
     this.onCapabilities = opts.onCapabilities;
@@ -894,6 +902,7 @@ export class CodexAppServerAgent {
     this.imageTempDir = opts.imageTempDir ?? defaultImageTempDir();
     this._clientForTesting = opts._clientForTesting;
     this._spawnFactory = opts._spawnFactory;
+    this._remoteTuiSpawnForTesting = opts._remoteTuiSpawnForTesting;
     this.threadIndex = opts._threadIndexForTesting ?? globalCasThreadIndex();
     // M6 · idle hibernate config. Env override only applies when opts
     // didn't set it explicitly so tests can pin a value regardless of
@@ -979,6 +988,7 @@ export class CodexAppServerAgent {
         env: { ...rotatedCodexChildEnv(childEnv), ...(this.env ?? {}) },
         codexBinary,
         codexArgs: this.codexArgs,
+        remoteSocketPath: this.remoteSocketPath,
       };
       const spawned = spawnFn(spawnOpts);
       this.client = spawned.client;
@@ -1069,6 +1079,13 @@ export class CodexAppServerAgent {
         /* swallow */
       }
     }
+    if (this.remoteTuiChild) {
+      try {
+        this.remoteTuiChild.kill('SIGTERM');
+      } catch {
+        /* swallow */
+      }
+    }
     if (this.child) {
       try {
         this.child.kill('SIGTERM');
@@ -1078,6 +1095,7 @@ export class CodexAppServerAgent {
     }
     this.client = null;
     this.child = null;
+    this.remoteTuiChild = null;
     this.initialized = false;
     this.sessionToThread.clear();
     this.threadToSession.clear();
@@ -1110,6 +1128,7 @@ export class CodexAppServerAgent {
    *  disabled. unref() so a CLI can still exit cleanly when the daemon
    *  is the only thing keeping the loop alive. */
   private armIdleTimer(): void {
+    if (this.remoteSocketPath) return;
     if (this.idleTimerHandle !== null) return;
     if (this.idleTimeoutMs <= 0) return;
     this.idleTimerHandle = setInterval(() => {
@@ -1328,6 +1347,20 @@ export class CodexAppServerAgent {
     // M6 · brand-new sessions are alive in the current daemon by
     // definition · no thread/resume needed before the first turn.
     this.currentDaemonSessions.add(sessionId);
+    if (this.remoteSocketPath && !this.remoteTuiChild) {
+      const explicitEnv = this.env ?? {};
+      const tuiEnv = {
+        ...rotatedCodexChildEnv({ ...process.env, ...explicitEnv }),
+        ...explicitEnv,
+      };
+      const spawnRemoteTui = this._remoteTuiSpawnForTesting ?? spawnCodexRemoteTui;
+      this.remoteTuiChild = spawnRemoteTui({
+        codexBinary: this.codexBinary ?? resolvePreferredCodexBinary(),
+        socketPath: this.remoteSocketPath,
+        cwd: this.cwd,
+        env: tuiEnv,
+      });
+    }
     debug.log('acp.client', 'session-new', { backendId: this.backendId, sessionId });
     return sessionId;
   }