elanous 0.2.13 → 0.2.15

package/src/task-orchestrator/surfaces/self-implement.ts

@@ -49,6 +49,7 @@ export interface SelfImplementDisposition {
   ok?: boolean;
   worktreePath?: string;
   branch?: string;
+  harvestable?: true;
   prUrl?: string;
   prNumber?: number;
   /** Head SHA checked by the Pod before host regate. */
@@ -84,6 +85,7 @@ export interface SelfImplementDisposition {
   reviewVerdict?: 'pass' | 'warn' | 'fail';
   /** 마지막 리뷰의 must-fix 수(`review.mustFix.length`). 같은 조건. */
   reviewMustFixCount?: number;
+  mustFix?: string[];
 }
 
 /**
@@ -265,7 +267,7 @@ export function createSelfImplementAdapter(opts: SelfImplementAdapterOptions) {
           : r.output.length === 0
             ? `${exitMessage} (child produced no output)`
             : r.disposition
-              ? `${exitMessage} (child terminal result contained no error diagnostic)`
+              ? `${exitMessage} (child stage=${r.disposition.stage ?? 'unknown'}; ${r.disposition.detail ?? `mustFix=${JSON.stringify(r.disposition.mustFix ?? 'unknown')}`})`
               : `${exitMessage} (child output did not contain a parseable terminal JSON diagnostic)`;
         return {
           ...exec,
@@ -461,6 +463,7 @@ export function parseSelfImplementJson(stdout: string): SelfImplementDisposition
         ...(typeof o.ok === 'boolean' ? { ok: o.ok } : {}),
         ...(typeof o.worktreePath === 'string' ? { worktreePath: o.worktreePath } : {}),
         ...(typeof o.branch === 'string' ? { branch: o.branch } : {}),
+        ...(o.harvestable === true && typeof o.branch === 'string' && o.branch.trim() ? { harvestable: true } : {}),
         ...(typeof o.prUrl === 'string' ? { prUrl: o.prUrl } : {}),
         ...(typeof o.prNumber === 'number' ? { prNumber: o.prNumber } : {}),
         ...(typeof o.checkedHeadCommit === 'string' ? { checkedHeadCommit: o.checkedHeadCommit } : {}),
@@ -483,6 +486,7 @@ export function parseSelfImplementJson(stdout: string): SelfImplementDisposition
           ? { providerErrors: o.providerErrors as SelfImplementDisposition['providerErrors'] } : {}),
         ...(typeof o.runId === 'string' && o.runId.trim() ? { runId: o.runId, childRunId: o.runId } : {}),
         ...reviewGateFields(o),
+        ...(Array.isArray(o.mustFix) && o.mustFix.every((item) => typeof item === 'string') ? { mustFix: o.mustFix as string[] } : {}),
       };
       reportUnmappedDispositionFields(o, mapped);
       return mapped;

package/src/telegram-commands.ts

@@ -14,6 +14,9 @@
 import type { TgIncoming, TgMessageStreamer } from './telegram.js';
 import type { UserConfig } from './user-config.js';
 import { botCommandsToTelegram } from './bots/command-surface.js';
+import { SLASH_COMMANDS, type SlashCommand } from './chat/index.js';
+import { FEATURE_MATURITY, type Maturity } from './maturity/feature-maturity.js';
+import { buildBotSlashCatalog } from './maturity/bot-slash-catalog.js';
 import {
   appendMessage,
   attachTelegramBinding,
@@ -46,6 +49,7 @@ import { classifyIntake } from './ad-pipeline/intake.js';
 import { createAdPipelineDeps, runAdPipeline } from './ad-pipeline/run.js';
 import { projectCommand } from './telegram-project-command.js';
 import { telegramNowSlash } from './context-bus/context-now-surfaces.js';
+import { telegramLoopsStatus } from './telegram-loops-command.js';
 import { createWishCard } from './intake-plane/wish-card.js';
 import { telegramDecisionOwner } from './decisions/telegram-decision-cards.js';
 import { CardStore } from './task-cards/card-store.js';
@@ -298,8 +302,12 @@ function dropChatSessionReply(ctx: TgIncoming): string {
 /** Build the default command set for a Telegram bot wired via
  *  botFromConfig. Returns the array rather than mutating globals so
  *  tests can construct a variant set with stubbed handlers. */
-export function defaultTelegramCommands(nowDeps?: ContextNowDeps): TgSlashCommand[] {
-  return [
+export function defaultTelegramCommands(
+  nowDeps?: ContextNowDeps,
+  coreCommands: readonly SlashCommand[] = SLASH_COMMANDS,
+  maturity: { tuiSlash: Readonly<Record<string, Maturity>>; telegramCommand: Readonly<Record<string, Maturity>>; discordCommand: Readonly<Record<string, Maturity>> } = FEATURE_MATURITY,
+): TgSlashCommand[] {
+  const handled: TgSlashCommand[] = [
     {
       name: 'help',
       description: 'List available commands',
@@ -316,6 +324,11 @@ export function defaultTelegramCommands(nowDeps?: ContextNowDeps): TgSlashComman
       description: 'Show current release, decisions, seats and context: /now [topic]',
       handler: async (args) => telegramNowSlash(args, nowDeps),
     },
+    {
+      name: 'loops',
+      description: '루프·크론 현황 — 늦음·실패를 먼저 보여줍니다',
+      handler: async (args) => telegramLoopsStatus(args),
+    },
     {
       name: 'status',
       description: 'Show bot identity, current session, provider + model',
@@ -604,7 +617,8 @@ export function defaultTelegramCommands(nowDeps?: ContextNowDeps): TgSlashComman
         if (args.length === 0) return '/wish <소원 한 줄>';
         const store = new CardStore();
         try {
-          const card = createWishCard({ text: args.join(' '), source: 'telegram', ref: `${ctx.chatId}:${ctx.messageId}` }, store);
+          const card = createWishCard({ text: args.join(' '), source: 'telegram', ref: `${ctx.chatId}:${ctx.messageId}`,
+            replyTo: { surface: 'telegram', chatId: String(ctx.chatId), ...(ctx.threadId != null ? { threadId: String(ctx.threadId) } : {}), ...(ctx.botId ? { botId: ctx.botId } : {}) } }, store);
           return `소원 카드로 남겼습니다 — ${card.title} (카드 ${card.cardId.slice(0, 8)})`;
         } finally {
           store.close();
@@ -951,6 +965,16 @@ export function defaultTelegramCommands(nowDeps?: ContextNowDeps): TgSlashComman
     },
     ...botCommandsToTelegram(),
   ];
+  const catalog = buildBotSlashCatalog({
+    surface: 'telegram', coreCommands, maturity,
+    handledCommands: handled,
+  });
+  const handlers = new Map(handled.map((command) => [command.name, command]));
+  return catalog.commands.map((entry) => handlers.get(entry.name) ?? {
+    name: entry.name,
+    description: entry.description,
+    handler: async () => catalog.unsupportedReply(entry.name)!,
+  });
 }
 
 /** Telegram-side adapter over the messenger-agnostic ACP turn runner.

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.ts

@@ -66,7 +66,9 @@ import { detectUrlRoute, type UrlRouteDecision } from './skills/url-router.js';
 import { observeDevRequestRouteFailSoft } from './skills/dev-request-router.js';
 import { runUrlRoute } from './skills/url-route-exec.js';
 import { recordRoutedLinkAbsorbed } from './intake-plane/link-ledger.js';
-import { classifyFrontInput } from './intake-plane/front-classifier.js';
+import { classifyFrontInput, telegramAbsorbUrls } from './intake-plane/front-classifier.js';
+import { scheduleIntakeEvent } from './intake-plane/route.js';
+import { dispatchTaskCreate } from './task-orchestrator/runtimes/create.js';
 import { handleTelegramSeatWork, type TelegramSeatWorkDeps } from './intake-plane/telegram-seat-work.js';
 import { deliverSeatAnswers } from './seat-dispatch/seat-ask.js';
 import { effectiveInstanceRoot } from './instance/resolve.js';
@@ -1919,11 +1921,30 @@ export class TelegramBot {
         ? getActiveDelegation(delegationChatKey(this.botId, ctx.chatId, ctx.threadId))
         : null;
       if (!activeDeleg) {
-        try {
-          classifyFrontInput({ text: ctx.text, surface: 'telegram' }, { urlRouting: getUserConfig().skills.urlRouting });
-        } catch { /* observation must not interrupt URL routing */ }
         const urlDec = detectUrlRoute(ctx.text, getUserConfig().skills.urlRouting);
         if (urlDec) {
+          try {
+            const frontInput = { text: ctx.text, surface: 'telegram' as const };
+            const decision = classifyFrontInput(frontInput, { urlRouting: getUserConfig().skills.urlRouting });
+            const absorbUrls = telegramAbsorbUrls(frontInput, decision);
+            for (const url of absorbUrls) {
+              const result = await scheduleIntakeEvent(effectiveInstanceRoot(), url, {
+                eventMax: getUserConfig().intake.eventMax,
+                post: async ({ url: link }) => {
+                  const posted = await dispatchTaskCreate({
+                    title: `흡수: ${link}`.slice(0, 80),
+                    surface: { kind: 'llm-direct', prompt: `이 링크를 흡수하고 노트로 저장하세요: ${link}` },
+                  });
+                  if (!posted.taskId) throw new Error('intake event task not created');
+                  return { taskId: posted.taskId };
+                },
+              });
+              if (result.reply) await this.sendMessage(ctx.chatId, result.reply, { threadId: ctx.threadId, markdown: true });
+            }
+            if (absorbUrls.length) return;
+          } catch (error) {
+            debug.log('intake.event', 'failed', { reason: error instanceof Error ? error.name : 'unknown' });
+          }
           const handled = await this.runUrlRouteReply(ctx, urlDec);
           if (handled) return;
         }

package/src/user-config.ts

@@ -3097,6 +3097,8 @@ export interface IntakeSurfaceConfig {
 }
 
 export interface IntakeConfig {
+  /** Maximum immediately scheduled Telegram absorption links per KST day. */
+  eventMax?: number;
   telegram: IntakeSurfaceConfig;
   discord: IntakeSurfaceConfig;
   approvals?: { repo?: string };
@@ -3477,13 +3479,20 @@ export function resolveRoleModel(role: ModelRole, config: UserConfig = getUserCo
 
 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';
+  idleRequest?: 'off' | 'shadow' | 'live';
+  /** FINISH-RATE — the queue tick reads finish metrics before launching; shadow logs the hold only, on holds (default shadow). */
+  finishGate?: 'off' | 'shadow' | 'on';
 }
 
 export const ORCHESTRATOR_DEFAULTS: OrchestratorLoopConfig = {
-  seatTrees: {}, seatCaps: { TC: 8, UX: 6, MK: 6, OP: 4 }, trafficMode: 'shadow',
+  mode: 'shadow', seatTrees: {}, seatCaps: { TC: 8, UX: 6, MK: 6, OP: 4 }, trafficMode: 'shadow', idleRequest: 'shadow', finishGate: 'shadow',
 };
 
 export function parseOrchestratorLoopConfig(raw: unknown): OrchestratorLoopConfig {
@@ -3492,25 +3501,36 @@ export function parseOrchestratorLoopConfig(raw: unknown): OrchestratorLoopConfi
     ? 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;
   }
-  return { seatTrees, seatCaps, trafficMode: value.trafficMode === 'live' ? 'live' : 'shadow' };
+  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',
+    idleRequest: value.idleRequest === 'off' || value.idleRequest === 'live' ? value.idleRequest : 'shadow',
+    finishGate: value.finishGate === 'off' || value.finishGate === 'on' ? value.finishGate : 'shadow' };
 }
 
 export type StewardLoopMode = 'off' | 'shadow' | 'live' | 'rescue';
 
-export type SeatLoopMode = 'off' | 'shadow' | 'on';
+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[];
@@ -3553,6 +3573,8 @@ export interface HqConfig {
   standby?: string;
   /** Lease TTL in seconds (default 1500 = 25 min). */
   ttlSeconds?: number;
+  /** Arbiter silence threshold (default 3); applying promotion requires explicit opt-in. */
+  autoPromote?: { enabled?: boolean; streak?: 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). */
@@ -3575,19 +3597,22 @@ export interface UserConfig {
   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 }; requireCrossCheck: 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?: { 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 };
+  /** 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; queue?: { seatCap?: Partial<Record<'OP' | 'TC' | 'MK' | 'UX', number>> } };
+  harness?: { revertGuard?: { depth: number }; pod?: { grokApiKeyOptIn: boolean }; budgetGate?: HarnessBudgetGateConfig; exposeGate?: 'warn' | 'strict'; difficultyPlacement?: boolean; defaultRepo?: string; /** Optional GitHub repository name (owner/repo), distinct from the local defaultRepo path. */ repo?: string; substrate?: 'local' | 'pod'; podPool?: string; worktreeAddTimeoutSec?: number; queue?: { seatCap?: Partial<Record<'OP' | 'TC' | 'MK' | 'UX', number>> }; /** `harness say` 문장을 Pod 안에서 저작부터 돌릴지. 생략·false = 끔(호스트가 저작). */ authorOnPod?: boolean };
   /** ☸️ 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 발사 기본값으로 쓸지 (기본 off). */ memory?: { adviseDefaults?: boolean } };
+  pod?: { pool?: string; /** 호스트 Git 미러 디렉터리 — Pod Job 에 읽기 전용으로 마운트한다. */ hostMirror?: string; /** 원격 그라운딩 엔드포인트(호스트 nexus · tailnet 주소) — Pod 가 토큰으로 «질의→인용»만 묻는다(P13). */ groundingUrl?: string; /** 읽기 전용 Pod lease 권장에 쓰는 계정별 동시 수. */ lease?: { perAccount?: number }; /** 실측 권고를 Pod 발사 기본값으로 쓸지 (기본 off). */ memory?: { adviseDefaults?: boolean }; /** 명령 Job 자식 로그(child.log) 상한 바이트. 양의 정수만. 넘으면 끝부분 우선. */ childLogMaxBytes?: number };
   skillRouter: SkillRouterConfig;
   llm: LLMConfig;
   skills: SkillsConfig;
@@ -3913,8 +3938,9 @@ function defaultConfig(): UserConfig {
   return {
     cli: { helpRole: 'owner' },
     coo: { linearProject: '외부 행정·큰 일 (COO)' },
-    decisions: { linearProjection: { enabled: false }, requireCrossCheck: false },
-    loops: { orchestrator: parseOrchestratorLoopConfig(undefined), 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(),
@@ -3945,7 +3971,7 @@ function defaultConfig(): UserConfig {
       },
     },
     voice: { stt: {}, tts: {}, vad: {}, chat: {}, discord: {}, telegram: {}, pwa: {} },
-    intake: { telegram: {}, discord: {} },
+    intake: { eventMax: 10, telegram: {}, discord: {} },
     dashboard: {
       promptBank: { ...DASHBOARD_PROMPT_BANK_DEFAULTS },
       foldMode: 'task-unit',
@@ -3983,7 +4009,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: {},
   };
@@ -4394,20 +4420,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 } : {}),
     ...(() => {
@@ -4472,6 +4573,13 @@ export function parseHqConfig(raw: unknown): HqConfig | undefined {
   }
   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 (r.autoPromote && typeof r.autoPromote === 'object' && !Array.isArray(r.autoPromote)) {
+    const auto = r.autoPromote as Record<string, unknown>;
+    const setting: NonNullable<HqConfig['autoPromote']> = {};
+    if (typeof auto.enabled === 'boolean') setting.enabled = auto.enabled;
+    if (typeof auto.streak === 'number' && Number.isSafeInteger(auto.streak) && auto.streak > 0) setting.streak = auto.streak;
+    if (Object.keys(setting).length) out.autoPromote = setting;
+  }
   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'));
@@ -4598,11 +4706,15 @@ 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.childLogMaxBytes === 'number' && Number.isSafeInteger(legacyPod.childLogMaxBytes) && legacyPod.childLogMaxBytes > 0 ? { childLogMaxBytes: legacyPod.childLogMaxBytes } : {}),
       ...(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) },
@@ -4614,8 +4726,14 @@ 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'
@@ -4629,6 +4747,9 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
         ? { worktreeAddTimeoutSec: harness.worktreeAddTimeoutSec } : {}),
       ...(typeof harness.defaultRepo === 'string' && isAbsolute(harness.defaultRepo)
         ? { defaultRepo: harness.defaultRepo } : {}),
+      ...(typeof harness.repo === 'string' && harness.repo.trim()
+        ? { repo: harness.repo.trim() } : {}),
+      ...(harness.authorOnPod === true ? { authorOnPod: true } : {}),
       budgetGate: parseHarnessBudgetGate(
         rawObj.harness && typeof rawObj.harness === 'object' && !Array.isArray(rawObj.harness)
           ? (rawObj.harness as Record<string, unknown>).budgetGate
@@ -5165,6 +5286,7 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
       },
     },
     intake: {
+      eventMax: typeof intake.eventMax === 'number' && Number.isSafeInteger(intake.eventMax) && intake.eventMax >= 0 ? intake.eventMax : 10,
       telegram: {
         ...(normalizeIntakeAmbientCaptureMode(intakeTelegram.ambientCapture) !== undefined
           ? { ambientCapture: normalizeIntakeAmbientCaptureMode(intakeTelegram.ambientCapture)! }
@@ -5270,9 +5392,8 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
     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) },
-      requireCrossCheck: (rawObj.decisions as { requireCrossCheck?: unknown } | undefined)?.requireCrossCheck === true },
-    loops: { ...(stewardLoops ?? {}), orchestrator: parseOrchestratorLoopConfig((rawObj.loops as { orchestrator?: unknown } | undefined)?.orchestrator), 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
@@ -5868,15 +5989,20 @@ 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,
+      repo: cfg.harness?.repo,
       substrate: cfg.harness?.substrate,
       podPool: cfg.harness?.podPool,
+      authorOnPod: cfg.harness?.authorOnPod === true ? true : undefined,
       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: {
@@ -5884,6 +6010,7 @@ export function saveUserConfig(
         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 }),
       } } : {}),
     } } : {}),
@@ -6104,6 +6231,7 @@ export function saveUserConfig(
         }),
       }),
     }),
+    intake: { ...(rawRest.intake && typeof rawRest.intake === 'object' ? rawRest.intake as Record<string, unknown> : {}), ...cfg.intake },
     dashboard: stripUndef({
       views: cfg.dashboard.views,
       theme: cfg.dashboard.theme,

package/src/version/packed-revision.json

@@ -1 +1 @@
-{"commit":"5116219907580581e7bb40b93018d155deafa5c2"}
+{"commit":"f89d24931e428797960330ae109e8919ee784a15"}

package/src/workflow-runtime/nodes/bash.ts

@@ -8,6 +8,14 @@
 import type { BashNode, NodeExecContext, NodeOutput, WorkflowDeps } from '../types.js';
 import { interpolate } from '../variables.js';
 
+/** Keep the start of stderr and its real error line. Bun prints the source frame first. */
+export function formatBashStderr(stderr: string): string {
+  const head = 200;
+  const tail = 800;
+  if (stderr.length <= head + tail) return stderr;
+  return `${stderr.slice(0, head)}…${stderr.slice(-tail)}`;
+}
+
 export async function executeBashNode(
   node: BashNode,
   ctx: NodeExecContext,
@@ -30,7 +38,7 @@ export async function executeBashNode(
       return {
         ok: false,
         output: r.stdout, // surface partial output for $node.output access
-        error: `bash exit ${r.exitCode}${r.stderr ? `: ${r.stderr.slice(0, 500)}` : ''}`,
+        error: `bash exit ${r.exitCode}${r.stderr ? `: ${formatBashStderr(r.stderr)}` : ''}`,
         durationMs: Date.now() - startedAt,
       };
     }