elanous 0.2.23 → 0.2.24

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

@@ -65,6 +65,7 @@ import { findGrokModel, GROK_MODELS } from '../grok/models.js';
 import { resolveModelAlias } from '../intelligence-map/model-alias.js';
 import { BUILTIN_CATALOG } from '../intelligence-map/model-catalog.js';
 import { BEDROCK_DEFAULT_MODEL, BEDROCK_MODELS, findBedrockModel, resolveBedrockModelId } from '../llm/bedrock.js';
+import { ZAI_CODING_DEFAULT_MODEL, ZAI_CODING_MODELS } from '../llm/zai-coding-plan.js';
 
 /** `dev --plan` 도움말이 가리키는 대응 문. ⛔ 도움말에 이 문자열을 리터럴로 다시 적지 마라. */
 export const DEV_PLAN_REPLACEMENT = 'elanous harness say';
@@ -1097,6 +1098,9 @@ export async function executeDevSelfRun(
     retainConfirmedMerge(result);
     await superviseRun({
       initial: [initialJob],
+      // A review-oscillation repair goal runs through the existing piece executor (fragment re-execution with the
+      // authored goal as its feature). Without that executor the rerun could only replay the same goal — declare false.
+      repairGoalExecution: supervise.executePiece !== undefined,
       enrich: (results) => hydrateDevGoalCauseObserved(
         hydrateDevDecomposeProposals(results, supervise.readProposals ?? readDecomposeProposals),
       ),
@@ -1157,7 +1161,24 @@ export async function executeDevSelfRun(
           }) + orderingNote,
         };
       },
-      rerun: async (previous, { relaunch }) => {
+      rerun: async (previous, { relaunch, repairGoals }) => {
+        const repairJobs = previous.flatMap((job) => repairGoals?.[job.taskId] === undefined ? [] : [{ job, goal: repairGoals[job.taskId]! }]);
+        if (repairJobs.length > 0 && supervise.executePiece !== undefined) {
+          if (recordRestart('relaunch', previous.at(-1)!)) return [];
+          executedRounds += 1;
+          // Every authored repair goal runs (one per oscillating task), each keeping its task's goal feature so a
+          // second oscillation is recognised as «already repaired».
+          const repaired: ReturnType<typeof asSupervisorJobResult>[] = [];
+          for (const { job, goal } of repairJobs) {
+            try { debug.log('self-dev.supervisor', 'oscillation-repair.executed', { surface: 'dev', taskId: job.taskId, chars: goal.length }); } catch { /* fail-open */ }
+            const repairResult = recordResult(await supervise.executePiece(goal));
+            retainConfirmedMerge(repairResult);
+            if (shardResults === undefined) result = repairResult;
+            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.
+          return [...repaired, ...previous.filter((job) => repairGoals?.[job.taskId] === undefined)];
+        }
         if (promotedPieces !== undefined) {
           const pieces = promotedPieces;
           promotedPieces = undefined;
@@ -1340,12 +1361,19 @@ export function normalizeChildLlmProvider(provider: string): string {
     : p;
 }
 
+/** CLAUDE-IMPL-LANE — claude-acp = Claude 구독 ACP 구현 레인(src/agent-substrate/acp-implementer.ts). 모델 카탈로그·사다리는 anthropic 과 같다. */
+function childModelCatalogProvider(provider: string): string {
+  const normalized = normalizeChildLlmProvider(provider);
+  return normalized === 'claude-acp' ? 'anthropic' : normalized;
+}
+
 function isKnownChildLlmProvider(provider: string): boolean {
-  return ['grok', 'anthropic', 'gemini', 'openai', 'openai-codex', 'local', 'openrouter', 'bedrock'].includes(normalizeChildLlmProvider(provider));
+  // ZAI-POD-CHILD (0.2.24) — glm = Z.ai GLM Coding Plan 직결(`ZAI_API_KEY` · src/llm/zai-coding-plan.ts). Pod 자식이 `--child-llm-provider glm` 으로 뜬다.
+  return ['grok', 'anthropic', 'claude-acp', 'gemini', 'openai', 'openai-codex', 'local', 'openrouter', 'bedrock', 'glm'].includes(normalizeChildLlmProvider(provider));
 }
 
 function findPickerCatalogModel(provider: string, id: string): CatalogModelView | undefined {
-  switch (normalizeChildLlmProvider(provider)) {
+  switch (childModelCatalogProvider(provider)) {
     case 'grok': return findGrokModel(id);
     case 'anthropic': return findClaudeModel(id);
     case 'gemini': return findGeminiModel(id);
@@ -1353,12 +1381,15 @@ function findPickerCatalogModel(provider: string, id: string): CatalogModelView
     case 'openai-codex': return findCodexModel(id);
     case 'openrouter': return findOpenRouterChildModel(id);
     case 'bedrock': return findBedrockChildModel(id);
+    case 'glm': return (ZAI_CODING_MODELS as readonly string[]).includes(id)
+      ? { id, tier: /flash/i.test(id) ? 'budget' : 'balanced', supportsThinking: true, recommended: id === ZAI_CODING_DEFAULT_MODEL }
+      : undefined;
     default: return undefined;
   }
 }
 
 /** BEDROCK-PROVIDER — `anthropic.claude-sonnet-5-5` · `bedrock/claude-sonnet-5-5` · (provider=bedrock 일 때) `claude-sonnet-5-5`
- *  를 받아 와이어 id(`anthropic.` 접두)로 해석한다. 표 밖은 «모른다» → 거부(다른 provider 와 같은 규율). */
+ *  를 받아 와이어 id 로 해석한다(5.5 = 전역 추론 프로필 `global.anthropic.…` · BEDROCK-RUNTIME-PATH). 표 밖은 «모른다» → 거부(다른 provider 와 같은 규율). */
 function findBedrockChildModel(id: string): CatalogModelView | undefined {
   const entry = findBedrockModel(id);
   if (!entry) return undefined;
@@ -1394,7 +1425,7 @@ function tierFromBuiltin(tags: readonly string[] | undefined): string {
 }
 
 function findBuiltinCatalogModel(provider: string, id: string): CatalogModelView | undefined {
-  const expected = normalizeChildLlmProvider(provider);
+  const expected = childModelCatalogProvider(provider);
   const entry = BUILTIN_CATALOG.models.find((model) => (
     model.id === id && normalizeChildLlmProvider(model.provider) === expected
   ));
@@ -1408,7 +1439,7 @@ function findBuiltinCatalogModel(provider: string, id: string): CatalogModelView
 }
 
 function listImplementationChildModelCandidates(provider: string): string[] {
-  const expected = normalizeChildLlmProvider(provider);
+  const expected = childModelCatalogProvider(provider);
   const picker = (() => {
     switch (expected) {
       case 'grok': return GROK_MODELS.map((model) => model.id);
@@ -1418,6 +1449,7 @@ function listImplementationChildModelCandidates(provider: string): string[] {
       case 'openai-codex': return CODEX_MODELS.map((model) => model.id);
       case 'openrouter': return [...new Set(MODEL_TIERS.map((t) => LLM_TIER_MAP_BY_PROVIDER.openrouter[t].model))];
       case 'bedrock': return BEDROCK_MODELS.map((model) => model.id);
+      case 'glm': return [...ZAI_CODING_MODELS];
       default: return [];
     }
   })();
@@ -1576,10 +1608,12 @@ export function grokWeeklyUsedPctFromUsageJson(stdout: string): number | undefin
 /** `elanous usage --json` 의 grok 행 → 잔량 판정. 한 행이라도 100% 미만이면 usable, 모두 100% 이상이면 exhausted. */
 export function grokQuotaFromUsageJson(stdout: string): 'usable' | 'exhausted' | 'unknown' {
   try {
-    const parsed = JSON.parse(stdout) as { rows?: Array<{ provider?: string; credits?: { status?: string; usedPercent?: number | null } }> };
+    const parsed = JSON.parse(stdout) as { rows?: Array<{ provider?: string; credits?: { status?: string; periodType?: string | null; usedPercent?: unknown } }> };
     const percents = (parsed.rows ?? [])
-      .filter((row) => row.provider === 'grok' && row.credits?.status === 'ok' && typeof row.credits.usedPercent === 'number')
-      .map((row) => row.credits!.usedPercent as number);
+      .filter((row) => row.provider === 'grok' && row.credits?.status === 'ok'
+        && row.credits.periodType === 'USAGE_PERIOD_TYPE_WEEKLY')
+      .map((row) => row.credits?.usedPercent)
+      .filter((pct): pct is number => typeof pct === 'number' && Number.isFinite(pct) && pct >= 0 && pct <= 100);
     if (percents.length === 0) return 'unknown';
     return percents.some((p) => p < 100) ? 'usable' : 'exhausted';
   } catch {
@@ -1722,7 +1756,7 @@ function announceChildLlmInterpretation(
 export const CHILD_LLM_DEFAULT_TIER = 'better' as const;
 
 export function defaultChildLlmModel(provider: string): string {
-  return tierModel(CHILD_LLM_DEFAULT_TIER, provider as never);
+  return tierModel(CHILD_LLM_DEFAULT_TIER, childModelCatalogProvider(provider) as never);
 }
 
 export type ChildLlmConfigSnapshot = { provider?: string; model?: string };

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

@@ -15,7 +15,8 @@
 //   self 는 backend 리스트 항목이 아니라 transport 축을 붕괴시키는 특수 갈래. 감독 축도 self=turn 레벨.
 
 import { execFileSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
+import { benchArmBranchForBase } from '../bench/bench.js';
 import { readFileSync } from 'node:fs';
 import { dispatchTask, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
 import { getNestDepth } from '../agent/nest-depth.js';
@@ -609,7 +610,11 @@ export function toSelfImplementOptions(text: string, plan: ResolvedDevPlan, seam
     ...(s.naturalLanguageDispatch ? { naturalLanguageDispatch: true } : {}),
     ...(s.childLlm ? { childLlm: s.childLlm } : {}),
     ...(s.correlationId !== undefined ? { correlationId: s.correlationId } : {}),
-    ...(s.branchName ? { branchName: s.branchName } : {}),
+    // 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());
+      return branchName ? { branchName } : {};
+    })(),
     ...(s.maxReworkRounds !== undefined ? { maxReworkRounds: s.maxReworkRounds } : {}),
     launch: resolveLaunchStamp({ entrance: plan.entrance, queueId: process.env.ELANOUS_HARNESS_QUEUE_LAUNCH }),
   };

package/src/self-dev/draft-residue.ts

@@ -23,11 +23,14 @@ export interface PrTerminalRecord {
   ownerSource: 'seat' | 'card' | 'unknown';
   card: string | null;
   at: string;
+  /** Which host-regate gate failed and why — null for every other terminal. */
+  hostRegateFailure: { step: string; detail: string; os: string } | null;
 }
 export interface PodTerminalInput {
   childRunId: string;
   state: 'complete' | 'failed' | 'aborted';
-  disposition?: { prNumber?: number | null; prUrl?: string | null; checkedHeadCommit?: string | null; stage?: string; merged?: boolean; ok?: boolean } | null;
+  disposition?: { prNumber?: number | null; prUrl?: string | null; checkedHeadCommit?: string | null; stage?: string; merged?: boolean; ok?: boolean;
+    hostRegate?: { passed: boolean; failures: Array<{ step: string; detail: string }>; os: string } | null } | null;
   env?: Readonly<Record<string, string | undefined>>;
   prBody?: string;
   goalText?: string;
@@ -47,13 +50,22 @@ export function classifyPodTerminal(input: PodTerminalInput): PrTerminalRecord {
   const card = cardOf(input.prBody) ?? cardOf(input.goalText);
   const seat = input.env?.ELANOUS_HARNESS_SEAT;
   const ownerSource = seat === 'OP' || seat === 'TC' || seat === 'MK' || seat === 'UX' ? 'seat' : card ? 'card' : 'unknown';
+  const hostRegate = d?.hostRegate;
+  const firstFailure = hostRegate?.passed === false && Array.isArray(hostRegate.failures) ? hostRegate.failures[0] : undefined;
+  const hostRegateFailure = d?.stage === 'host-regate-failed' && hostRegate?.passed === false
+    ? { step: typeof firstFailure?.step === 'string' && firstFailure.step ? firstFailure.step : 'unknown',
+      detail: typeof firstFailure?.detail === 'string' && firstFailure.detail
+        ? firstFailure.detail.split(/\s+/).filter(Boolean).join(' ').slice(0, 300)
+        : 'failures empty',
+      os: hostRegate.os }
+    : null;
   return {
     childRunId: input.childRunId, prNumber, prUrl, repository,
     headSha: typeof d?.checkedHeadCommit === 'string' && /^[a-f0-9]{40}$/i.test(d.checkedHeadCommit) ? d.checkedHeadCommit : null,
     terminalClass: !d ? 'failed-pr-unobserved' : d.merged === true ? 'landed'
       : prNumber === null ? 'failed-no-pr'
         : input.state === 'complete' && d.ok !== false ? 'merge-ready-not-merged' : 'failed-with-pr',
-    stage: d?.stage ?? null,
+    stage: d?.stage ?? null, hostRegateFailure,
     owner: ownerSource === 'seat' ? seat! : ownerSource === 'card' ? card! : 'unknown',
     ownerSource, card, at: input.at ?? new Date().toISOString(),
   };

package/src/self-dev/draft-sweep.ts

@@ -4,6 +4,7 @@ import { decideDraft, draftClaimComment, draftClaimState, draftReleaseComment, l
 import { cardPrNumber, draftTaskOwner, type TaskCard } from '../task-agent/task-hand.js';
 import type { PrTerminalRecord } from './draft-residue.js';
 import { branchLineageSlug } from '../cli/pr-lineage.js';
+import { branchLineageKey } from '../harness/worktree-branch-prefix.js';
 
 export interface SweepDraft extends DraftTriagePr {
   readonly title: string;
@@ -60,6 +61,12 @@ export interface DraftSweepAdapters {
   getReviewGate?(draft: SweepDraft, repository: string): Promise<SweepReviewGate | undefined>;
   /** One PR by number (any state); undefined means it could not be read. Only overlap metrics need it. */
   getPr?(repository: string, number: number): Promise<SweepMergedPr | undefined>;
+  /**
+   * Stops the still-live run behind a draft that a newer, also live, same-lineage run supersedes (`--apply` only).
+   * Must reject when the run could not be stopped — the draft is then neither labelled nor closed.
+   * Absent ⇒ a live duplicate is kept, never closed.
+   */
+  supersedeRun?(draft: SweepDraft, repository: string, newer: SweepDraft): Promise<void>;
 }
 
 /** Review PASS and gate posture used only by the daily old-draft count. */
@@ -138,6 +145,19 @@ export interface DraftMetrics {
   readonly conversion48h: number | null;
 }
 
+/** Default maximum unclaimed open harness drafts for one seat. */
+export const DRAFT_NEEDS_OWNER_SEAT_CAP = 15;
+
+/** Compare one seat's observed needsOwner count; the caller supplies counts of open drafts by seat. */
+export function isSeatDraftNeedsOwnerOverCap(
+  seat: string,
+  needsOwnerBySeat: Readonly<Record<string, number>>,
+  cap = DRAFT_NEEDS_OWNER_SEAT_CAP,
+): boolean {
+  const count = Object.hasOwn(needsOwnerBySeat, seat) ? needsOwnerBySeat[seat] : undefined;
+  return typeof count === 'number' && Number.isFinite(count) && count > cap;
+}
+
 export async function collectDraftMetrics(repository: string, adapters: Pick<DraftSweepAdapters, 'listDrafts' | 'listRecentClosed' | 'getActiveClaimOwner'>, now: Date): Promise<DraftMetrics> {
   const clock = now.getTime();
   if (!Number.isFinite(clock)) throw new Error('Invalid draft metric clock');
@@ -444,6 +464,7 @@ const stalledLabel = label('close', 'stalled');
 const supersededLabel = label('close', 'superseded');
 const approvalLabel = PR_LABELS.find((entry) => entry.axis === 'state' && entry.sweep.action === 'none')?.name;
 const keepLabel = PR_LABELS.find((entry) => entry.sweep.action === 'exclude')?.name;
+const benchLabel = PR_LABELS.find((entry) => entry.name === 'elanous:bench')!.name;
 const releaseHoldLabel = PR_LABELS.find((entry) => entry.axis === 'addon' && entry.sweep.action === 'none')?.name;
 const harvestableLabel = PR_LABELS.find((entry) => entry.name === 'elanous:harvestable')!.name;
 const PAGE_SIZE = 100;
@@ -596,9 +617,26 @@ export async function mapBounded<T, R>(items: readonly T[], limit: number, work:
 }
 
 function harnessDraft(draft: SweepDraft): boolean {
+  // BENCH-ISOLATED-ARMS — a bench arm PR is comparison material: the sweep never marks, supersedes or closes it.
+  if (draft.labels.includes(benchLabel)) return false;
   return draft.branch.startsWith('self-impl/') || draft.labels.some((name) => name.startsWith('elanous:'));
 }
 
+/**
+ * The newest open draft of the same goal lineage that was created strictly after `draft` — a rerun
+ * (e.g. a forced requeue) of the same goal. Reads only the branch, so a draft with no task card still has a lineage.
+ * ⛔ A branch without a goal id has no lineage key and never matches.
+ */
+export function newerLineageDraft(draft: SweepDraft, openDrafts: readonly SweepDraft[]): SweepDraft | undefined {
+  const key = branchLineageKey(draft.branch);
+  const created = Date.parse(draft.createdAt);
+  if (key === null || !Number.isFinite(created)) return undefined;
+  return openDrafts
+    .filter((pr) => pr.number !== draft.number && branchLineageKey(pr.branch) === key
+      && Number.isFinite(Date.parse(pr.createdAt)) && Date.parse(pr.createdAt) > created)
+    .sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt) || b.number - a.number)[0];
+}
+
 /**
  * Census of harness drafts older than 24h. Same-goal landing uses `sameGoalPr` unchanged.
  * A draft counts as closable when a same-goal merged PR exists, harvestable when review PASS and the gate passed,
@@ -842,6 +880,71 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     const ageHours = (now.getTime() - Date.parse(draft.createdAt)) / 3_600_000;
     const idleHours = typeof draft.updatedAt === 'string' && Number.isFinite(Date.parse(draft.updatedAt))
       ? (now.getTime() - Date.parse(draft.updatedAt)) / 3_600_000 : NaN;
+    // A newer open draft of the same goal lineage (a rerun, e.g. a forced requeue) supersedes this one even when
+    // its running claim is fresh or its run is still live. Holds, merged twins and the title-based duplicate rule keep their priority.
+    const lineageNewer = contradiction || draft.labels.includes(harvestableLabel) ? undefined : newerLineageDraft(draft, drafts);
+    if (lineageNewer) {
+      const base = decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+        finalRunResult, ageHours: runStatus ? ageHours : idleHours });
+      if (!base.reason.startsWith('label:') && !base.reason.startsWith('superseded-by #') && !base.reason.startsWith('duplicate-of-open #')) {
+        const live = (status: string | undefined, branch: string) => status === 'running' || status === 'probable-running'
+          || (status !== 'self-implement.result final' && liveBranches.has(branch));
+        const runLive = live(runStatus, draft.branch);
+        const lineageKey = branchLineageKey(draft.branch);
+        const reason = `duplicate-of-open #${lineageNewer.number} (lineage ${lineageKey})${runLive ? ` · stop run ${draft.runId ?? 'unknown'}` : ''}`;
+        // Every lineage outcome that does not close falls through to the existing rules (preservation contract):
+        // a duplicate this rule cannot settle is decided exactly as it was before this rule existed.
+        const fallThrough = (why: string) => {
+          try { debug.log('self-dev.draft-sweep', 'lineage-fall-through', { number: draft.number, newer: lineageNewer.number, lineageKey, why }); } catch { /* fail-soft */ }
+        };
+        if (runLive && !adapters.supersedeRun) fallThrough('lineage-duplicate-run-live');
+        // Safety (OP 10-11): a live run is stopped only when the newer run of the same lineage is itself live —
+        // never trade a running attempt for one that already ended or was never observed running.
+        else if (runLive && !live(statuses.get(lineageNewer.number), lineageNewer.branch)) fallThrough('lineage-newer-run-not-live');
+        else if (closes >= closeCap) {
+          record({ number: draft.number, action: 'keep', reason: 'close-cap', applied: false });
+          continue;
+        } else {
+          let stopFailed = false;
+          // --apply only: the run is stopped before anything is written; a stop that cannot be confirmed writes nothing.
+          if (apply && runLive) {
+            const observed = { number: draft.number, newer: lineageNewer.number, runId: draft.runId ?? null, newerRunId: lineageNewer.runId ?? null, lineageKey };
+            try {
+              await adapters.supersedeRun!(draft, repository, lineageNewer);
+              try { debug.log('self-dev.draft-sweep', 'supersede-run', observed); } catch { /* fail-soft */ }
+            } catch (error) {
+              stopFailed = true;
+              try { debug.log('self-dev.draft-sweep', 'supersede-run-failed', { ...observed, reason: sweepFailureReason(error) }, { level: 'warn' }); } catch { /* fail-soft */ }
+            }
+          }
+          if (stopFailed) fallThrough('supersede-run-failed');
+          else {
+            // A close is counted against the cap only once it is decided here; a failed write gives the slot back.
+            closes += 1;
+            const entry: DraftSweepEntry = { number: draft.number, action: 'close', reason, statusLabel: supersededLabel, applied: false };
+            record(entry);
+            if (!apply) continue;
+            let labelsChanged = false;
+            try {
+              if (!draft.labels.includes(supersededLabel)) {
+                await adapters.setLabels(repository, draft.number, {
+                  add: supersededLabel, remove: states.map((state) => state.name).filter((name) => name !== supersededLabel),
+                });
+                labelsChanged = true;
+              }
+              await adapters.closeDraft(repository, draft.number,
+                `Draft sweep: ${reason} (https://github.com/${repository}/pull/${lineageNewer.number}). Branch preserved.`);
+              entry.applied = true;
+            } catch (error) {
+              if (labelsChanged) entry.partialApplied = true;
+              else closes -= 1;
+              entry.error = String(error);
+            }
+            continue;
+          }
+        }
+      }
+    }
     // An unobserved claim may still have a merged twin: liveness/holds retain their priority,
     // but a superseded draft must not be hidden by the six-hour claim window.
     const mergedDecision = isClaimed ? decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,

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

@@ -103,3 +103,9 @@ export function intakeTakesQueue(label: 'queued' | 'direct', route: Pick<Journey
   const graphQueues = route.source === 'graph' ? route.to === 'queue' : label === 'queued';
   return graphQueues && eligible;
 }
+
+/** 병합 직전 동결 검사의 «승인 요구» — 동결이 아닌(open) 병합을 그래프가 hold 로 보내면 true.
+ *  ⛔ 그래프가 답을 못 내면(code-default) false — 오늘의 입장 판정 그대로. 동결·선점(frozen·taken)은 이미 코드가 정했다. */
+export function freezeCheckHolds(label: 'open' | 'frozen' | 'taken', route: Pick<JourneyRoute, 'source' | 'to'>): boolean {
+  return label === 'open' && route.source === 'graph' && route.to === 'hold';
+}

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

@@ -421,6 +421,9 @@ export async function runSelfOrchestrateCliCommand(
       await recordRoundPrs(results);
       results = await superviseRun({
         initial: results,
+        // The add-repair-task branch below runs each authored review-oscillation repair goal as that goal's new
+        // feature (a fresh piece, same goal id) — the supervisor records the repair text, so a second oscillation stops.
+        repairGoalExecution: true,
         limits,
         enrich: (rs) => backfillDecomposeProposals([...rs], deps),
         onDecision: (decision) => {
@@ -431,9 +434,28 @@ export async function runSelfOrchestrateCliCommand(
         onRound: (rs) => { try { baseRuntime.checkpoint?.([...rs]); } catch { /* fail-open */ } },
         // ⭐ 방금 끝난 결과를 넘긴다 — orchestrateSelfDev 가 classifyResumeDisposition 으로
         //   skip/rerun 을 갈라준다(재발명 0 · 착지한 조각은 다시 안 돈다).
-        rerun: async (previous) => {
+        rerun: async (previous, invocation) => {
           let addedRepairIds: string[] = [];
-          if (currentDecision?.action === 'add-repair-task') {
+          // A requested repair that cannot be bound to exactly one goal is held (not relaunched with the old strategy).
+          const unrepairedHold: string[] = [];
+          if (invocation.repairGoals) {
+            const replacements = new Map<SelfDevGoal, string>();
+            for (const [taskId, repairGoal] of Object.entries(invocation.repairGoals)) {
+              const source = previous.find((result) => result.taskId === taskId);
+              const matches = source ? currentGoals.filter((goal) => resumeKey(goal.feature) === resumeKey(source.feature)) : [];
+              if (matches.length === 1 && !replacements.has(matches[0]!)) replacements.set(matches[0]!, repairGoal);
+              else unrepairedHold.push(taskId);
+            }
+            currentGoals = currentGoals.map((goal) => replacements.has(goal) ? { ...goal, feature: replacements.get(goal)! } : goal);
+            spec = buildSelfOrchestrateDevSpec(currentGoals, input.concurrency);
+            try {
+              debug.log('self-dev.supervisor', 'oscillation-repair.executed', {
+                surface: 'orchestrate', replaced: replacements.size, requested: Object.keys(invocation.repairGoals).length, held: unrepairedHold,
+              });
+            } catch { /* fail-open */ }
+          }
+          // A review-oscillation decision attaches only its authored repair goals (above) — never deliverable fragments too.
+          if (currentDecision?.action === 'add-repair-task' && !currentDecision.oscillation) {
             const appended = appendRepairFragments(currentGoals, currentDecision.classifications, {
               seenFingerprints: repairFingerprints,
               addedCount: repairFragmentsAdded,
@@ -487,7 +509,7 @@ export async function runSelfOrchestrateCliCommand(
           baseRuntime = runtimeWithParentRequest();
           // ⛔⭐ 판정이 「사람이 볼 것」이라 한 조각은 집행이 다시 돌리지 않는다 — 판정과 집행이 갈리면
           //   `pr-opened` 조각이 duplicate-risk 로 재실행돼 PR 이 겹친다(2026-09-25 실측).
-          const resumeHold = currentDecision?.needsHuman ?? [];
+          const resumeHold = [...new Set([...(currentDecision?.needsHuman ?? []), ...unrepairedHold])];
           // The engine's resume lookup is last-result-wins for each normalized feature.
           // Use that exact predecessor, not any earlier task sharing the same feature.
           const selectedPrior = new Map(previous.map((result) => [resumeKey(result.feature), result.taskId]));

package/src/self-dev/orchestrate.ts

@@ -23,6 +23,7 @@ import { parentUnlandedProgressLine } from './run-supervisor.js';
 import { mkdirSync, openSync, writeFileSync, closeSync, renameSync, unlinkSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { goalPathFromArgv, launchRegistryDir, removeLaunchBinding, writeLaunchBinding } from '../harness/launch-registry.js';
+import { adoptRunCard } from '../task-agent/run-adopt.js';
 import { availableParallelism, cpus } from 'node:os';
 import { selfDevRunsDir } from './run-store.js';
 import { HARNESS_RUN_ID_ENV, normalizeRunId } from '../harness/harness-space.js';
@@ -369,6 +370,11 @@ export type TriageAction =
   | 'decompose-and-retry'
   /** 기존 조각을 치환하거나 재실행하지 않고 수리 조각을 추가한다. */
   | 'add-repair-task'
+  /**
+   * main 정합(LLM 충돌 해결)이 막힌 조각을 «조각당 한 번» 최신 main 위에서 다시 건다.
+   * 보존 가지는 지우지 않고 재발사 골의 참고로만 쓴다. 두 번째부터는 `needs-human`.
+   */
+  | 'relaunch-on-main'
   /** 실패가 아니었다(전송 불일치) — 건드리지 않는다. */
   | 'no-action'
   /** 모른다 — 사람이 본다. */
@@ -386,7 +392,11 @@ export interface FailureClassification {
 }
 
 /** 순수: 분류 → 다음 행동. ⛔ 한 자리에서만 정한다(소비자가 각자 매핑하면 갈린다). */
-export function triageActionFor(kind: FailureKind): TriageAction {
+export function triageActionFor(
+  kind: FailureKind,
+  /** `main-sync-blocked` 만 읽는다 — 이 조각의 재발사 한 번을 이미 썼으면 true. */
+  options: { mainSyncRelaunchSpent?: boolean } = {},
+): TriageAction {
   switch (kind) {
     case 'transient': return 'rerun';
     case 'blocked-upstream': return 'rerun-after-upstream';
@@ -396,14 +406,22 @@ export function triageActionFor(kind: FailureKind): TriageAction {
     case 'deliverable-broken':
     case 'oversized-goal': return 'add-repair-task';
     case 'false-failure': return 'no-action';
+    case 'main-sync-blocked': return options.mainSyncRelaunchSpent === true ? 'needs-human' : 'relaunch-on-main';
     case 'awaiting-human':
     case 'parent-unlanded':
-    case 'main-sync-blocked':
     case 'provider-rejected': return 'needs-human';
     default: return 'needs-human';
   }
 }
 
+/**
+ * main 정합 충돌로 멈춘 결과만 «최신 main 위 재발사» 후보다. harvestable 이라도 다른 단계(timed-out 등)에서
+ * 멈춘 결과는 후보가 아니다 — 지금처럼 사람이 수확한다.
+ */
+export function isMainSyncRelaunchCandidate(result: Pick<SelfDevJobResult, 'stage'>): boolean {
+  return result.stage === 'merge-conflict';
+}
+
 const LEDGER_FAILURE_KIND: Partial<Record<AbandonedClassification, FailureKind>> = {
   'implementation-deficit': 'unconverged',
   'report-deficit': 'unconverged',
@@ -588,6 +606,8 @@ export function failureFromDeployFindings(
 export function classifyFailures(
   results: SelfDevJobResult[],
   queryPreflight?: PreflightLogQuery,
+  /** 이 조각이 main 정합 재발사 한 번을 이미 썼나 — 생략은 «감독 없음» 이라 종전대로 needs-human. */
+  mainSyncRelaunchSpent?: (result: SelfDevJobResult) => boolean,
 ): FailureClassification[] {
   return results.flatMap((result) => {
     const preflightIdentifiers = [...new Set([result.runId, result.taskId].filter((id): id is string => Boolean(id)))];
@@ -603,7 +623,10 @@ export function classifyFailures(
       taskId: result.taskId,
       stage: result.stage ?? null,
       kind,
-      action: triageActionFor(kind),
+      action: triageActionFor(kind, {
+        // 생략 = 감독 없이 도는 경로(재발사할 주체가 없다) — 종전대로 needs-human. 재발사는 감독이 이력으로 셀 때만.
+        mainSyncRelaunchSpent: !isMainSyncRelaunchCandidate(result) || !mainSyncRelaunchSpent || mainSyncRelaunchSpent(result) === true,
+      }),
       ...(awaitingHuman ?? failureObservationFields(error?.code ?? 'UNKNOWN', error?.message ?? '')),
     }];
   });
@@ -651,8 +674,12 @@ export function triageRun(
   hasUnmeasuredDeliverables = false,
   /** Optional injected lookup of launch preflight observations; absence remains unknown. */
   queryPreflight?: PreflightLogQuery,
+  /** 이 조각이 main 정합 재발사 한 번을 이미 썼나 — 생략은 «감독 없음» 이라 종전대로 needs-human. */
+  mainSyncRelaunchSpent?: (result: SelfDevJobResult) => boolean,
 ): {
   classifications: FailureClassification[];
+  /** ⭐ main 정합이 막힌 조각 중 «첫 번» — 사람 수확 대신 최신 main 위에서 다시 건다. */
+  relaunchOnMain: string[];
   /** 그대로 다시 걸면 되는 조각(일시적·상류대기). */
   rerunnable: string[];
   /** 다시 걸 수는 있으나 같은 결과일 수 있는 조각(수렴 실패). */
@@ -678,21 +705,23 @@ export function triageRun(
     failureFromDeployFindings(taskId, observation.target, observation.findings));
   const classifications = [
     ...deployClassifications,
-    ...classifyFailures(results, queryPreflight),
+    ...classifyFailures(results, queryPreflight, mainSyncRelaunchSpent),
   ];
   const pick = (a: TriageAction) => classifications.filter((c) => c.action === a).map((c) => c.taskId);
   const rerunnable = [...pick('rerun'), ...pick('rerun-after-upstream')];
   const reworkable = pick('rework');
   const decomposable = pick('decompose-and-retry');
   const repairable = [...new Set(pick('add-repair-task'))];  // ⛔ finding 이 여럿이면 같은 taskId 가 겹친다
+  const relaunchOnMain = [...new Set(pick('relaunch-on-main'))];
   return {
     classifications,
+    relaunchOnMain,
     rerunnable,
     reworkable,
     decomposable,
     repairable,
     needsHuman: pick('needs-human'),
-    actionable: rerunnable.length + reworkable.length + decomposable.length + repairable.length > 0,
+    actionable: rerunnable.length + reworkable.length + decomposable.length + repairable.length + relaunchOnMain.length > 0,
     deliverableUnmeasured,
   };
 }
@@ -897,7 +926,11 @@ export function writeRunPidRecord(runId: string, runsDir: string = selfDevRunsDi
     const cwd = process.cwd();
     const goalPath = goalPathFromArgv(process.argv, cwd);
     writeLaunchBinding(runId, { pid: process.pid, startedAt: Date.now() - Math.floor(process.uptime() * 1000), argv0: process.argv0,
-      cwd, ...(goalPath ? { goalPath } : {}), runsDir: resolve(runsDir) }, registryDir);
+      cwd, ...(goalPath ? { goalPath } : {}), runsDir: resolve(runsDir),
+      ...(process.env.ELANOUS_POD_NAME ? { podName: process.env.ELANOUS_POD_NAME } : {}),
+      ...(process.env.ELANOUS_TASK_CARD_ID ? { taskCardId: process.env.ELANOUS_TASK_CARD_ID } : {}) }, registryDir);
+    try { adoptRunCard({ runId, cwd, goalPath, runsDir, env: process.env }); }
+    catch (error) { try { debug.log('task-agent', 'run-adopt-failed', { runId, error: String(error) }); } catch { /* launch must continue */ } }
   }
   return pidPath;
 }
@@ -1381,6 +1414,8 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
           ...(disp?.completionDisposition ? { completionDisposition: disp.completionDisposition } : {}),
           ...(disp?.failureClassification ? { failureClassification: disp.failureClassification } : {}),
           ...(disp?.providerErrors ? { providerErrors: disp.providerErrors } : {}),
+          ...(disp?.rework ? { rework: disp.rework } : {}),
+          ...(disp?.mustFix ? { reviewMustFix: disp.mustFix } : {}),
           ...(goalCauseObservedFromFailureClassification(disp?.failureClassification) === true
             ? { goalCauseObserved: true } : {}),
           ...(disp?.runId ? { runId: disp.runId } : {}),