elanous 0.2.12 → 0.2.14

package/src/steward/launch.ts

@@ -7,6 +7,7 @@ import { redactSecrets } from '../task-cards/card-store.js';
 import { preLaunchGate, type PreLaunchGateDecision } from '../execution-loop/launch-gate.js';
 import type { BudgetDecision } from '../self-implement/budget-gate.js';
 import type { ScheduledDecision, StewardSettings, TriageIssue } from './triage.js';
+import { launchModeOf, rescueAllows } from './rescue.js';
 
 /** `completed` = the run finished without a merge (a non-code artifact, or nothing to deliver) — never reported as a failure. */
 export type LaunchStatus = 'shadow' | 'launched' | 'skipped-budget' | 'blocked-duplicate' | 'blocked-location' | 'failed' | 'running' | 'merged' | 'completed';
@@ -50,7 +51,7 @@ const RUN_ID = /\brun-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{1
 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' => settings.mode ?? settings.launch ?? 'shadow';
+const launchMode = (settings: StewardSettings): 'off' | 'shadow' | 'live' => launchModeOf(settings.mode ?? settings.launch ?? 'shadow');
 const cli = (args: string[]) => ['bun', 'bin/elanous.mjs', ...(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)}`;
@@ -125,6 +126,7 @@ export function launch(item: LaunchItem, deps: LaunchDeps): LaunchEntry {
   const { ledger, settings, root } = deps;
   if (item.row.rung !== 4 || item.row.hitlReason || item.row.disposition !== 'now' || (ledger.launches[item.issue.identifier] && !['skipped-budget', 'blocked-duplicate', 'blocked-location'].includes(ledger.launches[item.issue.identifier].status) && !(launchMode(settings) === 'live' && ledger.launches[item.issue.identifier].status === 'shadow'))) throw new Error('steward launch is not eligible');
   if (launchMode(settings) === 'off') throw new Error('steward launch is off');
+  if (!rescueAllows(settings.mode, 'launch', { issue: item.issue.identifier })) throw new Error('steward rescue refused launch');
   const key = item.issue.identifier;
   const entry: LaunchEntry = { issue: key, title: redactSecrets(item.issue.title), source: item.source, command: redactSecrets(item.command), status: 'shadow' };
   if (launchMode(settings) !== 'live') {
@@ -187,6 +189,7 @@ export function launch(item: LaunchItem, deps: LaunchDeps): LaunchEntry {
 export function raiseHitl(issue: TriageIssue, row: ScheduledDecision, deps: LaunchDeps): HitlEntry {
   const old = deps.ledger.hitl[issue.identifier];
   if (old && (old.attempted || launchMode(deps.settings) !== 'live')) return old;
+  if (!rescueAllows(deps.settings.mode, 'decision-card', { issue: issue.identifier })) return old ?? { issue: issue.identifier, reason: redactSecrets(row.hitlReason ?? row.why), raised: false };
   const entry: HitlEntry = old ?? { issue: issue.identifier, reason: redactSecrets(row.hitlReason ?? row.why), raised: false };
   deps.ledger.hitl[issue.identifier] = entry;
   if (launchMode(deps.settings) !== 'live') {
@@ -215,6 +218,7 @@ function alive(pid: number | undefined): boolean {
 
 export function collectOutcomes(ledger: LaunchLedger, deps: LaunchDeps): LaunchEntry[] {
   if (launchMode(deps.settings) !== 'live') return [];
+  if (!rescueAllows(deps.settings.mode, 'harvest')) return [];
   const done: LaunchEntry[] = [];
   for (const entry of Object.values(ledger.launches)) {
     if (entry.reported || entry.status === 'shadow' || entry.status === 'skipped-budget' || entry.status === 'blocked-duplicate' || entry.status === 'blocked-location') continue;

package/src/steward/readiness.ts

@@ -0,0 +1,125 @@
+import { appendFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import type { LaunchPlan } from './launch.js';
+import type { ScheduledDecision } from './triage.js';
+
+// Planning estimates, not invoices: one harness run per launch, one Pod-hour per run.
+// No model/token or runtime telemetry is present in the shadow decision line.
+const ESTIMATED_LLM_USD_PER_LAUNCH = 2;
+const ESTIMATED_POD_USD_PER_LAUNCH = 1;
+const CATEGORY = 'steward.readiness';
+const EVENT = 'shadow-tick';
+
+export interface ShadowTick {
+  at: string;
+  decisions: Array<{ issue: string; rung: ScheduledDecision['rung']; disposition: ScheduledDecision['disposition'] }>;
+  actions: Array<{ issue: string; kind: 'launch' | 'hitl'; llmUsd: number; podUsd: number }>;
+}
+
+function ledgerPath(root: string): string { return join(root, 'steward', 'readiness.jsonl'); }
+
+/** Called by the shadow schedule after its launch/HITL candidates have been selected. */
+export function recordShadowTick(root: string, rows: ScheduledDecision[], plan: LaunchPlan, now: Date = new Date()): ShadowTick {
+  const tick: ShadowTick = {
+    at: now.toISOString(),
+    decisions: rows.map(({ issue, rung, disposition }) => ({ issue, rung, disposition })),
+    actions: [
+      ...plan.launches.map(({ issue }) => ({ issue: issue.identifier, kind: 'launch' as const, llmUsd: ESTIMATED_LLM_USD_PER_LAUNCH, podUsd: ESTIMATED_POD_USD_PER_LAUNCH })),
+      ...plan.hitl.map(({ issue }) => ({ issue: issue.identifier, kind: 'hitl' as const, llmUsd: 0, podUsd: 0 })),
+    ],
+  };
+  appendFileSync(ledgerPath(root), `${JSON.stringify(tick)}\n`);
+  return tick;
+}
+
+export interface ReadinessReport {
+  since: string;
+  until: string;
+  ticks: number;
+  judgments: number;
+  distribution: Record<string, number>;
+  actions: Array<ShadowTick['actions'][number] & { at: string }>;
+  budgetGate: { estimatedLlmUsd: number; estimatedPodUsd: number; estimatedTotalUsd: number; basis: string; verdict: 'estimate-only' };
+  hitlGate: { requiringHuman: number };
+  source: { decisions: string; logs: string };
+}
+
+/** Snapshot-only reader: no CardStore, stage, config setter, logger or write-capable DB handle. */
+export function stewardReadiness(root: string, sinceHours = 24, now: Date = new Date()): ReadinessReport {
+  if (!Number.isFinite(sinceHours) || sinceHours <= 0) throw new Error('--since must be a positive duration such as 24h');
+  const since = new Date(now.getTime() - sinceHours * 3_600_000);
+  if (!Number.isFinite(since.getTime())) throw new Error('--since is out of range');
+  const path = ledgerPath(root);
+  let text: string;
+  try { text = readFileSync(path, 'utf8'); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    text = '';
+  }
+  const ticks: ShadowTick[] = [];
+  for (const [index, line] of text.split('\n').entries()) {
+    if (!line.trim()) continue;
+    let parsed: ShadowTick;
+    try { parsed = JSON.parse(line) as ShadowTick; }
+    catch { throw new Error(`Invalid steward shadow decision line ${index + 1}`); }
+    if (!parsed || typeof parsed.at !== 'string' || !Number.isFinite(Date.parse(parsed.at)) ||
+      !Array.isArray(parsed.decisions) || !parsed.decisions.every(row => row && typeof row.issue === 'string' &&
+        [0, 1, 2, 3, 4, 5, 'hitl'].includes(row.rung) && ['now', 'wait', 'hitl'].includes(row.disposition)) ||
+      !Array.isArray(parsed.actions) || !parsed.actions.every(action => action && typeof action.issue === 'string' &&
+        ['launch', 'hitl'].includes(action.kind) && Number.isFinite(action.llmUsd) && action.llmUsd >= 0 &&
+        Number.isFinite(action.podUsd) && action.podUsd >= 0))
+      throw new Error(`Invalid steward shadow decision line ${index + 1}`);
+    const at = Date.parse(parsed.at);
+    if (at >= since.getTime() && at <= now.getTime()) ticks.push(parsed);
+  }
+  const distribution: Record<string, number> = {};
+  const actions = ticks.flatMap(tick => tick.actions.map(action => ({ at: tick.at, ...action })));
+  for (const row of ticks.flatMap(tick => tick.decisions)) {
+    const key = `${row.disposition} / rung ${row.rung}`;
+    distribution[key] = (distribution[key] ?? 0) + 1;
+  }
+  const estimatedLlmUsd = actions.reduce((sum, action) => sum + action.llmUsd, 0);
+  const estimatedPodUsd = actions.reduce((sum, action) => sum + action.podUsd, 0);
+  return {
+    since: since.toISOString(), until: now.toISOString(), ticks: ticks.length,
+    judgments: ticks.reduce((sum, tick) => sum + tick.decisions.length, 0), distribution, actions,
+    budgetGate: { estimatedLlmUsd, estimatedPodUsd, estimatedTotalUsd: estimatedLlmUsd + estimatedPodUsd,
+      basis: 'Planning assumption per launch: LLM $2 + Pod $1 (one Pod-hour); not metered usage or budget approval', verdict: 'estimate-only' },
+    hitlGate: { requiringHuman: actions.filter(action => action.kind === 'hitl').length },
+    source: { decisions: path, logs: `elanous logs --category ${CATEGORY} --event ${EVENT} --since ${sinceHours}h` },
+  };
+}
+
+export function formatStewardReadiness(report: ReadinessReport): string {
+  return [
+    `Steward shadow readiness | ${report.since} → ${report.until}`,
+    `Ticks | ${report.ticks}`,
+    `Judgments | ${report.judgments}`,
+    `Judgment distribution | ${Object.entries(report.distribution).map(([kind, count]) => `${kind}: ${count}`).join(' · ') || 'none'}`,
+    `If live, actions | ${report.actions.map(a => `${a.at} ${a.kind} ${a.issue}`).join(' · ') || 'none'}`,
+    `Budget gate | LLM ~$${report.budgetGate.estimatedLlmUsd} · Pod ~$${report.budgetGate.estimatedPodUsd} · total ~$${report.budgetGate.estimatedTotalUsd} (estimate only; not approval)`,
+    `HITL gate | ${report.hitlGate.requiringHuman} human confirmations`,
+    `Estimate basis | ${report.budgetGate.basis}`,
+    `Shadow decisions | ${report.source.decisions}`,
+    `First-class logs | ${report.source.logs}`,
+  ].join('\n');
+}
+
+export function parseReadinessSince(value: string): number {
+  if (!/^(?:\d+)(?:\.\d+)?h$/.test(value)) throw new Error('--since must be a positive duration such as 24h');
+  const hours = Number(value.slice(0, -1));
+  if (!Number.isFinite(hours) || hours <= 0) throw new Error('--since must be a positive duration such as 24h');
+  return hours;
+}
+
+export function runStewardReadinessCli(opts: { since: string; json?: boolean }, root = effectiveInstanceRoot()): number {
+  try {
+    const report = stewardReadiness(root, parseReadinessSince(opts.since));
+    console.log(opts.json ? JSON.stringify(report) : formatStewardReadiness(report));
+    return 0;
+  } catch (error) {
+    console.error(`steward readiness: ${error instanceof Error ? error.message : String(error)}`);
+    return 1;
+  }
+}

package/src/steward/rescue.ts

@@ -0,0 +1,75 @@
+// HQ-SEAT — steward «구조 모드»(rescue): after an HQ move the seat sessions are gone and the steward keeps
+// the line live, but only for the four reversible, internal actions below (OP 10-04 10:22 · 대표 directive).
+import { debug } from '../debug/log.js';
+
+export type StewardMode = 'off' | 'shadow' | 'live' | 'rescue';
+
+/** The whole rescue allow-list: launch queued goals · harvest finished runs · internal stuck alerts · decision cards. */
+export const RESCUE_ALLOWED = ['launch', 'harvest', 'alert', 'decision-card'] as const;
+export type RescueAllowedAction = typeof RESCUE_ALLOWED[number];
+export type RescueAction = RescueAllowedAction | 'publish' | 'release-run' | 'external-post' | 'delete' | 'config-change' | 'git-force';
+
+/** Shared, fail-closed policy for rescue and seat-loop live-safe decisions. */
+export function isRescueAllowedAction(action: string): action is RescueAllowedAction {
+  return (RESCUE_ALLOWED as readonly string[]).includes(action);
+}
+
+/** Launch semantics of a steward mode: rescue launches like live. */
+export function launchModeOf(mode: StewardMode): 'off' | 'shadow' | 'live' {
+  return mode === 'rescue' ? 'live' : mode;
+}
+
+/**
+ * Rescue-mode action gate. Outside rescue the steward's own mode rules decide (returns true).
+ * In rescue only RESCUE_ALLOWED pass; every decision is observed as steward.rescue/<action> or steward.rescue/refused.
+ */
+export function rescueAllows(mode: StewardMode | undefined, action: RescueAction, data: Record<string, unknown> = {}): boolean {
+  if (mode !== 'rescue') return true;
+  const allowed = isRescueAllowedAction(action);
+  try { debug.log('steward.rescue', allowed ? action : 'refused', { action, ...data }); } catch { /* observation is fail-soft */ }
+  return allowed;
+}
+
+export interface StewardModeStore {
+  read: () => StewardMode;
+  write: (mode: StewardMode) => void;
+}
+
+const MODES: readonly StewardMode[] = ['off', 'shadow', 'live', 'rescue'];
+
+export function parseStewardMode(value: string): StewardMode | null {
+  return (MODES as readonly string[]).includes(value) ? value as StewardMode : null;
+}
+
+/** `elanous steward mode [<mode>]` — HQ promotion sets rescue; a reattaching human seat sets shadow. */
+export async function runStewardModeCli(value: string | undefined, opts: { json?: boolean }, store?: StewardModeStore): Promise<number> {
+  const s = store ?? await defaultModeStore();
+  const before = s.read();
+  if (value === undefined) {
+    console.log(opts.json ? JSON.stringify({ mode: before }) : before);
+    return 0;
+  }
+  const mode = parseStewardMode(value);
+  if (!mode) { console.error(`steward mode: unknown mode ${JSON.stringify(value)} (off|shadow|live|rescue)`); return 2; }
+  s.write(mode);
+  const after = s.read();
+  try { debug.log('steward.rescue', 'mode-set', { before, after }); } catch { /* observation is fail-soft */ }
+  if (after !== mode) { console.error(`steward mode: saved value did not stick (read ${after})`); return 1; }
+  console.log(opts.json ? JSON.stringify({ before, mode: after }) : `steward mode ${before} → ${after}`);
+  return 0;
+}
+
+async function defaultModeStore(): Promise<StewardModeStore> {
+  const uc = await import('../user-config.js');
+  return {
+    read: () => (uc.getUserConfig().loops?.steward?.mode ?? 'shadow') as StewardMode,
+    write: (mode) => {
+      const cfg = uc.getUserConfig();
+      uc.backupUserConfig(uc.userConfigPath());
+      const loops = { ...(cfg.loops ?? {}) };
+      loops.steward = { ...(loops.steward ?? {}), mode };
+      uc.saveUserConfig({ ...cfg, loops });
+      uc.reloadUserConfig();
+    },
+  };
+}

package/src/steward/triage.ts

@@ -1,10 +1,13 @@
+import { randomUUID } from 'node:crypto';
 import { closeSync, existsSync, openSync, readFileSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { launchModeOf, rescueAllows } from './rescue.js';
 import { join } from 'node:path';
 import { fetchLinearIssues } from '../connectors/linear.js';
 import { getSecretAsync } from '../nexus/config/secrets/index.js';
 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 { effectiveInstanceRoot } from '../instance/resolve.js';
 import { redactSecrets } from '../task-cards/card-store.js';
 import { directiveHash } from './directive.js';
@@ -33,7 +36,8 @@ export interface TriageDecision {
 }
 export interface ScheduledDecision extends TriageDecision { disposition: 'now' | 'wait' | 'hitl' }
 export interface StewardSettings {
-  mode?: 'off' | 'shadow' | 'live'; linearTeam?: string;
+  /** `rescue` (HQ-SEAT): live launches/harvest/alerts/decision cards only — see ./rescue.ts. */
+  mode?: 'off' | 'shadow' | 'live' | 'rescue'; linearTeam?: string;
   roles?: Record<string, { maxConcurrent?: number }>;
   budget?: number;
   tracks?: Record<string, string>;
@@ -62,11 +66,14 @@ export interface StewardDeps {
   stageOwnedByCommand?: boolean;
 }
 
+/** rescue launches/harvests like live (HQ-SEAT). */
+const liveLike = (mode: StewardSettings['mode']): boolean => mode !== undefined && launchModeOf(mode) === 'live';
+
 export function stewardSettings(): StewardSettings {
   return getUserConfig().loops?.steward ?? { mode: 'shadow' };
 }
 
-function effectiveStewardMode(settings: StewardSettings): 'off' | 'shadow' | 'live' {
+function effectiveStewardMode(settings: StewardSettings): 'off' | 'shadow' | 'live' | 'rescue' {
   return settings.mode ?? settings.launch ?? 'shadow';
 }
 
@@ -115,6 +122,9 @@ export async function triageIssues(issues: TriageIssue[], judge?: NonNullable<St
   // Inventory is shared by every classification in this batch; do not spawn --help per issue.
   let inventory: ReturnType<typeof installedCapabilities> | undefined;
   const signal = (result: TriageDecision): void => {
+    try { debug.log('steward.triage', 'decision', {
+      kind: String(result.rung), target: result.issue, wouldAct: false,
+    }); } catch { /* logging must not change the judgment */ }
     decide({ kind: result.rung === 'hitl' ? 'ESCALATE' : 'ROUTE', what: result.issue, reason: result.why,
       purpose: 'steward triage', target: result.owner ? `${result.rung} · ${result.owner}` : String(result.rung), refs: { issue: result.issue } });
   };
@@ -279,6 +289,9 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
   const fetchFn = deps.fetch ?? fetch;
   const skip = skippedPath(root);
   if (stage !== 'sync' && existsSync(skip)) return;
+  const runId = (graphRunId() ?? process.env.ELANOUS_RUN_ID?.trim()) || `steward-stage-${randomUUID()}`;
+  let outcome: 'ok' | 'fail' = 'fail';
+  try {
   const key = await (deps.getSecret ?? getSecretAsync)('connector.linear.apiKey');
   if (!key) throw new Error('connector.linear.apiKey missing');
   if (stage === 'sync') {
@@ -368,6 +381,9 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
         ? { ...row, rung: 'hitl' as const, disposition: 'hitl' as const, hitlReason: 'other' as const, why: 'working-backwards draft invalid' }
         : row);
     }
+    for (const row of rows) try { debug.log('steward.schedule', 'decision', {
+      kind: row.disposition, target: row.issue, wouldAct: row.disposition === 'now' && liveLike(settings.mode),
+    }); } catch { /* logging must not change the schedule */ }
     writeFileSync(schedule, JSON.stringify(rows));
     const ledger = readLaunchLedger(root);
     const launchDeps: LaunchDeps = { root, settings, ledger, command: deps.launchCommand, spawn: deps.spawnLaunch, gate: deps.launchGate };
@@ -384,6 +400,11 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       const entry = launch(item, launchDeps);
       recordLaunchOnCard(item.issue, entry, cardDeps);
     }
+    if (settings.mode === 'shadow') {
+      const { recordShadowTick } = await import('./readiness.js');
+      const tick = recordShadowTick(root, rows, plan, (deps.now ?? (() => new Date()))());
+      debug.log('steward.readiness', 'shadow-tick', tick);
+    }
   } else {
     const rows = JSON.parse(readFileSync(schedule, 'utf8')) as ScheduledDecision[];
     const path = reportPath(root);
@@ -422,7 +443,7 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       const issue = issues.find(item => item.identifier === outcome.issue) ??
         { identifier: outcome.issue, title: outcome.title, ref: '', body: '' };
       recordOutcomeOnCard(issue, outcome, { root, store: deps.cardStore, now: deps.now });
-      notifyOutcome(outcome, { root, ledger, shadow: settings.mode !== 'live', ...deps.outcomeNotify });
+      notifyOutcome(outcome, { root, ledger, shadow: !(settings.mode === 'live' || settings.mode === 'rescue' && rescueAllows(settings.mode, 'alert', { issue: outcome.issue })), ...deps.outcomeNotify });
       const prefix = ['telegram', 'pwa', 'tui', 'cli'].includes(outcome.source) ? `${outcome.source} · ` : '';
       await (deps.sendDigest ?? sendStewardDigest)(`${prefix}${issue.title} · PR ${outcome.prNumber ?? '없음'} · ${outcome.status}`);
       outcome.reported = true;
@@ -430,11 +451,11 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
     }
     const justCollected = new Set(outcomes.map(outcome => outcome.issue));
     for (const outcome of Object.values(ledger.launches)) {
-      if ((settings.mode !== 'live' && outcome.status === 'shadow' && !outcome.notified) ||
-          (settings.mode === 'live' && !justCollected.has(outcome.issue) && outcome.reported && outcome.notified !== 'shadow') ||
+      if ((!liveLike(settings.mode) && outcome.status === 'shadow' && !outcome.notified) ||
+          (liveLike(settings.mode) && !justCollected.has(outcome.issue) && outcome.reported && outcome.notified !== 'shadow') ||
           // A finished run whose PR waits for merge still owes the wish's chat its PR link (once; failures retry).
-          (settings.mode === 'live' && outcome.awaitingMerge === true && !outcome.reported && outcome.notified !== 'sent')) {
-        notifyOutcome(outcome, { root, ledger, shadow: settings.mode !== 'live', ...deps.outcomeNotify });
+          (liveLike(settings.mode) && outcome.awaitingMerge === true && !outcome.reported && outcome.notified !== 'sent')) {
+        notifyOutcome(outcome, { root, ledger, shadow: !(settings.mode === 'live' || settings.mode === 'rescue' && rescueAllows(settings.mode, 'alert', { issue: outcome.issue })), ...deps.outcomeNotify });
       }
     }
     const day = at.slice(0, 10);
@@ -445,11 +466,17 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       writeFileSync(path, JSON.stringify(state));
     }
   }
+  outcome = 'ok';
+  } finally {
+    try { loopEvent('steward', 'tick', { runId, stage, outcome, reason: outcome,
+      sourceRef: 'graphs/steward/steward.yaml', profile: settings.mode }); }
+    catch { /* Observation must not change the stage outcome. */ }
+  }
 }
 
 async function sendStewardDigest(text: string): Promise<void> {
   const { deliver } = await import('../domains/outbound-alert.js');
-  if (!deliver(text, 'digest')) throw new Error('steward digest delivery failed');
+  if (!deliver(text, 'ops-report')) throw new Error('steward digest delivery failed');
 }
 
 export interface StewardCommandDeps extends StewardDeps {
@@ -543,13 +570,25 @@ export async function runStewardStageCommand(stage: StewardStage, deps: StewardC
   }, stage === 'sync' ? () => { skipOverlappingRun(root, currentOpen(root, stage)); return 0 as const; } : undefined);
 }
 
+export async function runStewardNodeCommand(
+  stage: StewardStage,
+  deps: StewardCommandDeps = {},
+  registerSink: () => Promise<unknown> = async () => (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('steward'),
+): Promise<0 | 1> {
+  try { await registerSink(); }
+  catch (error) {
+    console.error(`steward ${stage}: log sink registration failed — ${redactSecretText(error instanceof Error ? error.message : String(error))}`);
+  }
+  return runStewardStageCommand(stage, deps);
+}
+
 if (import.meta.main) {
   const stage = process.argv[2];
   if (!['sync', 'triage', 'schedule', 'report'].includes(stage ?? '')) {
     console.error('steward: expected sync|triage|schedule|report');
     process.exitCode = 2;
   } else {
-    runStewardStageCommand(stage as StewardStage).then(code => { process.exitCode = code; }).catch((error: unknown) => {
+    void runStewardNodeCommand(stage as StewardStage).then(code => { process.exitCode = code; }).catch((error: unknown) => {
       console.error(`steward ${stage}: ${redactSecretText(error instanceof Error ? error.message : String(error))}`);
       process.exitCode = 1;
     });

package/src/task-cards/card-cli.ts

@@ -1,11 +1,15 @@
 import type { Command } from 'commander';
 import { join, resolve } from 'node:path';
 import { scanWishFolder } from '../intake-plane/wish-folder.js';
+import { LINEAR_WISH_KEY_MISSING, scanLinearWishes, suggestLinearWishes } from '../intake-plane/linear-wish.js';
+import type { fetchLinearIssues } from '../connectors/linear.js';
 import { CardStore, type TaskCard } from './card-store.js';
 
 export interface CardCliDeps {
   createStore?: () => CardStore;
   write?: (text: string) => void;
+  getApiKey?: () => Promise<string | undefined>;
+  fetchIssues?: typeof fetchLinearIssues;
 }
 
 function formatCard(card: TaskCard): string {
@@ -84,5 +88,87 @@ export function registerCardCommand(program: Command, deps: CardCliDeps = {}): C
       }
     });
 
+  card.command('intake-scan')
+    .description('Scan Wish notes then Linear wishes in one scheduled invocation')
+    .option('--dir <path>', 'Wish folder path')
+    .option('--team <key>', 'Linear team key (omit to skip Linear)')
+    .option('--label <name>', 'Wish label or title prefix', 'wish')
+    .option('--json', 'Output JSON')
+    .action(async (options: { dir?: string; team?: string; label: string; json?: boolean }) => {
+      const result = {
+        folder: { added: 0, updated: 0, skipped: 0 },
+        linear: { added: 0, duplicate: 0, failed: 0 },
+        skipped: [] as string[],
+        failed: [] as string[],
+      };
+      let store: CardStore | undefined;
+      try {
+        const dir = resolve(options.dir ?? join(process.env.OBSIDIAN_VAULT_ROOT ?? '', '00. Inbox', '00. Wish'));
+        store = createStore();
+        result.folder = scanWishFolder({ dir, store });
+      } catch {
+        result.failed.push('Wish 폴더 스캔 실패');
+      } finally {
+        try { store?.close(); } catch {
+          if (!result.failed.includes('Wish 폴더 스캔 실패')) result.failed.push('Wish 폴더 스캔 실패');
+        }
+      }
+
+      store = undefined;
+      if (!options.team?.trim()) {
+        result.skipped.push('Linear 팀 미지정');
+      } else {
+        try {
+          store = createStore();
+          result.linear = await scanLinearWishes({ teamKey: options.team, label: options.label, store,
+            deps: { getApiKey: deps.getApiKey, fetchIssues: deps.fetchIssues } });
+          if (result.linear.failed > 0) result.failed.push(`Linear 항목 ${result.linear.failed}건 실패`);
+        } catch (error) {
+          if (error instanceof Error && error.message === LINEAR_WISH_KEY_MISSING) {
+            result.skipped.push('Linear 키 없음');
+          } else {
+            result.failed.push('Linear 스캔 실패');
+          }
+        } finally {
+          try { store?.close(); } catch {
+            if (!result.failed.includes('Linear 스캔 실패')) result.failed.push('Linear 스캔 실패');
+          }
+        }
+      }
+
+      write(options.json ? `${JSON.stringify(result)}\n` :
+        `폴더 추가 ${result.folder.added} · Linear 추가 ${result.linear.added} · 건너뜀(${result.skipped.join(', ') || '없음'})${result.failed.length ? ` · 실패(${result.failed.join(', ')})` : ''}\n`);
+      if (result.failed.length) process.exitCode = 1;
+    });
+
+  card.command('linear-scan')
+    .description('Create wish cards from open Linear issues')
+    .requiredOption('--team <key>', 'Linear team key')
+    .option('--label <name>', 'Wish label or title prefix', 'wish')
+    .option('--suggest', 'Suggest wish labels without writing to Linear or creating cards')
+    .option('--json', 'Output JSON')
+    .action(async (options: { team: string; label: string; suggest?: boolean; json?: boolean }) => {
+      let store: CardStore | undefined;
+      try {
+        if (options.suggest) {
+          const suggestions = await suggestLinearWishes({ teamKey: options.team,
+            deps: { getApiKey: deps.getApiKey, fetchIssues: deps.fetchIssues } });
+          write(options.json ? `${JSON.stringify(suggestions)}\n` :
+            suggestions.map(item => `${item.identifier}\t${item.title}\t${item.reason}\n`).join(''));
+          return;
+        }
+        store = createStore();
+        const result = await scanLinearWishes({ teamKey: options.team, label: options.label, store,
+          deps: { getApiKey: deps.getApiKey, fetchIssues: deps.fetchIssues } });
+        write(options.json ? `${JSON.stringify(result)}\n` : `추가 ${result.added} · 중복 ${result.duplicate} · 실패 ${result.failed}\n`);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message.split(/\r?\n/, 1)[0]}\n`);
+        process.exitCode = message === LINEAR_WISH_KEY_MISSING ? 2 : 1;
+      } finally {
+        store?.close();
+      }
+    });
+
   return card;
 }

package/src/task-cards/card-store.ts

@@ -42,7 +42,7 @@ export const SECTION_OWNERS: Readonly<Record<string, string | null>> = {
   gates: 'execution-loop', relations: 'execution-loop', memory: 'execution-loop',
   workspace: 'executor', run: 'executor',
   landing: 'landing-loop', release: 'release-loop', 'test-diet': 'test-diet',
-  incidents: null,
+  incidents: null, orch: 'orchestrator', flow: 'flow',
 };
 
 export function sectionOf(key: string): string {
@@ -80,10 +80,11 @@ export class CardStore {
   private readonly db: Database;
   readonly root: string;
 
-  constructor(root: string = elanousStateRoot()) {
+  constructor(root: string = elanousStateRoot(), private readonly readOnly = false) {
     this.root = root;
-    mkdirSync(taskCardsDir(root), { recursive: true });
-    this.db = new Database(cardIndexPath(root));
+    if (!readOnly) mkdirSync(taskCardsDir(root), { recursive: true });
+    this.db = readOnly ? new Database(cardIndexPath(root), { readonly: true }) : new Database(cardIndexPath(root));
+    if (readOnly) return;
     try {
       this.db.exec('PRAGMA busy_timeout = 5000');
       this.db.exec('PRAGMA journal_mode = WAL');
@@ -127,6 +128,7 @@ export class CardStore {
   }
 
   private reconcile(): void {
+    if (this.readOnly) return;
     for (const file of readdirSync(taskCardsDir(this.root))) {
       if (!/^[a-zA-Z0-9_-]+\.jsonl$/.test(file)) continue;
       const id = file.slice(0, -'.jsonl'.length);
@@ -220,6 +222,7 @@ export class CardStore {
   }
 
   getCard(id: string): TaskCard | null {
+    if (this.readOnly) return this.readCard(id);
     return this.db.transaction(() => {
       this.reconcile();
       return this.readCard(id);
@@ -227,12 +230,13 @@ export class CardStore {
   }
 
   listCards(options: { open?: boolean } = {}): TaskCard[] {
-    return this.db.transaction(() => {
+    const list = () => {
       this.reconcile();
       const rows = this.db.query(`SELECT id FROM cards ${options.open ? "WHERE status = 'open'" : ''} ORDER BY created_at DESC, id DESC`)
         .all() as Array<{ id: string }>;
       return rows.map(({ id }) => this.readCard(id)!);
-    }).immediate();
+    };
+    return this.readOnly ? list() : this.db.transaction(list).immediate();
   }
 
   close(): void {

package/src/task-orchestrator/surfaces/pod-lease.ts

@@ -5,19 +5,22 @@ import { createHash, randomUUID } from 'node:crypto';
 import { closeSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { dlopen } from 'bun:ffi';
-import { hostLeaseBaseDir } from '../../pod-lease/host-lease.js';
+import { hostLeaseBaseDir, type PendingJobIdentity } from '../../pod-lease/host-lease.js';
 
-/** Persisted on a Job admitted through the host lease; the file lease is released after apply. */
+/** Persisted on a Job admitted through the host lease; the file lease remains until its Pod is observed Running or terminal. */
 export const POD_HOST_LEASE_ANNOTATION = 'elanous.dev/host-lease-admitted';
 
 // `get pods --all-namespaces -o json` on a busy cluster is several MB — the default spawnSync
 // buffer fails with ENOBUFS (10-03 node-b measured). Same proxy stripping as the Pod launch kubectl.
-const LEASE_KUBECTL_MAX_BUFFER = 256 * 1024 * 1024;
+export const LEASE_KUBECTL_MAX_BUFFER = 256 * 1024 * 1024;
 export function leaseKubectl(args: readonly string[], input?: string): { status: number | null; stdout: string; stderr: string } {
   const env = { ...process.env };
   for (const k of ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy', 'ALL_PROXY', 'all_proxy']) delete env[k];
   const r = spawnSync('kubectl', [...args], { encoding: 'utf8', input, env, timeout: 120_000, maxBuffer: LEASE_KUBECTL_MAX_BUFFER });
-  return { status: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error ? String(r.error) : '') };
+  const error = (r.error as NodeJS.ErrnoException | undefined)?.code === 'ENOBUFS'
+    ? `kubectl 출력 너무 큼 (ENOBUFS; maxBuffer=${LEASE_KUBECTL_MAX_BUFFER} bytes)`
+    : r.error ? String(r.error) : '';
+  return { status: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + error };
 }
 
 export interface PodLeaseMember {
@@ -25,6 +28,8 @@ export interface PodLeaseMember {
   capacity: number;
   running: number | null;
   pending: number | null;
+  /** Job names of Pending harness Pods already included in pending (used to avoid counting the same Job's host lease twice). */
+  pendingJobs?: PendingJobIdentity[];
   /** Running harness Pods whose Jobs predate host lease admission. */
   unleasedRunning: number | null;
   memoryLimitBytes: number | null;
@@ -52,6 +57,8 @@ export interface PoolLeaseRecommendation {
   accountSlots: number | null;
   running: number | null;
   pending: number | null;
+  /** Names of Pending Jobs already counted in pending. */
+  pendingJobs?: PendingJobIdentity[];
   /** Absent only for injected legacy status fixtures; real measurements always report a number or null. */
   unleasedRunning?: number | null;
 }
@@ -294,6 +301,7 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
         }
         if (!jobsValid) reasons.push('cluster jobs: missing name/labels');
         let running = 0, pending = 0, unleasedRunning = 0, limits = 0, limitsValid = true, reservationsValid = nodeItems !== null && nodeNames.size === nodeItems.length;
+        const pendingJobs = new Map<string, PendingJobIdentity>();
         let unknownPhase = false;
         const seenPods = new Set<string>();
         for (const pod of podItems) {
@@ -314,8 +322,14 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
           const spec = object(pod.spec);
           let limit: number | null = null;
           if (harness) {
-            if (phase === 'Pending') pending++;
-            else {
+            if (phase === 'Pending') {
+              pending++;
+              const jobName = labels?.['elanous.job'] ?? labels?.['job-name'];
+              if (typeof jobName === 'string' && jobName && typeof metadata.namespace === 'string' && metadata.namespace) {
+                const identity = { context: member.context, namespace: metadata.namespace, job: jobName };
+                pendingJobs.set(JSON.stringify(identity), identity);
+              }
+            } else {
               running++;
               const jobName = labels?.['elanous.job'] ?? labels?.['job-name'];
               if (typeof jobName !== 'string' || !leasedJobs.has(jobName)) unleasedRunning++;
@@ -333,7 +347,7 @@ export function measurePoolLease(members: readonly PodPoolMember[], deps: { kube
           if (nodeFree.has(nodeName)) nodeFree.set(nodeName, nodeFree.get(nodeName)! - Math.max(requested, limit ?? 0));
         }
         if (unknownPhase) reasons.push('cluster pods: missing/Unknown phase');
-        if (jobsValid && !unknownPhase) { result.running = running; result.pending = pending; result.unleasedRunning = unleasedRunning; }
+        if (jobsValid && !unknownPhase) { result.running = running; result.pending = pending; result.pendingJobs = [...pendingJobs.values()]; result.unleasedRunning = unleasedRunning; }
         if (limitsValid && jobsValid && !unknownPhase) result.memoryLimitBytes = limits;
         else if (!limitsValid) reasons.push('cluster pods: Running Pod memory limit missing/invalid');
         if (reservationsValid && limitsValid && jobsValid && !unknownPhase) result.availableMemoryByNodeBytes = [...nodeFree.values()];
@@ -366,6 +380,7 @@ export function recommendConcurrency(measure: PoolLeaseMeasure, options: { capac
   if (!Number.isSafeInteger(options.capacity) || options.capacity < 0) return { ...empty, reason: '측정 불가: capacity' };
   const running = measure.members.reduce((sum, m) => sum + m.running!, 0);
   const pending = measure.members.reduce((sum, m) => sum + m.pending!, 0);
+  const pendingJobs = measure.members.flatMap((m) => m.pendingJobs ?? []);
   const unleasedRunning = measure.members.reduce((sum, m) => sum + m.unleasedRunning!, 0);
   // Pool-wide free = sum of per-member free slots: a member over its cap counts as full, never negative,
   // so it cannot zero another member's free slot (and its unleased Pods only consume its own free slots).
@@ -393,5 +408,5 @@ export function recommendConcurrency(measure: PoolLeaseMeasure, options: { capac
   const recommended = Math.max(0, Math.min(capacitySlots, memoryBound) - eligibleUnleasedRunning);
   const limitedBy = memoryBound < capacitySlots ? 'memory' : 'capacity';
   if (unleasedRunning > 0) debug.log('pod-lease', 'unleased', { unleasedRunning, running, recommended });
-  return { recommended, limitedBy, reason: measure.members.some((m) => m.reason === 'dns') ? 'dns' : null, capacitySlots, memorySlots, liteMemorySlots, placeableSlots, accountSlots, running, pending, unleasedRunning };
+  return { recommended, limitedBy, reason: measure.members.some((m) => m.reason === 'dns') ? 'dns' : null, capacitySlots, memorySlots, liteMemorySlots, placeableSlots, accountSlots, running, pending, pendingJobs, unleasedRunning };
 }