elanous 0.2.23 → 0.2.25

package/src/task-orchestrator/surfaces/pod-child-default.ts

@@ -0,0 +1,50 @@
+/** SUBSCRIPTION-EXHAUST-REROUTE (0.2.24 · P0) — Pod 구현 자식의 «기본» 모델을 codex 밖으로 뺀다.
+ *
+ *  🩸 10-11 실측(apiEq 24h): codex 소모의 ~95% 가 node-b Pod 구현 자식이었다($2,633 · 107런). 원인은
+ *    자식 모델을 안 준 Pod 발사가 `planPodProvider` 로 codex(gpt-6-sol)에 떨어진 것이다.
+ *  ⭐ 결정 지점은 «호스트가 발사 인자를 만드는 곳»(`self orchestrate --substrate pod`) — 여기서 «자식 모델 없음 → 기본값»을
+ *    `--child-llm-provider/--child-llm-model` 과 «같은 모양»으로 채운다. 그 뒤 경로(키 확인·passEnv·Job 인자)는 명시 발사와 같다.
+ *  ⛔ 명시(`--child-llm-*`)가 있으면 손대지 않는다 · `--bench-arms`(팔마다 모델) · `--pod-account`(codex 계정 고정 = 사람의 선택)도 손대지 않는다.
+ *  ⛔ 기본값이 «못 서면»(OpenRouter 키 없음) 종전 codex 경로로 간다 — 기본값 때문에 발사가 죽지 않는다(관측은 남긴다).
+ *  config = `tools.selfImplement.podChildDefault`: `{ provider, model? }` · `'off'`(종전 codex 기본). 없으면 아래 상수. */
+
+/** 대표 라우팅 «중» 시작 모델 — OpenRouter 키는 Pod 에 이미 있다(새 자격 0). */
+export const POD_CHILD_DEFAULT = { provider: 'openrouter', model: 'openrouter/z-ai/glm-5.3' } as const;
+
+export type PodChildDefaultDecision =
+  | { apply: true; provider: string; model?: string; source: 'config' | 'default' }
+  | { apply: false; reason: 'flag' | 'bench-arms' | 'pod-account' | 'config-off' | 'no-openrouter-key'; provider?: string; model?: string; source?: 'config' | 'default' };
+
+function parseConfigValue(raw: unknown): { value: { provider: string; model?: string } | 'off'; source: 'config' } | { value: typeof POD_CHILD_DEFAULT; source: 'default'; invalid?: unknown } {
+  if (raw === undefined) return { value: POD_CHILD_DEFAULT, source: 'default' };
+  if (raw === 'off' || raw === false) return { value: 'off', source: 'config' };
+  if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+    const v = raw as Record<string, unknown>;
+    const provider = typeof v.provider === 'string' ? v.provider.trim() : '';
+    const model = typeof v.model === 'string' ? v.model.trim() : '';
+    if (provider) return { value: { provider, ...(model ? { model } : {}) }, source: 'config' };
+  }
+  return { value: POD_CHILD_DEFAULT, source: 'default', invalid: raw };
+}
+
+/** 순수 판정 — 「무엇을 보고 정했나」가 인자에 다 있다. */
+export function resolvePodChildDefault(input: {
+  flags: { provider?: string; model?: string; effort?: string };
+  benchArms: boolean;
+  explicitPodAccount?: string;
+  config: unknown;
+  /** OpenRouter 키가 호스트에 «있나»(값은 안 본다) — openrouter 기본일 때만 묻는다. */
+  openrouterKeyPresent: () => boolean;
+}): PodChildDefaultDecision & { invalidConfig?: unknown } {
+  if (input.flags.provider?.trim() || input.flags.model?.trim() || input.flags.effort?.trim()) return { apply: false, reason: 'flag' };
+  if (input.benchArms) return { apply: false, reason: 'bench-arms' };
+  if (input.explicitPodAccount?.trim()) return { apply: false, reason: 'pod-account' };
+  const parsed = parseConfigValue(input.config);
+  const invalid = 'invalid' in parsed ? { invalidConfig: parsed.invalid } : {};
+  if (parsed.value === 'off') return { apply: false, reason: 'config-off', source: 'config' };
+  const { provider, model } = parsed.value as { provider: string; model?: string };
+  if (provider === 'openrouter' && !input.openrouterKeyPresent()) {
+    return { apply: false, reason: 'no-openrouter-key', provider, ...(model ? { model } : {}), source: parsed.source, ...invalid };
+  }
+  return { apply: true, provider, ...(model ? { model } : {}), source: parsed.source, ...invalid };
+}

package/src/task-orchestrator/surfaces/pod-child-providers.ts

@@ -7,7 +7,9 @@
  *   목록 밖 provider 는 발사 «전»에 같은 문면으로 거부된다.
  * ⛔ 이 모듈은 가볍게 둔다(무거운 import 0) — 하니스 CLI 가 Pod 표면 전체를 끌어오지 않게.
  */
-export const POD_CHILD_PROVIDERS = ['openai-codex', 'grok', 'openrouter', 'anthropic'] as const;
+// BEDROCK-PROVIDER ② (0.2.24) — bedrock 은 «이름 있는 AWS Secret» 이 클러스터에 있을 때만 뜬다(pod-bedrock-child.ts · 발사 전 거부).
+// ZAI-POD-CHILD (0.2.24) — glm 은 Z.ai GLM Coding Plan(정액 구독) · «이름 있는 ZAI Secret» 이 클러스터에 있을 때만 뜬다(pod-zai-child.ts · 발사 전 거부 · 동시 상한 넘치면 정책대로).
+export const POD_CHILD_PROVIDERS = ['openai-codex', 'grok', 'openrouter', 'anthropic', 'bedrock', 'glm'] as const;
 export type PodChildProvider = typeof POD_CHILD_PROVIDERS[number];
 
 /** 사람이 쓰는 별칭 → 정식 이름. */
@@ -27,3 +29,14 @@ export function podChildProviderRefusal(named: string | undefined): string | und
   if (!id || podChildProviderOf(id)) return undefined;
   return `pod: Pod 자식 provider 는 ${POD_CHILD_PROVIDERS.join('|')} 만 — 받음 ${id}`;
 }
+
+/**
+ * BEDROCK-POD-PROVIDER-DROP (0.2.24) — 발사(`index.ts`)가 고른 Pod provider 를 Pod 옵션(`provider` · `account`)으로 옮기는 «한 곳».
+ * 🩸 10-11: podBase 가 grok·openrouter·anthropic 만 손으로 나열해 `bedrock` 이 떨어졌다 — Pod 자식은 codex(team) 로 돌았다.
+ * ⭐ codex 가 아닌 provider 는 «그 이름»이 곧 account 다(Pod 표면 `plannedAccount` 와 같은 규칙) · codex 만 명시 계정 ?? team.
+ */
+export function podLaunchProviderOptions(podProvider: PodChildProvider, o: { explicitPodAccount?: string; grokApiKeyOptIn: boolean }): { account: string; provider: PodChildProvider; grokApiKeyOptIn?: boolean } {
+  // provider 는 여섯 전부 싣는다 — Pod 의 podChildLlmArgs 는 명시 발사에 provider 가 비면 거부한다(조용한 codex 금지).
+  if (podProvider === 'openai-codex') return { account: o.explicitPodAccount ?? 'team', provider: 'openai-codex' };
+  return { account: podProvider, provider: podProvider, ...(podProvider === 'grok' ? { grokApiKeyOptIn: o.grokApiKeyOptIn } : {}) };
+}

package/src/task-orchestrator/surfaces/pod-command-job.ts

@@ -371,6 +371,12 @@ export interface RunPodCommandOptions {
   runId?: string;
   name?: string;
   pollMs?: number;
+  /**
+   * GATE-MULTI-HOST — throw once the Job's status has been unreadable (`kubectl get job` failing) this long, instead of
+   * polling forever: a pool member that died mid-Job (host off · tailnet drop) then frees its caller to place the work
+   * elsewhere. Omitted = poll without a bound (unchanged for every caller but the release gate).
+   */
+  statusUnreadableMs?: number;
   kubectl?: Kubectl;
   /** A caller-owned scheduler is self-capped: acquires count only its own Jobs, never cluster occupancy (POOLGLOBAL-REG). */
   poolScheduler?: PodPoolScheduler;
@@ -536,10 +542,18 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       throw new Error(applied.stderr.trim() || 'pod command: Job 적용 실패');
     }
     let state: 'complete' | 'failed' = 'failed';
+    let unreadableSince: number | null = null;
     for (;;) {
       const got = kubectl(['-n', namespace, 'get', 'job', name, '-o', 'jsonpath={.status.conditions[*].type}']);
       const finished = jobFinished(got.stdout);
       if (finished) { state = finished; break; }
+      if (got.status !== 0 && options.statusUnreadableMs !== undefined) {
+        unreadableSince ??= Date.now();
+        if (Date.now() - unreadableSince >= options.statusUnreadableMs) {
+          log('pod.command', 'job-status-unreadable', { job: name, context, unreadableMs: Date.now() - unreadableSince, error: (got.stderr ?? '').trim().slice(0, 300) });
+          throw new Error(`pod command: Job 상태를 ${Math.round(options.statusUnreadableMs / 1000)}초 동안 못 읽었다(${context}) — ${(got.stderr ?? '').trim().split('\n').pop()?.slice(0, 200) ?? ''}`);
+        }
+      } else unreadableSince = null;
       await sleep(options.pollMs ?? 15_000);
     }
     const logsResult = kubectl(['-n', namespace, 'logs', `job/${name}`, '-c', 'child']);

package/src/task-orchestrator/surfaces/pod-failure-reason.ts

@@ -44,6 +44,81 @@ export function podTerminalRow(row: Record<string, unknown>): { stage: string; o
   return nestedPodResult(row);
 }
 
+export const POD_EXIT_CLASSES = ['oom-killed', 'deadline-exceeded', 'gh-login-failed', 'pod-secret', 'ask-reprompt', 'child-unconverged', 'child-error', 'no-result-line', 'unknown'] as const;
+
+export type PodExitClass = typeof POD_EXIT_CLASSES[number];
+
+const isPodBookkeepingLine = (line: string): boolean =>
+  /^(?:ELANOUS_(?:MEM|RUN_LEDGER|USAGE_ROLLUP|POD_)|\[graph\] |\[ask\]\s+\d+\)\s)/u.test(line) || /^(?:at\s+\S|\.\.\.\s+\d+\s+more\b|cleanup\s+(?:complete|done|finished)\b)/iu.test(line);
+
+const isPodErrorLine = (line: string): boolean =>
+  /\berror\b|\bfail(?:ed|ure)?\b|exception|fatal|denied|timed?\s*out|exceeded|overloaded|unavailable|exhausted|오류|실패/iu.test(line);
+
+const normalizePodLogLine = (line: string): string => line.replace(/\/home\/[^/\s]+\//gu, '~/').slice(0, 240);
+
+/** Classify a failed Pod using its terminal metadata and child output, without side effects. */
+export function classifyPodExit(input: {
+  errorCode?: string | null;
+  containerReason?: string | null;
+  containerExitCode?: number | null;
+  jobReason?: string | null;
+  logs: string;
+  result?: Record<string, unknown> | null;
+}): { class: PodExitClass; errorCode: string | null; containerReason: string | null; exitCode: number | null; jobReason: string | null; tail: string[] } {
+  const logLines = input.logs.split(/\r\n|\n|\r/u).map((line) => line.trim()).filter(Boolean);
+  let terminalResult: { stage: string; ok: boolean; error?: string } | null = null;
+  for (const line of logLines) {
+    if (!line.startsWith('{')) continue;
+    let parsed: unknown;
+    try { parsed = JSON.parse(line); } catch { continue; }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) continue;
+    terminalResult = podTerminalRow(parsed as Record<string, unknown>) ?? terminalResult;
+  }
+  if (!terminalResult && input.result) terminalResult = podTerminalRow(input.result);
+  const hasResultLine = terminalResult !== null;
+  const askReprompt = logLines.some((line) =>
+    /^\[ask\](?!\s+\d+\)\s).*(?:implementation[_ -]?target|reprompt|re-prompt|되묻)/iu.test(line));
+  // 파싱되는 JSON 줄(진행·결과 행)은 오류 «줄»로 세지 않는다 — tail 과 같은 기준.
+  const isParsedJsonLine = (line: string): boolean => {
+    if (!line.startsWith('{')) return false;
+    try { const parsed = JSON.parse(line); return !!parsed && typeof parsed === 'object' && !Array.isArray(parsed); } catch { return false; }
+  };
+  const hasErrorLine = logLines.some((line) => !isPodBookkeepingLine(line) && !isParsedJsonLine(line) && isPodErrorLine(line));
+  let exitClass: PodExitClass;
+  if (input.errorCode === 'pod-secret') exitClass = 'pod-secret';
+  else if (input.jobReason === 'DeadlineExceeded') exitClass = 'deadline-exceeded';
+  else if (input.containerReason === 'OOMKilled') exitClass = 'oom-killed';
+  else if (input.containerExitCode === 7) exitClass = 'gh-login-failed';
+  else if (askReprompt) exitClass = 'ask-reprompt';
+  else if (terminalResult?.stage && terminalResult.ok === false) exitClass = 'child-unconverged';
+  else if (!hasResultLine && hasErrorLine) exitClass = 'child-error';
+  else if (!hasResultLine) exitClass = 'no-result-line';
+  else exitClass = 'unknown';
+
+  const tail = logLines.flatMap((line) => {
+    if (line.startsWith('{')) {
+      let parsed: unknown;
+      try { parsed = JSON.parse(line); } catch { parsed = undefined; }
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        const terminal = podTerminalRow(parsed as Record<string, unknown>);
+        if (terminal?.error) return terminal.error.split(/\r\n|\n|\r/u).map((part) => part.trim())
+          .filter((part) => part && !isPodBookkeepingLine(part)).map(normalizePodLogLine);
+        return [];
+      }
+    }
+    return isPodBookkeepingLine(line) ? [] : [normalizePodLogLine(line)];
+  }).slice(-5);
+
+  return {
+    class: exitClass,
+    errorCode: input.errorCode ?? null,
+    containerReason: input.containerReason ?? null,
+    exitCode: input.containerExitCode ?? null,
+    jobReason: input.jobReason ?? null,
+    tail,
+  };
+}
+
 /** Extract a human-readable reason from a failed child Pod without treating transfer markers as child errors. */
 export function extractPodFailureReason(input: {
   logs: string;
@@ -59,10 +134,8 @@ export function extractPodFailureReason(input: {
   }
   if (input.containerReason === 'OOMKilled') return 'OOMKilled: 컨테이너 메모리 한도 초과';
 
-  const isBookkeeping = (line: string): boolean =>
-    /^(?:ELANOUS_(?:MEM|RUN_LEDGER|USAGE_ROLLUP|POD_)|\[graph\] |\[ask\]\s+\d+\)\s)/u.test(line) || /^(?:at\s+\S|\.\.\.\s+\d+\s+more\b|cleanup\s+(?:complete|done|finished)\b)/iu.test(line);
-  const isError = (line: string): boolean =>
-    /\berror\b|\bfail(?:ed|ure)?\b|exception|fatal|denied|timed?\s*out|exceeded|overloaded|unavailable|exhausted|오류|실패/iu.test(line);
+  const isBookkeeping = isPodBookkeepingLine;
+  const isError = isPodErrorLine;
   const meaningful: Array<{ text: string; terminal: boolean }> = [];
   for (const line of input.logs.split(/\r\n|\n|\r/u)) {
     const trimmed = line.trim();
@@ -90,7 +163,7 @@ export function extractPodFailureReason(input: {
     meaningful.push({ text: trimmed, terminal: false });
   }
   const errorLine = [...meaningful].reverse().find((line) => line.terminal || isError(line.text));
-  const reason = errorLine?.text.replace(/\/home\/[^/\s]+\//gu, '~/').slice(0, 240);
+  const reason = errorLine ? normalizePodLogLine(errorLine.text) : undefined;
   if (reason) return reason;
   // POD-NORESULT: an unconverged child (exit 2 → BackoffLimitExceeded under backoffLimit 0) often leaves a result row
   // with a stage and PR but no error text — report that instead of «unreadable».
@@ -101,5 +174,5 @@ export function extractPodFailureReason(input: {
     return pr ? `수확 가능(${stage}) · ${pr}` : `수렴 못 함(단계 ${stage})`;
   }
   const why = input.logTailReason?.trim() || (input.logs.trim() ? '로그에 읽을 수 있는 오류 줄 없음' : '자식 로그 비어 있음');
-  return `사유 못 읽음: ${why.replace(/\/home\/[^/\s]+\//gu, '~/').slice(0, 240)}`;
+  return `사유 못 읽음: ${normalizePodLogLine(why)}`;
 }

package/src/task-orchestrator/surfaces/pod-host-acp-review.ts

@@ -0,0 +1,122 @@
+// REVIEW-ACP-POD (0.2.25 · REVIEW-ACP-DEFAULT ② 조각) — Pod 런이 낸 merge-ready PR 을 «호스트»가 Claude ACP(구독)로 다시 본다.
+//
+// S  Pod 안 하니스 리뷰는 api 리뷰어(codex 기본 gpt-6-sol · OR Pod 는 glm 고정)로 돈다 — Pod 엔 Claude 구독도 정책 파일도 없어
+//    `roleLlm.reviewer = claude-acp`(운영에 이미 켜져 있다)가 Pod 안에선 «안 닿는다». 호스트 레인 런만 ACP 로 리뷰받는다.
+// C  Pod 가 호스트로 돌려보내는 유일한 문은 merge-ready → 호스트 재게이트 → 병합이다. 여기에 리뷰가 없다.
+// Q  Pod 런의 리뷰를 구독(ACP)으로 옮기려면 어디서 하나?
+// A  호스트 병합 직전 한 자리에서, 하니스 레인과 «같은» 정책 행(`resolveSubscriptionReviewer`)·같은 가용성 검사
+//    (`subscriptionReviewerAvailability` — 구독 확인 · 상한 · 프록시)·같은 ACP 리뷰어(`makeAcpReviewLLM`)로 PR 을 본다.
+//    ⛔ 못 쓰면(설정 없음·구독 확인 실패·상한·프록시 없음·리뷰 미완) «refused» 로 돌려주고 호출자는 종전 길(Pod 리뷰 결과로 재게이트)을 그대로 간다.
+//       조용히 다른 공급자로 새지 않는다 — 이 함수 안엔 api 폴백이 «없다».
+//    ⛔ 기본 꺼짐(opt-in): 옵션 → env `ELANOUS_POD_HOST_ACP_REVIEW` → config `llm.podHostAcpReview` 순.
+//    📌 남은 조각(②-b): 이 문이 켜진 런에서 Pod 안 api 리뷰를 «끄는» 것은 Pod 이미지 쪽 변경이라 따로 간다.
+import { spawnSync } from 'node:child_process';
+import { debug } from '../../debug/log.js';
+import type { ReviewResult } from '../../agent-substrate/pr-reviewer.js';
+import type { SubscriptionReviewerSpec } from '../../user-config.js';
+import type { SubscriptionReviewerDeps, subscriptionReviewerSpawn } from '../../self-dev/review-provider-fallback.js';
+
+export const POD_HOST_ACP_REVIEW_ENV = 'ELANOUS_POD_HOST_ACP_REVIEW';
+
+export type PodHostAcpReviewEnable = { enabled: boolean; source: 'option' | 'env' | 'config' | 'default' };
+
+/** 켜는 순서: 옵션 → env(`1`/`true` 켬 · `0`/`false` 끔) → config `llm.podHostAcpReview === true` → 꺼짐. 읽기 실패는 꺼짐(종전). */
+export function resolvePodHostAcpReview(
+  option: boolean | undefined,
+  env: NodeJS.ProcessEnv,
+  readConfig: () => unknown,
+): PodHostAcpReviewEnable {
+  if (typeof option === 'boolean') return { enabled: option, source: 'option' };
+  const raw = env[POD_HOST_ACP_REVIEW_ENV]?.trim().toLowerCase();
+  if (raw === '1' || raw === 'true') return { enabled: true, source: 'env' };
+  if (raw === '0' || raw === 'false') return { enabled: false, source: 'env' };
+  try {
+    const cfg = readConfig() as { llm?: { podHostAcpReview?: unknown } } | undefined;
+    if (cfg?.llm?.podHostAcpReview === true) return { enabled: true, source: 'config' };
+  } catch { /* 읽기 실패 = 꺼짐(종전 길) */ }
+  return { enabled: false, source: 'default' };
+}
+
+export type PodHostAcpReviewOutcome =
+  | { status: 'clean'; mustFix: 0; shouldFix: number }
+  | { status: 'must-fix'; mustFix: number; findings: string[]; verdict: ReviewResult['verdict'] }
+  | { status: 'refused'; reason: string };
+
+export interface PodHostAcpReviewDeps {
+  /** `{ spec, cap }` — 기본은 하니스 레인과 같은 정책 행(`resolveSubscriptionReviewer`). */
+  resolveReviewer?: () => { spec: SubscriptionReviewerSpec; cap: number } | undefined;
+  /** 구독·상한·프록시 확인 — 기본은 `subscriptionReviewerAvailability`. */
+  availability?: (spec: SubscriptionReviewerSpec, cap: number) => { spawn?: ReturnType<typeof subscriptionReviewerSpawn>; reason?: string };
+  subscriptionReviewerDeps?: SubscriptionReviewerDeps;
+  /** PR 머리 sha·제목·본문·diff. 기본은 `gh`. */
+  readPr?: (prNumber: number, repoRoot: string) => { headRefOid: string; title: string; body: string; diff: string } | undefined;
+  /** ACP 리뷰어(prompt→text). 기본은 `makeAcpReviewLLM({ backend: 'claude', backendSpec, env })`. */
+  makeAcpReviewLLM?: (spawn: ReturnType<typeof subscriptionReviewerSpawn>, repoRoot: string) => (prompt: string) => Promise<string>;
+  reviewPullRequest?: (input: { prDiff: string; phaseIntent: string }, llm: (prompt: string) => Promise<string>) => Promise<ReviewResult>;
+  env?: NodeJS.ProcessEnv;
+}
+
+function defaultReadPr(prNumber: number, repoRoot: string): { headRefOid: string; title: string; body: string; diff: string } | undefined {
+  const view = spawnSync('gh', ['pr', 'view', String(prNumber), '--json', 'headRefOid,title,body'], { cwd: repoRoot, encoding: 'utf8', timeout: 60_000 });
+  if (view.status !== 0) return undefined;
+  const diff = spawnSync('gh', ['pr', 'diff', String(prNumber)], { cwd: repoRoot, encoding: 'utf8', timeout: 120_000, maxBuffer: 64 * 1024 * 1024 });
+  if (diff.status !== 0) return undefined;
+  try {
+    const parsed = JSON.parse(view.stdout) as { headRefOid?: unknown; title?: unknown; body?: unknown };
+    if (typeof parsed.headRefOid !== 'string') return undefined;
+    return { headRefOid: parsed.headRefOid, title: typeof parsed.title === 'string' ? parsed.title : '', body: typeof parsed.body === 'string' ? parsed.body : '', diff: diff.stdout };
+  } catch { return undefined; }
+}
+
+function refused(reason: string, data: Record<string, unknown>): PodHostAcpReviewOutcome {
+  try { debug.log('self-implement.pod', 'acp-review-refused', { ...data, reason }, { level: 'warn' }); } catch { /* 관측은 결과를 안 바꾼다 */ }
+  return { status: 'refused', reason };
+}
+
+/** Pod merge-ready PR 을 호스트 Claude ACP 로 리뷰한다. ⛔ 던지지 않는다 — 모든 실패는 `refused`(호출자는 종전 길). */
+export async function runPodHostAcpReview(
+  input: { prNumber: number; headCommit: string; repoRoot: string; job?: string },
+  deps: PodHostAcpReviewDeps = {},
+): Promise<PodHostAcpReviewOutcome> {
+  const obs = { job: input.job ?? null, pr: input.prNumber, head: input.headCommit };
+  try {
+    const env = deps.env ?? process.env;
+    // 지연 import — 이 문이 꺼진 런은 정책·설정을 안 읽는다.
+    const picked = deps.resolveReviewer ? deps.resolveReviewer() : await (async () => {
+      const { loadLlmPolicy, resolveSubscriptionReviewer } = await import('../../policy/llm-policy.js');
+      const { getUserConfig } = await import('../../user-config.js');
+      return resolveSubscriptionReviewer(loadLlmPolicy(), getUserConfig().roleLlm);
+    })();
+    if (!picked) return refused('no-subscription-reviewer', obs);
+    const avail = deps.availability
+      ? deps.availability(picked.spec, picked.cap)
+      : (await import('../../self-dev/review-provider-fallback.js')).subscriptionReviewerAvailability(picked.spec, picked.cap, env, deps.subscriptionReviewerDeps);
+    if (!avail.spawn) return refused(`unavailable: ${avail.reason ?? 'unknown'}`, { ...obs, cap: picked.cap });
+    const pr = (deps.readPr ?? defaultReadPr)(input.prNumber, input.repoRoot);
+    if (!pr) return refused('pr-unreadable', obs);
+    if (pr.headRefOid.toLowerCase() !== input.headCommit.toLowerCase()) return refused('head-moved', { ...obs, prHead: pr.headRefOid });
+    if (!pr.diff.trim()) return refused('empty-diff', obs);
+    const llm = deps.makeAcpReviewLLM
+      ? deps.makeAcpReviewLLM(avail.spawn, input.repoRoot)
+      : await (async () => {
+        const { makeAcpReviewLLM } = await import('../../agent-substrate/acp-reviewer.js');
+        const spawn = avail.spawn!;
+        return makeAcpReviewLLM({ cwd: input.repoRoot, backend: 'claude', backendSpec: spawn.backendSpec, env: spawn.env });
+      })();
+    const review = deps.reviewPullRequest ?? (await import('../../agent-substrate/pr-reviewer.js')).reviewPullRequest;
+    const phaseIntent = [`Pod 런 PR #${input.prNumber} 의 호스트 Claude ACP 리뷰(병합 전 관문).`, pr.title, pr.body.slice(0, 4000)].filter((s) => s.trim()).join('\n\n');
+    const rr = await review({ prDiff: pr.diff, phaseIntent }, llm);
+    // ⛔ reviewed=false(파싱 실패·ACP 오류를 리뷰어가 흡수) 는 «리뷰 완료»가 아니다 — 통과로 읽지 않는다.
+    if (!rr.reviewed) return refused('acp-review-not-completed', obs);
+    const mustFix = rr.mustFix.length;
+    if (rr.verdict === 'fail' || mustFix > 0) {
+      debug.log('self-implement.pod', 'host-acp-review', { ...obs, status: 'must-fix', verdict: rr.verdict, mustFix, shouldFix: rr.shouldFix.length });
+      return { status: 'must-fix', mustFix, findings: rr.mustFix.slice(0, 10), verdict: rr.verdict };
+    }
+    debug.log('self-implement.pod', 'host-acp-review', { ...obs, status: 'clean', verdict: rr.verdict, mustFix: 0, shouldFix: rr.shouldFix.length });
+    return { status: 'clean', mustFix: 0, shouldFix: rr.shouldFix.length };
+  } catch (error) {
+    // 원문은 싣지 않는다 — 계정·프록시 문면이 섞일 수 있다(하니스 레인과 같은 규율).
+    return refused(/handshake timeout/i.test(error instanceof Error ? error.message : String(error)) ? 'acp-handshake-timeout' : 'acp-error', obs);
+  }
+}

package/src/task-orchestrator/surfaces/pod-lease.ts

@@ -40,6 +40,8 @@ export function leaseKubectl(args: readonly string[], input?: string): { status:
 export interface PodLeaseMember {
   context: string;
   capacity: number;
+  /** POD-POOL-UNCAPPED-SPEC — `capacity` came from the spec default (`:N` absent), not from the operator. */
+  capacityDefaulted?: boolean;
   running: number | null;
   pending: number | null;
   /** Job names of Pending harness Pods already included in pending (used to avoid counting the same Job's host lease twice). */
@@ -94,7 +96,12 @@ export interface PoolLeaseMeasure {
 
 export interface PoolLeaseRecommendation {
   recommended: number | null;
-  limitedBy: 'capacity' | 'memory' | null;
+  /**
+   * What stopped admission: `memory` = node memory headroom · `capacity` = the pool slot budget ·
+   * `pool-cap` = POD-POOL-UNCAPPED-SPEC — a member whose cap came from the spec default (`:N` absent → 2) is
+   * already at/over that cap, so the pool spec itself (not memory, not a configured budget) is the bound.
+   */
+  limitedBy: 'capacity' | 'memory' | 'pool-cap' | null;
   reason: string | null;
   capacitySlots: number | null;
   memorySlots: number | null;
@@ -392,7 +399,7 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
   const kubectl = deps.kubectl ?? leaseKubectl;
   return { members: members.map((member) => {
     const base = ['--context', member.context, '--request-timeout=10s'];
-    const result: PodLeaseMember = { context: member.context, capacity: member.capacity, running: null, pending: null, unleasedRunning: null, memoryLimitBytes: null, allocatableMemoryBytes: null, allocatableCpuMillicores: null, availableMemoryByNodeBytes: null, reason: null };
+    const result: PodLeaseMember = { context: member.context, capacity: member.capacity, ...(member.capacityDefaulted ? { capacityDefaulted: true } : {}), running: null, pending: null, unleasedRunning: null, memoryLimitBytes: null, allocatableMemoryBytes: null, allocatableCpuMillicores: null, availableMemoryByNodeBytes: null, reason: null };
     try {
       const nodes = kubectl([...base, 'get', 'nodes', '-o', 'json']);
       const jobs = kubectl([...base, '-n', 'elanous-test', 'get', 'jobs', '-l', 'elanous.substrate=pod', '-o', 'json']);
@@ -635,7 +642,7 @@ export function recommendConcurrency(measure: PoolLeaseMeasure, options: { capac
   if (goalBytes === null || goalBytes <= 0) return { ...empty, reason: '측정 불가: perGoalMemory' };
   const admission = admissionByUsage(measure, goalBytes, options.perGoalMemory !== undefined);
   if (!measure.members.length || measure.members.some((m) => m.running === null || m.pending === null || m.unleasedRunning === null || m.allocatableMemoryBytes === null || m.memoryLimitBytes === null || m.allocatableCpuMillicores === null || m.availableMemoryByNodeBytes === null)) {
-    debug.log('pod-lease', 'admit-by-usage', { samples: admission.samples, p95Bytes: admission.p95Bytes, admitBytes: admission.admitBytes, fallback: admission.fallback, recommended: null, limitedBy: null });
+    debug.log('pod-lease', 'admit-by-usage', { samples: admission.samples, p95Bytes: admission.p95Bytes, admitBytes: admission.admitBytes, fallback: admission.fallback, recommended: null, limitedBy: null, capacity: options.capacity, capacitySlots: null, memorySlots: null, running: null, pending: null });
     return { ...empty, reason: `측정 불가: cluster${measure.members.map((m) => m.reason ? ` ${m.context}: ${m.reason}` : '').join('')}` };
   }
   if (!Number.isSafeInteger(options.capacity) || options.capacity < 0) return { ...empty, reason: '측정 불가: capacity' };
@@ -680,9 +687,14 @@ export function recommendConcurrency(measure: PoolLeaseMeasure, options: { capac
     Math.floor((m.allocatableMemoryBytes! - m.memoryLimitBytes!) / liteBytes))), 0);
   const memoryBound = Math.min(memorySlots, placeableSlots);
   const recommended = Math.max(0, Math.min(capacitySlots, memoryBound) - eligibleUnleasedRunning);
-  const limitedBy = memoryBound < capacitySlots ? 'memory' : 'capacity';
+  // POD-POOL-UNCAPPED-SPEC — `capacity ≤ occupied` on a member whose cap is the spec default (`:N` absent → 2) means
+  // the «uncapped» pool spec is what admits nothing. Name it `pool-cap`, not the generic `capacity`, so a launch that
+  // sits on `recommended=0` says in its first admit line that the pool spec never declared a cap of its own.
+  const defaultCapFull = capacitySlots <= 0 && measure.members.some((m) => m.capacityDefaulted === true
+    && m.reason !== 'dns' && m.running !== null && m.pending !== null && m.running + m.pending >= m.capacity);
+  const limitedBy: PoolLeaseRecommendation['limitedBy'] = memoryBound < capacitySlots ? 'memory' : defaultCapFull ? 'pool-cap' : 'capacity';
   if (unleasedRunning > 0) debug.log('pod-lease', 'unleased', { unleasedRunning, running, recommended });
-  debug.log('pod-lease', 'admit-by-usage', { samples: admission.samples, p95Bytes: admission.p95Bytes, admitBytes: admission.admitBytes, fallback: admission.fallback, recommended, limitedBy });
+  debug.log('pod-lease', 'admit-by-usage', { samples: admission.samples, p95Bytes: admission.p95Bytes, admitBytes: admission.admitBytes, fallback: admission.fallback, recommended, limitedBy, capacity: options.capacity, capacitySlots, memorySlots, running, pending });
   return { recommended, limitedBy, reason: measure.members.some((m) => m.reason === 'dns') ? 'dns' : null, capacitySlots, memorySlots, liteMemorySlots, placeableSlots, accountSlots, running, pending, pendingJobs, unleasedRunning, admission };
 }
 

package/src/task-orchestrator/surfaces/pod-ledger-collect.ts

@@ -14,6 +14,8 @@ type ParseResult = Ledger[] | { error: Incomplete[]; ledgers: Ledger[] };
 const NON_PROGRESS_EVENTS = new Set(['progress-delivery-outcome']);
 const REEMIT_EXCLUDED_PREFIX = 'progress-delivery';
 type Emit = (category: string, event: string, data: Record<string, unknown>) => void;
+/** Heal-loop starter seam — defaults to the real `startHealLoop` inside `recordFailureEvent`. */
+type StartHealLoop = Parameters<typeof recordFailureEvent>[2];
 
 /** Reemit only complete ledger records; offsets name the first byte of each line in the Pod ledger. */
 function reemitLedgerLines(jsonl: string, runId: string, startOffset: number, emit: Emit): number {
@@ -93,7 +95,7 @@ export function parsePodLedgerChunks(logs: string): ParseResult {
   return error.length ? { error, ledgers } : ledgers;
 }
 
-function intakeCollectedFailure(runId: string, dir: string, log: Emit): void {
+function intakeCollectedFailure(runId: string, dir: string, log: Emit, startHealLoop?: StartHealLoop): void {
   let ledger: ReturnType<typeof loadRunLedger>;
   try { ledger = loadRunLedger(runId, dir); }
   catch { return; }
@@ -104,8 +106,10 @@ function intakeCollectedFailure(runId: string, dir: string, log: Emit): void {
   if (terminal?.data.runStatus !== 'failed' || !terminal.timestamp || !Number.isFinite(Date.parse(terminal.timestamp))
     || ledger.slice(terminalIndex + 1).some(entry => !TRAILING_BOOKKEEPING_EVENTS.includes(entry.event as typeof TRAILING_BOOKKEEPING_EVENTS[number]))) return;
   try {
+    // POD-HEAL-HOST — the recovered Pod failure is recorded into the HOST universe (`dirname(dir)`),
+    // so the host heal loop triages it (harvest + narrowed relaunch) instead of dying inside the Pod.
     recordFailureEvent({ source: 'harness-run', kind: 'pod-run', ref: runId,
-      summary: `Pod run ${runId} failed`, at: terminal.timestamp }, dirname(dir));
+      summary: `Pod run ${runId} failed`, at: terminal.timestamp }, dirname(dir), startHealLoop);
   } catch (error) {
     log('self-implement.pod', 'heal-intake-failed', { runId, reason: error instanceof Error ? error.message : String(error) });
   }
@@ -115,11 +119,13 @@ function intakeCollectedFailure(runId: string, dir: string, log: Emit): void {
  *  except a ledger that THIS run's live follower created (`replace`): that one is a partial copy and the final is complete. */
 export function collectPodLedgers(
   logs: string,
-  { dir = runLedgerDir(), log = defaultPodReemit(), emit = defaultPodReemit(), replace = new Set<string>() }: {
+  { dir = runLedgerDir(), log = defaultPodReemit(), emit = defaultPodReemit(), replace = new Set<string>(), startHealLoop }: {
     dir?: string;
     log?: (category: string, event: string, data: Record<string, unknown>) => void;
     emit?: Emit;
     replace?: ReadonlySet<string>;
+    /** Which starter receives a recovered Pod failure (POD-HEAL-HOST 판정선 measurement); default = real `startHealLoop`. */
+    startHealLoop?: StartHealLoop;
   } = {},
 ): void {
   const parsed = parsePodLedgerChunks(logs);
@@ -136,7 +142,7 @@ export function collectPodLedgers(
       const newLines = Buffer.from(jsonl).subarray(previousBytes).toString('utf8');
       reemitLedgerLines(newLines, runId, previousBytes, emit);
       log('self-implement.pod', 'ledger-collected', { runId, lines: jsonl.split('\n').filter(Boolean).length, bytes: Buffer.byteLength(jsonl) });
-      intakeCollectedFailure(runId, dir, log);
+      intakeCollectedFailure(runId, dir, log, startHealLoop);
     } catch (e) {
       if ((e as NodeJS.ErrnoException).code === 'EEXIST') {
         // A reattached Job may have already delivered this exact complete snapshot.
@@ -145,7 +151,7 @@ export function collectPodLedgers(
           const existing = readFileSync(runLedgerPath(runId, dir));
           const identical = existing.equals(Buffer.from(jsonl));
           log('self-implement.pod', identical ? 'ledger-collect-already-complete' : 'ledger-collect-skipped', { runId, reason: 'exists' });
-          if (identical) intakeCollectedFailure(runId, dir, log);
+          if (identical) intakeCollectedFailure(runId, dir, log, startHealLoop);
         } catch (readError) {
           log('self-implement.pod', 'ledger-collect-incomplete', { runId, reason: readError instanceof Error ? readError.message : String(readError) });
         }

package/src/task-orchestrator/surfaces/pod-manifest-test-normalize.ts

@@ -0,0 +1,23 @@
+import { BUDGET_SNAPSHOT_ENV } from '../../execution-loop/launch-gate.js';
+
+// Preserve the manifest contract except for two values generated per launch.
+export function stablePodManifestText(applied: Array<Record<string, any>>): string {
+  const manifests = structuredClone(applied.filter((entry) => entry.kind === 'Job' || entry.kind === 'Secret'));
+  let snapshots = 0;
+  for (const manifest of manifests) {
+    if (manifest.kind !== 'Job') continue;
+    for (const container of manifest.spec?.template?.spec?.containers ?? []) {
+      for (const entry of container.env ?? []) {
+        if (entry.name !== BUDGET_SNAPSHOT_ENV) continue;
+        snapshots++;
+        // Keep every original byte except this one volatile numeric value.
+        const measuredAt = /("measuredAt"\s*:\s*)\d+/g;
+        const matches = [...entry.value.matchAll(measuredAt)];
+        if (matches.length !== 1) throw new Error('budget snapshot must have exactly one numeric measuredAt');
+        entry.value = entry.value.replace(measuredAt, (_match: string, prefix: string) => `${prefix}0`);
+      }
+    }
+  }
+  if (snapshots === 0) throw new Error('manifest comparison requires a budget snapshot');
+  return JSON.stringify(manifests).replace(/run-[0-9a-f-]{36}/g, 'run-<id>');
+}

package/src/task-orchestrator/surfaces/pod-pool.ts

@@ -31,6 +31,11 @@ export interface PodPoolMember {
   /** 원격 클러스터가 도는 기계(ssh 호스트). 없으면 이 기계의 docker 에 있다. */
   readonly sshHost?: string;
   readonly capacity: number;
+  /**
+   * POD-POOL-UNCAPPED-SPEC — 스펙에 `:N` 이 없어서 `capacity` 가 운영자 숫자가 아니라 `POD_POOL_DEFAULT_CAPACITY` 다.
+   * 발사 허가는 이 표시로 «풀 기본 상한이 막았다»(`limitedBy=pool-cap`)를 일반 `capacity` 와 갈라 말한다.
+   */
+  readonly capacityDefaulted?: boolean;
   /** k3d 클러스터 이름(이미지 반입용). 기본: 컨텍스트가 `k3d-<이름>` 이면 그 이름, 원격이면 `elanous-pool`. */
   readonly k3dCluster: string;
   /** 노드 로컬 레지스트리의 이미지(커밋 태그) — 있으면 Pod 가 이것을 pull 한다(델타 · 대표 2026-09-26). 없으면 반입된 로컬 이미지. */
@@ -115,18 +120,23 @@ export function remoteImageSkillsDigest(member: PodPoolMember, image: string, ru
 
 const MEMBER = /^([A-Za-z0-9][A-Za-z0-9._-]*)(?:@([A-Za-z0-9][A-Za-z0-9._-]*))?(?::(\d+))?(?:#(k3d-[A-Za-z0-9][A-Za-z0-9._-]*):([1-9]\d{0,4}))?$/u;
 
+/** 상한 없는 풀 스펙(`:N` 없음)의 노드 상한 — 파일 머리 주석의 «기본 2» 정본(POD-POOL-UNCAPPED-SPEC). */
+export const POD_POOL_DEFAULT_CAPACITY = 2;
+
 export function parsePodPool(spec: string): PodPoolMember[] {
   const members = spec.split(',').map((s) => s.trim()).filter(Boolean).map((part) => {
     const m = MEMBER.exec(part);
     if (!m) throw new Error(`--pod-pool: 못 읽는 노드 「${part}」 — 형식 컨텍스트[@ssh호스트][:상한][#k3d-레지스트리:포트]`);
-    const capacity = m[3] === undefined ? 2 : Number(m[3]);
+    // `:N` 이 없으면 «상한 없음»이 아니라 기본 상한 2 다 — 그 사실(`capacityDefaulted`)을 멤버에 남긴다.
+    const capacityDefaulted = m[3] === undefined;
+    const capacity = capacityDefaulted ? POD_POOL_DEFAULT_CAPACITY : Number(m[3]);
     // POOL-LITE (10-07): `:0` means «this member is off» — a `node-c:0` entry once threw here and broke every launch.
     //   It is dropped below (never chosen); only a pool with no live member left is an error.
     if (!Number.isInteger(capacity) || capacity < 0) throw new Error(`--pod-pool: 상한은 1 이상 — 「${part}」`);
     if (m[5] && Number(m[5]) > 65535) throw new Error(`--pod-pool: 레지스트리 포트는 65535 이하 — 「${part}」`);
     const context = m[1]!;
     const k3dCluster = context.startsWith('k3d-') ? context.slice(4) : 'elanous-pool';
-    return { context, capacity, k3dCluster, ...(m[2] ? { sshHost: m[2] } : {}), ...(m[4] ? { registry: `${m[4]}:${m[5]}` } : {}) };
+    return { context, capacity, ...(capacityDefaulted ? { capacityDefaulted: true } : {}), k3dCluster, ...(m[2] ? { sshHost: m[2] } : {}), ...(m[4] ? { registry: `${m[4]}:${m[5]}` } : {}) };
   });
   if (members.length === 0) throw new Error('--pod-pool: 노드가 없다');
   if (new Set(members.map((m) => m.context)).size !== members.length) throw new Error('--pod-pool: 컨텍스트가 겹친다');
@@ -144,6 +154,59 @@ export function parsePodPool(spec: string): PodPoolMember[] {
  */
 export type PodPlacementKind = 'lite' | 'standard';
 
+/** Identity carried by a launched pool Job and its Pod; absent source fields stay absent. */
+export interface PodWorkIdentity {
+  ownerKind?: 'seat' | 'steward' | 'orchestrator' | 'external';
+  ownerId?: string;
+  taskCard?: string;
+  slotId?: string;
+  work?: 'harness' | 'authoring' | 'lite';
+}
+
+/** Kubernetes label values cannot exceed 63 characters or contain arbitrary card/owner text. */
+export function podWorkLabels(identity: PodWorkIdentity): Record<string, string> {
+  const value = (raw: string | undefined): string | undefined => {
+    const cleaned = (raw ?? '').replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 63).replace(/^[^A-Za-z0-9]+|[^A-Za-z0-9]+$/g, '');
+    return cleaned || undefined;
+  };
+  const ownerId = identity.ownerId && value(identity.ownerId) === identity.ownerId ? identity.ownerId : undefined;
+  const taskCard = identity.taskCard && value(identity.taskCard) === identity.taskCard ? identity.taskCard : undefined;
+  const slotId = identity.slotId && value(identity.slotId) === identity.slotId ? identity.slotId : undefined;
+  return {
+    ...(identity.ownerKind && ownerId ? { 'elanous.owner-kind': identity.ownerKind, 'elanous.owner-id': ownerId } : {}),
+    ...(taskCard ? { 'elanous.task-card': taskCard } : {}),
+    ...(slotId ? { 'elanous.checklist': slotId } : {}),
+    ...(identity.work ? { 'elanous.work': identity.work } : {}),
+  };
+}
+
+/** Minih standard-Job policy, independent of the configured pool member capacity. Not wired into allocation. */
+export type MinihLocation = 'home' | 'external';
+
+export function minihStandardCapacity(location: MinihLocation): number {
+  return location === 'home' ? 1 : 2;
+}
+
+/** A drain withholds new slots until occupancy falls to the target; it never evicts Running Pods. */
+export function decideMinihDrain(location: MinihLocation, runningPods: number, pendingPods = 0): {
+  capacity: number;
+  runningPods: number;
+  drainNewAdmissions: boolean;
+  availableSlots: number;
+} {
+  if (![runningPods, pendingPods].every((count) => Number.isSafeInteger(count) && count >= 0)) {
+    throw new RangeError('node-c occupancy must be non-negative whole Pods');
+  }
+  const capacity = minihStandardCapacity(location);
+  const occupied = runningPods + pendingPods;
+  return {
+    capacity,
+    runningPods,
+    drainNewAdmissions: occupied > capacity,
+    availableSlots: Math.max(0, capacity - occupied),
+  };
+}
+
 export interface PodPlacement {
   readonly member: string;
   readonly kind: PodPlacementKind | null;
@@ -642,7 +705,11 @@ export function syncPoolImage(member: PodPoolMember, image: string, localCommit:
     // The import phase gets its own stale window (the lock file's age restarts here).
     try { const now = new Date(); utimesSync(lockPath, now, now); } catch { /* lock gone · finish anyway */ }
     const imp = remote(host, `k3d image import ${image} -c ${member.k3dCluster}`);
-    if (imp.status !== 0) return { ok: false, action: 'failed', detail: `k3d import rc=${imp.status}: ${imp.stderr.slice(-300)}` };
+    // As in build.sh, only tools-node cleanup errors may follow a nonzero import rc.
+    // Ignore informational lines, but reject any other failure line (including WARN and untagged output).
+    const failures = imp.stderr.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !/^(?:INFO|DEBU|DEBUG|TRAC|TRACE)(?:\[|\s|:|$)/.test(line));
+    const cleanup = /^(?:(?:ERROR|ERRO|FATAL|FATA|WARNING|WARN|INFO)(?:\[[^\]]*\])?:?\s*)?(?:failed to import images: )?failed to delete tools node '[^']*': (?:Error response from daemon: )?(?:No such container: [A-Za-z0-9_.-]+|removal of container [A-Za-z0-9_.-]+ is already in progress)$/i;
+    if (imp.status !== 0 && (failures.length === 0 || !failures.every((line) => cleanup.test(line)))) return { ok: false, action: 'failed', detail: `k3d import rc=${imp.status}: ${imp.stderr.slice(-300)}` };
     const after = remoteImageCommit(member, image, remote);
     return after && (!localCommit || after === localCommit)
       ? { ok: true, action: 'shipped', detail: `${labelNow?.slice(0, 12) ?? '없음'} → ${after.slice(0, 12)}` }
@@ -736,7 +803,9 @@ export async function syncPoolImages(members: readonly PodPoolMember[], image: s
   const run = deps.run ?? defaultRemoteRun;
   const script = deps.buildScript === undefined ? podImageBuildScript() : deps.buildScript;
   const remoteBuild = deps.remoteBuild ?? (script ? defaultRemoteBuild(script, image) : null);
-  const ship = deps.ship ?? ((m: PodPoolMember, img: string, commit: string | null, remote: RemoteRun) => syncPoolImage(m, img, commit, { run: remote, inspect: deps.inspect, transfer: deps.transfer }));
+  // The registry-less build fallback below calls this ship path, including its remote import result check.
+  const ship = deps.ship ?? ((m: PodPoolMember, img: string, commit: string | null, remote: RemoteRun) =>
+    syncPoolImage(m, img, commit, { run: remote, inspect: deps.inspect, transfer: deps.transfer }));
   const results = new Map<string, PoolImageSync>();
   // pack 한 번 ⊕ 나눠 쓰기 — 원격 멤버가 둘 이상일 때만(하나뿐이면 종전대로 build.sh 가 스스로 pack 한다).
   //   주입된 remoteBuild(시험)에는 진짜 pack 을 붙이지 않는다 — pack 도 주입해야 쓴다.