elanous 0.2.22 → 0.2.24

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

@@ -12,7 +12,7 @@ import { launchAndVerifyGoalDeliverable } from '../harness/deliverable-verify-cl
 import type { DeployVerifyResult } from '../harness/browser-verify.js';
 import { buildSelfOrchestrateDevSpec, executeOrchestrateReroute } from './dev-pipeline.js';
 import type { DevPipelineDeps, OrchestrateRuntime } from './dev-pipeline.js';
-import { resolveOrchestrateConcurrency } from './orchestrate.js';
+import { resolveOrchestrateConcurrency, resumeKey } from './orchestrate.js';
 import type { FailureClassification, SelfDevGoal, SelfDevJobResult } from './orchestrate.js';
 import { superviseRun, type SupervisorDecision } from './run-supervisor.js';
 import { readDecomposeProposals, applyDecomposeProposals } from './decompose-proposal.js';
@@ -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,8 +434,28 @@ export async function runSelfOrchestrateCliCommand(
         onRound: (rs) => { try { baseRuntime.checkpoint?.([...rs]); } catch { /* fail-open */ } },
         // ⭐ 방금 끝난 결과를 넘긴다 — orchestrateSelfDev 가 classifyResumeDisposition 으로
         //   skip/rerun 을 갈라준다(재발명 0 · 착지한 조각은 다시 안 돈다).
-        rerun: async (previous) => {
-          if (currentDecision?.action === 'add-repair-task') {
+        rerun: async (previous, invocation) => {
+          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[] = [];
+          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,
@@ -441,6 +464,7 @@ export async function runSelfOrchestrateCliCommand(
             repairFragmentsAdded += appended.added.length;
             for (const outcome of appended.added) repairFingerprints.set(outcome.fingerprint, (repairFingerprints.get(outcome.fingerprint) ?? 0) + 1);
             repairAppend.push({ added: appended.added, skipped: appended.skipped });
+            addedRepairIds = appended.added.map((item) => `repair:${item.fingerprint}`);
             spec = buildSelfOrchestrateDevSpec(currentGoals, input.concurrency);
             if (appended.added.length === 0) {
               currentDecision.why = `${currentDecision.why} — 수리 조각 추가 없음 (${appended.skipped.length}건 건너뜀)`;
@@ -460,6 +484,7 @@ export async function runSelfOrchestrateCliCommand(
           //   판정(decompose-and-retry)은 트리아지가 이미 했다. 여기는 그 답을 집행만 한다.
           //   ⛔ 의존성은 조각이 «들고 온 그대로» 물려준다 ⇒ dependsOn 이 없는 조각은
           //     orchestrateSelfDev 의 위상 병렬로 «자동으로 동시에» 돈다(대표 2026-08-19 기본 동작).
+          const goalsBeforeDecompose = new Set(currentGoals);
           const applied = applyDecomposeProposals(currentGoals, previous, { alreadyDecomposed: decomposedFeatures });
           if (applied.decomposed.length > 0) {
             for (const f of applied.decomposed) decomposedFeatures.add(f);
@@ -484,8 +509,60 @@ export async function runSelfOrchestrateCliCommand(
           baseRuntime = runtimeWithParentRequest();
           // ⛔⭐ 판정이 「사람이 볼 것」이라 한 조각은 집행이 다시 돌리지 않는다 — 판정과 집행이 갈리면
           //   `pr-opened` 조각이 duplicate-risk 로 재실행돼 PR 이 겹친다(2026-09-25 실측).
-          const resumeHold = currentDecision?.needsHuman ?? [];
-          const next = await exec(spec, { ...baseRuntime, resumeFrom: [...previous], ...(resumeHold.length > 0 ? { resumeHold } : {}) }, pipelineDeps);
+          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]));
+          const strategyByPriorId = new Map<string, 'rerun' | 'rework' | 'decompose-and-retry'>();
+          for (const id of currentDecision?.rerunnable ?? []) strategyByPriorId.set(id, 'rerun');
+          for (const id of currentDecision?.reworkable ?? []) strategyByPriorId.set(id, 'rework');
+          for (const id of currentDecision?.decomposable ?? []) strategyByPriorId.set(id, 'decompose-and-retry');
+          const strategyByGoal = new Map<SelfDevGoal, string>();
+          for (const goal of currentGoals) {
+            const predecessor = selectedPrior.get(resumeKey(goal.feature));
+            if (predecessor && strategyByPriorId.has(predecessor)) strategyByGoal.set(goal, strategyByPriorId.get(predecessor)!);
+            if (goal.id && addedRepairIds.includes(goal.id)) strategyByGoal.set(goal, 'add-repair-task');
+          }
+          // Pieces have fresh goal objects; the selected source must actually have been decomposed.
+          for (const id of currentDecision?.decomposable ?? []) {
+            const source = previous.find((result) => result.taskId === id);
+            if (!source || selectedPrior.get(resumeKey(source.feature)) !== id || !applied.decomposed.includes(source.feature)) continue;
+            for (const piece of source.decomposeProposal?.pieces ?? []) {
+              const goal = currentGoals.find((candidate) => !goalsBeforeDecompose.has(candidate) && candidate.id === piece.id && candidate.feature === piece.feature);
+              if (goal) strategyByGoal.set(goal, 'decompose-and-retry');
+            }
+          }
+          const requested = new Map<string, number>();
+          for (const strategy of strategyByGoal.values()) requested.set(strategy, (requested.get(strategy) ?? 0) + 1);
+          const launchedByStrategy = new Map<string, string[]>();
+          const next = await exec(spec, {
+            ...baseRuntime, resumeFrom: [...previous], ...(resumeHold.length > 0 ? { resumeHold } : {}),
+            onTaskLaunched: (goal, taskId, priorTaskId) => {
+              baseRuntime.onTaskLaunched?.(goal, taskId, priorTaskId);
+              const strategy = strategyByGoal.get(goal);
+              if (!strategy) return;
+              if (strategy === 'add-repair-task' && !addedRepairIds.includes(goal.id ?? '')) return;
+              if (strategy === 'decompose-and-retry' && goalsBeforeDecompose.has(goal)
+                && (priorTaskId === undefined || priorTaskId !== selectedPrior.get(resumeKey(goal.feature)))) return;
+              if (strategy !== 'add-repair-task' && strategy !== 'decompose-and-retry'
+                && (priorTaskId === undefined || priorTaskId !== selectedPrior.get(resumeKey(goal.feature)))) return;
+              const launched = launchedByStrategy.get(strategy) ?? [];
+              launched.push(taskId);
+              launchedByStrategy.set(strategy, launched);
+            },
+          }, pipelineDeps);
+          // runSelfOrchestrateCliCommand → superviseRun.rerun → executeOrchestrateReroute → orchestrateSelfDev.
+          // Only task identities observed at dispatch count; a checkpoint result cannot claim another strategy's launch.
+          for (const [strategy, count] of requested) {
+            const returnedIds = new Set(next.results.map((result) => result.taskId));
+            const taskIds = (launchedByStrategy.get(strategy) ?? []).filter((id) => returnedIds.has(id));
+            try {
+              debug.log('self-dev.supervisor', 'strategy.launch', {
+                strategy, round: supervisedRound + 1, requested: count,
+                launched: taskIds.length, taskIds,
+              });
+            } catch { /* observation must not interrupt execution */ }
+          }
           exitCode = next.exitCode;
           supervisedRound += 1;
           await recordRoundPrs(next.results);

package/src/self-dev/orchestrate-summary-line.ts

@@ -0,0 +1,13 @@
+import type { SelfDevJobResult } from './run-types.js';
+
+/** Error codes whose message is the only place the Pod failure reason survives — the harness Pod exit
+ *  classifier (src/harness/harness-cli-command.ts) reads it back from this line (POD-EXIT-REASON-SHOWN). */
+const MESSAGE_CODES = new Set(['pod-job-failed', 'pod-child-failed']);
+
+/** One human summary line per job printed by `elanous self orchestrate` (src/index.ts). */
+export function formatOrchestrateResultLine(r: Pick<SelfDevJobResult, 'status' | 'feature' | 'merged' | 'prUrl' | 'stage' | 'error'>): string {
+  const icon = r.status === 'done' ? '✅' : r.status === 'cancelled' ? '⛔' : '❌';
+  const disp = r.merged ? ` → merged ${r.prUrl}` : r.prUrl ? ` → PR ${r.prUrl}` : r.stage ? ` [${r.stage}]` : '';
+  const error = r.error ? ` — ${r.error.code}${MESSAGE_CODES.has(r.error.code) ? `: ${r.error.message}` : ''}` : '';
+  return `  ${icon} ${r.status} · ${r.feature.slice(0, 56)}${disp}${error}`;
+}

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';
@@ -30,6 +31,8 @@ import { plannedSelfImplBranch } from '../harness/worktree-branch-prefix.js';
 import { parseGoalId } from '../self-implement/goal-author.js';
 import { isTransientExecutionFailure } from './execution-transient.js';
 import type { AbandonedClassification } from '../self-implement/abandoned-classification.js';
+import type { JobKind, SelfDevGoal, SelfDevJobResult } from './run-types.js';
+export type { JobKind, SelfDevGoalType, SelfDevGoal, SelfDevJobResult } from './run-types.js';
 import type { DeployVerifyFinding, DeployVerifyResult } from '../harness/browser-verify.js';
 import type { LogQuery, LogStoreRow } from '../mss/logging/log-store.js';
 import { observeDeliverables, type DeliverableObservationTarget } from '../harness/deliverable-observation.js';
@@ -80,9 +83,6 @@ const LEGIT_PIPELINE_FAIL_STAGES: ReadonlySet<string> = new Set([
   'gate-failed', 'review-blocked', 'merge-conflict', 'timed-out', 'aborted', 'pr-declined',
 ]);
 
-export type JobKind = 'dev' | 'search' | 'deploy' | 'media';
-export type SelfDevGoalType = 'implement' | 'research' | 'document' | 'operate';
-
 /** Maps a heterogeneous job kind to an existing TOX surface adapter. */
 export interface JobKindDefinition {
   surfaceKind: TaskSurfaceKind;
@@ -195,47 +195,6 @@ export function formatShardHandoffInput(
   return compact.length <= boundedLength ? compact : JSON.stringify({ truncated: true });
 }
 
-export interface SelfDevGoal {
-  /** F1 job kind. Omitted remains the legacy `dev` self-implement job. */
-  kind?: JobKind;
-  /** Decomposition intent; deliberately distinct from executable `kind`. */
-  goalType?: SelfDevGoalType;
-  /** Feature/goal text → `elanous self implement <feature>` for dev jobs. */
-  feature: string;
-  /** Pod lease predecessor goal ID or PR number. */
-  after?: string | number;
-  base?: string;
-  autoMerge?: boolean;
-  /** G8 — attach `auto-review` opt-in label on PR (subject to eligibility self-assessment). */
-  autoReview?: boolean;
-  /** S3 — open a draft PR via the job's own merge-decision node (HITL).
-   *  Promotion flows through the review node → disposition recorded
-   *  internally (no external hand-merge). */
-  openPr?: boolean;
-  draft?: boolean;
-  /** Optional short title (≤ 80 chars). Default = feature head. */
-  title?: string;
-  /** 계획 브랜치가 알려지면 같은 워크트리의 실행을 직렬화한다. */
-  planBranch?: string;
-  /** 계획 브랜치가 없는 저작 골의 안정 식별자. */
-  goalId?: string;
-  /** S2 — goal-local id for dependency wiring (default = array index). */
-  id?: string;
-  /** S2 — goal-local ids this goal depends on (must complete first).
-   *  The task becomes `ready` only after every dependency is `done`
-   *  (topological parallel via the graph). Unknown/self ids are dropped. */
-  dependsOn?: string[];
-  /** Read-only handoff memory emitted by this shard for dependent child input.
-   *  `[]` is a completed shard with no entries; null/undefined is unreadable. */
-  workingMemory?: readonly WorkingMemoryEntry[] | null;
-  /** 그 기억을 남긴 이 조각이 «착지했나». ⛔ 생략은 「모른다」이지 「착지」가 아니다. */
-  workingMemoryOutcome?: 'landed' | 'blocked' | 'unknown';
-  /** S2 — repo paths this job will touch. Two goals sharing a hot path
-   *  are serialized (an implicit dependency edge is added, earlier-first)
-   *  so their worktrees never merge concurrently. Cf. PLAN §8 risk 2. */
-  hotPaths?: string[];
-}
-
 interface SelfDevTerminalOutcome {
   /** Stable TOX task identity, matching the returned `SelfDevJobResult.taskId`. */
   taskId: string;
@@ -249,97 +208,6 @@ interface SelfDevTerminalOutcome {
   parentNoPr?: true;
 }
 
-export interface SelfDevJobResult {
-  taskId: string;
-  feature: string;
-  /** Run outcome — done | failed | cancelled | blocked (awaiting parent landing). */
-  status: TaskStatus;
-  error?: { code: string; message: string };
-  durationMs?: number;
-  /** S3 — real pipeline disposition from the child `--json`
-   *  (merged / pr-opened / gate-failed / review-blocked / pr-declined). */
-  stage?: string;
-  branch?: string;
-  /** Child confirmed the finished implementation was pushed for manual harvest. */
-  harvestable?: true;
-  worktreePath?: string;
-  prUrl?: string;
-  prNumber?: number;
-  merged?: boolean;
-  /** Child commit SHA, when observed by the Pod/host. */
-  checkedHeadCommit?: string;
-  /**
-   * This run's own `--base` (not main). A non-main completion mode
-   * (worktree-only, draft, `--base` other than main) lands commits here.
-   */
-  base?: string;
-  /** Child finished with GOAL-COMPLETE (`ok=true`). Distinct from a main merge. */
-  ok?: boolean;
-  /** Commits this child added against its own `--base`. 0 is not completion progress. */
-  commitsAheadOfBase?: number;
-  /** A dependency is done but its result is not on main; no child was launched. */
-  blockReason?: 'parent-unlanded';
-  parentPrNumber?: number;
-  /** The upstream completed in a worktree without opening a PR. */
-  parentNoPr?: true;
-  // ⭐⭐⭐ `A1`(2026-08-19 · 대표 *"R3 가 서브 프로세스여도 잘 도는 안"*) — ***판정 3종***.
-  //   🚨 이 셋이 트리아지의 입력 전부인데 종전엔 자식 → 부모 경계에서 «전부» 사라졌다.
-  //     값은 전선에 «실려 있었고»(자식이 `r.result` 를 통째로 낸다) 파서가 버렸다.
-  //   ⇒ 📌 서브프로세스에서 «먼저» 옳아야 한다 — 실행 방식을 바꾸지 않고 고치는 자리다.
-  /** auto-merge 를 «왜» 건너뛰었나 — 「도구 한계」와 「자식이 못 함」을 가르는 근거. */
-  mergeReason?: string;
-  /** 런이 «왜» 멈췄나. 없으면 「부모가 잘랐다」다. */
-  stopReason?: string;
-  /** 자식이 스스로 낸 완료 성격. */
-  completionDisposition?: string;
-  /** Abandoned-run classification from the child. Independent of completionDisposition. */
-  failureClassification?: AbandonedClassification;
-  /** Provider failure evidence from the child result; absent when unobserved. */
-  providerErrors?: { count: number; provider: string; category: 'quota' | 'credential' | 'request' | 'other' };
-  /** Stable child run identity used to join its run-ledger proposal. */
-  runId?: string;
-  /** Self review verdict bound to the PR head observed by the child; absent if either observation is missing. */
-  selfReview?: { verdict: 'pass' | 'fail'; head: string };
-  /** Whether the child review actually ran; omitted preserves legacy producers. */
-  reviewed?: boolean;
-  /** Why the child did not run review; omitted preserves legacy review-unobserved handling. */
-  reviewReason?: string;
-  /** The abandoned-run classifier observed a goal-side cause for this failed convergence. */
-  goalCauseObserved?: true;
-  /** Resume selection that decided whether this shard was carried forward or retried. */
-  resumeDisposition?: ResumeDisposition;
-  /**
-   * ⭐ 하니스가 이 조각에 대해 낸 「이렇게 쪼개라」(2026-08-19).
-   *
-   * ⛔ 이 값은 자식 결과로 «안 온다» — 전선 타입(SelfImplementDisposition)에 칸이 없다.
-   *   그래서 «중앙»이 원장에서 읽어 채운다(decompose-proposal.ts). 트리아지는 그것을 그냥 본다.
-   *   ⇒ 📌 출구 모듈은 ***「이 값이 어디서 왔는지 몰라야」*** 한다 — 알면 실행 방식마다 갈래가 는다.
-   * ⚠️ undefined = 「제안이 없다」와 「아직 안 읽었다」가 «같은 값»이다. 채우는 자가 그것을 구분해 관측한다.
-   */
-  decomposeProposal?: { pieces: Array<{ id: string; feature: string; dependsOn: readonly string[]; goalType?: string }> };
-  /**
-   * Parent-side observation of CONTRACT-CONFLICT goal-plan revision application attempts.
-   * undefined = the parent has not read the run ledger yet; it is not the same as attempted=0.
-   */
-  goalPlanRevision?:
-    | { status: 'read'; attempted: number; applied: number; failureReasons: string[] }
-    | { status: 'read-failed'; reason: 'directory-missing' | 'unreadable-directory' | 'unreadable-files'; scannedFiles: number; unreadableFiles: number; ledgerDirectory: string };
-  /** ⭐ 관측(2026-07-21 대표 co-design·"재현 없이 진단") — 자식 goal-loop 화면 버퍼 tail
-   *  (ANSI 제거·"docker logs <id>" 등가물). detached PTY goal-loop 은 스폰 프로세스 stdout 이
-   *  아니라 file-based 화면 버퍼에만 남으므로, 실패 진단의 유일한 cross-process 진실원. */
-  screenTail?: string;
-  /** 화면 버퍼에서 판정한 goal-loop 종결 상태(complete=성공 마커·incomplete·null=불명). */
-  screenOutcome?: 'complete' | 'incomplete' | null;
-  /** 화면 버퍼 공간 id — `elanous self screen --space <id>` 로 전체 전사 재생 가능. */
-  screenSpace?: string;
-  /** ⚠️ exit-code 실패인데 화면은 GOAL-COMPLETE = 스폰-신호 단절(false-failure). 조정 플래그. */
-  reconcileMismatch?: boolean;
-  /** ⭐ 이 시도의 «걸음» — 노드 진입 순서(2026-09-08 · 대표 지시).
-   *  🩸 그 전까지 이 배열엔 「요약 판정」만 있었고 걸음은 런 «안»에서 끝났다.
-   *  ⛔ 관측용이다 — 슈퍼바이저가 이것으로 «무엇을 할지»는 별개 결정이다. */
-  walk?: readonly { node: string; round: number }[];
-}
-
 /**
  * Resume identity for the legacy feature-only checkpoint format.
  * It deliberately absorbs only trim, whitespace runs, and case; wording,
@@ -502,6 +370,11 @@ export type TriageAction =
   | 'decompose-and-retry'
   /** 기존 조각을 치환하거나 재실행하지 않고 수리 조각을 추가한다. */
   | 'add-repair-task'
+  /**
+   * main 정합(LLM 충돌 해결)이 막힌 조각을 «조각당 한 번» 최신 main 위에서 다시 건다.
+   * 보존 가지는 지우지 않고 재발사 골의 참고로만 쓴다. 두 번째부터는 `needs-human`.
+   */
+  | 'relaunch-on-main'
   /** 실패가 아니었다(전송 불일치) — 건드리지 않는다. */
   | 'no-action'
   /** 모른다 — 사람이 본다. */
@@ -519,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';
@@ -529,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',
@@ -721,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)))];
@@ -736,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 ?? '')),
     }];
   });
@@ -784,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[];
   /** 다시 걸 수는 있으나 같은 결과일 수 있는 조각(수렴 실패). */
@@ -811,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,
   };
 }
@@ -944,6 +840,8 @@ export interface OrchestrateSelfDevOptions {
    *  🩸 2026-09-25 실측: 판정은 「재실행 1 · 사람 대기 2」였는데 `pr-opened` 가 `rerun-duplicate-risk` 로
    *    분류돼 PR 을 이미 연 두 조각까지 «다시» 돌았다(같은 골·새 task id · 과금 팔 포함). */
   resumeHold?: readonly string[];
+  /** Link a dispatched task to its exact goal and selected resume predecessor. */
+  onTaskLaunched?: (goal: SelfDevGoal, taskId: string, priorTaskId: string | undefined) => void;
   /** S3 — called with the full current result set after every job
    *  settles (+ at finish) so callers can persist a resumable checkpoint.
    *  Default CLI wiring = saveSelfDevRun. Fail-soft in the caller. */
@@ -1028,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;
 }
@@ -1160,6 +1062,10 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
     const goal = taskId ? taskByGoal.get(taskId) : undefined;
     if (cancelling) throw new Error('orchestration cancelled by signal');
     const started = baseSpawn({ ...input, feature: dependencyOutputFeature(input.spaceId, input.feature) });
+    if (goal && taskId) {
+      try { opts.onTaskLaunched?.(goal, taskId, priorByResumeKey.get(resumeKey(goal.feature))?.taskId); }
+      catch { /* observation must not interrupt execution */ }
+    }
     return {
       address: started.address,
       done: started.done.then((d) => {
@@ -1508,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 } : {}),

package/src/self-dev/review-provider-fallback.ts

@@ -24,6 +24,59 @@ import { claudeBackend, resolveBackendSpawn } from '../agent-mission/driver.js';
 import { checkClaudeSubscription } from '../agent-mission/claude-subscription.js';
 import { getAcpBackend, type AcpBackendSpec } from '../acp/backend-registry.js';
 import type { SubscriptionReviewerSpec } from '../user-config.js';
+import { debug } from '../debug/log.js';
+
+export interface TeamclaudeSubscriptionProbe {
+  subscribed: boolean;
+  usedPercent?: number;
+  reason: string;
+}
+
+/**
+ * Read `teamclaude status --json`. The human `teamclaude status` text names neither "subscription" nor a
+ * "usage: N%" label, so the text probe failed on every review (10-10 · mbp 0/0). Accounts are subscription
+ * (oauth) accounts; quota buckets `unified5h`/`unified7d` are utilization ratios 0-1 (teamclaude
+ * `account-manager.js`). Returns undefined when stdout is not that JSON, so an old teamclaude falls back to text.
+ */
+export function parseTeamclaudeStatusJson(stdout: string): TeamclaudeSubscriptionProbe | undefined {
+  let doc: unknown;
+  try { doc = JSON.parse(stdout); } catch { return undefined; }
+  if (!doc || typeof doc !== 'object' || !Array.isArray((doc as { accounts?: unknown }).accounts)) return undefined;
+  const root = doc as { accounts: unknown[]; currentAccount?: unknown; currentAccounts?: unknown };
+  // Every account must carry the string `type`/`status` this parser reads; another schema is "not this JSON".
+  if (!root.accounts.every((a) => a && typeof a === 'object'
+    && typeof (a as { type?: unknown }).type === 'string' && typeof (a as { status?: unknown }).status === 'string'
+    && typeof (a as { disabled?: unknown }).disabled === 'boolean')) return undefined;
+  const current = typeof root.currentAccount === 'string' ? root.currentAccount
+    : root.currentAccounts && typeof root.currentAccounts === 'object'
+      && typeof (root.currentAccounts as Record<string, unknown>).anthropic === 'string'
+      ? (root.currentAccounts as Record<string, string>).anthropic : undefined;
+  type Account = { name?: unknown; type?: unknown; status?: unknown; disabled?: unknown; quota?: Record<string, unknown> | null };
+  const usable = (root.accounts as Account[]).filter((a) => a && typeof a === 'object'
+    && a.type === 'oauth' && a.status === 'active' && a.disabled !== true);
+  if (usable.length === 0) return { subscribed: false, reason: 'no-active-oauth-account' };
+  const ratio = (v: unknown) => typeof v === 'number' && Number.isFinite(v) && v >= 0 && v <= 1 ? v : undefined;
+  // A bucket that is null was reset or not yet seen: teamclaude nulls `unified5h`/`unified7d` when their window
+  // expires (`_clearExpiredQuotas`), so the other measured bucket still gates. A present but invalid value
+  // (non-number, outside 0-1) or a missing key is not a measurement and fails closed. Both null is unmeasured.
+  const usedOf = (account: Account) => {
+    // A missing key (or no quota object) is not a reset: it stays unmeasured.
+    const raw = [account.quota?.unified5h, account.quota?.unified7d].filter((v) => v !== null);
+    const measured = raw.map(ratio);
+    if (measured.length === 0 || measured.some((v) => v === undefined)) return undefined;
+    return Math.max(...(measured as number[])) * 100;
+  };
+  // The usage that gates the review is the routed account's. The current account is the one the proxy routes to;
+  // without a usable current account, every usable account must be measured and the highest one counts.
+  const routed = usable.find((a) => a.name === current);
+  if (routed) {
+    const used = usedOf(routed);
+    return used === undefined ? { subscribed: true, reason: 'quota-unmeasured' } : { subscribed: true, usedPercent: used, reason: 'current-account' };
+  }
+  const all = usable.map(usedOf);
+  if (all.some((v) => v === undefined)) return { subscribed: true, reason: 'quota-unmeasured' };
+  return { subscribed: true, usedPercent: Math.max(...(all as number[])), reason: 'max-active-account' };
+}
 
 export interface SubscriptionReviewerDeps {
   /** Returns measured Claude subscription usage; unknown usage fails closed. */
@@ -32,18 +85,26 @@ export interface SubscriptionReviewerDeps {
   runStatus?: (command: string, args: string[], env: Record<string, string>) => { status: number | null; stdout?: string | Buffer | null };
 }
 
-/** The runner and the subscription probe share the PTY backend's billing-env scrub. */
-export function subscriptionReviewerSpawn(spec: SubscriptionReviewerSpec, env: NodeJS.ProcessEnv = process.env): {
+/**
+ * The runner and the subscription probe share the PTY backend's billing-env scrub.
+ * ⛔ The child must speak ACP: `teamclaude run` / `claude` start the interactive CLI, which never answers the ACP
+ * handshake (10-10 measured: the review hung with no timeout). Both executors therefore run the ACP adapter
+ * (`claude-agent-acp`); `cct` routes it through the teamclaude proxy by its base URL (`teamclaude env --no-mitm`).
+ */
+export function subscriptionReviewerSpawn(spec: SubscriptionReviewerSpec, env: NodeJS.ProcessEnv = process.env, proxyBaseUrl?: string): {
   command: string; args: string[]; env: Record<string, string>; backendSpec: AcpBackendSpec;
 } {
   const executor = spec.executor ?? 'cct';
-  const { env: cleanEnv } = resolveBackendSpawn(claudeBackend, env);
-  const command = executor === 'cct' ? 'teamclaude' : 'claude';
-  const args = executor === 'cct'
-    ? ['run', '--auto-fallback', '--', '--dangerously-skip-permissions']
-    : ['--dangerously-skip-permissions'];
-  return { command, args, env: cleanEnv,
-    backendSpec: { ...getAcpBackend('claude'), command, args } };
+  const { env: scrubbed } = resolveBackendSpawn(claudeBackend, env);
+  const cleanEnv = executor === 'cct' && proxyBaseUrl ? { ...scrubbed, ANTHROPIC_BASE_URL: proxyBaseUrl } : scrubbed;
+  const backendSpec = getAcpBackend('claude');
+  return { command: backendSpec.command, args: [...backendSpec.args], env: cleanEnv, backendSpec };
+}
+
+/** `teamclaude env --no-mitm` prints `export ANTHROPIC_BASE_URL=…`; only that line is read (never the proxy key). */
+export function parseTeamclaudeBaseUrl(stdout: string): string | undefined {
+  const match = stdout.match(/^\s*export\s+ANTHROPIC_BASE_URL=["']?(https?:\/\/[^\s"']+)["']?\s*$/m);
+  return match?.[1];
 }
 
 /** Guard the ACP review before spawning. An unmeasured quota never authorizes subscription use. */
@@ -57,25 +118,53 @@ export function subscriptionReviewerAvailability(
   const executor = spec.executor ?? 'cct';
   const runStatus = deps.runStatus ?? ((command: string, args: string[], cleanEnv: Record<string, string>) =>
     spawnSync(command, args, { env: { ...cleanEnv, NODE_ENV: process.env.NODE_ENV }, encoding: 'utf8', timeout: 5_000 }));
-  const usedPercent = deps.usedPercent ?? (() => {
-    const result = runStatus('teamclaude', ['status'], spawn.env);
-    if (result.status !== 0) return undefined;
+  // One `--json` read serves both questions; the text regexes stay only for a teamclaude without `--json`.
+  let jsonProbe: TeamclaudeSubscriptionProbe | null | undefined;
+  const readJsonProbe = (cleanEnv: Record<string, string>) => {
+    if (jsonProbe !== undefined) return jsonProbe ?? undefined;
+    const result = runStatus('teamclaude', ['status', '--json'], cleanEnv);
+    jsonProbe = result.status === 0 ? parseTeamclaudeStatusJson(String(result.stdout ?? '')) ?? null : null;
+    if (jsonProbe) debug.log('self-dev.reviewer', 'subscription-probe', { source: 'json', ...jsonProbe });
+    return jsonProbe ?? undefined;
+  };
+  // Old teamclaude: one text read answers both questions and is logged once with both values.
+  let textProbe: { subscribed: boolean; usedPercent?: number } | undefined;
+  const readTextProbe = (cleanEnv: Record<string, string>) => {
+    if (textProbe) return textProbe;
+    const status = runStatus('teamclaude', ['status'], cleanEnv);
+    const out = String(status.stdout ?? '');
+    const ok = status.status === 0;
     // Only a named usage percentage is accepted; a random percentage in status is not quota evidence.
-    const match = String(result.stdout).match(/(?:usage|used)\s*[:=]?\s*(\d+(?:\.\d+)?)\s*%/i);
-    return match ? Number(match[1]) : undefined;
+    const match = ok ? out.match(/(?:usage|used)\s*[:=]?\s*(\d+(?:\.\d+)?)\s*%/i) : null;
+    textProbe = {
+      subscribed: ok && /(?:subscription|claude\.ai|claude\s+(?:max|pro))/i.test(out)
+        && !/(?:logged\s*out|not\s+logged\s+in|api[_ -]?key|not\s+authenticated)/i.test(out),
+      usedPercent: match ? Number(match[1]) : undefined,
+    };
+    debug.log('self-dev.reviewer', 'subscription-probe', { source: 'text', ...textProbe,
+      reason: ok ? 'text-read' : `exit-${status.status}` });
+    return textProbe;
+  };
+  const usedPercent = deps.usedPercent ?? (() => {
+    const probe = executor === 'cct' ? readJsonProbe(spawn.env) : undefined;
+    return probe ? probe.usedPercent : readTextProbe(spawn.env).usedPercent;
   });
   try {
     const subscribed = deps.checkSubscription ?? ((cleanEnv: Record<string, string>) => {
       if (executor === 'cc') return checkClaudeSubscription({ env: cleanEnv }).ok;
-      const status = runStatus('teamclaude', ['status'], cleanEnv);
-      return status.status === 0 && /(?:subscription|claude\.ai|claude\s+(?:max|pro))/i.test(String(status.stdout))
-        && !/(?:logged\s*out|not\s+logged\s+in|api[_ -]?key|not\s+authenticated)/i.test(String(status.stdout));
+      const probe = readJsonProbe(cleanEnv);
+      return probe ? probe.subscribed : readTextProbe(cleanEnv).subscribed;
     });
     if (!subscribed(spawn.env)) return { reason: `${executor} subscription check failed` };
     const used = usedPercent();
     if (!Number.isFinite(cap) || cap < 0 || cap > 100 || used === undefined
       || !Number.isFinite(used) || used < 0 || used >= cap) return { reason: `Claude subscription usage unavailable or at harness cap (${cap}%)` };
-    return { spawn };
+    if (executor === 'cc') return { spawn };
+    const proxy = runStatus('teamclaude', ['env', '--no-mitm'], spawn.env);
+    const baseUrl = proxy.status === 0 ? parseTeamclaudeBaseUrl(String(proxy.stdout ?? '')) : undefined;
+    debug.log('self-dev.reviewer', 'proxy-base-url', { found: baseUrl !== undefined, exit: proxy.status });
+    if (!baseUrl) return { reason: 'cct proxy base URL unavailable' };
+    return { spawn: subscriptionReviewerSpawn(spec, env, baseUrl) };
   } catch {
     return { reason: `${executor} subscription check failed` };
   }
@@ -97,7 +186,14 @@ export async function runSubscriptionReviewer(
     try {
       const text = await acpReview(prompt, availability.spawn);
       if (text.trim()) return text;
-    } catch { /* ACP failure is not a completed review. */ }
+      debug.log('self-dev.reviewer', 'acp-review-failed', { reason: 'acp-empty-review' });
+    } catch (e) {
+      // ACP failure is not a completed review; the worst case stays the default reviewer.
+      // Only a reason code: the raw message may carry account or proxy details.
+      const message = e instanceof Error ? e.message : String(e);
+      debug.log('self-dev.reviewer', 'acp-review-failed', {
+        reason: /handshake timeout/i.test(message) ? 'acp-handshake-timeout' : 'acp-error' });
+    }
   }
   const reason = availability.reason ?? 'ACP review failed';
   return `${await defaultReview(prompt)}\n[reviewer fallback: ${reason}; default reviewer used]`;