elanous 0.2.36 → 0.2.38

package/src/research-bridge/format.ts

@@ -7,6 +7,7 @@
 //     into the chat pane so the user sees what was archived.
 
 import type { ExternalResearchResult } from './types.js';
+import type { ResearchOutputRouteDecision } from '../research/output-router.js';
 
 const PREFILL_OUTPUT_CAP = 6000;
 
@@ -19,13 +20,27 @@ export function formatResearchSummary(r: ExternalResearchResult): string {
   return head;
 }
 
-export function formatResearchPrefill(r: ExternalResearchResult): string {
+// TODO(AXIS-FANOUT): pass the route from the production caller when that upstream interface lands.
+// Keeping it optional preserves the existing prefill byte-for-byte until then.
+export function formatResearchPrefill(r: ExternalResearchResult, route?: ResearchOutputRouteDecision): string {
   const truncated = r.output.length > PREFILL_OUTPUT_CAP;
   const body = truncated ? r.output.slice(0, PREFILL_OUTPUT_CAP) + '\n\n…(truncated — see archive)' : r.output;
   const lines: string[] = [];
   lines.push('<external-research>');
   lines.push(`  <topic>${r.topic}</topic>`);
   lines.push(`  <skill>${r.skill}</skill>`);
+  if (route) {
+    lines.push(`  <output_format>${route.format}</output_format>`);
+    lines.push(`  <question_weight source="${route.weightSource}">${route.weight}</question_weight>`);
+    lines.push(`  <output_route_observation>${JSON.stringify(route.observation)}</output_route_observation>`);
+    if (route.skillCallPlan) {
+      lines.push(`  <output_skill>${route.skillCallPlan.skill}</output_skill>`);
+      lines.push('  <output_skill_args>');
+      lines.push(route.skillCallPlan.args);
+      lines.push('  </output_skill_args>');
+    }
+    if (route.fallbackReason) lines.push(`  <output_route_fallback>${route.fallbackReason}</output_route_fallback>`);
+  }
   lines.push(`  <duration_ms>${r.durationMs}</duration_ms>`);
   lines.push(`  <ok>${r.ok}</ok>`);
   lines.push(`  <output>`);

package/src/research-bridge/index.ts

@@ -7,6 +7,7 @@ export type {
 
 export {
   invokeResearch,
+  invokeResearchAxes,
   setResearchInvoker,
   type ResearchInvoker,
   type ResearchInvocationOutcome,

package/src/research-bridge/invoke.ts

@@ -15,6 +15,8 @@
 
 import type { ExternalResearchResult, InvokeResearchOpts } from './types.js';
 import type { SkillManifest } from '../skills/runner.js';
+import type { BloomResearchQuestion } from '../auto-research/question-ladder-contract.js';
+import type { AxisFanoutDeps, AxisFanoutResult } from '../research/axis-fanout.js';
 import { recordResult } from './store.js';
 
 const DEFAULT_SKILL = 'omni-crawl';
@@ -31,6 +33,15 @@ const DEFAULT_SKILL = 'omni-crawl';
 // 조사 부작용만 원천 봉쇄. deny wins over allow(tool-policy). 순수·spread(원본 불변).
 export const RESEARCH_DENIED_TOOLS = ['Write', 'Edit', 'NotebookEdit'] as const;
 
+const ANSI_CONTROL_SEQUENCES = /\u001B(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007]*(?:\u0007|\u001B\\))/g;
+
+/** Select the model's final answer, never the TUI-rendered tool transcript. */
+export function researchOutputFromSkillRun(
+  run: { finalResponse: string },
+): string {
+  return run.finalResponse.replace(ANSI_CONTROL_SEQUENCES, '');
+}
+
 export function withResearchIsolation(manifest: SkillManifest): SkillManifest {
   const deniedTools = [...new Set([...(manifest.deniedTools ?? []), ...RESEARCH_DENIED_TOOLS])];
   return { ...manifest, deniedTools };
@@ -45,6 +56,21 @@ export interface ResearchInvocationOutcome {
   error?: string;
 }
 
+/** A successful skill call with no final answer is an incomplete invocation. */
+export function researchOutcomeFromSkillRun(
+  run: { finalResponse: string },
+): ResearchInvocationOutcome {
+  const output = researchOutputFromSkillRun(run);
+  if (output.length === 0) {
+    return {
+      output,
+      ok: false,
+      error: 'skill run finished without a final assistant response',
+    };
+  }
+  return { output, ok: true };
+}
+
 export type ResearchInvoker = (
   skillName: string,
   args: string,
@@ -59,6 +85,18 @@ export function setResearchInvoker(fn: ResearchInvoker | null): void {
   invoker = fn;
 }
 
+/** Research-turn entry once Bloom has supplied its question axes. This uses
+ *  native search per axis; it never sends the entire request to a skill. */
+export async function invokeResearchAxes(
+  questions: readonly BloomResearchQuestion[],
+  deps: AxisFanoutDeps = {},
+): Promise<AxisFanoutResult> {
+  // Keep the generic chat entry's static module closure unchanged; axis search
+  // is loaded only for a Bloom research turn.
+  const { fanOutAxisEvidence } = await import('../research/axis-fanout.js');
+  return fanOutAxisEvidence(questions, deps);
+}
+
 async function defaultInvoker(
   skillName: string,
   args: string,
@@ -73,17 +111,15 @@ async function defaultInvoker(
       error: `skill "${skillName}" not found under ~/.claude/skills/`,
     };
   }
-  let buffered = '';
   try {
     // ★ research 격리 — 파일-쓰기 도구 deny 주입(main 트리 오염 차단). Bash·검색도구는 유지.
-    const result = await executeSkill(withResearchIsolation(manifest), args, (delta, full) => {
-      buffered = full;
+    const result = await executeSkill(withResearchIsolation(manifest), args, (delta) => {
       if (onProgress) onProgress(delta);
     });
-    return { output: result.fullResponse || buffered, ok: true };
+    return researchOutcomeFromSkillRun(result);
   } catch (err) {
     return {
-      output: buffered,
+      output: '',
       ok: false,
       error: err instanceof Error ? err.message : String(err),
     };

package/src/seat-loop/seat-report.ts

@@ -134,6 +134,7 @@ export async function seatReport(seat: string, deps: SeatReportDeps = {}): Promi
         const [{ resolveRepositoryName }, { githubDraftSweepAdapters }] = await Promise.all([
           import('../harness/repository-name.js'), import('../harness/harness-cli-command.js'),
         ]);
+        // The collector folds repeated PR pages before this report formats the census.
         return collectDraftMetrics(resolveRepositoryName({}), githubDraftSweepAdapters(), clock);
       }))(now);
       draftDetail = ` · draft 재고 ${metrics.inventory} · 최장 나이 ${metrics.oldestAgeHours === null ? '해당 없음' : `${metrics.oldestAgeHours.toFixed(1)}h`} · needs-owner ${metrics.needsOwner} · 48h 전환율 ${metrics.conversion48h === null ? '표본 없음' : `${(metrics.conversion48h * 100).toFixed(1)}% (${metrics.converted48h}/${metrics.cohort48h})`}`;

package/src/self-dev/ask-launch-flow.ts

@@ -10,7 +10,7 @@
 //   (바꾸면 이 추출이 회귀인지 개선인지 사후에 못 가른다.)
 // ⛔ 종료(`process.exit`)는 여기가 «안» 한다 — 호출자가 자기 표면에 맞게 끝낸다.
 //   그래서 결과를 «세 값»으로 낸다: 발사 / 저작 전 중단 / 전제 검사 중단.
-import { linesOutsideFencedCode } from '../self-implement/goal-author.js';
+import { linesOutsideFencedCode, readGoalAuthorGroundingTimebox, type GoalAuthorGroundingTimebox } from '../self-implement/goal-author.js';
 import { existsSync } from 'node:fs';
 import { debug } from '../debug/log.js';
 import { appendRunLedgerEntry, runLedgerDir } from '../self-implement/run-ledger.js';
@@ -69,6 +69,23 @@ export interface AskAuthoredGoal {
   readonly authored?: { readonly document?: string; readonly grounded?: boolean | null; readonly authorRunId?: string } | null;
 }
 
+/**
+ * ⭐ AUTHOR-TIMEBOX 결과 줄 — `formatOrchestrateResultLine`
+ * (`  ${icon} ${status} · ${feature}${disp}${error}`)과 **같은 모양**을 쓴다.
+ *
+ * ⛔ `src/self-dev/orchestrate-summary-line.ts` 는 «안 고친다» — 다른 명령·화면의 기본 동작과
+ *   원장 형식은 보존 계약이다. 그래서 같은 모양을 이 자리에서 «쓴다».
+ * ⛔ 접지가 예산 초과로 끊긴 저작이 «조용히» 지나가면 상위 디스패처는 그 런을 성공으로도
+ *   실패로도 판정하지 못한다(80분 런 사망의 실제 모양).
+ */
+export function formatGoalAuthorTimeboxResultLine(
+  goalFile: string,
+  timebox: GoalAuthorGroundingTimebox,
+): string {
+  const feature = (goalFile.split('/').at(-1) ?? goalFile).slice(0, 56);
+  return `  ❌ NOT-GROUNDED · ${feature} [author-timebox] — grounding-timebox: exceeded ${timebox.budgetMs}ms budget after ${timebox.elapsedMs}ms; authoring stopped before launch`;
+}
+
 export type LaunchingTreeProbe =
   | { readonly kind: 'measured'; readonly ahead: number; readonly behind: number; readonly reference: string }
   | { readonly kind: 'unmeasurable'; readonly error: string };
@@ -240,7 +257,12 @@ export type AskLaunchFlowResult =
   /** ⓪ 저작 «전»에 막혔다 — 100초를 안 썼다. */
   | { readonly kind: 'stopped-before-authoring'; readonly goalFile?: undefined }
   /** ⑵⑶⑷ 에서 막혔다 — 골은 «있다»(사람이 열어볼 수 있게 돌려준다). */
-  | { readonly kind: 'stopped-by-preflight'; readonly goalFile: string; readonly blockers: LaunchPreflightResult['blockers'] };
+  | { readonly kind: 'stopped-by-preflight'; readonly goalFile: string; readonly blockers: LaunchPreflightResult['blockers'] }
+  /** ⑴ 저작에서 접지 예산(AUTHOR-TIMEBOX)을 넘겨 NOT-GROUNDED 로 끝났다 — 발사하지 «않는다». */
+  | { readonly kind: 'stopped-by-timebox'; readonly goalFile: string };
+
+/** ⑴ AUTHOR-TIMEBOX NOT-GROUNDED — 결과 줄을 쓰고 흐름을 끊는 값. */
+export type AskLaunchFlowTimeboxStop = Extract<AskLaunchFlowResult, { kind: 'stopped-by-timebox' }>;
 
 /** 런 식별자가 흐름 뒤에 확정된 호출자는 이 관측으로 입구와 런을 조인한다. */
 export function observeAskLaunchRunIdentity(
@@ -738,7 +760,7 @@ async function intakeClarifications(
   input: AskLaunchFlowInput,
   deps: AskLaunchFlowDeps,
   selfResolveClarifications: ResolvedSelfResolveClarifications,
-): Promise<string> {
+): Promise<string | AskLaunchFlowTimeboxStop> {
   let effectiveGoalFile = authored.path;
   let document = deps.readFile(effectiveGoalFile);
   const { pending, mode } = planClarificationIntake(document, deps.isInteractive());
@@ -824,6 +846,28 @@ async function intakeClarifications(
   const parentDocument = document;
   effectiveGoalFile = isAbsolutePath(reauthored.path) ? reauthored.path : resolvePath(deps.cwd(), reauthored.path);
   deps.print(`[ask] ⑴b 재저작됨: ${reauthored.path}`);
+  // 재저작도 «같은 저작 진입점»이다 — 접지가 예산 초과로 끊기면 같은 결과 줄을 쓴다(조용히 넘기지 않는다).
+  const reauthoredTimebox = reauthored.authored?.document === undefined
+    ? null
+    : readGoalAuthorGroundingTimebox(reauthored.authored.document);
+  if (reauthoredTimebox !== null) {
+    deps.print(formatGoalAuthorTimeboxResultLine(reauthored.path, reauthoredTimebox));
+    deps.log('ask-author-timebox', {
+      goalFile: reauthored.path,
+      provenance: 'reauthor',
+      outcome: 'NOT-GROUNDED',
+      budgetMs: reauthoredTimebox.budgetMs,
+      elapsedMs: reauthoredTimebox.elapsedMs,
+      grounded: reauthored.authored?.grounded ?? null,
+    }, 'warn');
+    // ⛔⭐⭐ 재저작 NOT-GROUNDED 도 «끝»이다 — 결과 줄을 쓰고 되묻기 이후 단계로 지나가지 않는다.
+    observeFrontNodeExit({ node: 'author', outcome: 'not-grounded' }, {
+      ...(input.runId === undefined ? {} : { runId: input.runId }),
+      attempt: 1, goalFile: effectiveGoalFile,
+      reason: `grounding-timebox-exhausted (budget ${reauthoredTimebox.budgetMs}ms, elapsed ${reauthoredTimebox.elapsedMs}ms)`,
+    });
+    return { kind: 'stopped-by-timebox', goalFile: effectiveGoalFile };
+  }
   // ⛔ 「재저작이 «났다»」와 「재저작이 «옳았다»」는 다른 물음이다(JDG-T35 3단 ⑶).
   const childDocument = reauthored.authored?.document ?? deps.readFile(effectiveGoalFile);
   const askFidelity = classifyReauthoredAsk(parentDocument, childDocument);
@@ -886,10 +930,10 @@ export async function runAskLaunchFlow(
   if (launchPreflight === false) return { kind: 'stopped-before-authoring' };
 
   await deps.beforeAuthoring?.();
-  const authorAndPreflight = async (authorAskText: string = input.askText, machineSuggestedTargetPaths: readonly string[] = [], attempt = 1): Promise<{
-    readonly goalFile: string;
-    readonly decision: ReturnType<typeof decideAskPreflight>;
-  }> => {
+  const authorAndPreflight = async (authorAskText: string = input.askText, machineSuggestedTargetPaths: readonly string[] = [], attempt = 1): Promise<
+    | { readonly goalFile: string; readonly decision: ReturnType<typeof decideAskPreflight> }
+    | AskLaunchFlowTimeboxStop
+  > => {
     // ⛔ 수를 박지 않는다 — 「100~110초」가 박혀 있었고 2026-08-23 prod 실측은 «206초»(2배)였다.
     //    재는 명령: elanous logs --category goal-author --event phase-end --json --json-data
     deps.print('[ask] ⑴ 저작 — self author (수 분 걸린다 · 페이즈별 실측은 goal-author/phase-end)');
@@ -926,6 +970,29 @@ export async function runAskLaunchFlow(
       throw error;
     });
     deps.print(`[ask] 저작됨: ${authored.path}`);
+    // ⛔⭐⭐ AUTHOR-TIMEBOX — 접지가 예산을 넘겨 끊긴 저작은 «결과 줄» 없이 지나가면 안 된다.
+    //   이 자리가 ask → Pod 발사를 쥔 곳이므로(이 흐름이 발사 여부를 정한다), 여기서 한 줄을 쓴다.
+    const groundingTimebox = authored.authored?.document === undefined
+      ? null
+      : readGoalAuthorGroundingTimebox(authored.authored.document);
+    if (groundingTimebox !== null) {
+      deps.print(formatGoalAuthorTimeboxResultLine(authored.path, groundingTimebox));
+      deps.log('ask-author-timebox', {
+        goalFile: authored.path,
+        provenance: 'author',
+        outcome: 'NOT-GROUNDED',
+        budgetMs: groundingTimebox.budgetMs,
+        elapsedMs: groundingTimebox.elapsedMs,
+        grounded: authored.authored?.grounded ?? null,
+      }, 'warn');
+      // ⛔⭐⭐ NOT-GROUNDED 는 «끝»이다 — 이 흐름이 발사 여부를 정하므로, 결과 줄을 쓰고 나서
+      //   되묻기·전제 검사·발사로 «지나가지 않는다». 저작 종료 출구를 그래프에 남기고 흐름을 끊는다.
+      observeFrontNodeExit({ node: 'author', outcome: 'not-grounded' }, {
+        ...frontObservation, attempt, goalFile: authored.path,
+        reason: `grounding-timebox-exhausted (budget ${groundingTimebox.budgetMs}ms, elapsed ${groundingTimebox.elapsedMs}ms)`,
+      });
+      return { kind: 'stopped-by-timebox', goalFile: authored.path };
+    }
     // AUTHOR-TRACE: the authored goal file can be cleaned up later — keep path ⊕ sha256 ⊕ size in the run ledger and
     // archive the body, so authoring length is measurable after the fact (GOAL-BENCH · AUTHOR-LITE).
     const traceIds = {
@@ -979,10 +1046,13 @@ export async function runAskLaunchFlow(
     }, markerCounts !== null && markerCounts.missingMarkers > 0 ? 'warn' : 'info');
 
     // ⛔ 되묻기에 답하면 «새 골»이 나온다 — 아래 전제 검사·발사는 그 «최종» 골을 써야 한다.
-    const goalFile = await intakeClarifications({
+    const clarifiedGoalFile = await intakeClarifications({
       ...authored,
       path: isAbsolutePath(authored.path) ? authored.path : resolvePath(deps.cwd(), authored.path),
     }, input, deps, selfResolveClarifications);
+    // 재저작이 AUTHOR-TIMEBOX 로 끊겼으면 이 흐름도 그대로 끊는다 — 전제 검사·발사로 지나가지 않는다.
+    if (typeof clarifiedGoalFile !== 'string') return clarifiedGoalFile;
+    const goalFile = clarifiedGoalFile;
     // The child reads this file again. Filtering only preflight.paths would leave the same bogus
     // TRACED PATHS prose in the child and repeat its missing-file failure.
     let sanitizeFailed = false;
@@ -1090,7 +1160,10 @@ export async function runAskLaunchFlow(
     });
   };
 
-  let authored = await authorAndPreflight();
+  let firstAuthored = await authorAndPreflight();
+  // 저작 단계가 AUTHOR-TIMEBOX NOT-GROUNDED 로 끝났으면 이 흐름도 그대로 끊는다.
+  if ('kind' in firstAuthored) return firstAuthored;
+  let authored = firstAuthored;
   let reauthored = false;
   const retryableNoTargetPaths = !input.forceRequested
     && !authored.decision.shouldLaunch
@@ -1142,9 +1215,12 @@ export async function runAskLaunchFlow(
       deps.print('[ask] ⑴ ⚠️ 자동 재저작에 넣을 대상 경로 후보가 없다. 대상 경로를 확인해야 한다');
     }
     recordPodAuthoring('ask-auto-reauthor', { candidatePathCount: candidates.paths.length, firstPathCount: first.decision.result.paths.length, outcome: 'started' });
-    authored = await authorAndPreflight(selectedPaths.length > 0
+    const secondAuthored = await authorAndPreflight(selectedPaths.length > 0
       ? `대상 경로: ${selectedPaths.join(' · ')}\n${input.askText}`
       : input.askText, selectedPaths, 2);
+    // 재시도 저작도 AUTHOR-TIMEBOX 로 끊길 수 있다 — 그러면 발사하지 않는다.
+    if ('kind' in secondAuthored) return secondAuthored;
+    authored = secondAuthored;
     // 두 번째 not-grounded 는 re-ground 예산(max_visits 1)을 넘어 needs-human(근거 카드)으로 — 판정은 observeFrontNodeExit 가 선언에서 읽는다.
     observeAuthorExit(2, authored, !authored.decision.shouldLaunch && authorNotGrounded(authored.decision) ? 'not-grounded' : 're-authored');
     deps.log('ask-auto-reauthor', {

package/src/self-dev/decompose-proposal.ts

@@ -276,7 +276,7 @@ export interface ShadowFirstPlan {
 /** shadow-first 집행 판정. ⛔ 「고칠 수 없음」과 「거부」를 같은 값으로 접지 않는다. */
 export type ShadowFirstDispatch =
   | { kind: 'ok'; pieces: DecomposePiece[]; shadowFirst?: ShadowFirstPlan }
-  | { kind: 'rejected'; reason: 'dangling-dependsOn'; danglingIds: string[] };
+  | { kind: 'rejected'; reason: 'dangling-dependsOn' | 'shadow-depends-on-live' | 'shadow-depends-on-self'; detail: string[] };
 
 /**
  * ⭐⭐⭐ shadow 관측이 live 발사보다 «앞선다» — AUTHOR-SHADOW-FIRST-SPLIT ② (#26884 수확).
@@ -290,13 +290,21 @@ export type ShadowFirstDispatch =
  *     없는 조각을 선행으로 단 제안은 승격하지 않는다(`danglingDependsOn` 을 세는 것만으로는 live 발사를 못 막는다).
  *   ⓑ shadow 조각이 «둘» 이상 → `kind: 'ok'` 지만 «가드 없음» — 어느 쪽이 관측인지 모르는 제안은 고치지 않는다.
  *
- * ⭐ 선행 간선은 «실제 발사 지점»(다른 조각이 의존하지 않는 끝 조각)에만 건다 — 중간 조각은
- *   자기 선행 순서만 들고 있으면 되고, 그 것까지 shadow 에 매달면 계획이 사슬로 납작해진다.
- *   shadow 조각은 언제나 맨 앞으로 올라오고, 이미 shadow 를 선행으로 가진 조각은 건드리지 않는다.
+ * ⭐ 모든 live 조각이 shadow 를 선행으로 가져야 관측이 어떤 실행 순서보다 먼저다.
+ *   live 조각 사이의 기존 의미 의존성은 그대로 둔다. shadow 가 live 조각에 의존하는 경우는
+ *   이 순서와 모순이므로 거부한다.
  *
  * 순수 함수다 — 시계·파일·프로세스를 안 만진다. 입력 조각은 «변형하지 않는다».
  */
 export function planShadowFirstDispatch(pieces: readonly DecomposePiece[]): ShadowFirstDispatch {
+  const shadowPieces = pieces.filter((piece) => piece.id === SHADOW_PIECE_ID);
+  if (shadowPieces.length !== 1) return { kind: 'ok', pieces: [...pieces] };
+
+  const shadow = shadowPieces[0]!;
+  const rest = pieces.filter((piece) => piece !== shadow);
+  if (shadow.dependsOn.includes(SHADOW_PIECE_ID)) {
+    return { kind: 'rejected', reason: 'shadow-depends-on-self', detail: [SHADOW_PIECE_ID] };
+  }
   const known = new Set(pieces.map((piece) => piece.id));
   const danglingIds: string[] = [];
   for (const piece of pieces) {
@@ -305,19 +313,20 @@ export function planShadowFirstDispatch(pieces: readonly DecomposePiece[]): Shad
       danglingIds.push(dep);
     }
   }
-  if (danglingIds.length) return { kind: 'rejected', reason: 'dangling-dependsOn', danglingIds };
-
-  const shadowPieces = pieces.filter((piece) => piece.id === SHADOW_PIECE_ID);
-  if (shadowPieces.length !== 1) return { kind: 'ok', pieces: [...pieces] };
-
-  const shadow = shadowPieces[0]!;
-  const rest = pieces.filter((piece) => piece !== shadow);
-  const dependedUpon = new Set<string>();
-  for (const piece of rest) for (const dep of piece.dependsOn) dependedUpon.add(dep);
+  if (danglingIds.length) return { kind: 'rejected', reason: 'dangling-dependsOn', detail: danglingIds };
+
+  // A shadow observation cannot be ordered before a live piece if it itself
+  // depends on that piece. Reject this cyclic ordering instead of returning a
+  // plan that appears shadow-first but cannot be dispatched in that order.
+  const liveIds = new Set(rest.map((piece) => piece.id));
+  const shadowLiveDependencies = shadow.dependsOn.filter((dep) => liveIds.has(dep));
+  if (shadowLiveDependencies.length) {
+    return { kind: 'rejected', reason: 'shadow-depends-on-live', detail: [...new Set(shadowLiveDependencies)] };
+  }
 
   let restoredEdges = 0;
   const reordered = rest.map((piece) => {
-    if (dependedUpon.has(piece.id) || piece.dependsOn.includes(SHADOW_PIECE_ID)) return piece;
+    if (piece.dependsOn.includes(SHADOW_PIECE_ID)) return piece;
     restoredEdges++;
     return { ...piece, dependsOn: [...piece.dependsOn, SHADOW_PIECE_ID] };
   });
@@ -457,7 +466,7 @@ export function readDecomposeProposals(input: {
 /** 승격하지 «않은» 제안 하나 — ⛔ 조용히 원본만 두면 다음 라운드가 같은 제안을 다시 쓴다. */
 export interface DecomposeRejection {
   feature: string;
-  reason: 'dangling-dependsOn';
+  reason: 'dangling-dependsOn' | 'shadow-depends-on-live' | 'shadow-depends-on-self';
   /** 무엇이 매달렸나 — 조각 목록에 없는 선행 id 들. */
   detail: string[];
 }
@@ -533,17 +542,19 @@ export function applyDecomposeProposals(
   for (const goal of goals) {
     const pieces = byFeature.get(goal.feature);
     if (!pieces) { out.push(goal); continue; }
-    // ⛔⭐ shadow-first 가드 — 매달린 선행 간선이 있는 제안은 «쪼개지 않는다»(원본을 그대로 둔다).
+    // ⛔⭐ shadow-first 가드 — shadow proposal의 매달린 간선은 «쪼개지 않는다»(원본 유지).
+    // 일반 proposal은 기존 orderPiecesTopologically 계약대로 dangling 간선을 세고 계속 처리한다.
     const plan = planShadowFirstDispatch(pieces);
     if (plan.kind === 'rejected') {
-      rejected.push({ feature: goal.feature, reason: plan.reason, detail: [...plan.danglingIds] });
+      rejected.push({ feature: goal.feature, reason: plan.reason, detail: [...plan.detail] });
       // ⛔⭐ 거부를 «로그와 값에 다» 남긴다 — 조용히 버리면 다음 라운드가 같은 제안을 다시 쓴다.
       //   혼합 문서 거부(mixed-decompose-document)와 같은 관측 채널·같은 fail-open 규율이다.
       try {
         debug.log('self-dev.decompose', 'decompose-rejected', {
           feature: goal.feature,
           reason: plan.reason,
-          danglingIds: [...plan.danglingIds],
+          detail: [...plan.detail],
+          ...(plan.reason === 'dangling-dependsOn' ? { danglingIds: [...plan.detail] } : {}),
         });
       } catch { /* fail-open */ }
       out.push(goal);

package/src/self-dev/decompose.ts

@@ -442,6 +442,24 @@ function isRawSubtask(value: unknown): value is RawSubtask {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
+function ensureSingleCompletionCriterion(feature: string, targetPaths: string[]): string {
+  const lines = feature.split(/\r?\n/);
+  const criteria = lines.filter((line) => /^\s*완료 기준\s*:/.test(line));
+  if (criteria.length === 0) {
+    return `${feature}\n완료 기준: ${targetPaths.join(' · ')}의 변경을 확인하고 관련 시험을 통과한다.`;
+  }
+  if (criteria.length === 1 && criteria[0]!.trim().length > '완료 기준:'.length) return feature;
+  const criterionText = criteria
+    .map((line) => line.replace(/^\s*완료 기준\s*:\s*/, '').trim())
+    .filter(Boolean)
+    .join(' · ');
+  const normalizedCriterion = criterionText || `${targetPaths.join(' · ')}의 변경을 확인하고 관련 시험을 통과한다.`;
+  const firstCriterionIndex = lines.findIndex((line) => /^\s*완료 기준\s*:/.test(line));
+  const withoutCriteria = lines.filter((line) => !/^\s*완료 기준\s*:/.test(line));
+  withoutCriteria.splice(Math.min(firstCriterionIndex, withoutCriteria.length), 0, `완료 기준: ${normalizedCriterion}`);
+  return withoutCriteria.join('\n');
+}
+
 /**
  * G6 (1c) — 결정론적 hotPaths 추론. 분해된 sub-goal 의 feature 텍스트에서 repo 파일
  * 경로(src/…·docs/…·scripts/… + 확장자)를 뽑는다. LLM 이 hotPaths 를 안 채워도 hot-file
@@ -476,7 +494,8 @@ export function inheritDecomposedTargetPaths(parentFeature: string, goals: SelfD
         ? own[index]!
         : (goal.hotPaths ?? []).filter((path) => parentTargets.includes(path)));
       const claimedOwners = parentTargets.map((path) => goals.flatMap((_, index) => claims[index]!.includes(path) ? [index] : []));
-      const conflictingClaims = claimedOwners.some((indices) => indices.length > 1);
+      const sharedExplicitTarget = own.length === 2 && own[0]!.some((path) => own[1]!.includes(path));
+      const conflictingClaims = sharedExplicitTarget || claimedOwners.some((indices) => indices.length > 1);
       const nameOwners = parentTargets.map((path) => {
         const stemWords = path.split('/').at(-1)!.replace(/\.[^.]+$/, '').toLowerCase().match(/[a-z0-9]+/g) ?? [];
         if (!stemWords.length || stemWords.join('').length < 4) return [];
@@ -507,24 +526,41 @@ export function inheritDecomposedTargetPaths(parentFeature: string, goals: SelfD
       // A named path wins over model order; if every path points at one child,
       // keep the old scope rather than inventing work for the other child.
       const partitions = goals.map((_, index) => parentTargets.filter((_, pathIndex) => owners[pathIndex] === index));
-      const sharedOtherPaths = (goals[0]?.hotPaths ?? []).some((path) =>
-        !parentTargets.includes(path) && (goals[1]?.hotPaths ?? []).includes(path));
       const conflictingParentReference = goals.some((goal, index) =>
         own[index]!.length > 0 && (goal.hotPaths ?? []).some((path) =>
           parentTargets.includes(path) && !own[index]!.includes(path)));
       if (partitions.every((paths) => paths.length > 0)
         && !conflictingClaims && !ambiguousName && !conflictingNameClaim && !conflictingUnclaimedHint
-        && !sharedOtherPaths && !conflictingParentReference) return goals.map((goal, index) => {
+        && !conflictingParentReference) return goals.map((goal, index) => {
         const targets = partitions[index]!;
-        return { ...goal, hotPaths: [...new Set([...(goal.hotPaths ?? []), ...targets])],
-          feature: `${goal.feature}${own[index]!.length ? '' : `\n대상 경로: ${targets.join(' · ')}`}\n완료 기준: ${targets.join(' · ')}의 변경을 확인하고 관련 시험을 통과한다.` };
+        // A declared child target may add a helper outside the parent fence. Bare
+        // hotPaths outside that fence are references, so do not widen the write fence.
+        const explicitHelpers = own[index]!.filter((path) => !parentTargets.includes(path));
+        const feature = `${goal.feature}${own[index]!.length ? '' : `\n대상 경로: ${targets.join(' · ')}`}`;
+        return { ...goal, hotPaths: [...new Set([...targets, ...explicitHelpers])],
+          feature: ensureSingleCompletionCriterion(feature, targets) };
       });
     }
   }
-  return goals.map((goal) => {
+  const explicitChildTargets = goals.map((goal) => declaredTargets(goal.feature ?? ''));
+  const explicitParentTargets = explicitChildTargets.map((paths) => paths.filter((path) => parentTargets.includes(path)));
+  const explicitTargetsArePartition = goals.length === 2
+    && explicitParentTargets.every((paths) => paths.length > 0)
+    && new Set(explicitChildTargets.flat()).size === explicitChildTargets.flat().length
+    && explicitParentTargets[0]!.every((path) => !explicitParentTargets[1]!.includes(path))
+    && new Set(explicitParentTargets.flat()).size === parentTargets.length
+    && parentTargets.every((path) => explicitParentTargets.flat().includes(path))
+    && goals.every((goal, index) => (goal.hotPaths ?? []).every((path) =>
+      !parentTargets.includes(path) || explicitChildTargets[index]!.includes(path)));
+  return goals.map((goal, index) => {
     // hotPaths also contains inferred references; only an explicit target line establishes child scope.
-    const own = declaredTargets(goal.feature ?? '');
-    if (own.length) return goal;
+    const own = explicitChildTargets[index]!;
+    if (own.length) {
+      if (explicitTargetsArePartition) {
+        return { ...goal, hotPaths: own, feature: ensureSingleCompletionCriterion(goal.feature ?? '', own) };
+      }
+      return goal;
+    }
     return { ...goal, hotPaths: [...new Set([...(goal.hotPaths ?? []), ...parentTargets])],
       feature: `${goal.feature}\n대상 경로: ${parentTargets.join(' · ')}` };
   });

package/src/self-dev/dev-pipeline.ts

@@ -45,7 +45,7 @@ import { addSelfDevRunParticipant, processBirthId, saveSelfDevRun } from './run-
 import { getUserConfig, resolveRoleLlm, type RoleLlmSource } from '../user-config.js';
 import { applyGlmCredentialFallback, GlmChildCredentialError } from './glm-credential-guard.js';
 import { reviewReasoningEffort } from '../model-tier/review-effort.js';
-import { getProvider, inferProviderFromModel } from '../llm.js';
+import { getProvider, getProviderForConfig, inferProviderFromModel } from '../llm.js';
 import { buildReviewProviderAttempts, defaultReviewFallbackModel, runReviewWithFallback, reviewFallbackModelsFromConfig, runSubscriptionReviewer, type SubscriptionReviewerDeps } from './review-provider-fallback.js';
 import { loadLlmPolicy, resolveSubscriptionReviewer } from '../policy/llm-policy.js';
 import type { DefaultSeamsOptions } from '../self-implement/seams.js';
@@ -1126,12 +1126,34 @@ export async function buildDefaultSelfImplementSeams(
   //   ⛔ 쿼터 폴백(`DEFAULT_FALLBACK_CHAIN`)과 «다른 축»이다 — 그 자는 「계정이 남았나」를 본다.
   //   ⭐ 첫 시도 성공이면 종전과 «완전히 동일»하다(관측 한 줄만 는다).
   const reviewFallbackModels = reviewFallbackModelsFromConfig();
-  const reviewAttemptForModel = (model: string, label: string) => ({
-    model,
-    provider: inferProviderFromModel(model) ? getProvider(model) : undefined,
-    label,
-  });
-  const primaryReviewAttempt = reviewAttemptForModel(reviewModel, 'primary');
+  const reviewAttemptForModel = (model: string, label: string, configuredProvider?: string) => {
+    // GLM's historical alias and both OpenRouter spellings identify the same model even when
+    // a Pod/default role carries no provider source. Resolve the provider from the canonical ID.
+    const normalizedInput = model.trim().toLowerCase();
+    const isGlm53 = normalizedInput === 'glm-5.3'
+      || normalizedInput === 'z-ai/glm-5.3'
+      || normalizedInput === 'openrouter/z-ai/glm-5.3';
+    const normalizedModel = isGlm53
+      ? 'openrouter/z-ai/glm-5.3'
+      : configuredProvider === 'openrouter' && !model.startsWith('openrouter/') ? `openrouter/${model}` : model;
+    const routeProvider = normalizedModel === 'openrouter/z-ai/glm-5.3' ? 'openrouter' : configuredProvider;
+    let provider: ReturnType<typeof getProvider> | undefined;
+    try {
+      if (routeProvider) {
+        const config = getUserConfig();
+        provider = getProviderForConfig({ ...config, llm: { ...config.llm, provider: routeProvider as typeof config.llm.provider } }, normalizedModel);
+      } else if (inferProviderFromModel(normalizedModel)) {
+        provider = getProvider(normalizedModel);
+      }
+    } catch {
+      // An unavailable or unsupported configured primary must not prevent the existing fallback attempt.
+    }
+    return { model: normalizedModel, provider, label };
+  };
+  const primaryProviderIsPinned = reviewRole.source === 'flag' || reviewRole.source === 'config-role'
+    || reviewRole.source === 'environment';
+  const configuredPrimaryProvider = primaryProviderIsPinned ? reviewRole.provider : undefined;
+  const primaryReviewAttempt = reviewAttemptForModel(reviewModel, 'primary', configuredPrimaryProvider);
   const reviewAttempts = buildReviewProviderAttempts(
     primaryReviewAttempt,
     [...reviewFallbackModels, defaultReviewFallbackModel(primaryReviewAttempt.provider?.name)]