elanous 0.2.22 → 0.2.23

package/src/cli/skills-cli.ts

@@ -75,15 +75,24 @@ export function registerConnectCommand(program: Command): void {
 export function registerSkillsCommands(program: Command): void {
   const skills = program.command('skills').description('Check, install and repair skills');
   skills.command('install <pack>')
-    .description('Install a gift skill pack from a code')
+    .description('Install a gift skill pack from a code or a signed knowledge pack from a configured market')
     .option('--code <code>', 'Gift code')
     .option('--email <address>', 'Email for gift delivery')
     .option('--agree', 'Agree to email collection and retention')
     .option('--endpoint <url>', 'Gift API origin (overrides skills.giftEndpoint)')
+    .option('--market <name>', 'Install a signed knowledge pack from a configured market instead of redeeming a gift')
+    .option('--enterprise <id>', 'Authorized enterprise for an internal knowledge market')
     .option('--json', 'Print the install result as JSON')
-    .action(async (pack: string, opts: { code?: string; email?: string; agree?: boolean; endpoint?: string; json?: boolean }) => {
+    .action(async (pack: string, opts: { code?: string; email?: string; agree?: boolean; endpoint?: string; market?: string; enterprise?: string; json?: boolean }) => {
       const { getUserConfig } = await import('../user-config.js');
-      const { installGiftPack } = await import('../skills/gift-install.js');
+      const { installGiftPack, installMarketKnowledgePack } = await import('../skills/gift-install.js');
+      if (opts.market) {
+        const result = await installMarketKnowledgePack({ pack, market: opts.market, enterpriseId: opts.enterprise });
+        if (opts.json) console.log(JSON.stringify(result));
+        else console.log(result.ok ? `설치한 지식 팩: ${result.packId}` : `지식 팩 설치 실패: ${result.reason}`);
+        if (!result.ok) process.exitCode = 1;
+        return;
+      }
       const result = await installGiftPack({ pack, code: opts.code, email: opts.email, agree: opts.agree,
         endpoint: opts.endpoint ?? getUserConfig().skills.giftEndpoint });
       if (opts.json) console.log(JSON.stringify(result));

package/src/cli/tasks-cli.ts

@@ -9,8 +9,9 @@ import { readNexusRuntime } from '../nexus/runtime.js';
 import { checklistDevVersion } from '../release-loop/checklist.js';
 import { cardsBoard, countBoardTasks, INTERNAL_PACK_PROJECT, mergeBoards, releasePackBoard, type BoardNode } from '../task-agent/board.js';
 import type { Task } from '../task-orchestrator/types.js';
-import { cardPrNumber, COMPLETION_KINDS, handTask, nextMoveFor, readTaskAgentState, readTaskCard, taskAgentStatePath as taskStatePathDefault, shellQuote, TASK_CARD_PREFIX, TASK_SEATS, type CompletionKind, type TaskCard, type TaskLaunchContext, type TaskLaunchReceipt, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
+import { cardPrNumber, COMPLETION_KINDS, handTask, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, nextMoveFor, resolveHandText, readTaskAgentState, readTaskCard, taskAgentStatePath as taskStatePathDefault, shellQuote, TA_LAND_ENV, TASK_CARD_PREFIX, TASK_SEATS, type CompletionKind, type TaskCard, type TaskLaunchContext, type TaskLaunchReceipt, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
 import { readCardSalvageBranch, refreshCardRunBinding, type CardRunEvidenceDeps } from '../task-agent/card-evidence.js';
+import { captureReviewResults } from '../task-agent/review-result-capture.js';
 import { advanceMission, handMission, MissionAdvanceError, openMissionIds, recordPieceRef, type AdvanceMissionResult, type MissionDecompose, type PieceEvidenceReader } from '../task-agent/mission.js';
 import { formatTaskAgentCover, measureTaskAgentCover, type CoverRow, type TaskAgentCoverInput } from '../task-agent/cover.js';
 import { LogStore, STORE_SAFETY_MAX, type LogQuery, type LogStoreRow } from '../mss/logging/log-store.js';
@@ -25,6 +26,8 @@ export interface TasksCliDeps {
   output?: (line: string) => void;
   /** `task hand --live` 의 발사기(시험 주입). 기본은 운영 config-dir 로 `harness say` 를 떼어 띄운다. */
   taskLauncher?: TaskLauncher;
+  /** TA-REVIEW-RESULT-CAPTURE — `tasks show` 의 리뷰 결과 회수 시각(시험 주입 · 기본 지금). */
+  reviewResultNow?: () => Date;
   /** 과제 카드 상태 파일(시험 주입). 기본 = `effectiveInstanceRoot()/task-agent-actions.json`. */
   taskStatePath?: string;
   /** logs.db 싱크 등록(시험 주입). 기본 = `registerStandaloneLogSink`. `hand`·`show` 가 부른다. */
@@ -44,6 +47,10 @@ export interface TasksCliDeps {
   /** `tasks cover` logs 조회 seam. 기본은 등록된 모든 우주(운영 ⊕ test)의 logs.db 를 read-only 로 연다 —
    *  pr land 는 작업 트리마다 파생 test 우주에 기록되므로 현재 우주만 읽으면 분모가 늘 0 이다. */
   coverLogs?: (query: LogQuery) => LogStoreRow[] | CoverLogRead;
+  /** TA-REJUDGE-ON-HEAD — `tasks rejudge` 의 판단 의존(시험 주입 · 기본 = 설정 liveMoves ⊕ 실물 gh·리뷰·재게이트·land). */
+  rejudge?: Partial<import('../task-agent/rejudge-on-head.js').RejudgeDeps>;
+  /** TA-REJUDGE-ON-HEAD — `tasks regate-run` 의 재게이트(시험 주입 · 기본 `runHostRegate`). */
+  hostRegate?: (input: import('../self-implement/host-regate.js').HostRegateInput) => Promise<import('../self-implement/host-regate.js').HostRegateResult>;
 }
 
 /** `<조각id>=<값>` 반복 인자. */
@@ -108,7 +115,7 @@ export interface DefaultTaskLauncherDeps {
   /** 이미 stop 이 있나(시험 주입). 기본 = 이 우주 런 원장 ⊕ 이 프로세스 기록. */
   hasStop?: (runId: string) => boolean;
   /** HARNESS-PARENT-ON-MSB1 — 원격 부모 대상(시험 주입). undefined = 설정·env 에서 푼다 · null = 끔. */
-  parentHost?: import('../task-agent/parent-host.js').ParentHostConfig | null;
+  parentHost?: import('../task-agent/parent-host.js').ParentHostConfig | readonly import('../task-agent/parent-host.js').ParentHostConfig[] | null;
   /** 원격 ssh(시험 주입). */
   ssh?: import('../task-agent/parent-host.js').SshRunner;
   /** HQ 발사 동결(holdLaunches) 여부(시험 주입). */
@@ -125,21 +132,23 @@ export interface DefaultTaskLauncherDeps {
  */
 async function tryRemoteParent(args: string[], cwd: string | undefined, context: TaskLaunchContext, deps: DefaultTaskLauncherDeps): Promise<TaskLaunchReceipt | null> {
   const parentHostModule = await import('../task-agent/parent-host.js');
-  let target = deps.parentHost;
-  if (target === undefined) {
+  let configured: import('../task-agent/parent-host.js').ParentHostSetting | null | undefined = deps.parentHost;
+  if (configured === undefined) {
     const { getUserConfig } = await import('../user-config.js');
-    let configured: Parameters<typeof parentHostModule.resolveParentHost>[0];
     try { configured = getUserConfig().taskAgent?.parentHost; } catch { configured = undefined; }
-    target = parentHostModule.resolveParentHost(configured);
   }
-  if (!target) return null;
+  const multi = Array.isArray(configured);
+  const targets = configured === null ? [] : parentHostModule.resolveParentHosts(configured, deps.parentHost === undefined ? process.env : { ...process.env, ELANOUS_TA_PARENT_HOST: undefined });
+  if (!targets.length) return null;
   const notice = deps.notice ?? ((line: string) => { try { process.stderr.write(`${line}\n`); } catch { /* ignore */ } });
-  const fallback = (gaps: string[], facts: Record<string, string> = {}): null => {
-    try { debug.log('task-agent', 'parent-host-fallback', { host: target!.host, runId: context.runId, gaps, facts }); } catch { /* fail-soft */ }
-    notice(`[parent-host] ${target!.host} 로 못 띄움 — 로컬 발사로 간다: ${gaps.join(' · ')}`);
-    return null;
+  const failed = (target: typeof targets[number], gaps: string[], facts: Record<string, string> = {}): void => {
+    try { debug.log('task-agent', 'parent-host-fallback', { host: target.host, runId: context.runId, gaps, facts }); } catch { /* fail-soft */ }
+    notice(`[parent-host] ${target.host} 로 못 띄움 — ${multi ? '다음 호스트 또는 로컬 발사로 간다' : '로컬 발사로 간다'}: ${gaps.join(' · ')}`);
   };
-  if (cwd) return fallback(['project-target-is-local']);
+  if (cwd || context.env[TA_LAND_ENV] === '1') {
+    failed(targets[0]!, [cwd ? 'project-target-is-local' : 'ta-land-needs-local-parent']);
+    return null;
+  }
   let launchHoldActive = false;
   try {
     if (deps.launchHoldActive) launchHoldActive = deps.launchHoldActive();
@@ -149,18 +158,28 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
       launchHoldActive = readLandingFreeze(prodInstanceRoot())?.holdLaunches === true;
     }
   } catch { launchHoldActive = true; /* 못 읽으면 막힌 것으로(fail-closed) */ }
-  const preflight = parentHostModule.preflightParentHost({ target, localVersion: deps.localVersion ?? parentHostModule.localElanousVersion(), launchHoldActive, ...(deps.ssh ? { ssh: deps.ssh } : {}) });
-  if (!preflight.ok) return fallback(preflight.gaps, preflight.facts);
-  try {
-    const launched = parentHostModule.launchRemoteParent(target, args, context.env, deps.ssh);
-    try { debug.log('task-agent', 'parent-host-launched', { host: target.host, runId: context.runId, pid: launched.pid, log: launched.log }); } catch { /* fail-soft */ }
-    return { runId: context.runId, parentHost: { host: target.host, ...(target.configDir ? { configDir: target.configDir } : {}), pid: launched.pid, log: launched.log } };
-  } catch (error) {
-    // «확실히 안 떴다»일 때만 로컬로 — 불확실(ssh 끊김 등)은 던져 카드를 launch-failed 로 남긴다(중복 발사 방지).
-    if (error instanceof parentHostModule.RemoteParentNotLaunchedError) return fallback([error.message]);
-    try { debug.log('task-agent', 'parent-host-launch-uncertain', { host: target.host, runId: context.runId, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
-    throw error;
+  const capacities = Object.fromEntries(multi ? targets.map((target) => [target.host, parentHostModule.readParentHostCapacity(target, deps.ssh)]) : []);
+  const ordered = multi ? parentHostModule.orderParentHosts(targets, context.runId, capacities) : targets;
+  for (const target of ordered) {
+    if (multi && (!capacities[target.host] || capacities[target.host]!.approvalHeadroom <= 0)) {
+      failed(target, ['capacity-unavailable']);
+      continue;
+    }
+    let preflight: ReturnType<typeof parentHostModule.preflightParentHost>;
+    try { preflight = parentHostModule.preflightParentHost({ target, localVersion: deps.localVersion ?? parentHostModule.localElanousVersion(), launchHoldActive, ...(deps.ssh ? { ssh: deps.ssh } : {}) }); }
+    catch (error) { failed(target, [`preflight-error: ${error instanceof Error ? error.message : String(error)}`]); continue; }
+    if (!preflight.ok) { failed(target, preflight.gaps, preflight.facts); continue; }
+    try {
+      const launched = parentHostModule.launchRemoteParent(target, args, context.env, deps.ssh);
+      try { debug.log('task-agent', 'parent-host-launched', { host: target.host, runId: context.runId, pid: launched.pid, log: launched.log }); } catch { /* fail-soft */ }
+      return { runId: context.runId, parentHost: { host: target.host, ...(target.configDir ? { configDir: target.configDir } : {}), pid: launched.pid, log: launched.log } };
+    } catch (error) {
+      if (error instanceof parentHostModule.RemoteParentNotLaunchedError) { failed(target, [error.message]); continue; }
+      try { debug.log('task-agent', 'parent-host-launch-uncertain', { host: target.host, runId: context.runId, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+      throw error;
+    }
   }
+  return null;
 }
 
 /** stderr 파일의 첫 비어 있지 않은 줄(최대 4KB 만 읽는다 — 원 로그 꼬리를 싣지 않는다). */
@@ -315,10 +334,25 @@ function taskCardLines(card: TaskCard): string[] {
     [card.id, card.status, card.seat ?? '-', card.checklistId ?? '-', card.createdAt, card.text].join('\t'),
     ...(card.mission ? [`미션: ${card.mission} · after: ${card.after?.length ? card.after.join(', ') : '-'}`] : []),
     ...runLinkLine(card),
+    ...liveMoveLines(card),
     `다음 수: ${moveLine(card)}`,
   ];
 }
 
+/** TA-LIVE-MOVE-CARD-HISTORY — 카드 history 의 live-move 줄(실행·그림자)을 한 줄씩. 없으면 없다(옛 카드 그대로). */
+function liveMoveLines(card: TaskCard): string[] {
+  return (card.history ?? []).filter((item) => item.event === LIVE_MOVE_HISTORY_EVENT || item.event === LIVE_MOVE_RESULT_EVENT).map((item) => item.event === LIVE_MOVE_RESULT_EVENT ? [
+    // TA-REVIEW-RESULT-CAPTURE — 회수한 리뷰 결과(또는 «결과 없음») 줄.
+    `결과: ${item.at}`, `${item.kind ?? '?'}`, `PR ${item.pr !== undefined ? `#${item.pr}` : '-'}${item.head ? ` head ${item.head.slice(0, 12)}` : ''}`,
+    `verdict=${item.verdict ?? '—'} reviewed=${item.reviewed ?? '—'} must-fix=${item.mustFix ?? '—'} route=${item.reviewRoute ?? '—'}`,
+    `효과: ${item.effect ?? 'unknown'}`, (item.detail ?? '').replace(/\r\n|\r|\n/g, (match) => (match === '\r' ? '\\r' : '\\n')),
+  ].join(' · ') : [
+    `수: ${item.at}`, `${item.kind ?? '?'} ${item.executorResult ?? '?'}`, `executed=${item.executed === true} ok=${item.ok === undefined ? '—' : item.ok}`,
+    `PR ${item.pr !== undefined ? `#${item.pr}` : '-'}${item.head ? ` head ${item.head.slice(0, 12)}` : ''}`,
+    `효과: ${item.effect ?? 'unknown'}`, (item.detail ?? '').replace(/\r\n|\r|\n/g, (match) => (match === '\r' ? '\\r' : '\\n')),
+  ].join(' · '));
+}
+
 /** 미션 카드 — 머리 한 줄 ⊕ 조각 한 줄씩(상태·다음 수·선행) ⊕ 간선 한 줄씩. */
 function missionLines(mission: TaskCard, pieces: TaskCard[]): string[] {
   const edges = pieces.flatMap((piece) => (piece.after ?? []).map((before) => `간선: ${before} -> ${piece.id}`));
@@ -553,8 +587,11 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .option('--milestone <id>', '보드 소속 이정표 id (task board)')
     .option('--target <dir>', '프로젝트 대상 디렉터리(있어야 한다 · 상대 경로는 절대로 · git 이 아니면 --completion 이 code-pr 밖이어야 한다) — 발사기를 이 디렉터리에서 띄운다')
     .option('--live', '실제로 발사한다(기본은 shadow — 명령만 출력)')
+    .option('--ta-land', 'TA-LIVE-LAND-2 — 호스트는 재게이트만 하고 병합은 TASK-AGENT 의 propose-land(`pr land --expected-head`)에 맡긴다 · 카드 taLand ⊕ 발사 env ELANOUS_TA_LAND=1 · taskAgent.liveMoves 에 propose-land 가 없으면 종전대로 호스트가 병합')
+    .option('--child-llm <provider/model>', 'TASKS-HAND-CHILD-LLM — 구현 자식 LLM(예: grok/grok-4.7) → 발사 인자 --child-llm-provider <provider> --child-llm-model <model> · «첫» `/` 에서만 가른다(모델 id 의 `/` 는 보존) · openrouter 는 모델 id 가 openrouter/ 접두를 포함하므로 전체를 모델로(openrouter/z-ai/glm-5.3 → --child-llm-model openrouter/z-ai/glm-5.3) · 카드 childLlm · 안 주면 명령·카드 무변경')
+    .option('--child-llm-effort <level>', '구현 자식 추론 노력 → 발사 인자 --child-llm-effort(검증은 하니스 · --child-llm 과 함께)')
     .option('--json', 'JSON 출력')
-    .action(async (text: string | undefined, opts: { seat?: TaskSeat; checklist?: string; completion?: CompletionKind; mission?: string; project?: string; target?: string; goal?: string; milestone?: string; live?: boolean; json?: boolean }) => {
+    .action(async (text: string | undefined, opts: { seat?: TaskSeat; checklist?: string; completion?: CompletionKind; mission?: string; project?: string; target?: string; goal?: string; milestone?: string; live?: boolean; taLand?: boolean; childLlm?: string; childLlmEffort?: string; json?: boolean }) => {
       await registerTaskAgentSink(deps.registerSink);
       if ((text === undefined) === (opts.mission === undefined)) {
         out('과제 한 줄 «또는» --mission <문면> 중 하나만 준다');
@@ -566,8 +603,8 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         process.exitCode = 1;
         return;
       }
-      if (opts.mission !== undefined && (opts.completion !== undefined || opts.project !== undefined || opts.goal !== undefined || opts.milestone !== undefined)) {
-        out('--completion/--project/--target/--goal/--milestone 은 과제 한 줄에만 준다 — --mission 조각은 종전처럼 code-pr 이다');
+      if (opts.mission !== undefined && (opts.completion !== undefined || opts.project !== undefined || opts.goal !== undefined || opts.milestone !== undefined || opts.taLand === true || opts.childLlm !== undefined || opts.childLlmEffort !== undefined)) {
+        out('--completion/--project/--target/--goal/--milestone/--ta-land/--child-llm 은 과제 한 줄에만 준다 — --mission 조각은 종전처럼 code-pr 이다');
         process.exitCode = 1;
         return;
       }
@@ -601,8 +638,18 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         return;
       }
       try {
+        const resolved = resolveHandText(text!);
+        if (resolved.kind === 'rejected') {
+          try { debug.log('task-agent.hand', 'goal-file-rejected', { path: resolved.path, reason: resolved.reason }); } catch { /* fail-soft */ }
+          out(`골 파일 ${resolved.path}: ${resolved.reason}`);
+          process.exitCode = 1;
+          return;
+        }
+        if (resolved.kind === 'inlined') {
+          try { debug.log('task-agent.hand', 'goal-file-inlined', { path: resolved.path, chars: resolved.chars, sha256: resolved.sha256 }); } catch { /* fail-soft */ }
+        }
         const result = await handTask({
-          text: text!,
+          text: resolved.text,
           ...(opts.project !== undefined && opts.target !== undefined ? { project: { id: opts.project, target: opts.target } } : {}),
           ...(opts.goal !== undefined ? { goal: opts.goal } : {}),
           ...(opts.milestone !== undefined ? { milestone: opts.milestone } : {}),
@@ -610,6 +657,9 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           ...(opts.checklist ? { checklistId: opts.checklist } : {}),
           ...(opts.completion ? { completion: opts.completion } : {}),
           live: opts.live === true,
+          ...(opts.taLand === true ? { taLand: true } : {}),
+          ...(opts.childLlm !== undefined ? { childLlm: opts.childLlm } : {}),
+          ...(opts.childLlmEffort !== undefined ? { childLlmEffort: opts.childLlmEffort } : {}),
           ...(deps.taskStatePath ? { statePath: deps.taskStatePath } : {}),
           launcher: deps.taskLauncher ?? defaultTaskLauncher,
         });
@@ -618,6 +668,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           out(`${result.card.id}\t${result.mode}\t${result.launched ? 'launched' : 'not launched'}`);
           out(`elanous ${result.move.command!.map(shellQuote).join(' ')}`);
           if (result.cwd) out(`(cwd: ${result.cwd})`);
+          if (result.card.taLand) out('(ta-land — 발사 env ELANOUS_TA_LAND=1 · 로컬 부모 · taskAgent.liveMoves 에 propose-land 가 있으면 병합은 TASK-AGENT 몫, 없으면 종전대로 호스트 병합)');
           if (!result.launched) out('(shadow — 띄우지 않았다 · 띄우려면 --live)');
         }
       } catch (error) {
@@ -785,6 +836,8 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
               // 근거 없음으로 보인다 — 원장 부재와 갈리게 실패는 남긴다.
               try { debug.log('task-agent', 'card-bind-failed', { card: cardId, via: 'show', error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
             }
+            // TA-REVIEW-RESULT-CAPTURE — 떼어 띄운 live review 의 결과 파일을 이 카드 history 로 회수한다(대기 중인 요청이 있을 때만 쓴다 · 던지지 않는다).
+            captureReviewResults(deps.taskStatePath ?? taskStatePathDefault(), { cardIds: [cardId], ...(deps.reviewResultNow ? { now: deps.reviewResultNow } : {}) });
           }
           if (card) card = readTaskCard(id, deps.taskStatePath);
         } catch (error) {
@@ -841,6 +894,59 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       } catch (error) { handleError(error, out); }
     });
 
+  tasks.command('rejudge [id]')
+    .description('TA-REJUDGE-ON-HEAD — 런 멈춤 뒤 카드 PR 머리가 바뀌었으면 재게이트(떼어 띄움)·리뷰 재요청·land(재게이트 통과 ⊕ 지금 머리 pass ⊕ must-fix 0 · 겹침 증거)를 다시 판단한다 · 허용은 설정 taskAgent.liveMoves 그대로')
+    .option('--all', '묶인 PR 로 TA 리뷰를 요청한 적이 있는 카드 전부')
+    .option('--json', 'JSON 출력')
+    .action(async (id: string | undefined, opts: { all?: boolean; json?: boolean }) => {
+      await registerTaskAgentSink(deps.registerSink);
+      if ((id === undefined) === (opts.all !== true)) { out('카드 id «또는» --all 중 하나만 준다'); process.exitCode = 1; return; }
+      const { rejudgeCandidates, rejudgeCardOnHead } = await import('../task-agent/rejudge-on-head.js');
+      const statePath = deps.taskStatePath ?? taskStatePathDefault();
+      let ids: string[];
+      try { ids = id ? [id] : rejudgeCandidates(readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath).tasks ?? {}); } catch (error) {
+        out(error instanceof Error ? error.message : '과제 카드 읽기 실패'); process.exitCode = 1; return;
+      }
+      const { configuredTaskAgentLiveMoves } = await import('../task-agent/live-moves.js');
+      const liveMoves = deps.rejudge?.liveMoves ?? await configuredTaskAgentLiveMoves();
+      const all = [];
+      for (const cardId of ids) {
+        let outcomes: Awaited<ReturnType<typeof rejudgeCardOnHead>>;
+        try { outcomes = await rejudgeCardOnHead(cardId, { ...deps.rejudge, liveMoves, live: { ...deps.rejudge?.live, statePath } }); } catch (error) {
+          // 카드 하나의 예외가 --all 의 나머지 카드 판단을 멈추지 않게 — 사유를 남기고 다음 카드로.
+          const reason = (error instanceof Error ? error.message : String(error)).slice(-300);
+          try { debug.log('task-agent', 'rejudge-on-head', { card: cardId, pr: null, fromHead: null, toHead: null, step: 'target', decision: 'rejudge-threw', reason }, { level: 'warn' }); } catch { /* fail-soft */ }
+          outcomes = [{ card: cardId, pr: null, fromHead: null, toHead: null, step: 'target', decision: 'rejudge-threw', reason }];
+          process.exitCode = 1;
+        }
+        all.push(...outcomes);
+        if (!opts.json) for (const o of outcomes) out([o.card, `PR ${o.pr === null ? '-' : `#${o.pr}`}`, `${o.fromHead?.slice(0, 12) ?? '-'}→${o.toHead?.slice(0, 12) ?? '-'}`, o.step, o.decision, o.reason].join('\t'));
+      }
+      if (opts.json) out(JSON.stringify(all));
+    });
+
+  tasks.command('regate-run', { hidden: true })
+    .description('TA-REJUDGE-ON-HEAD 내부 — 카드 PR 머리 하나의 호스트 재게이트(병합 없음)를 돌리고 결과를 --out 파일로 쓴다(tasks rejudge 가 떼어 띄운다)')
+    .requiredOption('--card <id>').requiredOption('--pr <n>').requiredOption('--head <sha>').requiredOption('--repo <root>').requiredOption('--out <path>')
+    .action(async (opts: { card: string; pr: string; head: string; repo: string; out: string }) => {
+      await registerTaskAgentSink(deps.registerSink);
+      const pr = Number(opts.pr);
+      const { writeFileSync: write, mkdirSync: mkdir } = await import('node:fs');
+      const { dirname: dir } = await import('node:path');
+      let result: import('../self-implement/host-regate.js').HostRegateResult;
+      try {
+        const regate = deps.hostRegate ?? (await import('../self-implement/host-regate.js')).runHostRegate;
+        result = await regate({ prNumber: pr, headCommit: opts.head, repoRoot: opts.repo, noMerge: true });
+      } catch (error) {
+        result = { passed: false, failures: [{ step: 'host-regate', detail: (error instanceof Error ? error.message : String(error)).slice(-300) }], os: process.platform, status: 'unmeasured' };
+      }
+      const record = { pr, head: opts.head, passed: result.passed, ...(result.status ? { status: result.status } : {}), ...(result.baseCommit ? { baseCommit: result.baseCommit } : {}), failures: result.failures };
+      try { debug.log('task-agent', 'regate-run', { card: opts.card, ...record, failures: result.failures.slice(0, 3) }); } catch { /* fail-soft */ }
+      mkdir(dir(opts.out), { recursive: true });
+      write(opts.out, JSON.stringify(record));
+      if (!result.passed) process.exitCode = 1;
+    });
+
   tasks.command('approve <id...>')
     .description('외부 태스크 승인')
     .action(async (ids: string[]) => {

package/src/context-bus/context-first.ts

@@ -1,17 +1,59 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { debug } from '../debug/log.js';
 import type { ContextNowAnswer, ContextNowDeps } from './context-now.js';
 
 const CONTEXT_FIRST_GAP_MS = 6 * 60 * 60 * 1000;
 const CONTEXT_UNREADABLE = '맥락 못 읽음';
 
+/** Where the last-utterance times survive a daemon restart, so a restart does not read as a first utterance. */
+export interface ContextFirstStore {
+  load(): Record<string, number>;
+  save(lastUtteranceAt: Record<string, number>): void;
+}
+
+/** JSON-file store; unreadable or malformed content loads as empty, write failures never block the turn.
+ *  Both are logged (`context-first.store`) so a gate that keeps re-arming after restarts can be traced. */
+export function createContextFirstFileStore(path: string): ContextFirstStore {
+  return {
+    load() {
+      try {
+        const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
+        if (!parsed || typeof parsed !== 'object') return {};
+        return Object.fromEntries(Object.entries(parsed).filter((entry): entry is [string, number] => Number.isFinite(entry[1])));
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException)?.code !== 'ENOENT') {
+          debug.log('context-first.store', 'load-failed', { path, error: err instanceof Error ? err.message : String(err) });
+        }
+        return {};
+      }
+    },
+    save(lastUtteranceAt) {
+      try {
+        mkdirSync(dirname(path), { recursive: true });
+        // Write-then-rename so a daemon killed mid-write never leaves a torn file (which would re-arm every opening).
+        const tmp = `${path}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify(lastUtteranceAt));
+        renameSync(tmp, path);
+      } catch (err) {
+        // Persistence must not block the conversation, but a failure is observed.
+        debug.log('context-first.store', 'save-failed', { path, error: err instanceof Error ? err.message : String(err) });
+      }
+    },
+  };
+}
+
 /** Track every allowed utterance, consuming a pending summary only on a normal turn. */
-export function createContextFirstGate({ now, gapMs = CONTEXT_FIRST_GAP_MS }: { now: () => number; gapMs?: number }) {
-  const lastUtteranceAt = new Map<string, number>();
+export function createContextFirstGate({ now, gapMs = CONTEXT_FIRST_GAP_MS, store }: { now: () => number; gapMs?: number; store?: ContextFirstStore }) {
+  const lastUtteranceAt = new Map<string, number>(Object.entries(store?.load() ?? {}));
   const pending = new Set<string>();
   return {
     note(key: string): void {
       const at = now();
       const previous = lastUtteranceAt.get(key);
       lastUtteranceAt.set(key, at);
+      // An entry older than the gap behaves like no entry, so it is dropped from the persisted state.
+      store?.save(Object.fromEntries([...lastUtteranceAt].filter(([, time]) => at - time < gapMs)));
       if (previous === undefined || at - previous >= gapMs) pending.add(key);
     },
     take(key: string): boolean {
@@ -20,6 +62,13 @@ export function createContextFirstGate({ now, gapMs = CONTEXT_FIRST_GAP_MS }: {
   };
 }
 
+const OPERATIONAL_QUERY = /발행|릴리[스즈]|배포|버전|상태|현황|스케줄|체크리스트|도는\s*런|돌고\s*있|\brelease\b|\bversion\b|\bstatus\b|\/now\b/i;
+
+/** A question about the operation or the release itself already asks for the ledger, so the opening would only push the answer down. */
+export function isOperationalQuery(text: string | undefined): boolean {
+  return !!text && OPERATIONAL_QUERY.test(text);
+}
+
 export function renderContextFirst(
   read: (options: {}, deps?: ContextNowDeps) => ContextNowAnswer,
   deps: ContextNowDeps | undefined,

package/src/context-bus/context-now-surfaces.ts

@@ -57,6 +57,18 @@ export function renderTelegramNow(input: ContextNowAnswer, audience: ContextNowA
  *  release run, late schedules) ahead of the same `/now` body. `/now` itself stays unchanged. */
 export function renderContextFirstNow(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string {
   const answer = forAudience(input, audience);
+  const { lines, total } = operationalLines(answer);
+  if (total > lines.length) lines.push(`… 운영 항목 ${total - lines.length}개 더 (/now)`);
+  return [...lines, renderTelegramNow(answer, 'operator')].join('\n');
+}
+
+/** Telegram opening: at most three operational rows and nothing else — no `/now` body, no «최근:» row.
+ *  Empty when nothing operational is running, so the caller sends no opening at all. */
+export function renderContextFirstOpening(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string {
+  return operationalLines(forAudience(input, audience)).lines.join('\n');
+}
+
+function operationalLines(answer: ContextNowAnswer): { lines: string[]; total: number } {
   const labels = { run: '도는 런', release: '발행 런', 'schedule-late': '지연 스케줄' } as const;
   const operational = answer.facts.filter(fact => fact.kind === 'run' ||
     (fact.kind === 'release' && (fact.unreadable || fact.status !== 'done')) ||
@@ -67,8 +79,7 @@ export function renderContextFirstNow(input: ContextNowAnswer, audience: Context
     const text = fact.kind === 'run' && !fact.unreadable ? `${short(fact.goal.replace(/\s+/g, ' ').trim())} · ${fact.phase} · ${fact.elapsed}` : factText(fact);
     return `${labels[fact.kind as keyof typeof labels]}: ${text} — ${fact.source}`.replace(/\s+/g, ' ').trim();
   });
-  if (operational.length > lines.length) lines.push(`… 운영 항목 ${operational.length - lines.length}개 더 (/now)`);
-  return [...lines, renderTelegramNow(answer, 'operator')].join('\n');
+  return { lines, total: operational.length };
 }
 
 export function renderTuiNow(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string[] {

package/src/context-bus/long-term-memory.ts

@@ -252,7 +252,9 @@ export async function condenseContextWindowWithReport(
     if (!/^(?:https?:\/\/|elanous:\/\/)[^\s]+$/.test(link)) { skip('bad-link', source); continue; }
     const claim = summary.claim && { key: safeLine(summary.claim.key), value: safeLine(summary.claim.value) };
     if (claim && (!claim.key || !claim.value)) { skip('bad-claim', source); continue; }
-    if (source.kind === 'event' && !claim) { skip('no-claim', source); continue; }
+    // Sleep review can promote a sourced durable event without asserting a comparable fact.
+    // The ordinary condense command still requires a claim for event candidates.
+    if (source.kind === 'event' && !claim && policy.promotion !== 'sleep-review') { skip('no-claim', source); continue; }
     kept++;
     bump(funnel.summarized.accepted, source.seat);
     const key = keyFor({ project, seat, topic });

package/src/context-bus/nightly-condense.ts

@@ -151,7 +151,7 @@ export function summaryInstruction(recipe: 'standard' | 'sleep-review' = 'standa
   const system = 'Summarize this one-line context event as a compact project/seat memory item. Return ONLY JSON: {"project":"...","topic":"...","summary":"...","claim":{"key":"...","value":"..."}}. Omit claim when the event makes no comparable factual assertion. Never invent a project, topic or claim.';
   if (recipe === 'standard') return system;
   // SLEEP1 builds on this librarian recipe; the guardian owns storage hygiene, not promotion judgments.
-  return `${system.replace('"project":"..."', '"promote":false,"project":"..."')} You are the nightly task agent (librarian). Sleep review (librarian contract): apply the coordinator promotion policy. Return a boolean "promote" for every source. Set promote=true only for sourced, durable project/seat facts or decisions; set promote=false for chatter or speculative claims. A correction with a later timestamp wins; return a comparable claim only for an explicit factual assertion so opposing claims can become OP conflict candidates. Do not perform guardian hygiene (retention, compression, size, backup, integrity or rollback).`;
+  return `${system.replace('"project":"..."', '"promote":false,"project":"..."')} You are the nightly task agent (librarian). Sleep review (librarian contract): apply the coordinator promotion policy. Return a boolean "promote" for every source. Set promote=true only for sourced, durable project/seat facts or decisions, including durable updates without a comparable claim; set promote=false for chatter or speculative claims. A correction with a later timestamp wins; return a comparable claim only for an explicit factual assertion so opposing claims can become OP conflict candidates. Do not perform guardian hygiene (retention, compression, size, backup, integrity or rollback).`;
 }
 
 export async function summarize(source: MemorySource, injected?: Record<string, MemorySummary>, recipe: 'standard' | 'sleep-review' = 'standard'): Promise<MemorySummary> {
@@ -213,6 +213,7 @@ export async function runNightlyStage(stage: Stage, context: Context, root: stri
   if (!collected?.day || !collected.events || !collected.decisions) throw new Error('collect output missing');
   if (stage === 'condense') {
     const assignments: Array<{ owner: 'coordinator'; assignee: 'nightly-task-agent'; contract: 'librarian'; recipe: 'sleep-review'; workerPid: number }> = [];
+    const policy = { promotion: 'sleep-review', retention: 'guardian' } as const;
     const items = await condenseContextDay(collected.day, dryRun ? [] : storedItems(root).filter(item => Date.parse(item.updatedAt) < Date.parse(`${collected.day}T00:00:00Z`)), {
       events: () => collected.events!, decisions: () => collected.decisions!,
       summarize: async source => {
@@ -223,7 +224,7 @@ export async function runNightlyStage(stage: Stage, context: Context, root: stri
         assignments.push({ owner: 'coordinator', assignee: 'nightly-task-agent', contract: 'librarian', recipe: 'sleep-review', workerPid });
         return result;
       },
-    }, now, { promotion: 'sleep-review', retention: 'guardian' });
+    }, now, policy);
     return { outcome: 'ok', items, assignments };
   }
   const items = context.outputs.condense?.items;

package/src/core-turn/run-goal-loop.ts

@@ -33,7 +33,7 @@ import { debug } from '../debug/log.js';
 import { publishGoalLifecycle } from '../goals/loop.js';
 import { boundReadableText } from '../self-implement/orchestrator.js';
 import { changedFiles } from '../self-implement/seams.js';
-import { getHarnessRunId, getHarnessSpace } from '../harness/harness-space.js';
+import { getHarnessRole, getHarnessRunId, getHarnessSpace } from '../harness/harness-space.js';
 import { CONTROL_INBOX_DIR_ENV, drainControlInbox, drainSoftStopControlInbox, enqueueControlMemo, type ControlInboxDrain, type ControlMemoPayload } from '../harness/control-inbox.js';
 import { enqueuePendingUserInput } from '../session/pending-input.js';
 import { getCurrentPtyId } from '../agent/pty-identity.js';
@@ -200,6 +200,22 @@ export const GOAL_READBACK_PROMPT = [
   '이미 사용자에게 한 답을 다시 쓰지 마라 — 새 사실이 없으면 텍스트 없이 update_goal 만 호출하라.',
 ].join('\n');
 
+/** GOAL-LOOP-INTENT-STALL (0.2.24 · OP or-audit-1010) — 구현 자식이 «도구를 한 번도 안 부르고 말만 한 턴»에
+ *  넣는 재촉. hermes-agent stall guard(`agent/turn_final_response.py` 172-205)를 본떴다.
+ *  ⛔ 기존 프롬프트 상수는 건드리지 않는다 — 재촉 문면은 이 상수 하나뿐이다. */
+export const GOAL_INTENT_STALL_PROMPT = [
+  '[act now]',
+  '말로 계획만 적고 도구를 하나도 호출하지 않았다. 지금 바로 실제로 도구를 호출해 첫 스텝을 실행하라(예: 대상 파일 읽기).',
+  '설명 문장만으로 이 턴을 끝내지 마라.',
+].join('\n');
+
+/** 재촉 상한 — 이 횟수를 쓰고도 텍스트만이면 종전 ④(텍스트 수용)로 그대로 떨어진다. */
+export const GOAL_INTENT_STALL_MAX_REPROMPTS = 2;
+
+/** 재촉 가드가 켜지는 provider — ⭐ 이번 조각은 OpenRouter(오픈웨이트 모델) 구현 자식 «한정»이다
+ *  (OP 10-10 결정 · 실측 GLM Flash 첫 턴 40토큰 말만 하고 abandoned). 다른 provider 는 종전 그대로. */
+export const GOAL_INTENT_STALL_PROVIDERS: ReadonlySet<string> = new Set(['openrouter']);
+
 /** evidence 누락 complete 재주입 — update_goal(complete) 를 호출했으나 evidence 가 비었을 때. */
 export const GOAL_EVIDENCE_REQUIRED_PROMPT = [
   '[evidence required]',
@@ -264,6 +280,10 @@ export interface GoalLoopOptions {
   controlSpaceId?: string | null;
   /** Test seam — file-backed child liveness heartbeat. Default starts the workspace-file writer. */
   startLivenessHeartbeat?: typeof startChildLivenessHeartbeat;
+  /** GOAL-LOOP-INTENT-STALL — 구현 자식의 LLM provider. `openrouter` 일 때만 «도구 0회·텍스트만» 턴을
+   *  최대 2번 재촉한다. 생략하면 harness role 이 executor 인 프로세스에서만 활성 provider 로 푼다.
+   *  null = 가드 꺼짐. 시험은 이 인자를 명시해 env 에 기대지 않는다. */
+  intentStallProvider?: string | null;
 }
 
 export type GoalLoopStopReason =
@@ -449,10 +469,17 @@ export async function runGoalLoop(
   //   ※ 객체 홀더: onToolResult 클로저에서 변이하므로 let narrowing 대신 property 타입으로 읽는다.
   const runTests: { last: { ok: boolean; fail: number; unmatchedFilters: string[]; pass: number } | null } = { last: null };
   let lastResult: CoreTurnResult = { stopReason: 'end_turn', finalText: '' };
+  // GOAL-LOOP-INTENT-STALL — provider 는 루프 진입 시 «한 번» 정한다. 런 전체 도구 활동은 누적한다.
+  const intentStallProvider = await resolveIntentStallProvider(opts.intentStallProvider);
+  const intentStallGuard = intentStallProvider !== null && GOAL_INTENT_STALL_PROVIDERS.has(intentStallProvider);
+  let anyToolActivity = false;
+  let intentStallReprompts = 0;
+  // GOAL-LOOP-MIDRUN-STALL — 도구를 쓴 «뒤»의 말뿐인 턴 재촉은 런당 1회뿐이다.
+  let intentStallMidrunUsed = false;
 
   debug.log('goal.loop', 'start', {
     sessionId: ctx.sessionId, ...runAttribution, objective, maxIterations, noProgressLimit,
-    contextTokenLimit, contextPressureRatio,
+    contextTokenLimit, contextPressureRatio, intentStallGuard, intentStallProvider,
   }, { level: 'info' });
   const bus = getChannelBus();
   ensureProcessLifecycleBridge(bus, opts.attachLifecycleBridge ?? attachLifecycleBridge);
@@ -702,6 +729,7 @@ export async function runGoalLoop(
     const goalUpdate = findGoalUpdate(turnNewMessages);
     const rejectedTools = findRejectedToolCalls(turnNewMessages);
     const toolActivity = hadToolActivity(turnNewMessages);
+    if (toolActivity) anyToolActivity = true;
     const markerComplete = hasCompletionMarker(lastResult.finalText);
     const markerBlocked = hasBlockedMarker(lastResult.finalText);
 
@@ -868,6 +896,43 @@ export async function runGoalLoop(
     }
     readbackStreak = 0;
 
+    // ④-0 GOAL-LOOP-INTENT-STALL — OpenRouter 구현 자식이 런 내내 도구를 한 번도 안 부르고 말만 했다
+    //    (예: 「먼저 파일을 읽겠습니다」 후 멈춤). 일상 답변으로 수락하기 전에 «실제로 도구를 호출하라»를
+    //    최대 GOAL_INTENT_STALL_MAX_REPROMPTS 번 넣는다. 재촉 턴도 maxIterations 에 센다(하드캡이 이긴다).
+    //    상한을 쓰고도 텍스트만이면 포기 이벤트만 남기고 아래 ④ 로 «그대로» 떨어진다(포기 경로 불변).
+    //    ⛔ 가드가 꺼졌거나(다른 provider·비-executor) 한 번이라도 도구를 불렀으면 이 블록은 아무것도 안 한다.
+    //    ⭐ 빈 답(finalChars 0)도 «도구 0회»면 같은 정체로 본다 — 빈 답도 종전엔 text-only-accept 로 abandoned 됐다.
+    if (!toolActivity && intentStallGuard && !anyToolActivity) {
+      if (intentStallReprompts < GOAL_INTENT_STALL_MAX_REPROMPTS) {
+        intentStallReprompts += 1;
+        debug.log('goal.loop', 'intent-stall-reprompt', {
+          sessionId: ctx.sessionId, ...runAttribution, iterations, attempt: intentStallReprompts,
+          finalChars: lastResult.finalText.length, provider: intentStallProvider,
+        }, { level: 'info' });
+        messages.push({ role: 'user', content: GOAL_INTENT_STALL_PROMPT });
+        continue;
+      }
+      debug.log('goal.loop', 'intent-stall-exhausted', {
+        sessionId: ctx.sessionId, ...runAttribution, iterations, attempts: intentStallReprompts,
+        provider: intentStallProvider,
+      }, { level: 'warn' });
+    }
+
+    // ④-0b GOAL-LOOP-MIDRUN-STALL — 앞서 도구를 썼는데 이번 턴은 도구 없이 말로 끝났다
+    //    (예: 파일을 읽은 뒤 「이제 수정하겠습니다」 후 멈춤 → 변경 0 abort · 10-10). 같은 가드에서
+    //    같은 GOAL_INTENT_STALL_PROMPT 를 «런당 1회»만 넣는다. 재촉 턴도 maxIterations 에 센다.
+    //    두 번째 중간 정체는 아래 ④ 로 «그대로» 떨어진다(text-only-accept 불변).
+    //    ⛔ 가드가 꺼졌으면(다른 provider·비-executor) 이 블록은 아무것도 안 한다 · ④-0 과는 anyToolActivity 로 배타.
+    if (!toolActivity && intentStallGuard && anyToolActivity && !intentStallMidrunUsed) {
+      intentStallMidrunUsed = true;
+      debug.log('goal.loop', 'intent-stall-midrun', {
+        sessionId: ctx.sessionId, ...runAttribution, iterations,
+        finalChars: lastResult.finalText.length, provider: intentStallProvider,
+      }, { level: 'info' });
+      messages.push({ role: 'user', content: GOAL_INTENT_STALL_PROMPT });
+      continue;
+    }
+
     // ④ 순수 텍스트(도구 없음)로 끝났고 종결 신호도 없음 = 일상 답변(목표성 작업 아님).
     //    재주입하지 않고 그대로 수용해 trivial chat 을 이중 루프하지 않는다.
     if (!toolActivity) {
@@ -908,3 +973,22 @@ export async function runGoalLoop(
     stopLivenessHeartbeat();
   }
 }
+
+/** 가드 provider 를 정한다. 명시 인자가 이긴다(시험·호출부). 생략하면 «구현 자식»(harness role executor)
+ *  프로세스에서만 활성 provider(`resolveActiveProvider` — `ELANOUS_LLM_PROVIDER` 릴레이 포함)를 읽는다.
+ *  ⛔ executor 가 아닌 프로세스(ACP 대시보드·`chat --goal-loop`)는 읽지도 않는다 ⇒ null = 가드 꺼짐.
+ *  읽기 실패도 null(fail-open = 종전 동작). */
+async function resolveIntentStallProvider(explicit: string | null | undefined): Promise<string | null> {
+  if (explicit !== undefined) return explicit?.trim().toLowerCase() || null;
+  if (getHarnessRole() !== 'executor') return null;
+  try {
+    const { getUserConfig, resolveActiveProvider } = await import('../user-config.js');
+    return resolveActiveProvider(getUserConfig());
+  } catch (error) {
+    // fail-open(가드 꺼짐 = 종전 동작)이지만 «왜 꺼졌나»는 남긴다 — 조용한 꺼짐은 관측 안 한 것이다.
+    debug.log('goal.loop', 'intent-stall-provider-unresolved', {
+      error: error instanceof Error ? error.message : String(error),
+    }, { level: 'warn' });
+    return null;
+  }
+}

package/src/dashboard/chat-fold.ts

@@ -0,0 +1,20 @@
+import { format, getMessages } from '../expression/i18n/index.js';
+
+type Locale = NonNullable<Parameters<typeof getMessages>[0]>;
+
+export function splitNoSynthesisTail(text: string): { head: string; tail: string } | null {
+  const index = text.indexOf('[NO FINAL SYNTHESIS]');
+  if (index === -1) return null;
+  return {
+    head: text.slice(0, index).trimEnd(),
+    tail: text.slice(index),
+  };
+}
+
+/** English fallback for locale bundles that do not carry the optional key. */
+const FOLDED_TAIL_FALLBACK = '● Internal notes folded · {n} lines · press f to expand';
+
+export function buildFoldedTailLine(lineCount: number, locale?: Locale): string {
+  const template = getMessages(locale).chatFoldedInternalTail ?? FOLDED_TAIL_FALLBACK;
+  return format(template, { n: lineCount });
+}