elanous 0.2.11 → 0.2.13

package/src/self-implement/test-seams.ts

@@ -21,6 +21,7 @@ export function seams(over: Partial<SelfImplementSeams> & { gateResults?: boolea
     //   ⭐ 실제 경로는 그것을 «의도한» 전용 테스트에서만 탄다(그 테스트가 심을 명시로 준다).
     refreshCodexQuotaSignals: async () => ({ accounts: [] }),
     writeRunLedger: () => {},
+    emitContextEvent: () => {},
     registerLoopAgent: () => {},
     createWorktree: async ({ branch, base }) => ({ path: `/wt/${branch}`, branch, base, resolvedBase: 'a'.repeat(40), invokedHead: 'a'.repeat(40) }),
     implement: async ({ feature }) => { features.push(feature); return { ok: true, summary: 'impl' }; },

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 } 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,79 @@ 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('--json', 'Output JSON')
+    .action(async (options: { team: string; label: string; json?: boolean }) => {
+      let store: CardStore | undefined;
+      try {
+        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-orchestrator/surfaces/pod-command-job.ts

@@ -304,13 +304,15 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
 
   let member: PodPoolMember | null = null;
   let pool = options.poolScheduler;
-  if (!pool && options.pool) {
-    const spec = resolvePodPoolSpec(options.pool, env);
-    if (!spec) throw new Error('pod command: 풀 스펙이 비었다');
-    const members = parsePodPool(spec);
-    const checked = (options.checkPool ?? checkPodPool)(members, baseKubectl as PoolKubectl);
-    if (!checked.ok) throw new Error('pod command: 풀의 노드가 하나도 준비되지 않았다');
-    pool = new PodPoolScheduler(checked.ready);
+  if (!pool) {
+    const spec = resolvePodPoolSpec(options.pool, env, () => options.kubectl ? undefined : getUserConfig().pod?.pool);
+    if (options.pool && !spec) throw new Error('pod command: 풀 스펙이 비었다');
+    if (spec) {
+      const members = parsePodPool(spec);
+      const checked = (options.checkPool ?? checkPodPool)(members, baseKubectl as PoolKubectl);
+      if (!checked.ok) throw new Error('pod command: 풀의 노드가 하나도 준비되지 않았다');
+      pool = new PodPoolScheduler(checked.ready);
+    }
   }
   if (pool) {
     for (;;) {
@@ -357,6 +359,8 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       if (synced && !synced.ok) throw new Error(`pod command: 이미지 판을 못 맞췄다: ${synced.detail}`);
       if (synced?.imageRef) member = { ...member, imageRef: synced.imageRef };
     }
+    const imageRef = member?.imageRef;
+    if (!imageRef) log('pod.command-job', 'image-fallback-local', { reason: !member ? 'no-pool-member' : !imageCommit ? 'image-commit-unavailable' : 'registry-tag-unavailable' });
     const ghToken = options.clone ? (options.ghToken ?? defaultGhToken)() : undefined;
     const secret = commandJobSecret({ name, namespace, launch, skills, skillEnvText, ...(grokAuth !== undefined ? { grokAuth } : {}), ...(ghToken !== undefined ? { ghToken } : {}) });
     if (secret) {
@@ -364,8 +368,8 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       if (applied.status !== 0) throw new Error(applied.stderr.trim() || 'pod command: Secret 적용 실패');
     }
     const manifest = podCommandJobManifest({
-      name, namespace, launch, image: member?.imageRef ?? image,
-      ...(member?.imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}),
+      name, namespace, launch, image: imageRef ?? image,
+      ...(imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}),
       repoUrl, command, skills, ...(llm ? { llm } : {}), ...(options.clone ? { clone: true } : {}),
       ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), ...(bunCache ? { bunCache } : {}), ...(memoryLimit ? { memoryLimit } : {}), deadlineSeconds,
       ...(options.runId ? { runId: options.runId } : {}),
@@ -398,7 +402,7 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       llm: llm ?? null,
       command: command.join(' ').slice(0, COMMAND_LOG_CHARS),
     });
-    return { exitCode, artifactsDir, job: name, image: member?.imageRef ?? image };
+    return { exitCode, artifactsDir, job: name, image: imageRef ?? image };
   } catch (err) {
     cleanupSecret();
     throw err;

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

@@ -5,9 +5,9 @@ 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
@@ -25,6 +25,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 +54,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 +298,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 +319,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 +344,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 +377,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 +405,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 };
 }