elanous 0.2.23 → 0.2.24

package/src/self-implement/seams.ts

@@ -34,6 +34,7 @@ import { isWorktreeInUse, listActiveTerminalDirectories } from '../harness/harne
 import { readWorktreePorcelain } from './abandoned-classification.js';
 import { recordHarnessWorktreeGoalMetadata, recordHarnessWorktreeProvenance, type HarnessWorktreeGoalMetadata } from '../harness/harness-worktree-add.js';
 import { runGitCommand } from '../git-fs/runner.js';
+import { BENCH_LABEL, BENCH_LOG_CATEGORY, benchIdFromBase, parseBenchArmBranch } from '../bench/bench.js';
 import { provisionDerivedUniverse } from '../instance/provision.js';
 import { DEFAULT_GATE_STEPS, runIntegrityGate, type GateResult, type GateStepName } from '../autopilot/build/integrity-gate.js';
 import { androidFilesIn, runAndroidUnitTestGate } from '../../scripts/ci-android-unit-tests.js';
@@ -94,6 +95,7 @@ import { isSupervisorDecisionSection, splitGoalSections, supervisorGoalDigest }
 import type { SupervisionReworkSource } from './supervision-vocabulary.js';
 import type { ReworkBudgetVerdict } from './run-outcome.js';
 import { pickImplementRoleForGoal, runHeadlessGoalLoopPty } from './headless-elanous-driver.js';
+import { isClaudeAcpChild, runClaudeAcpImplement } from './claude-acp-implement.js';
 import { childLlmSelectionEnv } from '../agent/run-context.js';
 import { observeExternalEvent } from '../context-bus/external-events.js';
 import { buildLlmHitlRelay, SIDE_EFFECT_RE } from '../harness/llm-hitl-relay.js';
@@ -1067,6 +1069,8 @@ export interface DefaultSeamsOptions {
   buildLlmHitlRelay?: typeof buildLlmHitlRelay;
   /** 테스트용 PTY executor 주입. */
   runHeadlessGoalLoopPty?: typeof runHeadlessGoalLoopPty;
+  /** CLAUDE-IMPL-LANE 시험 주입 — claude-acp 자식의 구독 ACP 구현 실행. */
+  runClaudeAcpImplement?: typeof runClaudeAcpImplement;
   /** 테스트용 PTY 가용성 주입. */
   ptyAvailable?: () => boolean;
   /** Tests may inject the shared provenance writer to exercise the self-implement failure contract. */
@@ -1367,6 +1371,8 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
   const removeCleanupWorktree = o.removeWorktree ?? removeWorktree;
   const runCleanupGitCommand = o.runGitCommand ?? runGitCommand;
   const baselineRefs = new Map<string, string>();
+  // BENCH-ISOLATED-ARMS — 벤치 base(`bench/<id>/base`) 위에서 만든 작업 트리 → bench id.
+  const benchWorktrees = new Map<string, string>();
   const gateVerifyOrdinals = new Map<string, number>();
   const gateVerifyIdentity = (runId: string | undefined) => {
     if (!runId?.trim()) return { runId: runId === undefined ? null : runId, ordinal: null };
@@ -1535,6 +1541,18 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
     defaultBranchRef,
     // ★ G2(2026-07-21) — 호출부가 해석한 대상만 PR 직전에 정합한다.
     mergeMain: async (worktreePath, mergeTarget) => {
+      // BENCH-ISOLATED-ARMS ③ — 벤치 팔은 main 에 정합하지 않는다: 판정은 고정 base 위 게이트·시험·리뷰.
+      //   ⭐ 표지는 둘 중 하나 — 이 프로세스가 벤치 base 로 만든 트리이거나, 트리 가지가 `bench/<id>/<arm>` 이다
+      //   (재개 프로세스는 앞의 Map 이 비어 있으므로 가지 이름으로 다시 안다).
+      const benchArm = benchWorktrees.has(worktreePath) ? undefined : (() => {
+        const head = runGitCommand(worktreePath, ['rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf8', timeout: GIT_TIMEOUT });
+        return head.status === 0 ? parseBenchArmBranch(String(head.stdout).trim()) : null;
+      })();
+      const benchId = benchWorktrees.get(worktreePath) ?? benchArm?.id;
+      if (benchId) {
+        debug.log(BENCH_LOG_CATEGORY, 'main-sync-skipped', { benchId, worktreePath, mergeTarget, source: benchWorktrees.has(worktreePath) ? 'base' : 'branch' });
+        return { status: 'up-to-date' as const };
+      }
       const { mergeMainIntoWorktreeWithLlm } = await import('../autopilot/build/llm-conflict-merge.js');
       return mergeMainIntoWorktreeWithLlm(worktreePath, mergeTarget);
     },
@@ -1586,6 +1604,8 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         ...(runId ? { currentOwner: `dev:${runId}` } : {}),
       });
       if (r.resolvedBase) baselineRefs.set(r.path, r.resolvedBase);
+      const benchId = benchIdFromBase(base);
+      if (benchId) benchWorktrees.set(r.path, benchId);
       const provenance = runId ? {
         owner: `dev:${runId}`,
         command: 'elanous dev',
@@ -1686,6 +1706,28 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         ...(runId ? { runId } : {}),
       });
       const prompt = featurePrompt(feature, cwd, o.reviewerContext);
+      // CLAUDE-IMPL-LANE — claude-acp 는 PTY 자식(`elanous chat` → getProvider)으로 보내지 않는다:
+      //   거기서는 모델 이름(claude-…)이 anthropic(API 키 provider)으로 풀려 «구독» 런이 API 로 과금된다(#26277 보류 판독).
+      //   구독 ACP 구현기만 쓰고, 구독 확인이 안 되면 실패로 끝낸다(다른 공급자로 조용히 새지 않는다).
+      if (isClaudeAcpChild(childLlm)) {
+        const outcome = await (o.runClaudeAcpImplement ?? runClaudeAcpImplement)({
+          cwd, prompt, ...(childLlm?.model ? { model: childLlm.model } : {}), ...(runId ? { runId } : {}),
+        });
+        if (outcome.kind === 'refused') {
+          debug.log('self-implement', 'implement.result', { reached: false, changed: false, transport: 'claude-acp', refused: outcome.reason, ...(runId ? { runId } : {}) });
+          return { ok: false, summary: `claude-acp 구현 레인 거부: ${outcome.reason}` };
+        }
+        const changed = worktreeHasChanges(cwd, harnessSeededPaths ?? []);
+        // 도구 호출 수 = 허가를 요청한 호출(허가 ⊕ 거부) — ACP 는 읽기 전용 호출 일부를 묻지 않으니 하한이다.
+        const toolCalls = outcome.result.allowed + outcome.result.denied;
+        debug.log('self-implement', 'implement.result', { reached: true, changed, toolCalls, transport: 'claude-acp', allowed: outcome.result.allowed, denied: outcome.result.denied, ...(runId ? { runId } : {}) });
+        return {
+          ok: changed,
+          ...buildImplementReport(outcome.result.text, { changed, toolCalls, reached: true, timedOut: false }),
+          toolCalls,
+          terminalStatus: { reached: true, changed, toolCalls, timedOut: false },
+        };
+      }
       // S4 P2b/P3: input은 관측만 하며, done만 config와 stall 확증을 모두 만족할 때 부모 대기를 끝낸다.
       // 이 종료-보고 규칙은 self-implement child에만 적용한다. 범용 brain의 기본 프롬프트를 바꾸지 않는다.
       const brain = createSelfImplementControlBrain({ goal: feature });
@@ -2436,7 +2478,11 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         commitMessage: title,
         ...(resolvedBase ? { base: resolvedBase } : {}),
         ...(draft !== undefined ? { draft } : {}),
-        ...(labels?.length ? { labels } : {}),
+        // BENCH-ISOLATED-ARMS ② — base 가 `bench/<id>/base` 면 라벨 `elanous:bench` 를 더한다.
+        ...(() => {
+          const all = benchIdFromBase(resolvedBase) && !labels?.includes(BENCH_LABEL) ? [...(labels ?? []), BENCH_LABEL] : labels;
+          return all?.length ? { labels: all } : {};
+        })(),
       });
       if (!outcome.ok) throw new Error(`self-implement PR ${outcome.reason} 실패: ${outcome.detail}`);
       const number = Number.parseInt(outcome.url.match(/\/pull\/(\d+)/)?.[1] ?? '', 10);

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

@@ -120,6 +120,8 @@ export function singleRunAsJobResult(feature: string, r: SelfImplementResultWith
     ...(r.abandonedClassification?.classification
       ? { failureClassification: r.abandonedClassification.classification } : {}),
     ...(r.decomposeProposal ? { decomposeProposal: r.decomposeProposal } : {}),
+    ...(r.rework ? { rework: r.rework } : {}),
+    ...(r.review?.reviewed && r.review.mustFix?.length ? { reviewMustFix: r.review.mustFix } : {}),
     ...(r.goalPlanRevision ? { goalPlanRevision: r.goalPlanRevision } : {}),
     ...(r.salvage !== undefined ? { salvage: r.salvage } : {}),
     ...(r.review?.reviewed === true && r.review.verdict === 'pass'
@@ -240,8 +242,10 @@ export async function runSelfImplementCliCommand(
           }
         : undefined;
 
+      const initialJob = singleRunAsJobResult(feature, result);
       await superviseRun({
-        initial: [singleRunAsJobResult(feature, result)],
+        initial: [initialJob],
+        repairGoalExecution: true,
         limits,
         ...(deliverableEye ? { observeDeliverables: deliverableEye } : {}),
         ...(opts.supervise.onDecision ? { onDecision: opts.supervise.onDecision } : {}),
@@ -250,11 +254,12 @@ export async function runSelfImplementCliCommand(
         },
         // ⛔ 단일의 「다시 걸기」는 «같은 골을 다시»다 — 연합의 resumeFrom 과 다르다.
         //   ⇒ 그래서 판정은 «같고» 집행만 여기서 안다(superviseRun 은 그것을 모른다).
-        rerun: async () => {
-          const next = await exec(spec, pipelineDeps ? { pipelineDeps } : undefined);
+        rerun: async (_, invocation) => {
+          const repairGoal = invocation.repairGoals?.[initialJob.taskId];
+          const next = await exec(repairGoal ? { ...spec, input: { ...spec.input, text: repairGoal } } : spec, pipelineDeps ? { pipelineDeps } : undefined);
           result = next.result;
           exitCode = next.exitCode;
-          return [singleRunAsJobResult(feature, next.result)];
+          return [{ ...singleRunAsJobResult(feature, next.result), taskId: initialJob.taskId }];
         },
       });
     }

package/src/self-implement/stop-autoheal.ts

@@ -15,12 +15,19 @@
  *   evidence-uncovered → derive-evidence-rejudge  런 출력·시험·배선에서 증거를 끌어내 1회 재판정
  *   review-repeat · review-out-of-scope · fabric · launch-failed · unclassified → needs-owner(새 라운드 없음)
  *
+ * 사다리의 «출처»: `graphs/overlays/stop-heal-ladder.yaml` 이 갈래마다 처방 노드(id = 처방 이름)를 선언한다.
+ *    그 갈래에 얹힌 오버레이가 더한 노드 id 가 처방이다(source='graph'). 선언이 없거나 못 읽으면
+ *    위 표(`AUTOHEAL_ACTION_BY_CLASS`)로 간다(source='code-default'). 둘이 같은 답을 내는지는 시험이 문다.
+ *
  * 모드 `tools.selfImplement.autoheal.mode` = `shadow`(기본: 할 일을 원장에만 적고 손대지 않는다) | `live`.
  * ⛔ live 에서도 행동은 주입 seam 으로만 한다 — seam 이 없는 행동은 `needs-owner`(action-unwired)로 떨어진다.
  *    «안 이어진 손»을 「고쳤다」로 읽지 않게.
  * 관측 = `debug.log('self-implement.autoheal', …)` ⊕ 원장 `event='autoheal'`.
  */
 import { debug } from '../debug/log.js';
+import { applyGraphOverlays, defaultOverlaysDir, loadGraphOverlays, selectOverlays, type GraphOverlaySpec } from './graph-overlay-yaml.js';
+import type { GraphTemplateSpec } from './graph-yaml.js';
+import { GRAPH_SPECS } from './graph-templates.js';
 import { appendRunLedgerEntry, loadRunLedger, type RunLedgerEntry, type RunLedgerWriter } from './run-ledger.js';
 import type { RunStopClass, RunStopRecord } from './run-stop.js';
 
@@ -48,6 +55,58 @@ export const AUTOHEAL_ACTION_BY_CLASS: Readonly<Record<RunStopClass, AutohealAct
   unclassified: 'needs-owner',
 };
 
+/** 처방 노드 id 로 인정하는 이름 — 오버레이가 더한 노드 중 이 넷만 처방으로 읽는다. */
+const HEAL_ACTION_NODE_IDS: ReadonlySet<string> = new Set<Exclude<AutohealAction, 'needs-owner'>>([
+  'clean-workspace-regate', 'rebase-regate', 'resume-from-salvage', 'derive-evidence-rejudge',
+]);
+
+/** 처방이 «어디서» 왔나 — `graph` = 그 갈래에 얹힌 오버레이가 더한 노드 · `code-default` = 위 표. */
+export type AutohealActionSource = 'graph' | 'code-default';
+
+export interface AutohealPick {
+  action: AutohealAction;
+  source: AutohealActionSource;
+  /** source='graph' 일 때 그 처방 노드를 더한 오버레이. */
+  overlayId?: string;
+}
+
+/** 사다리를 읽어 오는 자리 — 활성 템플릿 선언 ⊕ 오버레이 목록. 시험이 갈아 끼운다. */
+export interface AutohealLadder {
+  template: GraphTemplateSpec | undefined;
+  overlays: readonly GraphOverlaySpec[];
+}
+
+function loadDefaultLadder(): AutohealLadder {
+  return { template: GRAPH_SPECS['self-implement'], overlays: loadGraphOverlays(defaultOverlaysDir()).overlays };
+}
+
+/**
+ * 갈래 → 처방. 그 `stop_class` 에 얹힌 오버레이가 활성 템플릿에 더한 처방 노드 id 를 고른다.
+ * ⛔ 오버레이가 없거나 · 조건 키가 없거나 · 로드·적용이 실패하거나 · 처방 노드가 정확히 하나가 아니면
+ *    «조용히» 코드 표로 간다 — 그 사실은 `source` 가 말한다. 던지지 않는다.
+ */
+export function pickAutohealAction(cls: RunStopClass, loadLadder: () => AutohealLadder = loadDefaultLadder): AutohealPick {
+  const codeDefault: AutohealPick = { action: AUTOHEAL_ACTION_BY_CLASS[cls] ?? 'needs-owner', source: 'code-default' };
+  try {
+    const { template, overlays } = loadLadder();
+    if (!template) return codeDefault;
+    const { applied } = selectOverlays(overlays, { graphId: template.graphId, stage: 'heal', state: { stop_class: cls } });
+    const declared = new Set(template.nodes.map((node) => node.nodeId));
+    for (const overlay of applied) {
+      const result = applyGraphOverlays(template, [overlay]);
+      if (!result.ok) {
+        observe('overlay-rejected', { stopClass: cls, overlayId: overlay.overlayId, rejections: result.rejections.map((r) => r.kind) });
+        continue;
+      }
+      const added = result.template.nodes.map((node) => node.nodeId).filter((id) => !declared.has(id) && HEAL_ACTION_NODE_IDS.has(id));
+      if (added.length === 1) return { action: added[0] as AutohealAction, source: 'graph', overlayId: overlay.overlayId };
+    }
+  } catch (error) {
+    observe('ladder-unreadable', { stopClass: cls, error: error instanceof Error ? error.message : String(error) });
+  }
+  return codeDefault;
+}
+
 /** 설정 원값 → 모드. 모르는 값은 «좁은 쪽»(shadow). */
 export function parseAutohealMode(raw: unknown): AutohealMode {
   return raw === 'live' ? 'live' : 'shadow';
@@ -84,6 +143,10 @@ export interface AutohealResult {
   runId: string;
   class: RunStopClass;
   action: AutohealAction;
+  /** 처방을 «어디서» 골랐나 — 그래프 선언 또는 코드 표. */
+  source: AutohealActionSource;
+  /** source='graph' 일 때 처방 노드를 더한 오버레이. */
+  overlayId?: string;
   mode: AutohealMode;
   outcome: AutohealOutcome;
   /** needs-owner 일 때 사람이 볼 이유(멈춘 원인 그대로 또는 행동 실패). */
@@ -98,6 +161,8 @@ export interface AutohealDeps {
   /** 가드용 원장 읽기 — 기본 `loadRunLedger(runId)`. null = 원장 없음(첫 시도). */
   loadLedger?: (runId: string) => readonly RunLedgerEntry[] | null;
   writeLedger?: RunLedgerWriter;
+  /** 사다리 선언 읽기 — 기본은 활성 템플릿 ⊕ `graphs/overlays`. 던지면 코드 표로 간다. */
+  loadLadder?: () => AutohealLadder;
 }
 
 /**
@@ -128,8 +193,8 @@ function observe(event: string, data: Record<string, unknown>): void {
 export async function autohealFromStop(ctx: AutohealContext, deps: AutohealDeps = {}): Promise<AutohealResult> {
   const mode = deps.mode ?? DEFAULT_AUTOHEAL_MODE;
   const cls = ctx.record.class;
-  const action = AUTOHEAL_ACTION_BY_CLASS[cls] ?? 'needs-owner';
-  const base = { runId: ctx.runId, class: cls, action, mode };
+  const { action, source, overlayId } = pickAutohealAction(cls, deps.loadLadder);
+  const base = { runId: ctx.runId, class: cls, action, source, ...(overlayId ? { overlayId } : {}), mode };
 
   let ledger: readonly RunLedgerEntry[] | null = null;
   try {
@@ -145,6 +210,8 @@ export async function autohealFromStop(ctx: AutohealContext, deps: AutohealDeps
     return { ...base, outcome: 'already-attempted' };
   }
 
+  observe('action-source', { stopClass: cls, action, source, overlayId: overlayId ?? null });
+
   let outcome: AutohealOutcome;
   let reason: string | undefined;
   let detail: string | undefined;

package/src/session-runtime/retry-policy.ts

@@ -225,7 +225,8 @@ export function providerNamesFromFallbackChain(chain: readonly string[]): string
   const out: string[] = [];
   const seen = new Set<string>();
   for (const step of chain) {
-    const name = step === 'grok' ? 'grok' : step === 'codex-rotate' ? 'openai-codex' : undefined;
+    // `codex-credits`(체인 마지막 칸 · 크레딧)도 provider 는 openai-codex 다 — 이미 앞에 있으면 중복이라 빠진다.
+    const name = step === 'grok' ? 'grok' : step === 'codex-rotate' || step === 'codex-credits' ? 'openai-codex' : undefined;
     if (!name || seen.has(name)) continue;
     seen.add(name);
     out.push(name);

package/src/steward/launch.ts

@@ -1,8 +1,8 @@
 import { randomUUID } from 'node:crypto';
 import { closeSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { join } from 'node:path';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
-import { resolveHqLaunchSeat } from '../hq/seats.js';
+import { installedCliArgv, resolveHqLaunchSeat } from '../hq/seats.js';
 import { debug } from '../debug/log.js';
 import { publishInsideEvent } from '../nexus/api/inside-events.js';
 import { redactSecrets } from '../task-cards/card-store.js';
@@ -56,7 +56,7 @@ const DEFAULT_POOL = 'pool-node-b@node-b:8';
 // `harness budget --json` outcomes: proceed | next-provider | wait-reset | stop. next-provider still runs (the harness switches provider itself).
 const BUDGET_PROCEED: readonly string[] = ['proceed', 'next-provider'];
 const launchMode = (settings: StewardSettings): 'off' | 'shadow' | 'live' => launchModeOf(settings.mode ?? settings.launch ?? 'shadow');
-const cli = (args: string[]) => [process.execPath, resolve(import.meta.dir, '../../bin/elanous.mjs'), ...(process.env.NODE_ENV === 'test' ? ['--test'] : []), ...args];
+const cli = (args: string[]) => installedCliArgv([...(process.env.NODE_ENV === 'test' ? ['--test'] : []), ...args]);
 const sourceOf = (issue: TriageIssue): string => /^출처: (telegram|pwa|tui|cli)$/m.exec(issue.body)?.[1] ?? `linear:${issue.identifier}`;
 const promptOf = (issue: TriageIssue): string => `${issue.title}\n${issue.body.slice(0, 1500)}`;
 const argvFor = (issue: TriageIssue, settings: StewardSettings): string[] =>
@@ -108,7 +108,8 @@ function stewardLaunchSeat(): string {
   return resolveHqLaunchSeat('OP', getElanousConfigDir());
 }
 
-function runCommand(args: string[], cwd = resolve(import.meta.dir, '../..')): { exitCode: number; stdout: string; stderr: string } {
+/** Read commands run in the registered OP seat as well: the tree this module was loaded from may be a stale clone. */
+function runCommand(args: string[], cwd = stewardLaunchSeat()): { exitCode: number; stdout: string; stderr: string } {
   const result = Bun.spawnSync(args, { cwd, stdout: 'pipe', stderr: 'pipe' });
   return { exitCode: result.exitCode, stdout: result.stdout.toString(), stderr: result.stderr.toString() };
 }

package/src/steward/triage-budget.ts

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { debug } from '../debug/log.js';
 import type { TriageDecision, TriageIssue } from './triage.js';
+import { InvalidWorkingBackwardsDraft } from './working-backwards.js';
 
 export interface HashedTriageDecision extends TriageDecision {
   inputHash: string;
@@ -125,3 +126,64 @@ export async function triageWithinBudget({ issues, previous, judge, tracks, conc
   debug.log('steward.triage', 'budget', stats);
   return { decisions, stats };
 }
+
+export interface CarriedDraft<T> {
+  wish: T;
+  /** `deadline` = never started before the stage deadline; `timeout` = per-item or stage deadline hit mid-draft. */
+  reason: 'timeout' | 'deadline' | 'error';
+}
+
+type DraftOutcome<T> = { kind: 'drafted' } | { kind: 'invalid' } | { kind: 'carried'; reason: CarriedDraft<T>['reason'] };
+
+export async function draftWithinBudget<T>({ wishes, draft, concurrency = 4, perItemMs = 120_000, deadlineMs = 240_000, now = Date.now }: {
+  wishes: T[];
+  /** `expired` rejects once this item's own deadline passes; drafts should race their slow calls against it. */
+  draft: (wish: T, expired: Promise<never>) => Promise<void>;
+  concurrency?: number;
+  perItemMs?: number;
+  deadlineMs?: number;
+  now?: () => number;
+}): Promise<{ drafted: T[]; carried: Array<CarriedDraft<T>>; invalid: T[]; stats: { drafted: number; carried: number; invalid: number } }> {
+  const end = now() + deadlineMs;
+  const slots = Number.isFinite(concurrency) ? Math.max(1, Math.floor(concurrency)) : 4;
+  const outcomes: Array<DraftOutcome<T> | undefined> = new Array(wishes.length);
+  let stageTimer: ReturnType<typeof setTimeout> | undefined;
+  const stageExpired = new Promise<void>(resolve => { stageTimer = setTimeout(resolve, Math.max(0, end - now())); });
+  const timedOut = Symbol('draft-timeout');
+  let cursor = 0;
+  const worker = async (): Promise<void> => {
+    while (cursor < wishes.length) {
+      const remaining = end - now();
+      if (remaining <= 0) return;
+      const index = cursor++;
+      let itemTimer: ReturnType<typeof setTimeout> | undefined;
+      const expired = new Promise<never>((_, reject) => { itemTimer = setTimeout(() => reject(timedOut), Math.min(perItemMs, remaining)); });
+      // The draft may finish without ever racing this promise — never leave its rejection unhandled.
+      expired.catch(() => undefined);
+      const work = Promise.resolve().then(() => draft(wishes[index]!, expired));
+      const settled = work.then(() => undefined, () => undefined);
+      try {
+        await Promise.race([work, expired]);
+        outcomes[index] = { kind: 'drafted' };
+      } catch (error) {
+        outcomes[index] = error instanceof InvalidWorkingBackwardsDraft ? { kind: 'invalid' }
+          : { kind: 'carried', reason: error === timedOut ? 'timeout' : 'error' };
+        // A timed-out draft keeps its concurrency slot until the underlying call settles or the stage ends.
+        await Promise.race([settled, stageExpired]);
+      } finally { if (itemTimer) clearTimeout(itemTimer); }
+    }
+  };
+  try {
+    await Promise.all(Array.from({ length: Math.min(slots, wishes.length) }, () => worker()));
+  } finally { if (stageTimer) clearTimeout(stageTimer); }
+  const result = { drafted: [] as T[], carried: [] as Array<CarriedDraft<T>>, invalid: [] as T[] };
+  for (const [index, wish] of wishes.entries()) {
+    const outcome = outcomes[index];
+    if (outcome?.kind === 'drafted') result.drafted.push(wish);
+    else if (outcome?.kind === 'invalid') result.invalid.push(wish);
+    else result.carried.push({ wish, reason: outcome?.kind === 'carried' ? outcome.reason : 'deadline' });
+  }
+  const stats = { drafted: result.drafted.length, carried: result.carried.length, invalid: result.invalid.length };
+  debug.log('steward.triage', 'draft-budget', stats);
+  return { ...result, stats };
+}

package/src/steward/triage.ts

@@ -8,6 +8,10 @@ import { getUserConfig } from '../user-config.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { debug, redactSecretText } from '../debug/log.js';
 import { loopEvent } from '../loops/observe.js';
+import { checkLoops, daemonScheduleEntries, entriesFromRegistry, extendHealthyLauncher, launcherEvidence, notifyOwners, scheduleFindings, versionEvidence, type CheckEntry } from '../loops/checker.js';
+import { listSchedules, schedulesDbPath, type ScheduleRow } from '../domains/schedule-registry.js';
+import { Database } from 'bun:sqlite';
+import { defaultLoopRoot, listAllLoops, listLoops } from '../loops/registry.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { redactSecrets } from '../task-cards/card-store.js';
 import { directiveHash } from './directive.js';
@@ -17,7 +21,7 @@ import { planLaunches, launch, collectOutcomes, raiseHitl, readLaunchLedger, sav
 import { listFabricExecutionCandidates } from '../self-dev/fabric-plan-core.js';
 import { InvalidWorkingBackwardsDraft, recordWorkingBackwardsOnCards } from './working-backwards.js';
 import { CardStore } from '../task-cards/card-store.js';
-import { triageWithinBudget } from './triage-budget.js';
+import { draftWithinBudget, triageWithinBudget } from './triage-budget.js';
 import { askSteward, classifyIssue, installedCapabilities, planIssues, ruleJudgment, unsafeReason, type ClassifiedIssue, type StewardAsk } from './triage-plan.js';
 import { failureAlertText, markStageStart, markStageEnd, readFailureStreak, shouldAlert, writeFailureStreak, type FailureStreak, type StewardStage } from './failure-streak.js';
 
@@ -59,6 +63,8 @@ export interface StewardDeps {
   ask?: StewardAsk;
   /** Maximum time for each working-backwards wish draft in schedule (milliseconds). */
   draftItemMs?: number;
+  /** Maximum time for the whole wish-drafting phase in schedule (milliseconds); wishes still undrafted are carried. */
+  draftDeadlineMs?: number;
   launchSettings?: Pick<StewardSettings, 'mode' | 'launch' | 'maxParallel' | 'podPool'>;
   launchCommand?: LaunchDeps['command'];
   spawnLaunch?: LaunchDeps['spawn'];
@@ -68,6 +74,9 @@ export interface StewardDeps {
   outcomeNotify?: Pick<OutcomeNotifyDeps, 'document' | 'message' | 'worktreeCommand' | 'loadOrigin' | 'loadOrigins'>;
   /** Internal command boundary: the current sync has already claimed this pid. */
   stageOwnedByCommand?: boolean;
+  /** Isolated scheduler inventory for this tick; production reads the unified registry. */
+  scheduleInventory?: () => CheckEntry[];
+  daemonSchedules?: () => ScheduleRow[];
 }
 
 /** rescue launches/harvests like live (HQ-SEAT). */
@@ -314,6 +323,61 @@ function logStageFailure(root: string, stage: StewardStage, reason: string): voi
   if (runId) try { rmSync(tickDecisionPath(root, runId), { force: true }); } catch { /* Observation must not change the failure. */ }
   logTickDecision(root, 'failed', `${stage}: ${reason}`);
 }
+const SCHEDULE_CHECK_MS = 15 * 60_000;
+
+/** Called by runStewardStage(sync) under its stage slot, never from the checker CLI. */
+async function checkStewardSchedules(root: string, settings: StewardSettings, deps: StewardDeps): Promise<void> {
+  const now = (deps.now ?? (() => new Date()))();
+  const marker = join(root, 'steward', 'schedule-check.json');
+  let previous: { at?: string } = {};
+  try { previous = JSON.parse(readFileSync(marker, 'utf8')) as typeof previous; }
+  catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+  const elapsed = now.getTime() - Date.parse(previous.at ?? '');
+  if (Number.isFinite(elapsed) && elapsed >= 0 && elapsed < SCHEDULE_CHECK_MS) return;
+  const inventory = deps.scheduleInventory ?? (() => {
+    const repo = deps.root ? process.cwd() : defaultLoopRoot();
+    const registryOptions = { now, root: repo, stateRoot: root,
+      ...(deps.root ? { schedules: [] } : {}) };
+    const { entries } = entriesFromRegistry({ now, listAllLoops: () => listAllLoops(registryOptions) });
+    const graphs = listLoops(registryOptions);
+    const byId = new Map(graphs.map(graph => [graph.id, graph.file]));
+    return versionEvidence(launcherEvidence(entries.map(entry => byId.has(entry.id)
+      ? { ...entry, file: byId.get(entry.id) } : entry), root), repo, root);
+  });
+  const daemonRows = deps.daemonSchedules ?? (() => {
+    const path = deps.root ? join(root, 'schedules.db') : schedulesDbPath();
+    if (!existsSync(path)) return [];
+    try {
+      const db = new Database(path, { readonly: true });
+      try { return listSchedules(db); } finally { db.close(); }
+    } catch (error) {
+      debug.log('steward.schedule-check', 'daemon-inventory-unavailable', { reason: redactSecretText(String(error)) });
+      return [];
+    }
+  });
+  const entries = inventory();
+  const seen = new Set(entries.map(entry => entry.id));
+  const checked = checkLoops([...entries, ...daemonScheduleEntries(daemonRows(), now).filter(row => !seen.has(row.id))], now);
+  const findings = scheduleFindings(checked, now);
+  if (settings.mode === 'live') {
+    let recovered = 0;
+    const unresolved = findings.filter(finding => {
+      try {
+        if (extendHealthyLauncher(root, finding, now)) { recovered++; return false; }
+      } catch (error) {
+        debug.log('steward.schedule-check', 'recovery-failed', { id: finding.id, reason: redactSecretText(String(error)) });
+      }
+      return true;
+    });
+    const remainingChecks = checked.filter(row => unresolved.some(finding => finding.id === row.id && finding.kind === row.state));
+    const ownerRequests = notifyOwners(remainingChecks, { root, now }, unresolved);
+    const opEscalations = notifyOwners(remainingChecks, { root, now }, unresolved, true);
+    debug.log('steward.schedule-check', 'routing', { ownerRequests, opEscalations, recovered });
+  }
+  debug.log('steward.schedule-check', 'checked', { count: checked.length, findings: findings.length, mode: settings.mode });
+  writeFileSync(marker, JSON.stringify({ at: now.toISOString() }));
+}
+
 function readState(path: string): { issues: Record<string, string>; digestDay?: string } {
   try { return JSON.parse(readFileSync(path, 'utf8')) as ReturnType<typeof readState>; }
   catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { issues: {} }; throw error; }
@@ -343,6 +407,11 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
   const runId = (graphRunId() ?? process.env.ELANOUS_RUN_ID?.trim()) || `steward-stage-${randomUUID()}`;
   let outcome: 'ok' | 'fail' = 'fail';
   try {
+  if (stage === 'sync') {
+    // The schedule check is an add-on to sync: its failure is observed, never allowed to stop the Linear sync.
+    try { await checkStewardSchedules(root, settings, deps); }
+    catch (error) { debug.log('steward.schedule-check', 'failed', { reason: redactSecretText(String(error)) }, { level: 'warn' }); }
+  }
   const key = await (deps.getSecret ?? getSecretAsync)('connector.linear.apiKey');
   if (!key) throw new Error('connector.linear.apiKey missing');
   if (stage === 'sync') {
@@ -420,27 +489,19 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       const carried = new Set<string>();
       if (store) try {
         recordTriageOnCards(wishes, issues, { root, store, now: deps.now });
-        for (const wish of wishes) {
-          const timedOut = Symbol('draft-timeout');
-          let timer: ReturnType<typeof setTimeout> | undefined;
-          const timeout = new Promise<never>((_, reject) => {
-            timer = setTimeout(() => reject(timedOut), deps.draftItemMs ?? 120_000);
-          });
-          // The draft may finish without ever racing this promise (no ask needed) — never leave its rejection unhandled.
-          timeout.catch(() => undefined);
-          try {
-            // Bound the ask itself so a late answer cannot write to a store closed after this tick.
-            const ask: StewardAsk = (prompt, role) => Promise.race([(deps.ask ?? askSteward)(prompt, role), timeout]);
-            await recordWorkingBackwardsOnCards([wish], issues, store, ask);
-          } catch (error) {
-            if (error instanceof InvalidWorkingBackwardsDraft) {
-              invalid.add(wish.issue);
-              debug.log('steward.stage', 'draft-invalid', { issue: wish.issue });
-            } else {
-              carried.add(wish.issue);
-              debug.log('steward.schedule', 'draft-carried', { issue: wish.issue, reason: error === timedOut ? 'timeout' : 'error' });
-            }
-          } finally { if (timer) clearTimeout(timer); }
+        const outcome = await draftWithinBudget({
+          wishes, perItemMs: deps.draftItemMs ?? 120_000, deadlineMs: deps.draftDeadlineMs ?? 240_000,
+          // Bound the ask itself so a late answer cannot write to a store closed after this tick.
+          draft: (wish, expired) => recordWorkingBackwardsOnCards([wish], issues, store,
+            (prompt, role) => Promise.race([(deps.ask ?? askSteward)(prompt, role), expired])),
+        });
+        for (const wish of outcome.invalid) {
+          invalid.add(wish.issue);
+          debug.log('steward.stage', 'draft-invalid', { issue: wish.issue });
+        }
+        for (const { wish, reason } of outcome.carried) {
+          carried.add(wish.issue);
+          debug.log('steward.schedule', 'draft-carried', { issue: wish.issue, reason });
         }
       } finally { if (!deps.cardStore) store.close(); }
       if (invalid.size || carried.size) rows = rows.map(row => invalid.has(row.issue)