elanous 0.2.23 → 0.2.25

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/skills/tools/agent.ts

@@ -44,7 +44,7 @@ import { enhanceAgentResultWithSeed } from '../../agent/seed.js';
 import { resolveAgent } from '../../agent/loader.js';
 import { resolveAgentLayered } from '../../agent/definition-registry.js';
 import type { AgentDefinition } from '../../agent/types.js';
-import { getSessionCwd } from '../../session/working-dir.js';
+import { getSessionCwd, setSessionCwd } from '../../session/working-dir.js';
 import {
   agentCacheKey, dedupeStub, logDedupHit, type SessionCache,
   DEDUP_CASCADE_HALT_THRESHOLD, CONSECUTIVE_DEDUP_BLOCK_THRESHOLD,
@@ -485,6 +485,11 @@ export async function dispatchAgent(
   } else if (isolation === 'worktree') {
     const { enterWorktreeRuntime } = await import('../../tool-runtime/git-worktree-runtimes.js');
     const wtName = `${spawnName ?? definition.name}-${debugCorrelationId}`.replace(/[^a-zA-Z0-9._/-]/g, '-');
+    // enterWorktreeRuntime.run mutates the parent session cwd via
+    // setSessionCwd(path, 'tool'). Capture and restore so Agent(isolation:
+    // 'worktree') never leaks the child's worktree into the parent status
+    // line — enter_worktree (human-invoked) still moves cwd intentionally.
+    const parentCwd = getSessionCwd();
     try {
       const wt = await enterWorktreeRuntime.run({ name: wtName }, { surface: 'skill' as any });
       childCwd = wt.path;
@@ -506,6 +511,16 @@ export async function dispatchAgent(
         requestedIsolation: 'worktree',
         reason: message,
       }, { level: 'warn' });
+    } finally {
+      const afterCwd = getSessionCwd();
+      if (afterCwd !== parentCwd) {
+        setSessionCwd(parentCwd, 'tool');
+        debug.log('agent.spawn', 'worktree-parent-cwd-restored', {
+          agent: definition.name,
+          from: afterCwd,
+          to: parentCwd,
+        });
+      }
     }
   } else {
     childCwd = opts.cwd ?? getSessionCwd();

package/src/skills/tools/persistent-grounding.ts

@@ -153,6 +153,16 @@ function rejectionSample(value: string): string {
   return value.slice(0, EVIDENCE_REJECTION_SAMPLE_PREFIX_LENGTH);
 }
 
+function stripLeadingListMarkers(line: string): string {
+  let stripped = line;
+  let previous: string;
+  do {
+    previous = stripped;
+    stripped = stripped.replace(/^\s*(?:[-*+•]|\d+[.)])\s+/, '');
+  } while (stripped !== previous);
+  return stripped;
+}
+
 function verifiedEvidenceFromCompletion(evidence: string, readFiles: Set<string>): { files: string[]; evidence: string[]; rejection: EvidenceRejection } {
   const lines = evidence.split(/\r?\n/).filter((line) => line.trim());
   const rejection: {
@@ -185,7 +195,7 @@ function verifiedEvidenceFromCompletion(evidence: string, readFiles: Set<string>
     return hasPath && insideRoot && unreadPaths.length === 0 && hasMeaningfulText;
   });
   const files = Array.from(new Set(verifiedLines.flatMap(repositoryRelativeCodePaths)));
-  return { files, evidence: verifiedLines, rejection };
+  return { files, evidence: verifiedLines.map(stripLeadingListMarkers), rejection };
 }
 
 function groundingMessages(goal: string, terms: readonly string[]): LLMMessage[] {

package/src/skills/tools/shell.ts

@@ -113,7 +113,7 @@ export interface RunShellDispatchResult extends Record<string, unknown> {
    *  follow in the structured fields below. */
   output: string;
   exitCode: number | null;
-  outcome: ShellResult['outcome'];
+  outcome: ShellResult['outcome'] | 'started';
   elapsedMs: number;
   stdout: string;
   stderr: string;
@@ -260,6 +260,38 @@ async function dispatchViaRunner(args: {
     ...(args.signal !== undefined ? { signal: args.signal } : {}),
   };
   const handle = runnerDispatch(req, args.deps);
+  if (args.mode === 'bg') {
+    const bgStartedAt = Date.now();
+    void handle.result.then(
+      (result) => {
+        debug.log('skill-tool.shell', 'bg-finished', {
+          handle: handle.id,
+          exitCode: result.exitCode ?? null,
+          durationMs: result.durationMs,
+        });
+      },
+      (err: unknown) => {
+        debug.log('skill-tool.shell', 'bg-finished', {
+          handle: handle.id,
+          exitCode: null,
+          durationMs: Date.now() - bgStartedAt,
+          error: err instanceof Error ? err.message : String(err),
+        });
+      },
+    );
+    return {
+      output: `RunShell outcome=started handle=${handle.id} bg=${handle.id}`,
+      exitCode: null,
+      outcome: 'started',
+      elapsedMs: 0,
+      stdout: '',
+      stderr: '',
+      truncated: false,
+      approvalKey: `runner:${handle.id}`,
+      sandboxed: false,
+      sandboxTool: 'none',
+    };
+  }
   const result = await handle.result;
   return runnerToLegacyResult(handle.id, result);
 }

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/rejudge-tick.ts

@@ -0,0 +1,142 @@
+/**
+ * TA-REJUDGE-PERIODIC — the steward (coordinator) tick re-runs `tasks rejudge --all` on a cadence.
+ *
+ * `tasks rejudge` only ran when someone typed it (OP bridged the gap with a 30-minute shell loop). This node is the
+ * product form: the steward graph already ticks every 15 minutes, so the rejudge rides that tick — no new resident loop.
+ *
+ * - Off by default: `taskAgent.rejudgeEveryMinutes` absent/0 → one `disabled` line per tick and nothing else.
+ *   Rejudge can land PRs (per `taskAgent.liveMoves`), so it is switched on by an operator, not by an upgrade.
+ * - Cadence: due when the last started run is ≥ interval − 2 min ago (tick start jitter must not skip a whole tick).
+ * - Load guard: 1-minute load average above `taskAgent.rejudgeMaxLoad` (default 60) skips this tick without stamping,
+ *   so the next tick retries.
+ * - Fail-soft: every outcome exits 0 — a rejudge problem never stops the steward's own stages.
+ * - Observation: one `debug.log('loop.steward', 'rejudge-tick', …)` per tick.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { loadavg } from 'node:os';
+import { dirname, join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { spawnElanous } from '../instance/spawn-elanous.js';
+import { getUserConfig } from '../user-config.js';
+
+export const REJUDGE_TICK_EVENT = 'rejudge-tick';
+export const REJUDGE_DEFAULT_MAX_LOAD = 60;
+export const REJUDGE_JITTER_MS = 2 * 60_000;
+export const REJUDGE_TIMEOUT_MS = 600_000;
+
+export type RejudgeTickDecision = 'disabled' | 'not-due' | 'load-skip' | 'ran' | 'failed';
+
+export interface RejudgeTickResult {
+  decision: RejudgeTickDecision;
+  everyMinutes: number | null;
+  load?: number;
+  maxLoad?: number;
+  lastStartedAt?: string | null;
+  rc?: number | null;
+  timedOut?: boolean;
+  cards?: number;
+  decisions?: Record<string, number>;
+  ms?: number;
+  reason?: string;
+}
+
+export interface RejudgeRun { code: number | null; stdout: string; stderr: string; timedOut: boolean }
+
+export interface RejudgeTickDeps {
+  now?: () => Date;
+  /** `taskAgent.rejudgeEveryMinutes` / `taskAgent.rejudgeMaxLoad` — default reads the user config. */
+  config?: () => { rejudgeEveryMinutes?: number; rejudgeMaxLoad?: number } | undefined;
+  load?: () => number;
+  stampPath?: string;
+  run?: () => Promise<RejudgeRun>;
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+function defaultStampPath(): string {
+  // Resolved at call time, in the node process's own universe (prod cron vs --test graph run).
+  return join(effectiveInstanceRoot(), 'steward', 'rejudge-tick.json');
+}
+
+function readStamp(path: string): string | null {
+  try {
+    const value = (JSON.parse(readFileSync(path, 'utf8')) as { startedAt?: unknown }).startedAt;
+    return typeof value === 'string' && Number.isFinite(Date.parse(value)) ? value : null;
+  } catch { return null; }
+}
+
+/** Same universe as this process (env inherited) · same installed version (entry next to this module). */
+export function defaultRejudgeRun(timeoutMs = REJUDGE_TIMEOUT_MS): Promise<RejudgeRun> {
+  return new Promise(done => {
+    const child = spawnElanous(['tasks', 'rejudge', '--all', '--json'], { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    const timer = setTimeout(() => { timedOut = true; child.kill('SIGTERM'); }, timeoutMs);
+    child.stdout?.on('data', chunk => { stdout += String(chunk); });
+    child.stderr?.on('data', chunk => { stderr += String(chunk); });
+    child.on('error', error => { clearTimeout(timer); done({ code: null, stdout, stderr: `${stderr}${error.message}`, timedOut }); });
+    child.on('close', code => { clearTimeout(timer); done({ code, stdout, stderr, timedOut }); });
+  });
+}
+
+/** The last `[...]` line of `tasks rejudge --all --json` → card count and a decision histogram. */
+function summarize(stdout: string): { cards: number; decisions: Record<string, number> } | null {
+  const line = stdout.split('\n').map(text => text.trim()).filter(text => text.startsWith('[')).at(-1);
+  if (!line) return null;
+  try {
+    const rows = JSON.parse(line) as Array<{ card?: unknown; decision?: unknown }>;
+    if (!Array.isArray(rows)) return null;
+    const decisions: Record<string, number> = {};
+    for (const row of rows) { const key = String(row?.decision ?? 'unknown'); decisions[key] = (decisions[key] ?? 0) + 1; }
+    return { cards: new Set(rows.map(row => String(row?.card))).size, decisions };
+  } catch { return null; }
+}
+
+function positive(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : null;
+}
+
+export async function rejudgeTick(deps: RejudgeTickDeps = {}): Promise<RejudgeTickResult> {
+  const log = deps.log ?? ((event, data) => debug.log('loop.steward', event, data));
+  const emit = (result: RejudgeTickResult): RejudgeTickResult => {
+    try { log(REJUDGE_TICK_EVENT, { ...result }); } catch { /* fail-soft */ }
+    return result;
+  };
+  try {
+    const cfg = (deps.config ?? (() => getUserConfig().taskAgent))();
+    const everyMinutes = positive(cfg?.rejudgeEveryMinutes);
+    if (everyMinutes === null) return emit({ decision: 'disabled', everyMinutes: null, reason: 'taskAgent.rejudgeEveryMinutes unset' });
+    const now = (deps.now ?? (() => new Date()))();
+    const stampPath = deps.stampPath ?? defaultStampPath();
+    const lastStartedAt = readStamp(stampPath);
+    if (lastStartedAt && now.getTime() - Date.parse(lastStartedAt) < everyMinutes * 60_000 - REJUDGE_JITTER_MS) {
+      return emit({ decision: 'not-due', everyMinutes, lastStartedAt });
+    }
+    const maxLoad = positive(cfg?.rejudgeMaxLoad) ?? REJUDGE_DEFAULT_MAX_LOAD;
+    const load = (deps.load ?? (() => loadavg()[0] ?? 0))();
+    if (load > maxLoad) return emit({ decision: 'load-skip', everyMinutes, load, maxLoad, lastStartedAt });
+    // Claim before running so an overlapping steward tick does not start a second rejudge.
+    mkdirSync(dirname(stampPath), { recursive: true });
+    writeFileSync(stampPath, JSON.stringify({ startedAt: now.toISOString() }));
+    const started = Date.now();
+    const run = await (deps.run ?? (() => defaultRejudgeRun()))();
+    const summary = summarize(run.stdout);
+    const ok = run.code === 0 && !run.timedOut && summary !== null;
+    return emit({
+      decision: ok ? 'ran' : 'failed', everyMinutes, load, maxLoad, lastStartedAt, rc: run.code, timedOut: run.timedOut,
+      cards: summary?.cards ?? 0, decisions: summary?.decisions ?? {}, ms: Date.now() - started,
+      ...(ok ? {} : { reason: (run.stderr || run.stdout).trim().slice(-300) || (summary === null ? 'no JSON result line' : 'nonzero exit') }),
+    });
+  } catch (error) {
+    return emit({ decision: 'failed', everyMinutes: null, reason: (error instanceof Error ? error.message : String(error)).slice(-300) });
+  }
+}
+
+if (import.meta.main) {
+  try { await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('steward'); }
+  catch (error) { console.error(`steward rejudge: log sink registration failed — ${error instanceof Error ? error.message : String(error)}`); }
+  const result = await rejudgeTick();
+  console.log(`steward rejudge: ${result.decision}${result.reason ? ` — ${result.reason}` : ''}`);
+  process.exitCode = 0;
+}

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 };
+}