elanous 0.2.21 → 0.2.23

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';
@@ -432,6 +432,7 @@ export async function runSelfOrchestrateCliCommand(
         // ⭐ 방금 끝난 결과를 넘긴다 — orchestrateSelfDev 가 classifyResumeDisposition 으로
         //   skip/rerun 을 갈라준다(재발명 0 · 착지한 조각은 다시 안 돈다).
         rerun: async (previous) => {
+          let addedRepairIds: string[] = [];
           if (currentDecision?.action === 'add-repair-task') {
             const appended = appendRepairFragments(currentGoals, currentDecision.classifications, {
               seenFingerprints: repairFingerprints,
@@ -441,6 +442,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 +462,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);
@@ -485,7 +488,59 @@ export async function runSelfOrchestrateCliCommand(
           // ⛔⭐ 판정이 「사람이 볼 것」이라 한 조각은 집행이 다시 돌리지 않는다 — 판정과 집행이 갈리면
           //   `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);
+          // 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

@@ -30,6 +30,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 +82,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 +194,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,95 +207,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;
-  /** 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,
@@ -942,6 +811,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. */
@@ -1158,6 +1029,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) => {
@@ -1499,6 +1374,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
           ...(disp?.prNumber !== undefined ? { prNumber: disp.prNumber } : {}),
           ...(disp?.merged !== undefined ? { merged: disp.merged } : {}),
           ...(disp?.checkedHeadCommit ? { checkedHeadCommit: disp.checkedHeadCommit } : {}),
+          ...(disp?.selfReview ? { selfReview: disp.selfReview } : {}),
           // ⭐ `A1` — 판정 3종을 «끝까지» 옮긴다. 여기서 빠지면 트리아지가 눈을 잃는다.
           ...(disp?.mergeReason ? { mergeReason: disp.mergeReason } : {}),
           ...(!cancelling && disp?.stopReason ? { stopReason: disp.stopReason } : {}),

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

@@ -19,6 +19,185 @@
 //     쿼터 축은 과부하에 «반응하지 않는다».
 import { resolveModelAlias } from '../intelligence-map/model-alias.js';
 import type { LLMProvider } from '../llm.js';
+import { spawnSync } from 'node:child_process';
+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. */
+  usedPercent?: () => number | undefined;
+  checkSubscription?: (env: Record<string, string>) => boolean;
+  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.
+ * ⛔ 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: 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. */
+export function subscriptionReviewerAvailability(
+  spec: SubscriptionReviewerSpec,
+  cap: number,
+  env: NodeJS.ProcessEnv = process.env,
+  deps: SubscriptionReviewerDeps = {},
+): { spawn?: ReturnType<typeof subscriptionReviewerSpawn>; reason?: string } {
+  const spawn = subscriptionReviewerSpawn(spec, env);
+  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 }));
+  // 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 = 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 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}%)` };
+    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` };
+  }
+}
+
+/** Keep a single notice attached to the actual default review result. */
+export async function runSubscriptionReviewer(
+  spec: SubscriptionReviewerSpec | undefined,
+  cap: number,
+  prompt: string,
+  defaultReview: (prompt: string) => Promise<string>,
+  acpReview: (prompt: string, spawn: ReturnType<typeof subscriptionReviewerSpawn>) => Promise<string>,
+  env: NodeJS.ProcessEnv = process.env,
+  deps: SubscriptionReviewerDeps = {},
+): Promise<string> {
+  if (!spec) return defaultReview(prompt);
+  const availability = subscriptionReviewerAvailability(spec, cap, env, deps);
+  if (availability.spawn) {
+    try {
+      const text = await acpReview(prompt, availability.spawn);
+      if (text.trim()) return text;
+      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]`;
+}
 
 export type ReviewFailureReason =
   | 'overloaded'

package/src/self-dev/run-store.ts

@@ -26,9 +26,7 @@ import { isPidAlive } from '../git-fs/worktree.js';
 import type { EmbodiedTransportKind } from '../agent/embodiment.js';
 import type { RunIdSource } from '../harness/harness-space.js';
 import { withFileLockSync } from '../storage/file-lock.js';
-import type { SelfDevJobResult, SelfDevGoal } from './orchestrate.js';
-import type { SupervisorStopReason } from './run-supervisor.js';
-import type { SupervisorNext } from './supervisor-verdict-edges.js';
+import type { SelfDevJobResult, SelfDevGoal, SupervisorStopReason, SupervisorNext } from './run-types.js';
 import { loadMirroredRunRecord, mirrorRunRecord } from './run-record-mirror.js';
 
 export interface SelfDevRunParticipant {

package/src/self-dev/run-supervisor.ts

@@ -2,11 +2,12 @@
 
 import { hasDelivered, triageRun, type FailureClassification } from './orchestrate.js';
 import type { DeployVerifyFinding } from '../harness/browser-verify.js';
-import type { SelfDevJobResult } from './orchestrate.js';
+import type { SelfDevJobResult, SupervisorStopReason, SupervisorNext } from './run-types.js';
+export type { SupervisorStopReason } from './run-types.js';
 import { recordSelfDevRunSupervisorStop, selfDevRunsDir } from './run-store.js';
 import { debug } from '../debug/log.js';
 import { sweepFrozenMerges } from '../self-implement/frozen-merges.js';
-import { routeSupervisorVerdict, type SupervisorNext } from './supervisor-verdict-edges.js';
+import { routeSupervisorVerdict } from './supervisor-verdict-edges.js';
 import { recordTaskAgentShadowMove, type TaskAgentShadowInput } from '../task-agent/shadow.js';
 
 export interface SupervisorRound {
@@ -24,26 +25,6 @@ export interface SupervisorRound {
   reviewMustFixTrend?: SupervisorDecision['reviewMustFixTrend'];
 }
 
-export type SupervisorStopReason =
-  | 'converged'
-  /** 사람이 명시적으로 이 런을 중단했다. */
-  | 'human-stopped'
-  /** 승격 분해는 끝났지만 부모 결정 신호가 적색이라 완주를 승인할 수 없다. */
-  | 'parent-signals-red'
-  | 'needs-human'
-  | 'no-actionable-work'
-  | 'harvestable-awaiting-human'
-  | 'handed-off-to-salvage'
-  | 'max-rounds'
-  | 'no-progress'
-  | 'provider-exhausted'
-  /** 제자리인데 이번 라운드 재시도 후보가 전부 단계 시간 초과(`timed-out`) — 판정을 못 내고 다시 걸었다. */
-  | 'step-timeout'
-  | 'decomposable-no-progress'
-  | 'review-unobserved'
-  | 'deliverable-unobserved'
-  | 'deliverable-merged';
-
 export const SUPERVISOR_STOP_REASONS = [
   'converged',
   'human-stopped',
@@ -623,7 +604,11 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
       if (decision.stopReason && opts.taskAgentShadow !== false) {
         // TASK-AGENT-SHADOW — 판단부를 그림자로 부른다(실행 0). 어떤 오류도 런의 결말을 바꾸지 않는다.
         try {
-          await (opts.taskAgentShadow ?? recordTaskAgentShadowMove)({ runId, stopReason: decision.stopReason, results });
+          const pr = results.find((result) => typeof result.prNumber === 'number' && result.prNumber > 0)?.prNumber;
+          const reviewed = results.filter((result) => result.prNumber === pr && result.selfReview && result.merged !== true);
+          const selfReview = pr && reviewed.length === 1 ? reviewed[0]!.selfReview : undefined;
+          await (opts.taskAgentShadow ?? recordTaskAgentShadowMove)({ runId, stopReason: decision.stopReason, results,
+            ...(selfReview ? { selfReview } : {}), cycleId: `${runId ?? 'unknown'}:${decision.round}` });
         } catch (error) {
           try { debug.log('task-agent', 'shadow-move-failed', { runId, stopReason: decision.stopReason, error: String(error) }); } catch { /* fail-open */ }
         }