elanous 0.2.12 → 0.2.14

package/src/telegram-fabric-plan.ts

@@ -0,0 +1,90 @@
+import { defaultBaseUrl, defaultToken } from './telegram-dispatch-forward.js';
+import type { FabricPlan } from './self-dev/fabric-plan-core.js';
+import type { TelegramBot, TgIncoming } from './telegram.js';
+
+export interface TelegramFabricPlanDeps {
+  fetchImpl?: typeof fetch;
+  baseUrl?: () => string | null;
+  token?: () => string | null;
+}
+
+/** Only a successful daemon draft is offered for approval; no execution endpoint is called here. */
+export function attachTelegramFabricPlan(
+  bot: Pick<TelegramBot, 'isOwnerAllowed' | 'sendMessage' | 'sendInlineKeyboard' | 'onCallbackQuery' | 'answerCallbackQuery'>,
+  deps: TelegramFabricPlanDeps = {},
+): (ctx: TgIncoming) => Promise<boolean> {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const pending = new Map<string, { chatId: number; userId: number; threadId?: number; messageId: number }>();
+  const endpoint = (path: string): { url: string; token: string | null } => {
+    const base = (deps.baseUrl ?? defaultBaseUrl)();
+    if (!base) throw new Error('데몬에 연결할 수 없습니다');
+    return { url: `${base}${path}`, token: (deps.token ?? defaultToken)() };
+  };
+  const post = async (path: string, body?: unknown): Promise<unknown> => {
+    const { url, token } = endpoint(path);
+    const response = await fetchImpl(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...(token ? { authorization: `Bearer ${token}` } : {}) },
+      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    });
+    if (!response.ok) throw new Error(`데몬 응답 ${response.status}`);
+    return response.json();
+  };
+
+  bot.onCallbackQuery(async (q) => {
+    const match = /^fabric:(approve|edit):([a-f0-9-]{36})$/i.exec(q.data);
+    if (!match) return;
+    const planId = match[2]!;
+    const original = pending.get(planId);
+    if (!original || !bot.isOwnerAllowed(q.userId) || q.userId !== original.userId
+      || q.chatId !== original.chatId || q.threadId !== original.threadId || q.messageId !== original.messageId) {
+      await bot.answerCallbackQuery(q.id, { text: '이 초안의 요청자만 선택할 수 있습니다' });
+      return;
+    }
+    if (match[1] === 'edit') {
+      pending.delete(planId);
+      await bot.answerCallbackQuery(q.id);
+      await bot.sendMessage(original.chatId, '고칠 내용을 반영해 «아크: <복합 문장>»으로 다시 보내세요. 이 초안은 승인되지 않았습니다.', { threadId: original.threadId });
+      return;
+    }
+    try {
+      await post(`/v1/fabric/plans/${planId}/approve`);
+      pending.delete(planId);
+      await bot.answerCallbackQuery(q.id, { text: '승인되었습니다' });
+      await bot.sendMessage(original.chatId, `아크 초안 ${planId} 승인됨 — 실행은 별도 단계입니다.`, { threadId: original.threadId });
+    } catch (error) {
+      await bot.answerCallbackQuery(q.id, { text: `승인 실패: ${error instanceof Error ? error.message : String(error)}` });
+    }
+  });
+
+  return async (ctx) => {
+    if (ctx.attachments.length || ctx.video || !ctx.text.startsWith('아크:')) return false;
+    const request = ctx.text.slice('아크:'.length).trim();
+    if (!request || request.includes('\n')) {
+      await bot.sendMessage(ctx.chatId, '«아크: <복합 문장>» 한 줄로 보내세요.', { replyTo: ctx.messageId, threadId: ctx.threadId });
+      return true;
+    }
+    try {
+      const body = await post('/v1/fabric/decompose', { request }) as { plan?: FabricPlan };
+      const plan = body.plan;
+      if (!plan || plan.status !== 'draft' || !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(plan.id)
+        || !Array.isArray(plan.nodes) || plan.nodes.length === 0) throw new Error('초안 형식 오류');
+      const steps = plan.nodes.map((node, i) => `${i + 1}. ${node.title}`).join('\n');
+      const preview = `아크 초안 · 실행 전 검토\n${steps}`;
+      const reply = { replyTo: ctx.messageId, threadId: ctx.threadId };
+      for (let offset = 0; offset + 4000 < preview.length; offset += 4000) {
+        const sent = await bot.sendMessage(ctx.chatId, preview.slice(offset, offset + 4000), reply);
+        if (sent?.messageId === undefined) throw new Error('단계 미리보기를 전부 전달하지 못했습니다 — 승인 불가');
+      }
+      const finalOffset = Math.floor((preview.length - 1) / 4000) * 4000;
+      const sent = await bot.sendInlineKeyboard(ctx.chatId, preview.slice(finalOffset), [[
+        { text: '승인', data: `fabric:approve:${plan.id}` },
+        { text: '고치기', data: `fabric:edit:${plan.id}` },
+      ]], reply);
+      if (sent?.messageId !== undefined) pending.set(plan.id, { chatId: ctx.chatId, userId: ctx.userId, threadId: ctx.threadId, messageId: sent.messageId });
+    } catch (error) {
+      await bot.sendMessage(ctx.chatId, `아크 초안 생성 실패: ${error instanceof Error ? error.message : String(error)}`, { replyTo: ctx.messageId, threadId: ctx.threadId });
+    }
+    return true;
+  };
+}

package/src/telegram-loops-command.ts

@@ -0,0 +1,44 @@
+import { dashboardLoops } from './domains/dashboard-data.js';
+import { readSchedulesInventory } from './nexus/api/schedules-read.js';
+import { loadLoopRows, LOOP_SCHEDULES_PATH, LOOPS_PATH, type LoopRow } from './loops/status-rows.js';
+
+interface LoopsSources {
+  schedules: () => unknown;
+  loops: () => unknown;
+  now: () => number;
+}
+
+const defaultSources: LoopsSources = {
+  schedules: () => ({ schedules: readSchedulesInventory() }),
+  loops: () => ({ loops: dashboardLoops() }),
+  now: Date.now,
+};
+
+const clean = (text: string) => text.replace(/[\r\n\t]+/g, ' ').replace(/\s+/g, ' ').trim();
+
+/** Read the same two inventories and apply the same row verdicts as PWA /loops. */
+export async function telegramLoopsStatus(args: string[], sources: LoopsSources = defaultSources): Promise<string> {
+  if (args.length) return '사용법: /loops';
+  try {
+    const rows = await loadLoopRows(async (path) => {
+      if (path === LOOP_SCHEDULES_PATH) return sources.schedules();
+      if (path === LOOPS_PATH) return sources.loops();
+      throw new Error('unknown inventory');
+    }, sources.now());
+    if (!rows.length) return '등록된 루프·크론이 없습니다.';
+    const counts = (['늦음', '실패', '살아 있음', '꺼짐', '판정 불가'] as const)
+      .map(verdict => `${verdict} ${rows.filter(row => row.verdict === verdict).length}`);
+    const priority: Record<LoopRow['verdict'], number> = { '늦음': 0, '실패': 1, '살아 있음': 2, '꺼짐': 3, '판정 불가': 4 };
+    const lines = rows.slice().sort((a, b) => priority[a.verdict] - priority[b.verdict]).map(row =>
+      `• ${row.verdict === '늦음' ? '🔴' : row.verdict === '실패' ? '❌' : row.verdict === '살아 있음' ? '🟢' : '⚪'} ${row.verdict} · ${clean(row.name)} (${clean(row.layer)}) · ${clean(row.mode)} · 마지막 ${row.lastRun ?? '기록 없음'} · ${clean(row.id)}`);
+    let reply = ['루프·크론 현황', counts.join(' · ')].join('\n');
+    for (const [index, line] of lines.entries()) {
+      // Telegram caps a message at 4096 characters; leave space for an explicit omission count.
+      if (reply.length + line.length + 35 > 4000) return `${reply}\n… ${lines.length - index}개 더 (메시지 길이 제한)`;
+      reply += `\n${line}`;
+    }
+    return reply;
+  } catch {
+    return '루프 현황을 읽지 못했습니다. 일부 레지스트리 조회가 실패했습니다. 데몬 연결을 확인하세요.';
+  }
+}

package/src/telegram-project-command.ts

@@ -35,17 +35,23 @@ export function projectCommand(deps: TelegramProjectCommandDeps = {
         debug.log('telegram.project', 'listed', { projects: projects.slice(0, 20).map(p => ({ id: p.id, name: p.name })) });
         if (ctx.isDm && ctx.chatId === ctx.userId
           && String(ctx.userId) === telegramDecisionOwner(ctxOptions.userConfig) && ctxOptions.sendButtons) {
-          const buttons = projects.filter(p => {
+          const eligible = projects.filter(p => {
             const bytes = Buffer.byteLength(`prj:${p.id}`, 'utf8');
             if (bytes <= 64) return true;
             debug.log('telegram.project', 'button-rejected', { reason: 'callback-data-too-long', projectId: p.id, bytes });
             return false;
-          }).slice(0, 8).map(p => ({ text: p.name, data: `prj:${p.id}` }));
-          buttons.push({ text: '받은 대화로', data: 'prj:-' });
+          });
+          const visible = eligible.slice(0, 7);
+          if (current && eligible.some(p => p.id === current.id) && !visible.some(p => p.id === current.id)) {
+            visible[visible.length - 1] = current;
+          }
+          const buttons = visible.map(p => ({ text: `${p.id === current?.id ? '✓ ' : ''}${p.name}`, data: `prj:${p.id}` }));
+          buttons.push({ text: `${session.projectId ? '' : '✓ '}받은 대화로`, data: 'prj:-' });
           const rows: Array<Array<{ text: string; data: string }>> = [];
           for (let i = 0; i < buttons.length; i += 2) rows.push(buttons.slice(i, i + 2));
           try {
             await ctxOptions.sendButtons('프로젝트를 선택하세요', rows);
+            return;
           } catch (err) {
             debug.log('telegram.project', 'button-rejected', {
               reason: 'send-failed', error: err instanceof Error ? err.message : String(err),
@@ -140,6 +146,6 @@ export function attachTelegramProjectButtons(
     deps.update(session.id, m => { m.projectId = project.id; });
     debug.log('telegram.project', 'button-moved', { chatId, sessionId: session.id, projectId: project.id });
     await bot.answerCallbackQuery(q.id);
-    await bot.sendMessage(chatId, `이 대화를 ${project.name} 프로젝트로 옮겼습니다`);
+    await bot.sendMessage(chatId, `지금 프로젝트: ${project.name}`);
   });
 }

package/src/telegram.ts

@@ -77,6 +77,7 @@ import { handleTelegramFieldNote } from './field-note/telegram.js';
 import type { TranscriptionEngine, FieldAudio } from './field-note/transcribe.js';
 import { maybeHandleCardPhoto, type CardPhotoDeps } from './telegram-card-followup.js';
 import { attachTelegramProjectButtons } from './telegram-project-command.js';
+import { attachTelegramFabricPlan } from './telegram-fabric-plan.js';
 
 export type TgAttachmentKind = 'photo' | 'voice' | 'audio' | 'document';
 
@@ -229,6 +230,7 @@ export interface TelegramBotOpts {
   fieldNoteDecodeAudio?: (file: string, recordedAt: string) => FieldAudio;
   /** Test seam for the business-card graph and its private run root. */
   cardFollowupDeps?: Pick<CardPhotoDeps, 'runGraph' | 'rootDir' | 'ocrText'>;
+  fabricPlanDeps?: import('./telegram-fabric-plan.js').TelegramFabricPlanDeps;
 }
 
 /** Surface-unification v2 (FU-2) — Telegram trigger event passed to
@@ -350,6 +352,7 @@ export class TelegramBot {
   private readonly fieldNoteDecodeAudio?: (file: string, recordedAt: string) => FieldAudio;
   private readonly cardFollowupDeps: Pick<CardPhotoDeps, 'runGraph' | 'rootDir' | 'ocrText'>;
   private readonly seatWorkDeps: TelegramSeatWorkDeps;
+  private readonly handleFabricPlan: (ctx: TgIncoming) => Promise<boolean>;
   private seatAskTimer: ReturnType<typeof setInterval> | null = null;
   /** 앨범 id → `#현장` 행사 · 답장 디바운스. 태그된 앨범만 들어온다. */
   private readonly fieldGroups = new Map<string, {
@@ -388,6 +391,7 @@ export class TelegramBot {
     this.fieldNoteEngine = opts.fieldNoteEngine;
     this.fieldNoteDecodeAudio = opts.fieldNoteDecodeAudio;
     this.cardFollowupDeps = opts.cardFollowupDeps ?? {};
+    this.handleFabricPlan = attachTelegramFabricPlan(this, opts.fabricPlanDeps);
     this.seatWorkDeps = { ...opts.seatWorkDeps, askDeps: { ...opts.seatWorkDeps?.askDeps,
       channel: 'telegram', botId: this.botId,
       send: opts.seatWorkDeps?.askDeps?.send ?? (async (origin, text) => {
@@ -1539,6 +1543,7 @@ export class TelegramBot {
       await this.refuseMessage(ctx);
       return;
     }
+    if (await this.handleFabricPlan(ctx)) return;
     // 현장 업로드 — `#현장` 캡션(또는 태그된 앨범의 나머지)의 사진·영상은 LLM 대신 현장 폴더로.
     if (await this.tryHandleFieldUpload(ctx)) return;
     if (await handleTelegramFieldNote(ctx, {

package/src/tool-runtime/elanous-control-runtimes.ts

@@ -3,6 +3,7 @@ import { StringDecoder } from 'node:string_decoder';
 import { fileURLToPath } from 'node:url';
 import { dirname, resolve } from 'node:path';
 import type { LLMToolSpec } from '../llm.js';
+import { stateDirSourceForChild } from '../agent/identity-env.js';
 import { debug } from '../debug/log.js';
 import { canonicalizeForBoundary, isWithinBoundary, resolveHarnessBoundary } from '../harness/harness-write-boundary.js';
 import { getHarnessSpace } from '../harness/harness-space.js';
@@ -133,7 +134,7 @@ async function spawnHeldElanous(command: string[], cwd: string, instanceRoot: st
     try {
       child = deps.spawn(command[0]!, command.slice(1), {
         cwd,
-        env: { ...process.env, ELANOUS_STATE_DIR: instanceRoot },
+        env: { ...process.env, ELANOUS_STATE_DIR: instanceRoot, ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(instanceRoot) },
         detached: true,
         stdio: ['ignore', 'pipe', 'pipe'],
       });

package/src/user-config.ts

@@ -3475,15 +3475,55 @@ export function resolveRoleModel(role: ModelRole, config: UserConfig = getUserCo
 }
 
 
-export type StewardLoopMode = 'off' | 'shadow' | 'live';
+export type OrchestratorSeat = 'OP' | 'TC' | 'MK' | 'UX';
+export interface OrchestratorLoopConfig {
+  /** ORCH1 graph mode — shadow writes observations only; live appends delegations (default shadow). */
+  mode: 'off' | 'shadow' | 'live';
+  seatTrees: Partial<Record<OrchestratorSeat, string[]>>;
+  seatCaps: Record<OrchestratorSeat, number>;
+  /** Per-seat release gate; absent seats retain the spawn-budget default. */
+  releaseGate?: Partial<Record<OrchestratorSeat, number>>;
+  trafficMode: 'shadow' | 'live';
+}
+
+export const ORCHESTRATOR_DEFAULTS: OrchestratorLoopConfig = {
+  mode: 'shadow', seatTrees: {}, seatCaps: { TC: 8, UX: 6, MK: 6, OP: 4 }, trafficMode: 'shadow',
+};
+
+export function parseOrchestratorLoopConfig(raw: unknown): OrchestratorLoopConfig {
+  const value = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw as Record<string, unknown> : {};
+  const rawTrees = value.seatTrees && typeof value.seatTrees === 'object' && !Array.isArray(value.seatTrees)
+    ? value.seatTrees as Record<string, unknown> : {};
+  const rawCaps = value.seatCaps && typeof value.seatCaps === 'object' && !Array.isArray(value.seatCaps)
+    ? value.seatCaps as Record<string, unknown> : {};
+  const rawGate = value.releaseGate && typeof value.releaseGate === 'object' && !Array.isArray(value.releaseGate)
+    ? value.releaseGate as Record<string, unknown> : {};
+  const seatTrees: OrchestratorLoopConfig['seatTrees'] = {};
+  const seatCaps = { ...ORCHESTRATOR_DEFAULTS.seatCaps };
+  const releaseGate: NonNullable<OrchestratorLoopConfig['releaseGate']> = {};
+  for (const seat of ['OP', 'TC', 'MK', 'UX'] as const) {
+    if (Array.isArray(rawTrees[seat])) seatTrees[seat] = rawTrees[seat].filter((path): path is string => typeof path === 'string' && isAbsolute(path));
+    const cap = rawCaps[seat];
+    if (typeof cap === 'number' && Number.isSafeInteger(cap) && cap >= 0) seatCaps[seat] = cap;
+    const gate = rawGate[seat];
+    if (typeof gate === 'number' && Number.isSafeInteger(gate) && gate >= 0) releaseGate[seat] = gate;
+  }
+  const mode = value.mode === 'off' || value.mode === 'live' ? value.mode : 'shadow';
+  return { mode, seatTrees, seatCaps, ...(Object.keys(releaseGate).length ? { releaseGate } : {}),
+    trafficMode: value.trafficMode === 'live' ? 'live' : 'shadow' };
+}
 
-export type SeatLoopMode = 'off' | 'shadow' | 'on';
+export type StewardLoopMode = 'off' | 'shadow' | 'live' | 'rescue';
+
+export type SeatLoopMode = 'off' | 'shadow' | 'on' | 'live-safe';
 
 export interface PersonaLoopConfig { enabled: boolean }
 
 export interface SeatLoopConfig {
-  /** No seat actions by default; shadow observes without execution, on permits the seat loop to act. */
+  /** Shadow observes by default; live-safe acts only through the shared rescue policy, while legacy on retains its behavior. */
   mode: SeatLoopMode;
+  /** Validated loop-agent neighbor entries keyed by the observing seat. */
+  neighbors?: Partial<Record<'OP' | 'TC' | 'MK' | 'UX', import('./loops/neighbors.js').Neighbor[]>>;
   /** Seat-to-seat and human questions default to shadow even when the checklist loop is on. */
   questions?: 'shadow' | 'on';
   seats?: string[];
@@ -3516,25 +3556,54 @@ export function parseEventsConfig(input: unknown): EventsConfig {
   return { mode: events.mode === 'on' ? 'on' : 'shadow', routes, linearAssignees };
 }
 
+export type HqFenceRole = 'telegram-poller' | 'cron' | 'seat-loop' | 'release-run' | 'conatus' | 'git-push' | 'ledger-cli';
+export interface HqConfig {
+  /** ssh host that keeps the lease record — homes push to it; it never sshes back (default cloud-vm). */
+  arbiter?: string;
+  /** This host's identity in the lease (default os.hostname()). */
+  hostName?: string;
+  /** Standby host (default node-b) — the quorum's third member; promoted only by the arbiter. */
+  standby?: string;
+  /** Lease TTL in seconds (default 1500 = 25 min). */
+  ttlSeconds?: number;
+  /** Roles that may still run when this host is fenced only for lack of quorum (never when a newer generation exists). Absent = none. */
+  failOpenRoles?: HqFenceRole[];
+  /** Per-host nexus health URL over the tailnet (default https://<host>.<tailnetDomain>:31415/v1/health). */
+  healthUrls?: Record<string, string>;
+  /** MagicDNS suffix (default: read from `tailscale status --json`). */
+  tailnetDomain?: string;
+  /** `tailscale` binary (default tailscale). */
+  tailscaleBin?: string;
+  /** Highest lease generation this host ever saw (default ~/.elanous-hq/seen-generation · 600). */
+  seenGenerationFile?: string;
+  /** Per-probe timeout in seconds (default 5). */
+  probeTimeoutSeconds?: number;
+}
+
 export interface UserConfig {
   events?: EventsConfig;
   /** Explicit HTTPS destination for doctor diagnostics; absent means no upload. */
   diagnostics?: { uploadUrl?: string };
+  /** HQ lease (본부 임대 · 10-04 HQ-HB/HQ-FENCE): arbiter host over ssh, this host's name, per-role fail-open when the arbiter is unreachable (default: fail closed). */
+  hq?: HqConfig;
   /** Root CLI help audience; absent or invalid means owner. */
   cli?: { helpRole?: 'owner' | 'contributor' | 'general' };
+  /** Daemon public demonstration mode; absent means off. */
+  nexus?: { demoMode?: boolean };
   /** Execution-phase HITL answer deadline; absent means 30 minutes. */
   hitl?: { executionDeadlineMinutes?: number };
   coo?: { linearProject?: string };
-  decisions?: { linearProjection: { enabled: boolean } };
+  decisions?: { linearProjection: { enabled: boolean }; requireCrossCheck: boolean;
+    crossCheckNeighbor: Record<EventSeat, EventSeat>; crossCheckWaitMinutes: number };
   /** Per-seat goal and Pod limits; missing or invalid limits use seat-budget defaults. */
   org?: { budget?: Record<string, { dailyGoals?: number; concurrentPods?: number }> };
-  /** Steward and seat loops are parsed independently. An absent seat remains off. */
-  loops?: { steward?: { mode?: StewardLoopMode; linearTeam?: string; roles?: Record<string, { maxConcurrent?: number }>; budget?: number; tracks?: Record<string, string>; alertAfterFailures?: number; launch?: 'off' | 'shadow' | 'live'; maxParallel?: number; podPool?: string }; seat?: SeatLoopConfig; persona?: PersonaLoopConfig };
+  /** Steward and seat loops are parsed independently. An absent seat defaults to shadow. */
+  loops?: { owners?: Record<string, EventSeat>; defaultOwner?: EventSeat; orchestrator?: OrchestratorLoopConfig; steward?: { mode?: StewardLoopMode; linearTeam?: string; roles?: Record<string, { maxConcurrent?: number }>; budget?: number; tracks?: Record<string, string>; alertAfterFailures?: number; launch?: 'off' | 'shadow' | 'live'; maxParallel?: number; podPool?: string }; seat?: SeatLoopConfig; persona?: PersonaLoopConfig };
   /** 🔐 Pod 의 Grok API 키 과금은 명시 opt-in 만. 생략·잘못된 값은 false.
    *  budgetGate 와 같은 `harness` 객체다 — 중복 선언이면 뒤 타입이 앞을 지운다. */
-  harness?: { pod?: { grokApiKeyOptIn: boolean }; budgetGate?: HarnessBudgetGateConfig; difficultyPlacement?: boolean; defaultRepo?: string; substrate?: 'local' | 'pod'; podPool?: string; worktreeAddTimeoutSec?: number };
+  harness?: { revertGuard?: { depth: number }; pod?: { grokApiKeyOptIn: boolean }; budgetGate?: HarnessBudgetGateConfig; exposeGate?: 'warn' | 'strict'; difficultyPlacement?: boolean; defaultRepo?: string; substrate?: 'local' | 'pod'; podPool?: string; worktreeAddTimeoutSec?: number; queue?: { seatCap?: Partial<Record<'OP' | 'TC' | 'MK' | 'UX', number>> } };
   /** ☸️ Pod 실행 칸 — `pool` = 기존 기본 풀(`컨텍스트[@ssh호스트][:상한][#k3d-레지스트리:포트]` 쉼표 · 앞이 우선). harness 실행은 인자·ELANOUS_POD_POOL·harness.podPool 다음으로 읽는다. */
-  pod?: { pool?: string; /** 호스트 Git 미러 디렉터리 — Pod Job 에 읽기 전용으로 마운트한다. */ hostMirror?: string; /** 원격 그라운딩 엔드포인트(호스트 nexus · tailnet 주소) — Pod 가 토큰으로 «질의→인용»만 묻는다(P13). */ groundingUrl?: string; /** 읽기 전용 Pod lease 권장에 쓰는 계정별 동시 수. */ lease?: { perAccount?: number } };
+  pod?: { pool?: string; /** 호스트 Git 미러 디렉터리 — Pod Job 에 읽기 전용으로 마운트한다. */ hostMirror?: string; /** 원격 그라운딩 엔드포인트(호스트 nexus · tailnet 주소) — Pod 가 토큰으로 «질의→인용»만 묻는다(P13). */ groundingUrl?: string; /** 읽기 전용 Pod lease 권장에 쓰는 계정별 동시 수. */ lease?: { perAccount?: number }; /** 실측 권고를 Pod 발사 기본값으로 쓸지 (기본 off). */ memory?: { adviseDefaults?: boolean } };
   skillRouter: SkillRouterConfig;
   llm: LLMConfig;
   skills: SkillsConfig;
@@ -3860,8 +3929,9 @@ function defaultConfig(): UserConfig {
   return {
     cli: { helpRole: 'owner' },
     coo: { linearProject: '외부 행정·큰 일 (COO)' },
-    decisions: { linearProjection: { enabled: false } },
-    loops: { steward: { mode: 'shadow' }, seat: { mode: 'off', questions: 'shadow', seats: ['MK'], podPool: 'pool-node-b@node-b:8' }, persona: { enabled: false } },
+    decisions: { linearProjection: { enabled: false }, requireCrossCheck: false,
+      crossCheckNeighbor: { OP: 'TC', TC: 'OP', MK: 'OP', UX: 'OP' }, crossCheckWaitMinutes: 120 },
+    loops: { owners: {}, defaultOwner: 'OP', orchestrator: parseOrchestratorLoopConfig(undefined), steward: { mode: 'shadow' }, seat: { mode: 'shadow', questions: 'shadow', seats: ['MK'], podPool: 'pool-node-b@node-b:8' }, persona: { enabled: false } },
     skillRouter: { ...SR_DEFAULTS },
     llm: { ...LLM_DEFAULTS },
     skills: skillsDefaults(),
@@ -3930,7 +4000,7 @@ function defaultConfig(): UserConfig {
       nativeStructure: { ...TOOLS_DEFAULTS.nativeStructure },
       selfImplement: { ...TOOLS_DEFAULTS.selfImplement },
     },
-    harness: { budgetGate: { ...DEFAULT_BUDGET_GATE }, difficultyPlacement: false },
+    harness: { revertGuard: { depth: 50 }, budgetGate: { ...DEFAULT_BUDGET_GATE }, exposeGate: 'warn', difficultyPlacement: false },
     grounding: { sources: [] },
     raw: {},
   };
@@ -4341,20 +4411,95 @@ function parseStewardTracks(input: unknown): Record<string, string> | undefined
   return Object.keys(out).length ? out : undefined;
 }
 
+function parseDecisionsConfig(input: unknown): NonNullable<UserConfig['decisions']> {
+  const defaults: Record<EventSeat, EventSeat> = { OP: 'TC', TC: 'OP', MK: 'OP', UX: 'OP' };
+  const raw = input && typeof input === 'object' && !Array.isArray(input) ? input as Record<string, unknown> : {};
+  const neighbors = { ...defaults };
+  if (raw.crossCheckNeighbor !== undefined) {
+    if (!raw.crossCheckNeighbor || typeof raw.crossCheckNeighbor !== 'object' || Array.isArray(raw.crossCheckNeighbor)) {
+      warnUserConfigDrop('decisions.crossCheckNeighbor', '자리별 이웃 자리 객체가 아닙니다 — 기본값으로 진행합니다.');
+    } else {
+      const values = raw.crossCheckNeighbor as Record<string, unknown>;
+      for (const seat of Object.keys(defaults) as EventSeat[]) {
+        if (values[seat] === undefined) continue;
+        const to = values[seat];
+        if ((to === 'OP' || to === 'TC' || to === 'MK' || to === 'UX') && to !== seat) neighbors[seat] = to;
+        else warnUserConfigDrop(`decisions.crossCheckNeighbor.${seat}`, '다른 자리가 아닙니다 — 기본값으로 진행합니다.');
+      }
+      for (const seat of Object.keys(values)) {
+        if (!(seat in defaults)) warnUserConfigDrop(`decisions.crossCheckNeighbor.${seat}`, '알 수 없는 자리입니다 — 기본값으로 진행합니다.');
+      }
+    }
+  }
+  const wait = raw.crossCheckWaitMinutes;
+  if (wait !== undefined && !(typeof wait === 'number' && Number.isSafeInteger(wait) && wait > 0)) {
+    warnUserConfigDrop('decisions.crossCheckWaitMinutes', '양의 정수가 아닙니다 — 기본값 120으로 진행합니다.');
+  }
+  return { linearProjection: { enabled: (raw.linearProjection as { enabled?: unknown } | undefined)?.enabled === true },
+    requireCrossCheck: raw.requireCrossCheck === true, crossCheckNeighbor: neighbors,
+    crossCheckWaitMinutes: typeof wait === 'number' && Number.isSafeInteger(wait) && wait > 0 ? wait : 120 };
+}
+
+function parseLoopOwners(input: unknown): { owners: Record<string, EventSeat>; defaultOwner: EventSeat } {
+  const raw = input && typeof input === 'object' && !Array.isArray(input) ? input as Record<string, unknown> : {};
+  const valid = (value: unknown): value is EventSeat => value === 'OP' || value === 'TC' || value === 'MK' || value === 'UX';
+  const defaultOwner = valid(raw.defaultOwner) ? raw.defaultOwner : 'OP';
+  if (raw.defaultOwner !== undefined && !valid(raw.defaultOwner)) warnUserConfigDrop('loops.defaultOwner', '잘못된 자리 — 기본 OP 로 진행');
+  // Prototype-less: a loop titled «__proto__» (or «constructor») must keep its owner (review round 3).
+  const owners: Record<string, EventSeat> = Object.create(null) as Record<string, EventSeat>;
+  if (raw.owners !== undefined) {
+    if (!raw.owners || typeof raw.owners !== 'object' || Array.isArray(raw.owners)) {
+      warnUserConfigDrop('loops.owners', '객체가 아니다 — 기본 자리로 진행');
+    } else {
+      for (const [key, value] of Object.entries(raw.owners)) {
+        if (key.trim() && valid(value)) owners[key] = value;
+        else warnUserConfigDrop(`loops.owners.${key}`, `잘못된 자리 — 기본 ${defaultOwner} 로 진행`);
+      }
+    }
+  }
+  return { owners, defaultOwner };
+}
+
 function parseSeatLoopsConfig(input: unknown): SeatLoopConfig {
-  const defaults: SeatLoopConfig = { mode: 'off', questions: 'shadow', seats: ['MK'], podPool: 'pool-node-b@node-b:8' };
+  const defaults: SeatLoopConfig = { mode: 'shadow', questions: 'shadow', seats: ['MK'], podPool: 'pool-node-b@node-b:8' };
   if (!input || typeof input !== 'object' || Array.isArray(input)) return defaults;
   const seat = (input as Record<string, unknown>).seat;
   if (!seat || typeof seat !== 'object' || Array.isArray(seat)) return defaults;
   const values = seat as Record<string, unknown>;
   const mode = values.mode;
   return {
-    mode: mode === 'on' || mode === 'shadow' ? mode : 'off',
+    mode: mode === 'on' || mode === 'shadow' || mode === 'live-safe' || mode === 'off' ? mode : 'shadow',
     questions: values.questions === 'on' ? 'on' : 'shadow',
     seats: Array.isArray(values.seats) && values.seats.length > 0
       && values.seats.every((value) => typeof value === 'string' && /^(?:MK|OP|TC|UX)$/.test(value))
       ? [...new Set(values.seats as string[])] : ['MK'],
     podPool: typeof values.podPool === 'string' && values.podPool.trim() ? values.podPool.trim() : defaults.podPool,
+    ...(() => {
+      const raw = values.neighbors;
+      if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+      const neighbors: NonNullable<SeatLoopConfig['neighbors']> = {};
+      for (const [owner, entries] of Object.entries(raw)) {
+        if (!/^(?:OP|TC|MK|UX)$/.test(owner) || !Array.isArray(entries)) continue;
+        const valid = entries.filter((entry): entry is import('./loops/neighbors.js').Neighbor => {
+          if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return false;
+          const value = entry as Record<string, unknown>;
+          const heartbeat = value.heartbeat && typeof value.heartbeat === 'object' && !Array.isArray(value.heartbeat)
+            ? value.heartbeat as Record<string, unknown> : undefined;
+          const onAbsent = value.onAbsent && typeof value.onAbsent === 'object' && !Array.isArray(value.onAbsent)
+            ? value.onAbsent as Record<string, unknown> : undefined;
+          return typeof value.id === 'string' && /^(?:op|tc|mk|ux)-seat$/.test(value.id)
+            && value.id !== `${owner.toLowerCase()}-seat`
+            && Array.isArray(value.exchange) && value.exchange.length > 0
+            && value.exchange.every((item) => typeof item === 'string' && ['status', 'request', 'decision', 'blocked'].includes(item))
+            && !!heartbeat && Number.isSafeInteger(heartbeat.everyMinutes) && (heartbeat.everyMinutes as number) > 0
+            && Number.isSafeInteger(heartbeat.missedTicks) && (heartbeat.missedTicks as number) > 0
+            && !!onAbsent && typeof onAbsent.action === 'string' && ['delegate', 'defer', 'escalate'].includes(onAbsent.action)
+            && typeof onAbsent.delegateTo === 'string' && onAbsent.delegateTo.trim().length > 0;
+        });
+        neighbors[owner as keyof typeof neighbors] = valid;
+      }
+      return { neighbors };
+    })(),
     ...(typeof values.reportPr === 'number' && Number.isSafeInteger(values.reportPr) && values.reportPr > 0
       ? { reportPr: values.reportPr } : {}),
     ...(() => {
@@ -4388,7 +4533,7 @@ function parseStewardLoopsConfig(input: unknown): UserConfig['loops'] {
     }
   }
   return { steward: {
-    mode: s.mode === 'off' || s.mode === 'shadow' || s.mode === 'live' ? s.mode :
+    mode: s.mode === 'off' || s.mode === 'shadow' || s.mode === 'live' || s.mode === 'rescue' ? s.mode :
       s.launch === 'off' || s.launch === 'shadow' || s.launch === 'live' ? s.launch : 'shadow',
     // A valid legacy launch setting remains effective when mode is absent; explicit mode always wins.
     ...(s.launch === 'off' || s.launch === 'shadow' || s.launch === 'live' ? { launch: s.launch } : {}),
@@ -4407,6 +4552,25 @@ export function parseCliHelpRole(raw: unknown): NonNullable<UserConfig['cli']>['
   return cli.helpRole === 'general' || cli.helpRole === 'contributor' ? cli.helpRole : 'owner';
 }
 
+const HQ_FENCE_ROLES: readonly HqFenceRole[] = ['telegram-poller', 'cron', 'seat-loop', 'release-run', 'conatus', 'git-push'];
+/** `hq` block (HQ-HB · HQ-FENCE): keep only well-typed fields — absent/invalid fields fall back to the hq module defaults. */
+export function parseHqConfig(raw: unknown): HqConfig | undefined {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return undefined;
+  const r = raw as Record<string, unknown>;
+  const str = (v: unknown) => typeof v === 'string' && v.trim() ? v.trim() : undefined;
+  const out: HqConfig = {};
+  for (const key of ['arbiter', 'hostName', 'standby', 'tailnetDomain', 'tailscaleBin', 'seenGenerationFile'] as const) {
+    const v = str(r[key]); if (v) out[key] = v;
+  }
+  if (typeof r.ttlSeconds === 'number' && Number.isFinite(r.ttlSeconds) && r.ttlSeconds > 0) out.ttlSeconds = r.ttlSeconds;
+  if (typeof r.probeTimeoutSeconds === 'number' && Number.isFinite(r.probeTimeoutSeconds) && r.probeTimeoutSeconds > 0) out.probeTimeoutSeconds = r.probeTimeoutSeconds;
+  if (Array.isArray(r.failOpenRoles)) out.failOpenRoles = r.failOpenRoles.filter((v): v is HqFenceRole => HQ_FENCE_ROLES.includes(v as HqFenceRole));
+  if (r.healthUrls && typeof r.healthUrls === 'object' && !Array.isArray(r.healthUrls)) {
+    out.healthUrls = Object.fromEntries(Object.entries(r.healthUrls as Record<string, unknown>).filter((e): e is [string, string] => typeof e[1] === 'string'));
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+
 export function buildUserConfig(path: string = defaultPath()): UserConfig {
   if (!existsSync(path)) return defaultConfigWithRuntimeProvider();
   let raw: unknown;
@@ -4526,12 +4690,17 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
     };
   }
 
+  const nexus = rawObj.nexus && typeof rawObj.nexus === 'object' && !Array.isArray(rawObj.nexus)
+    ? rawObj.nexus as Record<string, unknown> : {};
   return {
+    nexus: { demoMode: nexus.demoMode === true },
     ...(Object.keys(seatBudgets).length ? { org: { budget: seatBudgets } } : {}),
     pod: {
       ...(typeof legacyPod.pool === 'string' && legacyPod.pool.trim() ? { pool: legacyPod.pool.trim() } : {}),
       ...(typeof legacyPod.hostMirror === 'string' && legacyPod.hostMirror.trim() ? { hostMirror: legacyPod.hostMirror.trim() } : {}),
       ...(typeof legacyPod.groundingUrl === 'string' ? { groundingUrl: legacyPod.groundingUrl } : {}),
+      memory: { adviseDefaults: Boolean(legacyPod.memory && typeof legacyPod.memory === 'object' && !Array.isArray(legacyPod.memory)
+        && (legacyPod.memory as Record<string, unknown>).adviseDefaults === true) },
       lease: { perAccount: (() => {
         const lease = legacyPod.lease && typeof legacyPod.lease === 'object' && !Array.isArray(legacyPod.lease)
           ? (legacyPod.lease as Record<string, unknown>) : {};
@@ -4540,8 +4709,20 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
       })() },
     },
     harness: {
+      revertGuard: { depth: (() => {
+        const value = harness.revertGuard && typeof harness.revertGuard === 'object' && !Array.isArray(harness.revertGuard)
+          ? (harness.revertGuard as Record<string, unknown>).depth : undefined;
+        return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : 50;
+      })() },
       pod: { grokApiKeyOptIn: harnessPod.grokApiKeyOptIn === true },
       difficultyPlacement: harness.difficultyPlacement === true,
+      exposeGate: harness.exposeGate === 'strict' ? 'strict' : 'warn',
+      queue: { seatCap: Object.fromEntries(Object.entries(
+        harness.queue && typeof harness.queue === 'object' && !Array.isArray(harness.queue)
+          && (harness.queue as Record<string, unknown>).seatCap && typeof (harness.queue as Record<string, unknown>).seatCap === 'object'
+          && !Array.isArray((harness.queue as Record<string, unknown>).seatCap)
+          ? (harness.queue as { seatCap: Record<string, unknown> }).seatCap : {},
+      ).filter(([seat, cap]) => /^(OP|TC|MK|UX)$/.test(seat) && typeof cap === 'number' && Number.isSafeInteger(cap) && cap > 0)) },
       ...(harness.substrate === 'local' || harness.substrate === 'pod' ? { substrate: harness.substrate } : {}),
       ...(typeof harness.podPool === 'string' && harness.podPool.trim() ? { podPool: harness.podPool.trim() } : {}),
       ...(typeof harness.worktreeAddTimeoutSec === 'number' && Number.isSafeInteger(harness.worktreeAddTimeoutSec)
@@ -5186,11 +5367,12 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
       && typeof (rawObj.hitl as Record<string, unknown>).executionDeadlineMinutes === 'number'
       ? { hitl: { executionDeadlineMinutes: (rawObj.hitl as { executionDeadlineMinutes: number }).executionDeadlineMinutes } }
       : {}),
+    ...(parseHqConfig(rawObj.hq) ? { hq: parseHqConfig(rawObj.hq)! } : {}),
     cli: { helpRole: parseCliHelpRole(rawObj.cli) },
     coo: { linearProject: typeof (rawObj.coo as { linearProject?: unknown } | undefined)?.linearProject === 'string' && (rawObj.coo as { linearProject: string }).linearProject.trim()
       ? (rawObj.coo as { linearProject: string }).linearProject.trim() : '외부 행정·큰 일 (COO)' },
-    decisions: { linearProjection: { enabled: ((rawObj.decisions as { linearProjection?: { enabled?: unknown } } | undefined)?.linearProjection?.enabled === true) } },
-    loops: { ...(stewardLoops ?? {}), seat: parseSeatLoopsConfig(rawObj.loops),
+    decisions: parseDecisionsConfig(rawObj.decisions),
+    loops: { ...(stewardLoops ?? {}), ...parseLoopOwners(rawObj.loops), orchestrator: parseOrchestratorLoopConfig((rawObj.loops as { orchestrator?: unknown } | undefined)?.orchestrator), seat: parseSeatLoopsConfig(rawObj.loops),
       persona: { enabled: (rawObj.loops as { persona?: { enabled?: unknown } } | undefined)?.persona?.enabled === true } },
     events: parseEventsConfig(rawObj.events),
     // M1-1: sparse — undefined when the user hasn't set anything, so
@@ -5786,20 +5968,26 @@ export function saveUserConfig(
       ...rawHarness,
       pod: cfg.harness?.pod ?? rawHarness.pod,
       budgetGate: cfg.harness?.budgetGate ?? rawHarness.budgetGate,
+      exposeGate: cfg.harness?.exposeGate ?? rawHarness.exposeGate,
+      revertGuard: cfg.harness?.revertGuard ?? rawHarness.revertGuard,
       difficultyPlacement: cfg.harness?.difficultyPlacement ?? rawHarness.difficultyPlacement,
       defaultRepo: cfg.harness?.defaultRepo ?? rawHarness.defaultRepo,
       substrate: cfg.harness?.substrate,
       podPool: cfg.harness?.podPool,
+      queue: cfg.harness?.queue ?? rawHarness.queue,
     }),
     ...rawRest,
     ...(cfg.loops ? { loops: {
       ...rawLoops,
+      owners: cfg.loops.owners ?? {}, defaultOwner: cfg.loops.defaultOwner ?? 'OP',
       ...(cfg.loops.steward ? { steward: { ...rawSteward, mode: cfg.loops.steward.mode ?? cfg.loops.steward.launch ?? 'shadow' } } : {}),
+      ...(cfg.loops.orchestrator ? { orchestrator: cfg.loops.orchestrator } : {}),
       ...(cfg.loops.seat ? { seat: {
         mode: cfg.loops.seat.mode,
         questions: cfg.loops.seat.questions ?? 'shadow',
         seats: cfg.loops.seat.seats ?? ['MK'],
         podPool: cfg.loops.seat.podPool ?? 'pool-node-b@node-b:8',
+        ...(cfg.loops.seat.neighbors ? { neighbors: cfg.loops.seat.neighbors } : {}),
         ...(cfg.loops.seat.reportPr === undefined ? {} : { reportPr: cfg.loops.seat.reportPr }),
       } } : {}),
     } } : {}),

package/src/version/packed-revision.json

@@ -1 +1 @@
-{"commit":"27045f4612b148543fb0f91b82d37592d1d6c9f2"}
+{"commit":"855920facfd9b702ac0c47f96011b2fd67dc0f30"}

package/src/workflow-runtime/executor.ts

@@ -18,6 +18,7 @@ import {
   isClassifyNode,
   isExtractNode,
   isFilterNode,
+  isKnowledgeNode,
   isHttpRequestNode,
   isIfNode,
   isIterationNode,
@@ -57,6 +58,7 @@ import { executeExtractNode } from './nodes/extract.js';
 import { executeSetNode } from './nodes/set.js';
 import { executeTaskNode } from './nodes/task.js';
 import { executeFilterNode } from './nodes/filter.js';
+import { executeKnowledgeNode } from './nodes/knowledge.js';
 import { executeTemplateNode } from './nodes/template.js';
 import { executeHttpRequestNode } from './nodes/http.js';
 import { executeShowroomNode } from './nodes/showroom.js';
@@ -706,6 +708,7 @@ async function dispatchNode(
   if (isExtractNode(node)) return executeExtractNode(node, ctx, deps);
   if (isSetNode(node)) return executeSetNode(node, ctx, deps);
   if (isFilterNode(node)) return executeFilterNode(node, ctx, deps);
+  if (isKnowledgeNode(node)) return executeKnowledgeNode(node, ctx, deps);
   if (isTemplateNode(node)) return executeTemplateNode(node, ctx, deps);
   if (isHttpRequestNode(node)) return executeHttpRequestNode(node, ctx, deps);
   if (isShowroomNode(node)) return executeShowroomNode(node, ctx, deps);
@@ -748,6 +751,7 @@ function isTriggerVariant(node: DagNode): boolean {
 
 function variantOf(node: DagNode): string {
   if (isPluginKindNode(node)) return node.kind;
+  if (isKnowledgeNode(node)) return 'knowledge';
   const guards: ReadonlyArray<(node: DagNode) => boolean> = [
     isPromptNode, isBashNode, isSkillNode, isCftNode, isApprovalNode, isIfNode,
     isSwitchNode, isIterationNode, isClassifyNode, isExtractNode, isSetNode,