elanous 0.2.32 → 0.2.35

package/src/self-implement/seams.ts

@@ -69,6 +69,7 @@ import { stageNonGitDir, stageFile, applyShadowToTarget, applyFileToTarget } fro
 import type { TargetKind } from './target-kind.js';
 import { basename } from 'node:path';
 import { ghAutomationEnv, makePrManager, type PrManager } from '../autopilot/pr-manager.js';
+import { cardPrNumber, taskAgentStatePath, updateTaskCard } from '../task-agent/task-hand.js';
 import { defaultSpawnGh, lookupOpenDraftPrs } from '../cli/logs-abandoned-draft-prs.js';
 import { loadRunLedger, runLedgerDir } from './run-ledger.js';
 import { readdirSync } from 'node:fs';
@@ -1259,11 +1260,126 @@ type DefaultSeamsDiagnoseInput = Omit<Parameters<NonNullable<SelfImplementSeams[
   kind: SupervisionReworkSource;
 };
 
-type DefaultSeamsResult = Omit<SelfImplementSeams, 'diagnose'> & {
+/** 같은 칸 카드 재결속 사유 — debug.log `same-cell-card-rebind-<reason>` 이름과 1:1 로 대응한다. */
+export type SameCellCardRebindReason =
+  | 'card-id-absent'
+  | 'card-store-absent'
+  | 'card-missing'
+  | 'manual-ref'
+  | 'bound-other-pr'
+  | 'already-rebound'
+  | 'rebound'
+  | 'card-store-unreadable';
+
+/** openPr 반환이 싣는 재결속 관측 — `deferred` 면 PR 은 열렸고 카드 결속은 부모 pr-terminal(#29948) 몫이다. */
+export interface SameCellCardRebindObservation {
+  outcome: 'rebound' | 'already-rebound' | 'deferred';
+  reason: SameCellCardRebindReason;
+  cardId: string | null;
+  oldPr: number;
+  newPr: number;
+  boundPr?: number;
+  detail?: string;
+}
+
+export type OpenPrOutcome = { url: string; number: number; rebind?: SameCellCardRebindObservation };
+
+type DefaultSeamsResult = Omit<SelfImplementSeams, 'diagnose' | 'openPr'> & {
   diagnose: (ctx: DefaultSeamsDiagnoseInput) => Promise<string>;
   closePr: (prUrl: string, comment?: string) => boolean;
+  openPr: (input: Parameters<NonNullable<SelfImplementSeams['openPr']>>[0]) => Promise<OpenPrOutcome>;
 };
 
+type SameCellRebindDecision =
+  | { kind: 'rebound' }
+  | { kind: 'already-rebound' }
+  | { kind: 'card-missing' }
+  | { kind: 'manual-ref' }
+  | { kind: 'bound-other-pr'; boundPr: number };
+
+type SameCellRebindExtra = { boundPr?: number; detail?: string };
+
+/** 같은 칸 새 draft 뒤 카드 재결속 — 사유를 다섯 갈래로 나눠 남기고, 카드 저장소가 없는 실행은 던지지 않고
+ *  deferred 로 돌려준다(Pod 자식은 본부 카드 저장소가 없다 · 부모 pr-terminal 결속은 #29948 이 맡는다). */
+function rebindSameCellCardToPr(input: {
+  taskCardId: string | undefined;
+  storePath: string;
+  oldPr: number;
+  newPr: number;
+  url: string;
+}): SameCellCardRebindObservation {
+  const cardId = input.taskCardId ?? null;
+  const base = { cardId, oldPr: input.oldPr, newPr: input.newPr, url: input.url };
+  const observe = (reason: SameCellCardRebindReason, extra: SameCellRebindExtra = {}, level: 'info' | 'warn' = 'info'): void => {
+    debug.log('self-implement.pr', `same-cell-card-rebind-${reason}`, { ...base, ...extra }, { level });
+  };
+  const deferred = (reason: SameCellCardRebindReason, extra: SameCellRebindExtra = {}): SameCellCardRebindObservation => {
+    observe(reason, extra, 'warn');
+    debug.log('self-implement.pr', 'same-cell-card-rebind-deferred', { ...base, ...extra, reason }, { level: 'warn' });
+    return { outcome: 'deferred', reason, cardId, oldPr: input.oldPr, newPr: input.newPr, ...extra };
+  };
+  const failed = (reason: SameCellCardRebindReason, extra: SameCellRebindExtra = {}): never => {
+    const reasonText = reason === 'bound-other-pr' ? `bound-other-pr(${String(extra.boundPr)})` : reason;
+    observe(reason, extra, 'warn');
+    debug.log('self-implement.pr', 'same-cell-card-rebind-failed', { ...base, ...extra, reason }, { level: 'warn' });
+    throw new Error(`same-cell 새 draft ${input.url} 개설됨; 카드 재결속 실패(${reasonText}) — 새 PR 수확 필요`);
+  };
+  if (!input.taskCardId) return deferred('card-id-absent');
+  if (!existsSync(input.storePath)) return deferred('card-store-absent');
+  let decision: SameCellRebindDecision | undefined;
+  let updated: ReturnType<typeof updateTaskCard>;
+  try {
+    updated = updateTaskCard(input.storePath, input.taskCardId, (card) => {
+      if (!card) {
+        decision = { kind: 'card-missing' };
+        return undefined;
+      }
+      if (card.refSource === 'manual') {
+        decision = { kind: 'manual-ref' };
+        return undefined;
+      }
+      const currentPr = cardPrNumber(card);
+      if (currentPr !== undefined && currentPr !== input.oldPr && currentPr !== input.newPr) {
+        decision = { kind: 'bound-other-pr', boundPr: currentPr };
+        return undefined;
+      }
+      if (currentPr === input.newPr && card.history.some((event) => event.event === 'same-cell-pr-rebound' && event.pr === input.newPr)) {
+        decision = { kind: 'already-rebound' };
+        return undefined;
+      }
+      decision = { kind: 'rebound' };
+      return {
+        ...card,
+        pr: { number: input.newPr, url: input.url },
+        history: [...card.history, {
+          at: new Date().toISOString(), event: 'same-cell-pr-rebound', pr: input.newPr,
+          detail: `이전 draft #${input.oldPr} 정리 후속 · 새 PR #${input.newPr} 결속`,
+        }],
+      };
+    });
+  } catch (error) {
+    return failed('card-store-unreadable', { detail: error instanceof Error ? error.message : String(error) });
+  }
+  const decided: SameCellRebindDecision = decision ?? { kind: 'card-missing' };
+  switch (decided.kind) {
+    case 'bound-other-pr':
+      return failed('bound-other-pr', { boundPr: decided.boundPr });
+    case 'manual-ref':
+      return failed('manual-ref');
+    case 'card-missing':
+      return deferred('card-missing');
+    case 'already-rebound':
+      observe('already-rebound');
+      return { outcome: 'already-rebound', reason: 'already-rebound', cardId, oldPr: input.oldPr, newPr: input.newPr };
+    case 'rebound':
+      if (!updated || cardPrNumber(updated) !== input.newPr) {
+        return failed('card-store-unreadable', { detail: '카드 갱신 결과가 새 PR 을 가리키지 않는다' });
+      }
+      observe('rebound');
+      return { outcome: 'rebound', reason: 'rebound', cardId, oldPr: input.oldPr, newPr: input.newPr };
+  }
+}
+
 const GOAL_DESCRIPTION_MAX_CHARS = 250;
 const DEFAULT_GOAL_SUMMARY_TIMEOUT_MS = 10_000;
 
@@ -2491,14 +2607,19 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
     // ⛔ await 한다 — spawn 실패를 삼키면 발사 실패도 `salvage:'launched'` 로 거짓 관측된다(3차 M4).
     launchReworkSalvage: async (input) => { await launchReworkSalvage(input); },
 
-    openPr: async ({ title, body, head, base, draft, labels, cwd }) => {
+    openPr: async ({ title, body, head, base, draft, labels, cwd, runId }) => {
       const resolvedBase = assertBaseBranchOnOrigin(cwd, base);
       const harnessSeat = process.env.ELANOUS_HARNESS_SEAT;
+      const taskCardId = process.env.ELANOUS_TASK_CARD_ID;
+      const bodyWithCard = taskCardId && /^[A-Za-z0-9][A-Za-z0-9._:-]{2,}$/.test(taskCardId)
+        ? `${body}\n\n카드: ${taskCardId}` : body;
+      const prRunId = runId ?? getHarnessRunId();
       const outcome = (o.prManager ?? makePrManager()).upsertPr({
         branch: head,
+        ...(prRunId ? { runId: prRunId } : {}),
         worktreePath: cwd,
         title,
-        body: buildPrBody(cwd, body),
+        body: buildPrBody(cwd, bodyWithCard),
         commitMessage: title,
         ...(resolvedBase ? { base: resolvedBase } : {}),
         ...(draft !== undefined ? { draft } : {}),
@@ -2511,7 +2632,18 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       });
       if (!outcome.ok) throw new Error(`self-implement PR ${outcome.reason} 실패: ${outcome.detail}`);
       const number = Number.parseInt(outcome.url.match(/\/pull\/(\d+)/)?.[1] ?? '', 10);
-      return { url: outcome.url, number: Number.isFinite(number) ? number : 0 };
+      let rebind: SameCellCardRebindObservation | undefined;
+      if (outcome.supersededPr && Number.isSafeInteger(number) && number > 0) {
+        debug.log('self-implement.pr', 'same-cell-rebound', {
+          cardId: taskCardId ?? null, oldPr: outcome.supersededPr, newPr: number, url: outcome.url,
+          oldDraftCleanup: 'deferred',
+        });
+        rebind = rebindSameCellCardToPr({
+          taskCardId, storePath: taskAgentStatePath(), oldPr: outcome.supersededPr, newPr: number, url: outcome.url,
+        });
+      }
+      const opened: OpenPrOutcome = { url: outcome.url, number: Number.isFinite(number) ? number : 0, ...(rebind ? { rebind } : {}) };
+      return opened;
     },
 
     // 재발명 0 — PrManager.closePr 시그니처·동작을 그대로 위임한다(mission-lifecycle 이 이미 쓴다).
@@ -2689,6 +2821,8 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       //   소화(C1 Bug2 "replace it with" 자기모순류를 스스로 진단). llmReview(동일 LLM 래퍼) 재사용·fail-soft.
       judgmentCallLLM: async ({ prompt }) => o.llmReview!(prompt),
       classifyCallLLM: async ({ prompt }) => o.llmReview!(prompt),
+      // E1 GOAL-ELABORATE-ON-ARRIVAL — 착수 구체화 카드 작성·판정(같은 LLM 래퍼 · 실패는 카드 없이 진행).
+      elaborateCallLLM: async ({ prompt, systemPrompt }) => o.llmReview!(systemPrompt ? `${systemPrompt}\n\n${prompt}` : prompt),
       diagnose: async ({ runId, note, kind, round, goal, history, supervisorDecisionHistory = [], judgePredictionAccuracy: predictionAccuracy, effectiveMax, priorRuns, reviewFindingTelemetry, refutations = [], refutationRound, purpose = 'budget' }: DefaultSeamsDiagnoseInput): Promise<string> => {
         const goalDigest = supervisorGoalDigest(goal, 3000);
         const predictionAccuracyForPrompt = predictionAccuracy

package/src/self-implement/stop-autoheal.ts

@@ -13,7 +13,7 @@
  *   main-sync          → rebase-regate            리베이스(MERGE-INTENT-RESOLVE 의도 해석) 뒤 재게이트
  *   pod-died           → resume-from-salvage      `salvage/run-<6hex>/<leaf>` 가지에서 resume(DRAFT-NOT-ARCHIVE)
  *   evidence-uncovered → derive-evidence-rejudge  런 출력·시험·배선에서 증거를 끌어내 1회 재판정
- *   review-repeat · review-out-of-scope · fabric · launch-failed · gate-failed · unclassified → needs-owner(새 라운드 없음)
+ *   review-repeat · review-out-of-scope · scope-escape · fabric · launch-failed · gate-failed · unclassified → needs-owner(새 라운드 없음)
  *
  * 사다리의 «출처»: `graphs/overlays/stop-heal-ladder.yaml` 이 갈래마다 처방 노드(id = 처방 이름)를 선언한다.
  *    그 갈래에 얹힌 오버레이가 더한 노드 id 가 처방이다(source='graph'). 선언이 없거나 못 읽으면
@@ -25,11 +25,15 @@
  * 관측 = `debug.log('self-implement.autoheal', …)` ⊕ 원장 `event='autoheal'`.
  */
 import { debug } from '../debug/log.js';
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { withFileLockSync } from '../storage/file-lock.js';
 import { applyGraphOverlays, defaultOverlaysDir, loadGraphOverlays, selectOverlays, type GraphOverlaySpec } from './graph-overlay-yaml.js';
 import type { GraphTemplateSpec } from './graph-yaml.js';
 import { GRAPH_SPECS } from './graph-templates.js';
 import { appendRunLedgerEntry, loadRunLedger, type RunLedgerEntry, type RunLedgerWriter } from './run-ledger.js';
-import type { RunStopClass, RunStopRecord } from './run-stop.js';
+import { boundRunStopCause, type RunStopClass, type RunStopRecord } from './run-stop.js';
 
 export const AUTOHEAL_EVENT = 'autoheal';
 export type AutohealMode = 'shadow' | 'live';
@@ -50,6 +54,7 @@ export const AUTOHEAL_ACTION_BY_CLASS: Readonly<Record<RunStopClass, AutohealAct
   'evidence-uncovered': 'derive-evidence-rejudge',
   'review-repeat': 'needs-owner',
   'review-out-of-scope': 'needs-owner',
+  'scope-escape': 'needs-owner',
   fabric: 'needs-owner',
   'launch-failed': 'needs-owner',
   'gate-failed': 'needs-owner',
@@ -164,6 +169,86 @@ export interface AutohealDeps {
   writeLedger?: RunLedgerWriter;
   /** 사다리 선언 읽기 — 기본은 활성 템플릿 ⊕ `graphs/overlays`. 던지면 코드 표로 간다. */
   loadLadder?: () => AutohealLadder;
+  /**
+   * 같은 골·칸의 «앞 런» stop 레코드(원장 줄은 `readRunStopRecord` 로 읽는다).
+   * 같은 갈래(class)의 멈춤이 반복되면 자동 재시도를 하지 않고 사유를 골 되먹임 대상으로 넘긴다.
+   * 안 주면 지금과 똑같이 동작한다.
+   */
+  priorStops?: readonly RunStopRecord[];
+  /** Parent-only candidate store. Omit in pure consumers/tests; the orchestrator supplies its instance root. */
+  knowhowCandidateDir?: string;
+}
+
+export type IntermediateStopReason = 'no-progress' | 'scope-escape' | 'wallclock-cap' | 'pod-job-failed';
+export interface StopKnowhowCandidate {
+  cell: string | null;
+  cellUnknownReason?: string;
+  reason: IntermediateStopReason;
+  stage: string;
+  stageUnknownReason?: string;
+  causeLine: string;
+  nextLaunchChange: string;
+  firstAt: string;
+  lastAt: string;
+  occurrences: number;
+  runIds: string[];
+}
+
+function intermediateStopReason(record: RunStopRecord): IntermediateStopReason | undefined {
+  const termination = record.childEvidence?.terminationReason;
+  if (record.class === 'scope-escape' || record.childEvidence?.scopeEscape === true || termination === 'scope-escape') return 'scope-escape';
+  if (termination === 'wallclock-cap') return 'wallclock-cap';
+  if (termination === 'no-progress') return 'no-progress';
+  if (record.terminationReason === 'pod-job-failed' || termination === 'pod-job-failed') return 'pod-job-failed';
+  return undefined;
+}
+
+const NEXT_LAUNCH_CHANGE: Record<IntermediateStopReason, string> = {
+  'no-progress': '골·완료 경계와 이미 끝난 범위를 다시 확인하고 남은 한 조각으로 고쳐 발사한다.',
+  'scope-escape': '허용 대상 경로와 범위 밖 편집 원문을 대조해 골의 경계를 수정한다.',
+  'wallclock-cap': '실행 시간을 넘긴 단계를 확인해 독립 조각으로 줄이고 중간 산출을 보존한다.',
+  'pod-job-failed': '자식 첫 오류와 Pod 종료 원인을 확인한 뒤 실행 환경 또는 골을 고쳐 발사한다.',
+};
+
+/** One file per cell and reason; the lock makes repeated parent stops one candidate. */
+export function captureStopKnowhowCandidate(ctx: AutohealContext, dir: string, now: () => Date = () => new Date()): { path: string; candidate: StopKnowhowCandidate; created: boolean } | undefined {
+  const reason = intermediateStopReason(ctx.record);
+  if (!reason) return undefined;
+  const cell = ctx.goalId?.trim() || null;
+  const key = createHash('sha256').update(`${cell ?? `unknown:${ctx.runId}`}\0${reason}`).digest('hex');
+  const path = join(dir, `${key}.json`);
+  mkdirSync(dir, { recursive: true });
+  return withFileLockSync(`${path}.lock`, () => {
+    const at = now().toISOString();
+    const old = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) as StopKnowhowCandidate : undefined;
+    if (old?.runIds.includes(ctx.runId)) return { path, candidate: old, created: false };
+    const created = old === undefined;
+    const candidate: StopKnowhowCandidate = old ? {
+      ...old,
+      stage: ctx.record.site ?? '미상',
+      ...(ctx.record.site ? { stageUnknownReason: undefined } : { stageUnknownReason: '기존 stop 원장에 site가 기록되지 않음' }),
+      causeLine: boundRunStopCause(String(ctx.record.childEvidence?.detail ?? ctx.record.cause)),
+      lastAt: at,
+      occurrences: old.occurrences + 1,
+      runIds: [...old.runIds, ctx.runId],
+    } : {
+      cell,
+      ...(cell ? {} : { cellUnknownReason: '칸 미상 · stop 호출에 goalId가 전달되지 않음' }),
+      reason,
+      stage: ctx.record.site ?? '미상',
+      ...(ctx.record.site ? {} : { stageUnknownReason: '기존 stop 원장에 site가 기록되지 않음' }),
+      causeLine: boundRunStopCause(String(ctx.record.childEvidence?.detail ?? ctx.record.cause)),
+      nextLaunchChange: NEXT_LAUNCH_CHANGE[reason],
+      firstAt: at,
+      lastAt: at,
+      occurrences: 1,
+      runIds: [ctx.runId],
+    };
+    const temp = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(candidate, null, 2)}\n`, { mode: 0o600 });
+    renameSync(temp, path);
+    return { path, candidate, created };
+  });
 }
 
 /**
@@ -184,6 +269,15 @@ export function autohealAlreadyAttempted(ledger: readonly RunLedgerEntry[] | nul
   return ledger.some((e) => e.event === AUTOHEAL_EVENT && e.data?.class === cls && e.data?.mode === mode);
 }
 
+/**
+ * 반복 멈춤 가드 — 앞 런의 stop 레코드 중 같은 갈래(class)가 `threshold` 이상이면 참.
+ * 같은 골에서 같은 갈래가 반복되면 자동 재시도를 끊고 사유를 골 되먹임 대상으로 넘긴다.
+ */
+export function repeatedStop(prior: readonly RunStopRecord[] | undefined, record: RunStopRecord, threshold = 2): boolean {
+  if (!prior) return false;
+  return prior.filter((p) => p.class === record.class).length >= threshold;
+}
+
 function observe(event: string, data: Record<string, unknown>): void {
   try { debug.log('self-implement.autoheal', event, data); } catch { /* observation is fail-soft */ }
 }
@@ -192,11 +286,27 @@ function observe(event: string, data: Record<string, unknown>): void {
  * stop 레코드 하나 → 최대 한 번의 힐 시도. 예외를 던지지 않는다(행동 seam 의 throw 도 needs-owner 로 접는다).
  */
 export async function autohealFromStop(ctx: AutohealContext, deps: AutohealDeps = {}): Promise<AutohealResult> {
+  if (deps.knowhowCandidateDir) {
+    try {
+      const captured = captureStopKnowhowCandidate(ctx, deps.knowhowCandidateDir);
+      if (captured) observe('knowhow-candidate', { runId: ctx.runId, cell: captured.candidate.cell, reason: captured.candidate.reason, created: captured.created, occurrences: captured.candidate.occurrences, path: captured.path });
+    } catch (error) {
+      observe('knowhow-candidate-failed', { runId: ctx.runId, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
   const mode = deps.mode ?? DEFAULT_AUTOHEAL_MODE;
   const cls = ctx.record.class;
   const { action, source, overlayId } = pickAutohealAction(cls, deps.loadLadder);
   const base = { runId: ctx.runId, class: cls, action, source, ...(overlayId ? { overlayId } : {}), mode };
 
+  if (repeatedStop(deps.priorStops, ctx.record)) {
+    // ⛔ 같은 골에서 같은 갈래의 멈춤이 반복되면 자동 재시도를 하지 않는다 — 사유를 골 되먹임 대상으로 넘긴다.
+    const n = deps.priorStops!.filter((p) => p.class === cls).length;
+    const reason = `repeat-stop: ${cls} ×${n} — feed back to goal: ${ctx.record.cause}`;
+    observe('repeat-stop', { ...base, reason });
+    return { ...base, outcome: 'needs-owner', reason };
+  }
+
   let ledger: readonly RunLedgerEntry[] | null = null;
   try {
     ledger = (deps.loadLedger ?? ((id) => loadRunLedger(id)))(ctx.runId);

package/src/session/chat.ts

@@ -42,6 +42,8 @@ import {
 // chat 툴루프를 canonical 엔진(runGoalLoop→runCoreTurn→streamLLMWithTools)으로 라우팅.
 // ACP bridge(core-turn-bridge.ts)·dashboard(runGoalLoopHook)와 동일 엔진 재사용(재발명 제거).
 import { runGoalLoop, type CoreTurnContext, type CoreTurnDispatchTool } from '../core-turn/index.js';
+import { composeChildContext, type ChildContextProfile } from '../self-implement/child-context-composition.js';
+import { getHarnessSpace } from '../harness/harness-space.js';
 
 export interface RunTurnOpts {
   userConfig: UserConfig;
@@ -272,6 +274,10 @@ export function buildRecentToolObservations(
   return `[직전 턴에 네가 실행한 도구와 결과 (참고용 컨텍스트) — 이어서 교정·판단할 때 근거로 삼되, 사용자가 이 원문을 봤다고 가정하지 말 것]\n${body}`;
 }
 
+/** CHILD-CONTEXT-BUDGET — 세션별 첫 goal-loop 턴 계측 1회 플래그(모듈 인메모리 —
+ * 원장·세션 저장소 형식은 무변경). 키: runTurn sessionId. */
+const childContextComposedSessions = new Set<string>();
+
 /** Run one conversational turn, persisting both sides to the session
  *  JSONL. Never throws on LLM failure — reraises with context. */
 export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
@@ -435,6 +441,27 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
     const goalLoopCfg = opts.userConfig.llm.goalLoop;
     const armGoalLoop = opts.goalLoop === true || goalLoopCfg?.enabled === true;
     if (armGoalLoop) {
+      // ⭐ CHILD-CONTEXT-BUDGET(0.2.35 칸) — 구현 자식(self-implement 공간)의 첫 goal-loop
+      //    턴에서 실제 effectiveSystemPrompt·turnTools 스키마·userText(골)의 구성 바이트를
+      //    composeChildContext 로 계측해 child.context-composition 사건 1회로 남긴다.
+      //    관측 전용 — 프롬프트·메시지는 무변경, 계측이 턴을 깨지 않는다(fail-open).
+      //    게이트: harness-space SSOT 로 구현 자식만 판별(getHarnessSpace().kind === 'self-implement')·
+      //    세션 첫 goal-loop 무장 턴 1회(모듈 인메모리 플래그 — 원장·세션 저장소는 무변경).
+      //    profile 은 자식 프롬프트 예산 신호(ELANOUS_PROMPT_BUDGET=lean — local 자식 스폰 시 주입)에서
+      //    실측 파생한다: lean → small(32k 바이트 상한), 아니면 default(무상한).
+      const isSelfImplementChild = getHarnessSpace()?.kind === 'self-implement';
+      if (isSelfImplementChild && !childContextComposedSessions.has(opts.sessionId)) {
+        childContextComposedSessions.add(opts.sessionId);
+        const childContextProfile: ChildContextProfile
+          = process.env.ELANOUS_PROMPT_BUDGET?.trim() === 'lean' ? 'small' : 'default';
+        try {
+          composeChildContext({
+            systemPrompt: effectiveSystemPrompt,
+            toolSchemas: JSON.stringify(turnTools),
+            goal: opts.userText,
+          }, { profile: childContextProfile });
+        } catch { /* 계측은 턴을 깨지 않는다 */ }
+      }
       const coreCtx: CoreTurnContext = {
         sessionId: opts.sessionId,
         // ⭐ 이 턴의 «사람 문장» 운반자. 없으면 표면 판정이 늘 기본값으로 떨어진다

package/src/session-runtime/index.ts

@@ -689,7 +689,7 @@ const SESSION_RUNTIME_TOOL_FAMILY_RULES: SessionRuntimeToolFamilyRule[] = [
   {
     id: 'ops-ledger',
     description: 'In-process seat messages and release checklist operations.',
-    names: ['msg_list', 'msg_post', 'msg_ack', 'checklist_list', 'checklist_add', 'checklist_set', 'checklist_edit', 'checklist_move'],
+    names: ['msg_list', 'msg_post', 'msg_ask', 'msg_ack', 'checklist_list', 'checklist_add', 'checklist_set', 'checklist_edit', 'checklist_move'],
     match: () => false,
   },
   {

package/src/session-runtime/retry-policy.ts

@@ -226,7 +226,8 @@ export function providerNamesFromFallbackChain(chain: readonly string[]): string
   const seen = new Set<string>();
   for (const step of chain) {
     // `codex-credits`(체인 마지막 칸 · 크레딧)도 provider 는 openai-codex 다 — 이미 앞에 있으면 중복이라 빠진다.
-    const name = step === 'grok' ? 'grok' : step === 'codex-rotate' || step === 'codex-credits' ? 'openai-codex' : undefined;
+    const name = step === 'grok' ? 'grok' : step === 'zai' ? 'glm'
+      : step === 'codex-rotate' || step === 'codex-credits' ? 'openai-codex' : undefined;
     if (!name || seen.has(name)) continue;
     seen.add(name);
     out.push(name);

package/src/setup/llm-env-detect.ts

@@ -77,6 +77,11 @@ export const PROVIDER_ENV_SPEC: readonly ProviderEnvSpec[] = [
     primaryKeyEnv: 'OPENROUTER_API_KEY',
     modelEnv: 'OPENROUTER_MODEL',
   },
+  {
+    provider: 'opengateway',
+    primaryKeyEnv: 'OPENGATEWAY_API_KEY',
+    modelEnv: 'OPENGATEWAY_MODEL',
+  },
 ] as const;
 
 export interface ProviderEnvDetection {