elanous 0.2.12 → 0.2.13

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

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

@@ -19,7 +19,7 @@ import { join, resolve } from 'node:path';
 import { debug } from '../../debug/log.js';
 import { PodLeaseAdmission, type PodLeasePredecessor, type PodLeaseRelease } from '../../pod-lease/admission.js';
 import { predecessorState, type PredecessorState } from '../../pod-lease/dependency-state.js';
-import { HostPoolLease } from '../../pod-lease/host-lease.js';
+import { HostPoolLease, leaseHasPendingPod } from '../../pod-lease/host-lease.js';
 import { measurePoolLease, recommendConcurrency, type PoolDnsProbe, type PoolLeaseRecommendation } from './pod-lease.js';
 
 export interface PodPoolMember {
@@ -143,6 +143,10 @@ export function genericConfigPodPool(config: { pod?: { pool?: string }; harness?
 }
 
 /** 노드 자리 배분 — 우선순위 순서로 첫 빈 자리. 순수(시각·대기는 호출자가). */
+export function podPoolHostLease(members: readonly PodPoolMember[]): HostPoolLease {
+  return new HostPoolLease([...members.map((m) => `${m.context}@${m.sshHost ?? ''}`)].sort().join(','));
+}
+
 export class PodPoolScheduler {
   private readonly inflight = new Map<string, number>();
   private readonly admission: PodLeaseAdmission;
@@ -157,7 +161,7 @@ export class PodPoolScheduler {
   constructor(readonly members: readonly PodPoolMember[], options: { status?: () => PoolLeaseRecommendation | Promise<PoolLeaseRecommendation>; kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe; pollMs?: number; hostLease?: HostPoolLease; dependencyMerged?: (after: PodLeasePredecessor, signal?: AbortSignal) => PredecessorState | boolean | Promise<PredecessorState | boolean> } = {}) {
     this.pollMs = options.pollMs ?? 15_000;
     // One lease directory per pool (contexts, not caps) — every CLI process launching into the same clusters shares it.
-    this.hostLease = options.hostLease ?? new HostPoolLease([...members.map((m) => `${m.context}@${m.sshHost ?? ''}`)].sort().join(','));
+    this.hostLease = options.hostLease ?? podPoolHostLease(members);
     const measureStatus = options.status ?? (() => {
       const measure = measurePoolLease(members, { ...(options.kubectl ? { kubectl: options.kubectl } : {}), ...(options.dns ? { dns: options.dns } : {}) });
       return recommendConcurrency(measure, { capacity: members.reduce((n, m) => n + m.capacity, 0), accounts: 0, perAccount: 0 });
@@ -166,9 +170,13 @@ export class PodPoolScheduler {
     this.admission = new PodLeaseAdmission({ status: async () => {
       const measured = await measureStatus();
       this.lastRaw = measured;
-      // Launches admitted by other processes on this host but not yet visible as Jobs hold free slots too.
-      const others = measured.recommended === null ? 0 : this.hostLease.othersPending();
-      const decision = measured.recommended === null ? measured : { ...measured, recommended: Math.max(0, measured.recommended - others) };
+      const pendingJobs = measured.pendingJobs ?? [];
+      const ownStart = this.hostLease.selfStart();
+      const transferId = process.env.ELANOUS_POD_RESERVED_LEASE;
+      const transferIsOther = !!transferId && this.hostLease.reservationIsOther(transferId);
+      const others = measured.recommended === null ? 0 : this.hostLease.live().filter((r) =>
+        (r.pid !== process.pid || r.startedAt !== ownStart) && !leaseHasPendingPod(r, pendingJobs)).length;
+      const decision = measured.recommended === null ? measured : { ...measured, recommended: Math.max(0, measured.recommended - others + (transferIsOther ? 1 : 0)) };
       // An unknown reading cannot erase permits already granted: on recovery,
       // the first healthy recommendation must still account for their slots.
       if (decision.recommended === null) return decision;
@@ -181,19 +189,28 @@ export class PodPoolScheduler {
     }, ...(options.pollMs ? { pollMs: options.pollMs } : {}), dependencyMerged: options.dependencyMerged ?? ((after, signal) => predecessorState(after, {}, signal)) });
   }
   /** FIFO gate within this process, then a host lease so independent CLI processes cannot over-admit the same pool. */
-  async acquireAdmission(signal?: AbortSignal, after?: PodLeasePredecessor): Promise<PodLeaseRelease & { applied: () => void }> {
+  async acquireAdmission(signal?: AbortSignal, after?: PodLeasePredecessor): Promise<PodLeaseRelease & { applied: (job: string, context: string, namespace: string) => void; observed: () => void }> {
     const local = await this.acquireLocalAdmission(signal, after);
     try {
       for (;;) {
         if (signal?.aborted) throw new Error('pod lease admission aborted');
         const free = this.lastRaw?.recommended ?? null;
-        // Same check as the local gate, but atomic across processes: other unapplied leases must stay under the free slots.
-        const lease = free !== null && free > 0 ? this.hostLease.tryReserve((others) => others < free) : null;
+        // Same check as the local gate, but atomic across processes: other authoring and pre-Running leases hold slots.
+        const reservedId = process.env.ELANOUS_POD_RESERVED_LEASE;
+        const transferred = reservedId ? this.hostLease.claim(reservedId) : null;
+        if (reservedId && !transferred) throw new Error('pod lease: authoring reservation could not be transferred');
+        if (transferred) delete process.env.ELANOUS_POD_RESERVED_LEASE;
+        const pendingJobs = this.lastRaw?.pendingJobs ?? [];
+        const lease = transferred ?? (free !== null && free > 0 ? this.hostLease.tryReserve((others) =>
+          others - this.hostLease.live().filter((r) => leaseHasPendingPod(r, pendingJobs) &&
+            (r.pid !== process.pid || r.startedAt !== this.hostLease.selfStart())).length < free) : null);
         if (lease) {
           let hostReleased = false;
           const releaseHost = () => { if (!hostReleased) { hostReleased = true; lease(); } };
-          // Once the Job is applied the cluster measurement counts it — the host lease would double count.
-          return Object.assign(() => { releaseHost(); local(); }, { applied: releaseHost });
+          return Object.assign(() => { releaseHost(); local(); }, {
+            applied: (job: string, context: string, namespace: string) => lease.applied(job, context, namespace),
+            observed: releaseHost,
+          });
         }
         await new Promise<void>((resolve, reject) => {
           const timer = setTimeout(() => { signal?.removeEventListener('abort', onAbort); resolve(); }, this.pollMs);