elanous 0.2.35 → 0.2.36

package/src/self-dev/decompose.ts

@@ -460,6 +460,67 @@ export function inheritDecomposedTargetPaths(parentFeature: string, goals: SelfD
     .flatMap(inferHotPaths))];
   const parentTargets = declaredTargets(parentFeature);
   if (!parentTargets.length) return goals;
+  // A two-part implementation must not hand a pathless child its sibling's
+  // target as part of the parent edit fence. Keep other decompositions below.
+  if (goals.length === 2 && parentTargets.length >= 2
+    && goals.every((goal) => goal.goalType === undefined || goal.goalType === 'implement')) {
+    const own = goals.map((goal) => declaredTargets(goal.feature ?? ''));
+    const undeclared = own.map((paths, index) => paths.length ? -1 : index).filter((index) => index >= 0);
+    const declared = own.flat();
+    const canDivide = undeclared.length === 2
+      || (undeclared.length === 1 && declared.length > 0
+        && declared.some((path) => parentTargets.includes(path))
+        && parentTargets.some((path) => !declared.includes(path)));
+    if (canDivide) {
+      const claims = goals.map((goal, index) => own[index]!.length
+        ? 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 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 [];
+        return goals.flatMap((goal, childIndex) => {
+          const words = (goal.feature ?? '').toLowerCase().match(/[a-z0-9]+/g) ?? [];
+          return words.some((_, start) => stemWords.every((word, offset) => words[start + offset] === word)) ? [childIndex] : [];
+        });
+      });
+      const ambiguousName = nameOwners.some((indices, index) => claimedOwners[index]!.length === 0 && indices.length > 1);
+      const conflictingNameClaim = claimedOwners.some((indices, index) => indices.length === 1
+        && nameOwners[index]!.some((namedOwner) => namedOwner !== indices[0]));
+      const claimCounts = [0, 1].map((index) => claimedOwners.filter((indices) => indices.length === 1 && indices[0] === index).length);
+      const soleClaimant = claimCounts[0]! > 0 && claimCounts[1] === 0 ? 0
+        : claimCounts[1]! > 0 && claimCounts[0] === 0 ? 1 : undefined;
+      const conflictingUnclaimedHint = soleClaimant !== undefined && nameOwners.some((indices, index) =>
+        claimedOwners[index]!.length === 0 && indices.includes(soleClaimant));
+      const owners = parentTargets.map((_, index) => claimedOwners[index]!.length === 1
+        ? claimedOwners[index]![0]
+        : soleClaimant !== undefined ? 1 - soleClaimant
+          : nameOwners[index]!.length === 1 ? nameOwners[index]![0] : undefined);
+      const ownerCounts = [owners.filter((owner) => owner === 0).length, owners.filter((owner) => owner === 1).length];
+      owners.forEach((owner, index) => {
+        if (owner !== undefined) return;
+        const next = ownerCounts[0]! <= ownerCounts[1]! ? 0 : 1;
+        owners[index] = next;
+        ownerCounts[next] = (ownerCounts[next] ?? 0) + 1;
+      });
+      // 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) => {
+        const targets = partitions[index]!;
+        return { ...goal, hotPaths: [...new Set([...(goal.hotPaths ?? []), ...targets])],
+          feature: `${goal.feature}${own[index]!.length ? '' : `\n대상 경로: ${targets.join(' · ')}`}\n완료 기준: ${targets.join(' · ')}의 변경을 확인하고 관련 시험을 통과한다.` };
+      });
+    }
+  }
   return goals.map((goal) => {
     // hotPaths also contains inferred references; only an explicit target line establishes child scope.
     const own = declaredTargets(goal.feature ?? '');

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

@@ -1064,7 +1064,23 @@ export async function executeDevSelfRun(
 
     // ⛔ 슈퍼바이저 직전이 아니라 «호출 시작»이다 — 첫 런 도중의 정지도 이 호출의 정지다.
     const invocationStartedAt = supervise.invocationStartedAtMs ?? enteredAtMs;
-    const recordRestart = (kind: 'relaunch' | 'promoted-piece', previousResult: { worktreePath?: string }): boolean => {
+    const honorChildSoftStop = (kind: 'relaunch' | 'promoted-piece', previousResult: { worktreePath?: string; stage?: string; runId?: string }): boolean => {
+      // A Pod stop marker lives inside the child container, while its result intentionally
+      // omits the container worktree path. The child's soft-stopped stage is therefore the
+      // durable evidence available to this host before it decides to launch another Pod.
+      if (previousResult.stage !== 'soft-stopped') return false;
+      const spaceId = getHarnessSpace()?.id || normalizeSpaceId(basename(previousResult.worktreePath ?? ''));
+      supervisorStopReason = 'human-stopped';
+      try {
+        debug.log('self-dev.supervisor', 'soft-stop-honored', {
+          spaceId: spaceId || null, runId: previousResult.runId ?? null,
+          source: 'child-stage', skipped: kind === 'promoted-piece' ? 'piece' : kind, surface: 'dev',
+        });
+      } catch { /* fail-open */ }
+      return true;
+    };
+    const recordRestart = (kind: 'relaunch' | 'promoted-piece', previousResult: { worktreePath?: string; stage?: string; runId?: string }): boolean => {
+      if (honorChildSoftStop(kind, previousResult)) return true;
       const spaceId = getHarnessSpace()?.id || normalizeSpaceId(basename(previousResult.worktreePath ?? ''));
       writeHarnessStageFrame(spaceId, 'supervisor', `${kind} after ${Date.now() - invocationStartedAt}ms`);
       if (!spaceId) {
@@ -1091,6 +1107,10 @@ export async function executeDevSelfRun(
       }
     };
     retainConfirmedMerge(result);
+    if (honorChildSoftStop('relaunch', result)) {
+      triageDrafts();
+      return { result, supervisorStopReason: 'human-stopped' };
+    }
     await superviseRun({
       initial: [initialJob],
       // A review-oscillation repair goal runs through the existing piece executor (fragment re-execution with the
@@ -1169,6 +1189,10 @@ export async function executeDevSelfRun(
             const repairResult = recordResult(await supervise.executePiece(goal));
             retainConfirmedMerge(repairResult);
             if (shardResults === undefined) result = repairResult;
+            if (honorChildSoftStop('relaunch', repairResult)) {
+              result = repairResult;
+              return [];
+            }
             repaired.push({ ...asSupervisorJobResult(job.feature, repairResult), oscillationRepairOf: job.taskId });
           }
           // Jobs without a repair goal are not dropped: their last result stays in the round for the next decision.
@@ -1188,10 +1212,15 @@ export async function executeDevSelfRun(
                 pieceIndex: index, ...(base === undefined ? {} : { base }), surface: 'dev',
               });
             } catch { /* fail-open */ }
-            pieceResults.push(recordResult(await supervise.executePiece!(
+            const pieceResult = recordResult(await supervise.executePiece!(
               piece.feature,
               base === undefined ? undefined : { base },
-            )));
+            ));
+            if (honorChildSoftStop('promoted-piece', pieceResult)) {
+              result = pieceResult;
+              return [];
+            }
+            pieceResults.push(pieceResult);
           }
           shardResults = pieceResults.map((pieceResult, index) => asSupervisorJobResult(pieces[index]!.feature, pieceResult));
           const folded = foldDevShardResults(shardResults);
@@ -1213,9 +1242,14 @@ export async function executeDevSelfRun(
         const rerunResult = recordResult(await execute(relaunch));
         retainConfirmedMerge(rerunResult);
         if (shardResults === undefined) result = rerunResult;
+        if (honorChildSoftStop('relaunch', rerunResult)) {
+          result = rerunResult;
+          return [];
+        }
         return [asSupervisorJobResult(feature, rerunResult)];
       },
     });
+    if (result.stage === 'soft-stopped' && supervisorStopReason !== 'human-stopped') honorChildSoftStop('relaunch', result);
     if (supervisorStopReason === 'converged' && promotedDecomposition && (() => {
       try { return statSync(feature).isFile(); } catch { return false; }
     })()) {

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

@@ -43,6 +43,7 @@ import type { ReviewerContextItem } from '../agent-substrate/pr-reviewer.js';
 import { resolveRunIdentity, type RunIdSource } from '../harness/harness-space.js';
 import { addSelfDevRunParticipant, processBirthId, saveSelfDevRun } from './run-store.js';
 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 { buildReviewProviderAttempts, defaultReviewFallbackModel, runReviewWithFallback, reviewFallbackModelsFromConfig, runSubscriptionReviewer, type SubscriptionReviewerDeps } from './review-provider-fallback.js';
@@ -587,6 +588,11 @@ export async function defaultDispatchAcp(
 export function toSelfImplementOptions(text: string, plan: ResolvedDevPlan, seams: SelfImplementSeams): SelfImplementOptions {
   const s = plan.self ?? {};
   const goalId = 'file' in plan.input ? parseGoalId(text) : null;
+  // GLM-NO-CREDENTIAL-FALLBACK (OP #28375) — glm 자식인데 Z.ai 자격이 없으면 «발사 전»에 OpenRouter GLM 으로 바꾸거나
+  //   이유 한 줄로 거부한다(구현 0 라운드를 만들지 않는다). glm 이 아니거나 자격이 있으면 그대로다.
+  let childLlm = s.childLlm;
+  try { childLlm = applyGlmCredentialFallback(s.childLlm); }
+  catch (error) { if (error instanceof GlmChildCredentialError) throw new DevPipelineError(error.message); throw error; }
   return {
     feature: text,
     seams,
@@ -611,11 +617,11 @@ export function toSelfImplementOptions(text: string, plan: ResolvedDevPlan, seam
     ...(s.parentSessionId ? { parentSessionId: s.parentSessionId } : {}),
     ...(s.documentReferences ? { documentReferences: s.documentReferences } : {}),
     ...(s.naturalLanguageDispatch ? { naturalLanguageDispatch: true } : {}),
-    ...(s.childLlm ? { childLlm: s.childLlm } : {}),
+    ...(childLlm ? { childLlm } : {}),
     ...(s.correlationId !== undefined ? { correlationId: s.correlationId } : {}),
     // BENCH-ISOLATED-ARMS ② — base 가 `bench/<id>/base` 면 팔 가지 `bench/<id>/<arm>` (명시 branchName 이 이긴다).
     ...(() => {
-      const branchName = s.branchName ?? benchArmBranchForBase(plan.base, s.childLlm?.model, process.env.ELANOUS_RUN_ID?.trim() || randomUUID());
+      const branchName = s.branchName ?? benchArmBranchForBase(plan.base, childLlm?.model, process.env.ELANOUS_RUN_ID?.trim() || randomUUID());
       return branchName ? { branchName } : {};
     })(),
     ...(s.maxReworkRounds !== undefined ? { maxReworkRounds: s.maxReworkRounds } : {}),

package/src/self-dev/draft-triage-rules.ts

@@ -17,6 +17,12 @@ export function draftClaimState(draft: { labels: readonly string[]; updatedAt?:
   return (now.getTime() - updated) / 3_600_000 < CLAIM_IDLE_HOURS ? 'claimed' : 'expired';
 }
 
+/** DRAFT-CLAIM-AUTO-2-FU — 카드에 남은 claim 기록(`draftClaim.at`)이 아직 살아 있나 — `draftClaimState` 와 «같은 창»(CLAIM_IDLE_HOURS)을 쓴다. */
+export function draftClaimRecordLive(at: string, now: Date): boolean {
+  const updated = Date.parse(at);
+  return Number.isFinite(updated) && (now.getTime() - updated) / 3_600_000 < CLAIM_IDLE_HOURS;
+}
+
 export interface DraftTriagePr {
   number: number;
   title?: string;
@@ -209,7 +215,32 @@ export function laterMergedTwins(draft: DraftTriagePr, mergedTwins: readonly Dra
       || (draftSlot && slot(pr.body) === draftSlot) || (stem && branchStem(pr.branch) === stem)));
 }
 
+/**
+ * DRAFT-ZERO — explicit harvest-deferred marker: the exact PR-metadata key·value a failed run's termination
+ * path records when the draft's changes must survive the sweep for harvest. The marker line is
+ * `수확보류: harvest-deferred` (body key·value, never a label-registry entry); the value byte-matches the keep reason.
+ */
+export const HARVEST_DEFERRED_MARKER_KEY = '수확보류';
+export const HARVEST_DEFERRED_MARKER_VALUE = 'harvest-deferred';
+
+const HARVEST_DEFERRED_ROW_RE = new RegExp(`^${HARVEST_DEFERRED_MARKER_KEY}:\\s*([^\\r\\n]*)$`);
+const HARVEST_DEFERRED_CONFLICT_RE = new RegExp(`^\\s*${HARVEST_DEFERRED_MARKER_KEY}\\s*:`);
+
+/** Verified only when at least one unindented `수확보류:` body line exists and every such line carries exactly the marker value — missing, indented or conflicting lines never verify. */
+export function harvestDeferredMarker(body: string | undefined): boolean {
+  const lines = (body ?? '').split(/\r?\n/);
+  const rows = lines.flatMap((line) => {
+    const match = HARVEST_DEFERRED_ROW_RE.exec(line);
+    return match ? [match[1]!.trim()] : [];
+  });
+  return lines.filter((line) => HARVEST_DEFERRED_CONFLICT_RE.test(line)).length === rows.length
+    && rows.length > 0 && rows.every((value) => value === HARVEST_DEFERRED_MARKER_VALUE);
+}
+
 export function decideDraft({ draft, runStatus, mergedTwins, openDrafts, ageHours, liveBranches, finalRunResult }: DraftTriageInput): DraftDecision {
+  // DRAFT-ZERO — a verified harvest-deferred marker is the strongest hold: it outranks protected labels
+  // and every close rule, so a failed run's harvestable draft survives the sweep for harvest.
+  if (runStatus === 'failed' && harvestDeferredMarker(draft.body)) return { action: 'keep', reason: 'harvest-deferred' };
   const held = draft.labels?.find((label) => PROTECTED_LABELS.has(label));
   if (held) return { action: 'keep', reason: `label:${held}` };
   if (runStatus !== 'self-implement.result final' && draft.branch && liveBranches.has(draft.branch)

package/src/self-dev/glm-credential-guard.ts

@@ -0,0 +1,77 @@
+/**
+ * GLM-NO-CREDENTIAL-FALLBACK (OP #28375 · 10-22) — 하니스 자식 공급자가 `glm`(Z.ai GLM Coding Plan 직결)인데
+ * 이 프로세스에 Z.ai 자격이 없으면, 구현 라운드를 «열기 전»에 정한다:
+ *   · OpenRouter 키가 있으면 → `openrouter` / `openrouter/z-ai/glm-5.3` 로 바꿔 발사한다(같은 GLM 계열 · 관측 한 줄).
+ *   · 둘 다 없으면 → 이유 한 줄로 발사 전에 거부한다(조용한 no-progress 라운드를 만들지 않는다).
+ *
+ * ⭐ 자격 판정은 생산 해석기 그대로다 — `zaiCodingPlanAvailable()`(키 캐시 `~/.cache/zai_api_key` → env `ZAI_API_KEY`)이
+ *   `getProviderForConfig` 가 glm 직결을 세우는 조건과 «같은» 함수이고, OpenRouter 는 `getOpenRouterApiKey()` 다.
+ * ⛔ Pod 경로는 이 판정 «전»에 이미 fail-closed 다(`pod-zai-child.ts` · 클러스터 Secret 판정). Pod 안에선 Secret 이
+ *   `ZAI_API_KEY` 를 env 로 주므로 여기는 그대로 통과한다(keep). 이 모듈은 호스트 로컬 자식·Secret 밖 경로의 받침이다.
+ * ⛔ 이 모듈은 가볍게 둔다(무거운 import 0) — dev-pipeline 이 발사 직전에 부른다.
+ */
+
+import type { ChildLlmSelection } from '../agent/run-context.js';
+import { getOpenRouterApiKey } from '../config.js';
+import { debug } from '../debug/log.js';
+import { ZAI_OPENROUTER_FALLBACK_MODEL, zaiCodingPlanAvailable } from '../llm/zai-coding-plan.js';
+
+export interface GlmCredentialProbe {
+  /** Z.ai 직결이 서나 — 기본 = 생산 `zaiCodingPlanAvailable()`. */
+  readonly zai: () => boolean;
+  /** OpenRouter 키가 있나 — 기본 = 생산 `getOpenRouterApiKey()`. */
+  readonly openrouter: () => boolean;
+}
+
+export const defaultGlmCredentialProbe: GlmCredentialProbe = {
+  zai: () => zaiCodingPlanAvailable(),
+  openrouter: () => Boolean(getOpenRouterApiKey()?.trim()),
+};
+
+export type GlmCredentialDecision =
+  | { kind: 'keep' }
+  | { kind: 'fallback'; from: string; to: string; reason: string }
+  | { kind: 'refuse'; reason: string };
+
+/** 발사 전 거부 — 호출부가 자기 오류 종류로 감싼다(dev-pipeline 은 DevPipelineError). */
+export class GlmChildCredentialError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'GlmChildCredentialError';
+  }
+}
+
+const ZAI_MISSING = 'Z.ai 자격 없음(~/.cache/zai_api_key · env ZAI_API_KEY)';
+
+/** 순수 판정 — glm 이 아니면 언제나 keep. */
+export function decideGlmChildCredential(
+  selection: Pick<ChildLlmSelection, 'provider' | 'model'> | undefined,
+  probe: GlmCredentialProbe = defaultGlmCredentialProbe,
+): GlmCredentialDecision {
+  if (!selection || selection.provider.trim().toLowerCase() !== 'glm') return { kind: 'keep' };
+  if (probe.zai()) return { kind: 'keep' };
+  const from = `glm/${selection.model}`;
+  if (probe.openrouter()) {
+    return { kind: 'fallback', from, to: `openrouter/${ZAI_OPENROUTER_FALLBACK_MODEL}`, reason: `${ZAI_MISSING} · OpenRouter 키 있음 → OpenRouter GLM 으로 발사` };
+  }
+  return {
+    kind: 'refuse',
+    reason: `child provider glm(${selection.model}) 발사 전 거부 — ${ZAI_MISSING} ⊕ OpenRouter 키 없음(~/.cache/openrouter_api_key · env OPENROUTER_API_KEY) · 자격 하나를 세우거나 --child-llm-provider 를 바꿔라`,
+  };
+}
+
+/** 발사 직전 적용 — keep 이면 같은 객체, fallback 이면 바꾼 선택, refuse 면 던진다. 결정마다 관측 한 줄. */
+export function applyGlmCredentialFallback(
+  selection: ChildLlmSelection | undefined,
+  probe: GlmCredentialProbe = defaultGlmCredentialProbe,
+): ChildLlmSelection | undefined {
+  const decision = decideGlmChildCredential(selection, probe);
+  if (decision.kind === 'keep') return selection;
+  if (decision.kind === 'fallback') {
+    debug.log('self-dev.child-llm', 'glm-no-credential-fallback', { from: decision.from, to: decision.to, reason: decision.reason }, { level: 'warn' });
+    // effort·source·codexQuotaPolicy 는 그대로 — 바뀌는 것은 «길»(provider·model)뿐이다.
+    return { ...selection!, provider: 'openrouter', model: ZAI_OPENROUTER_FALLBACK_MODEL };
+  }
+  debug.log('self-dev.child-llm', 'glm-no-credential-refused', { from: `glm/${selection!.model}`, reason: decision.reason }, { level: 'warn' });
+  throw new GlmChildCredentialError(decision.reason);
+}

package/src/self-dev/graph-journey-nodes.ts

@@ -42,6 +42,7 @@ export const JOURNEY_NODE_IDS = [
   'decision-card',
   'ready',
   'pr-head-checkout',
+  'recover',          // LAND-REFUSAL-EDGES — 착지 거부 결속 간선의 목적지(recover@1 subgraph)
   'stopped',
 ] as const;
 export type JourneyNodeId = typeof JOURNEY_NODE_IDS[number];

package/src/self-dev/graph-journey-route.ts

@@ -117,8 +117,16 @@ export function readJourneyEdge(
   return route;
 }
 
+/** 간선 행에 덧붙이는 조인·근거 칸.
+ *  `moveId` 는 next-move 결정 순간 한 번 만든 값(HARNESS-FULL-GRAPH-NEXTMOVE · 여기서 만들지 않는다).
+ *  그 밖의 칸은 그 간선에 결속할 근거(예: 착지 거부 원문·cardId · LAND-REFUSAL-EDGES) — 간선 칸(from·to·taken…)을 덮지 못한다. */
+export interface JourneyEdgeFields {
+  readonly moveId?: string;
+  readonly [key: string]: unknown;
+}
+
 /** 실제로 탄 간선을 남긴다 — `taken` 은 실제 다음 노드(그래프 답과 다르면 `honored: false` · 그 이유를 `reason` 에). */
-export function recordJourneyEdge(route: JourneyRoute, taken: string, reason?: string): void {
+export function recordJourneyEdge(route: JourneyRoute, taken: string, reason?: string, data: JourneyEdgeFields = {}): void {
   try {
     if (route.ambiguousConditions?.length) debug.log('self-implement', 'edge-ambiguous', {
       graphId: 'self-implement', from: route.from, conditions: route.ambiguousConditions,
@@ -132,8 +140,10 @@ export function recordJourneyEdge(route: JourneyRoute, taken: string, reason?: s
       graphId: 'self-implement', node: skipped.node, reason: 'condition', condition: skipped.condition,
       ...journeyJoinFields(),
     });
+    // Evidence never overrides an edge field: the later spread wins, and `reason`/join keys are reserved.
+    const { reason: _reservedReason, journeyKey: _reservedJourney, queueLaunchId: _reservedLaunch, ...evidence } = data ?? {};
     debug.log('self-implement', 'graph-edge-taken', {
-      graphId: 'self-implement', ...route, taken, honored: route.to === null || route.to === taken,
+      ...evidence, graphId: 'self-implement', ...route, taken, honored: route.to === null || route.to === taken,
       ...(reason === undefined ? {} : { reason }), ...journeyJoinFields(),
     });
   } catch { /* 관측은 fail-soft */ }

package/src/self-dev/orchestrate-cli.ts

@@ -342,9 +342,15 @@ export async function runSelfOrchestrateCliCommand(
   try {
     // ⭐ goals·spec 이 «라운드마다 바뀔 수 있다» — 분해 제안이 조각을 쪼개면 연합으로 승격된다.
     let currentGoals = input.goals;
+    // A supervised split starts from an ordinary single goal, so the CLI did not
+    // receive --decompose/parentRequest. Preserve that goal as the boundary source
+    // when its children replace it in a later round.
+    let supervisedParentRequest = input.parentRequest;
     let spec = buildSelfOrchestrateDevSpec(currentGoals, input.concurrency);
     /** 이미 쪼갠 goal — ⛔ 같은 것을 두 번 쪼개면 조각이 무한히 불어난다. */
     const decomposedFeatures = new Set<string>();
+    /** 거부된 제안의 feature — ⛔ 다음 라운드가 같은 제안을 다시 쓰고 다시 조용히 거부하는 것을 막는다. */
+    const rejectedFeatures = new Set<string>();
     const repairFingerprints = new Map<string, number>();
     const repairAppend: RepairAppendObservation[] = [];
     let repairFragmentsAdded = 0;
@@ -383,7 +389,7 @@ export async function runSelfOrchestrateCliCommand(
     };
     const runtimeWithParentRequest = (): OrchestrateRuntime => {
       const runtime = runtimeForObservationCycle();
-      return input.parentRequest === undefined ? runtime : { ...runtime, parentRequest: input.parentRequest };
+      return supervisedParentRequest === undefined ? runtime : { ...runtime, parentRequest: supervisedParentRequest };
     };
     const exec = deps.executeReroute ?? executeOrchestrateReroute;
     const pipelineDeps = deps.pipelineDeps ? { pipelineDeps: deps.pipelineDeps } : undefined;
@@ -391,11 +397,35 @@ export async function runSelfOrchestrateCliCommand(
     let baseRuntime = runtimeWithParentRequest();
     let { results, exitCode } = await exec(spec, baseRuntime, pipelineDeps);
 
+    // ⭐⭐⭐ SUPERVISOR-SOFTSTOP-HONOR — 사람이 child 를 멈췄다는 신호(stage 'soft-stopped')는
+    //   «라운드 경계»에서 존중된다(재현 원장 run-8cf691c5: ccaf Pod 가 soft-stopped 로 끝났는데
+    //   5초 뒤 fa fa Pod 가 발사됐다). 근거는 «이번 invocation 에서 막 끝난 결과»뿐이다 —
+    //   과거 checkpoint 의 soft-stopped 항목을 읽지 않으므로 새 호출의 무관한 작업을 막지 않는다.
+    const childSoftStop = (rs: readonly SelfDevJobResult[]): SelfDevJobResult | undefined =>
+      rs.find((r) => r.stage === 'soft-stopped');
+    // ⭐ 원샷 래치 — 이번 invocation 이 «같은 정지된 조각»을 두 번 계상하지 않는다: rerun 재진입
+    //   방어가 pair 를 이미 냈으면 종착 관측(stoppedAfter)이 같은 taskId 로 재발행하지 않는다.
+    //   #30606 리뷰: 방어가 여러 번 재진입돼도(결과 불변 감독 루프) pair 는 정확히 1회.
+    const honoredStops = new Set<string>();
+    const observeSoftStopHonored = (stopped: SelfDevJobResult, round: number): void => {
+      if (honoredStops.has(stopped.taskId)) return;
+      honoredStops.add(stopped.taskId);
+      try {
+        debug.log('self-dev.supervisor', 'human-stopped', { stage: 'soft-stopped', taskId: stopped.taskId, round });
+        debug.log('self-dev.supervisor', 'soft-stop-honored', { stage: 'soft-stopped', taskId: stopped.taskId, round });
+      } catch { /* observation must not interrupt execution */ }
+    };
+
     // ⭐⭐⭐ 런 슈퍼바이저 — 스위치가 켜졌으면 «여기»서 끝까지 돈다.
     //   ⛔ 프로세스를 다시 띄우지 않는다: resumeFrom 심으로 같은 프로세스 안에서 라운드를 돌아야
     //     runId·체크포인트·관측이 한 줄로 이어진다.
     //   ⛔ 판정은 순수 모듈(run-supervisor)이 하고, 이 심은 그 답을 «집행»만 한다.
     if (input.supervise) {
+      const stoppedFirst = childSoftStop(results);
+      // 첫 라운드가 사람 정지로 끝났으면 재발사를 «시작하지 않는다» — 총 exec 1 · 다음 Pod 0.
+      // 라운드 표기는 strategy.launch 와 같은 1-기반(첫 exec = round 1)을 쓴다.
+      if (stoppedFirst) observeSoftStopHonored(stoppedFirst, 1);
+      if (!stoppedFirst) {
       const limits = {
         ...(input.supervise.rounds === undefined ? {} : { maxRounds: input.supervise.rounds }),
         ...(input.supervise.stallRounds === undefined ? {} : { stallRounds: input.supervise.stallRounds }),
@@ -435,6 +465,14 @@ export async function runSelfOrchestrateCliCommand(
         // ⭐ 방금 끝난 결과를 넘긴다 — orchestrateSelfDev 가 classifyResumeDisposition 으로
         //   skip/rerun 을 갈라준다(재발명 0 · 착지한 조각은 다시 안 돈다).
         rerun: async (previous, invocation) => {
+          // ⭐⭐⭐ SUPERVISOR-SOFTSTOP-HONOR — 직전 라운드가 사람 정지(stage 'soft-stopped')로
+          //   끝났으면 다음 exec(spec, resumeFrom…) 직전에 멈춘다. 근거는 «이번 invocation 에서
+          //   막 끝난 previous» 하나뿐 — 과거 checkpoint 를 읽지 않으므로 새 호출을 막지 않는다.
+          const stoppedPrevious = childSoftStop(previous);
+          if (stoppedPrevious) {
+            observeSoftStopHonored(stoppedPrevious, supervisedRound + 1);
+            return previous;
+          }
           let addedRepairIds: string[] = [];
           // A requested repair that cannot be bound to exactly one goal is held (not relaunched with the old strategy).
           const unrepairedHold: string[] = [];
@@ -485,15 +523,37 @@ export async function runSelfOrchestrateCliCommand(
           //   ⛔ 의존성은 조각이 «들고 온 그대로» 물려준다 ⇒ dependsOn 이 없는 조각은
           //     orchestrateSelfDev 의 위상 병렬로 «자동으로 동시에» 돈다(대표 2026-08-19 기본 동작).
           const goalsBeforeDecompose = new Set(currentGoals);
-          const applied = applyDecomposeProposals(currentGoals, previous, { alreadyDecomposed: decomposedFeatures });
+          const applied = applyDecomposeProposals(currentGoals, previous, {
+            // ⛔⭐ 거부된 feature 도 «다시 제안되지 않게» 한다 — 이미 쪼갠 것과 같은 상태로 센다.
+            //   이렇게 하지 않으면 다음 라운드가 같은 제안을 다시 읽고 다시 조용히 거부한다.
+            alreadyDecomposed: new Set([...decomposedFeatures, ...rejectedFeatures]),
+          });
+          // ⛔⭐ 거부된 제안을 «상태로» 남긴다 — applyDecomposeProposals 안의 관측과 함께
+          //   「쪼개지 않았다」는 사실과 그 사유가 로그와 라운드 간 상태에 다 남는다.
+          if (applied.rejected.length > 0) {
+            for (const rejection of applied.rejected) rejectedFeatures.add(rejection.feature);
+            try {
+              debug.log('self-dev.supervisor', 'decompose-rejected.applied', {
+                rejected: applied.rejected.map((rejection) => ({
+                  feature: rejection.feature.slice(0, 120),
+                  reason: rejection.reason,
+                  danglingIds: [...rejection.detail],
+                })),
+              });
+            } catch { /* fail-open */ }
+          }
           if (applied.decomposed.length > 0) {
+            if (supervisedParentRequest === undefined && applied.decomposed.length === 1
+              && currentGoals.length === 1 && currentGoals[0]?.feature === applied.decomposed[0]) {
+              supervisedParentRequest = applied.decomposed[0];
+            }
             for (const f of applied.decomposed) decomposedFeatures.add(f);
             currentGoals = applied.goals;
             spec = buildSelfOrchestrateDevSpec(currentGoals, input.concurrency);
             try {
               // ⛔⭐ 「원본 ↔ 조각」을 «이름»으로 남긴다 — 수만 남기면 그 연결이 «영영» 안 남는다.
               //   📏 2026-08-19 자수: 초판이 decomposed.length 만 실었다. 그러면 나중에
-              //     「이 런이 어느 원본에서 쪼개졌나」를 «아무 데서도» 못 가린다.
+              //     「이 런이 어느 원본에서 쪼개졌나»를 «아무 데서도» 못 가린다.
               //   ⚠️ 그리고 이 값은 «로그»라 보존이 짧다(~2.5시간 실측 · 원장은 15일) —
               //     원장에 싣는 것이 다음 칸이다(🅣 축 · E0).
               debug.log('self-dev.supervisor', 'decompose-and-retry.applied', {
@@ -569,6 +629,11 @@ export async function runSelfOrchestrateCliCommand(
           return next.results;
         },
       });
+      // 감독 루프가 사람 정지 라운드 뒤 rerun 없이 스스로 멈출 수도 있다 — 그 종결도
+      // 이번 invocation 의 «막 끝난» 결과만 근거로 이름 있는 관측으로 남긴다.
+      const stoppedAfter = childSoftStop(results);
+      if (stoppedAfter) observeSoftStopHonored(stoppedAfter, supervisedRound + 1);
+      } // (!stoppedFirst — 사람 정지면 superviseRun 자체를 시작하지 않는다)
     }
 
     return { ok: true, results, exitCode, ...(repairAppend.length ? { repairAppend } : {}) };