elanous 0.2.8 → 0.2.10

package/src/steward/launch.ts

@@ -0,0 +1,250 @@
+import { randomUUID } from 'node:crypto';
+import { closeSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { debug } from '../debug/log.js';
+import { redactSecrets } from '../task-cards/card-store.js';
+import type { ScheduledDecision, StewardSettings, TriageIssue } from './triage.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' | 'failed' | 'running' | 'merged' | 'completed';
+export interface LaunchEntry {
+  issue: string;
+  title: string;
+  source: string;
+  command: string;
+  status: LaunchStatus;
+  runId?: string;
+  pid?: number;
+  log?: string;
+  reason?: string;
+  prNumber?: number;
+  prUrl?: string;
+  reported?: boolean;
+  notified?: 'sent' | 'shadow' | 'skipped-no-origin' | 'failed';
+  notifyAttempts?: number;
+  notifyRecipients?: Record<string, { notified: 'sent' | 'failed'; attempts: number }>;
+  notifyPreview?: { hasChatId: boolean; kind: 'file' | 'link' };
+  artifactRef?: string;
+  artifactBranch?: string;
+  artifactWorktree?: string;
+  awaitingMerge?: boolean;
+}
+export interface HitlEntry { issue: string; reason: string; raised: boolean; attempted?: boolean }
+export interface LaunchLedger { launches: Record<string, LaunchEntry>; hitl: Record<string, HitlEntry> }
+export interface LaunchItem { issue: TriageIssue; row: ScheduledDecision; command: string; source: string }
+export interface LaunchPlan { launches: LaunchItem[]; hitl: Array<{ issue: TriageIssue; row: ScheduledDecision }> }
+export interface LaunchDeps {
+  root: string;
+  settings: StewardSettings;
+  ledger: LaunchLedger;
+  /** Injected command boundary; the production adapter runs only argv, never a shell. */
+  command?: (args: string[]) => { exitCode: number; stdout: string; stderr?: string };
+  spawn?: (args: string[], log: string) => { pid: number };
+}
+
+const RUN_ID = /\brun-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i;
+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 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)}`;
+const argvFor = (issue: TriageIssue, settings: StewardSettings): string[] =>
+  // Options first, then `--`: an issue title that starts with `-` must stay part of the sentence.
+  cli(['harness', 'say', '--substrate', 'pod', '--pod-pool', settings.podPool ?? DEFAULT_POOL, '--base', 'main', '--json', '--', promptOf(issue)]);
+
+export function readLaunchLedger(root: string): LaunchLedger {
+  try {
+    const value = JSON.parse(readFileSync(join(root, 'steward', 'launches.json'), 'utf8')) as LaunchLedger;
+    if (!value || typeof value.launches !== 'object' || !value.launches || typeof value.hitl !== 'object' || !value.hitl) throw new Error('Invalid steward launch ledger');
+    return value;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { launches: {}, hitl: {} };
+    throw error;
+  }
+}
+
+export function saveLaunchLedger(root: string, ledger: LaunchLedger): void {
+  const dir = join(root, 'steward');
+  mkdirSync(dir, { recursive: true });
+  const target = join(dir, 'launches.json');
+  const temp = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync(temp, JSON.stringify(ledger));
+  renameSync(temp, target);
+}
+
+export function planLaunches(rows: ScheduledDecision[], issues: TriageIssue[], ledger: LaunchLedger, settings: StewardSettings): LaunchPlan {
+  const byId = new Map(issues.map(issue => [issue.identifier, issue]));
+  const activeCount = Object.values(ledger.launches).filter(entry => !entry.awaitingMerge && (entry.status === 'launched' || entry.status === 'running')).length;
+  const available = Math.max(0, (settings.maxParallel ?? 3) - activeCount);
+  const launches: LaunchItem[] = [];
+  const hitl: LaunchPlan['hitl'] = [];
+  for (const row of rows) {
+    const issue = byId.get(row.issue);
+    if (!issue) continue;
+    if (row.rung === 'hitl' || row.hitlReason || row.disposition === 'hitl') {
+      if (settings.launch !== 'off' && (!ledger.hitl[row.issue] || settings.launch === 'live' && !ledger.hitl[row.issue].attempted)) hitl.push({ issue, row });
+      continue;
+    }
+    if ((settings.launch ?? 'shadow') === 'off' || row.disposition !== 'now' || row.rung !== 4 || (ledger.launches[row.issue] && ledger.launches[row.issue].status !== 'skipped-budget' && !(settings.launch === 'live' && ledger.launches[row.issue].status === 'shadow')) || launches.length >= available) continue;
+    const args = argvFor(issue, settings);
+    launches.push({ issue, row, source: sourceOf(issue), command: args.map(arg => JSON.stringify(arg)).join(' ') });
+  }
+  debug.log('steward.launch', 'planned', { count: launches.length, hitl: hitl.length, available });
+  return { launches, hitl };
+}
+
+function runCommand(args: string[]): { exitCode: number; stdout: string; stderr: string } {
+  const result = Bun.spawnSync(args, { cwd: resolve(import.meta.dir, '../..'), stdout: 'pipe', stderr: 'pipe' });
+  return { exitCode: result.exitCode, stdout: result.stdout.toString(), stderr: result.stderr.toString() };
+}
+
+function spawnDetached(args: string[], log: string): { pid: number } {
+  const fd = openSync(log, 'a');
+  try {
+    const child = Bun.spawn(args, { cwd: resolve(import.meta.dir, '../..'), stdout: fd, stderr: fd, stdin: 'ignore', detached: true });
+    child.unref();
+    return { pid: child.pid };
+  } finally { closeSync(fd); }
+}
+
+function lastJson(stdout: string): Record<string, unknown> {
+  const line = stdout.trim().split('\n').at(-1);
+  const value: unknown = JSON.parse(line ?? '');
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid CLI JSON');
+  return value as Record<string, unknown>;
+}
+
+/** One issue is reserved before any side effect; budget skips are retriable, never counted as a launch. */
+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] && ledger.launches[item.issue.identifier].status !== 'skipped-budget' && !(settings.launch === 'live' && ledger.launches[item.issue.identifier].status === 'shadow'))) throw new Error('steward launch is not eligible');
+  if (settings.launch === 'off') throw new Error('steward launch is off');
+  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 (settings.launch !== 'live') {
+    ledger.launches[key] = entry;
+    saveLaunchLedger(root, ledger);
+    debug.log('steward.launch', 'shadow', { issue: key, command: entry.command });
+    return entry;
+  }
+  const command = deps.command ?? runCommand;
+  try {
+    const budget = command(cli(['harness', 'budget', '--json']));
+    const decision = budget.exitCode === 0 ? lastJson(budget.stdout) : {};
+    if (!BUDGET_PROCEED.includes(String(decision.outcome))) {
+      entry.status = 'skipped-budget';
+      entry.reason = redactSecrets(budget.exitCode === 0 ? JSON.stringify(decision.reasons ?? ['budget unavailable']) : budget.stderr ?? 'budget unavailable');
+      // A budget skip may be reconsidered on the next cycle, but the reason remains observable now.
+      ledger.launches[key] = entry;
+      saveLaunchLedger(root, ledger);
+      debug.log('steward.launch', 'skipped-budget', { issue: key, reason: entry.reason });
+      return entry;
+    }
+  } catch (error) {
+    entry.status = 'skipped-budget';
+    entry.reason = redactSecrets(String(error));
+    ledger.launches[key] = entry;
+    saveLaunchLedger(root, ledger);
+    debug.log('steward.launch', 'skipped-budget', { issue: key, reason: entry.reason });
+    return entry;
+  }
+  entry.status = 'launched';
+  entry.log = join(root, 'steward', 'launch', `${key.replace(/[^a-zA-Z0-9_-]/g, '_')}.log`);
+  mkdirSync(join(root, 'steward', 'launch'), { recursive: true });
+  ledger.launches[key] = entry;
+  saveLaunchLedger(root, ledger);
+  try {
+    entry.pid = (deps.spawn ?? spawnDetached)(argvFor(item.issue, settings), entry.log).pid;
+  } catch (error) {
+    entry.status = 'failed';
+    entry.reason = redactSecrets(String(error));
+  }
+  if (entry.pid) {
+    try { entry.runId = readFileSync(entry.log, 'utf8').match(RUN_ID)?.[0]; }
+    catch { /* The detached child may not have written its log yet. */ }
+  }
+  saveLaunchLedger(root, ledger);
+  debug.log('steward.launch', 'launched', { issue: key, runId: entry.runId, pid: entry.pid, status: entry.status });
+  return entry;
+}
+
+export function raiseHitl(issue: TriageIssue, row: ScheduledDecision, deps: LaunchDeps): HitlEntry {
+  const old = deps.ledger.hitl[issue.identifier];
+  if (old && (old.attempted || deps.settings.launch !== 'live')) return old;
+  const entry: HitlEntry = old ?? { issue: issue.identifier, reason: redactSecrets(row.hitlReason ?? row.why), raised: false };
+  deps.ledger.hitl[issue.identifier] = entry;
+  if (deps.settings.launch !== 'live') {
+    saveLaunchLedger(deps.root, deps.ledger);
+    return entry;
+  }
+  entry.attempted = true;
+  saveLaunchLedger(deps.root, deps.ledger);
+  try {
+    const category = row.hitlReason === 'public' ? 'publish' : ['money', 'security', 'irreversible'].includes(row.hitlReason ?? '') ? row.hitlReason! : 'other';
+    const title = redactSecrets(issue.title);
+    const result = (deps.command ?? runCommand)(cli(['decisions', 'raise', '--title', title, '--category', category,
+      '--s', title.slice(0, 240), '--c', redactSecrets(row.why).slice(0, 240), '--option', 'a=approve:execute after human decision',
+      '--option', 'b=decline:do not execute', '--skip-recommend', 'human decision required', '--agent', 'steward', ...(issue.ref ? ['--ref', issue.ref] : []), '--json']));
+    entry.raised = result.exitCode === 0;
+  } catch { /* Command may not be installed; card remains the human handoff. */ }
+  saveLaunchLedger(deps.root, deps.ledger);
+  if (entry.raised) debug.log('steward.launch', 'hitl-raised', { issue: issue.identifier });
+  return entry;
+}
+
+function alive(pid: number | undefined): boolean {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch (error) { return (error as NodeJS.ErrnoException).code === 'EPERM'; }
+}
+
+export function collectOutcomes(ledger: LaunchLedger, deps: LaunchDeps): LaunchEntry[] {
+  if (deps.settings.launch !== 'live') return [];
+  const done: LaunchEntry[] = [];
+  for (const entry of Object.values(ledger.launches)) {
+    if (entry.reported || entry.status === 'shadow' || entry.status === 'skipped-budget') continue;
+    if (!entry.runId && entry.log) {
+      try { entry.runId = readFileSync(entry.log, 'utf8').match(RUN_ID)?.[0]; } catch { /* Wait for log. */ }
+    }
+    if (entry.runId) {
+      try {
+        const result = (deps.command ?? runCommand)(cli(['self', 'run-ledger', entry.runId, '--json']));
+        if (result.exitCode !== 0) throw new Error(result.stderr ?? 'run ledger unavailable');
+        const events = result.stdout.trim().split('\n').filter(Boolean).map(line => JSON.parse(line) as { event?: string; data?: Record<string, unknown> });
+        if (!events.length) throw new Error('empty run ledger');
+        const reversed = [...events].reverse();
+        const mergedOffset = reversed.findIndex(event => event.event === 'merged' && event.data?.merged === true);
+        const terminalOffset = reversed.findIndex(event => event.event === 'run-status' || event.event === 'terminal');
+        const mergedIndex = mergedOffset < 0 ? -1 : events.length - 1 - mergedOffset;
+        const terminalIndex = terminalOffset < 0 ? -1 : events.length - 1 - terminalOffset;
+        const merged = mergedIndex >= 0 ? events[mergedIndex] : undefined;
+        const terminal = terminalIndex >= 0 ? events[terminalIndex] : undefined;
+        const pr = reversed.find(event => event.event === 'pr-opened');
+        const artifact = reversed.find(event => event.event === 'deploy-noncode' && typeof event.data?.ref === 'string');
+        entry.artifactRef = typeof artifact?.data?.ref === 'string' ? artifact.data.ref : undefined;
+        entry.artifactBranch = typeof artifact?.data?.branch === 'string' ? artifact.data.branch : undefined;
+        const worktree = reversed.find(event => event.event === 'planned' && typeof event.data?.worktree === 'string' && event.data.worktree);
+        entry.artifactWorktree = typeof worktree?.data?.worktree === 'string' ? worktree.data.worktree : undefined;
+        const number = merged?.data?.number ?? pr?.data?.number;
+        const url = merged?.data?.url ?? pr?.data?.url;
+        const validUrl = typeof url === 'string' && /^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+$/.test(url) ? url : undefined;
+        entry.prNumber = typeof number === 'number' ? number : validUrl ? Number(validUrl.split('/').at(-1)) : undefined;
+        entry.prUrl = validUrl && (entry.prNumber === undefined || validUrl.endsWith(`/pull/${entry.prNumber}`)) ? validUrl : undefined;
+        const failed = terminalIndex > mergedIndex && (terminal?.data?.runStatus === 'failed' || terminal?.data?.terminal === 'failed');
+        entry.awaitingMerge = !failed && !merged && !artifact && !!pr && terminal?.data?.runStatus === 'completed';
+        const completed = !failed && !merged && terminal?.data?.runStatus === 'completed';
+        // A finished run is only «merged» when a merge event exists; finishing with an artifact or with nothing is `completed`, not a failure.
+        entry.status = failed ? 'failed' : merged ? 'merged' : entry.awaitingMerge ? 'running' : completed ? 'completed' : terminal ? 'failed' : 'running';
+        if (entry.status === 'failed' && !entry.reason) {
+          const reason = terminal?.data?.reason ?? terminal?.data?.terminal;
+          entry.reason = redactSecrets(typeof reason === 'string' ? reason : '런 실패');
+        }
+      } catch { if (entry.status !== 'failed') entry.status = 'running'; }
+    } else if (entry.status !== 'failed') entry.status = alive(entry.pid) ? 'running' : 'failed';
+    if (entry.status === 'running') continue;
+    done.push(entry);
+    debug.log('steward.launch', 'outcome', { issue: entry.issue, status: entry.status, runId: entry.runId, prNumber: entry.prNumber });
+  }
+  saveLaunchLedger(deps.root, ledger);
+  return done;
+}

package/src/steward/outcome-notify.ts

@@ -0,0 +1,115 @@
+import { realpathSync, statSync } from 'node:fs';
+import { isAbsolute, extname, relative, resolve } from 'node:path';
+import { debug } from '../debug/log.js';
+import { notifyMissionDocument, notifyMissionOrigin } from '../autopilot/mission-notify.js';
+import type { MissionOrigin } from '../autopilot/mission-origin.js';
+import { redactSecrets } from '../task-cards/card-store.js';
+import { loadDirectiveOrigins } from './directive.js';
+import { saveLaunchLedger, type LaunchEntry, type LaunchLedger } from './launch.js';
+
+export interface OutcomeNotifyDeps {
+  root: string;
+  ledger: LaunchLedger;
+  shadow?: boolean;
+  loadOrigin?: (root: string, issue: string) => MissionOrigin | null;
+  loadOrigins?: typeof loadDirectiveOrigins;
+  document?: typeof notifyMissionDocument;
+  message?: typeof notifyMissionOrigin;
+  worktreeCommand?: (args: string[]) => { exitCode: number; stdout: string };
+}
+
+const EXTENSIONS = new Set(['.md', '.pdf', '.png', '.jpg', '.csv', '.txt', '.html', '.json']);
+const MAX_BYTES = 20 * 1024 * 1024;
+
+function localArtifact(outcome: LaunchEntry, deps: OutcomeNotifyDeps): string | null {
+  const ref = outcome.artifactRef;
+  const branch = outcome.artifactBranch;
+  if (!ref || !branch || isAbsolute(ref) || !EXTENSIONS.has(extname(ref).toLowerCase())) return null;
+  const command = deps.worktreeCommand ?? ((args: string[]) => {
+    const result = Bun.spawnSync(args, { cwd: resolve(import.meta.dir, '../..'), stdout: 'pipe', stderr: 'pipe' });
+    return { exitCode: result.exitCode, stdout: result.stdout.toString() };
+  });
+  try {
+    const result = command(['git', 'worktree', 'list', '--porcelain']);
+    if (result.exitCode !== 0) return null;
+    for (const block of result.stdout.split(/\n\s*\n/)) {
+      const path = /^worktree (.+)$/m.exec(block)?.[1];
+      if (!path || !block.split('\n').includes(`branch refs/heads/${branch}`) ||
+          (outcome.artifactWorktree && !path.endsWith(outcome.artifactWorktree))) continue;
+      try {
+        const base = realpathSync(path);
+        const file = realpathSync(resolve(base, ref));
+        const inside = relative(base, file);
+        if (!inside || inside === '..' || inside.startsWith('../') || isAbsolute(inside)) continue;
+        const stat = statSync(file);
+        return stat.isFile() && stat.size <= MAX_BYTES ? file : null;
+      } catch { /* Worktree or file is gone; try another matching worktree. */ }
+    }
+  } catch { /* No accessible worktree or artifact: use PR link instead. */ }
+  return null;
+}
+
+/** Persist each conversation's delivery independently; only failed recipients retry (up to three times). */
+export function notifyOutcome(outcome: LaunchEntry, deps: OutcomeNotifyDeps): LaunchEntry['notified'] {
+  if (outcome.notified === 'shadow') return 'shadow';
+  let origins: MissionOrigin[] = [];
+  try {
+    origins = deps.loadOrigin
+      ? [deps.loadOrigin(deps.root, outcome.issue)].filter((item): item is MissionOrigin => item !== null)
+      : (deps.loadOrigins ?? loadDirectiveOrigins)(deps.root, outcome.issue);
+  } catch { /* Damaged or unavailable origin cannot route a result. */ }
+  const recipients = new Map<string, MissionOrigin>();
+  for (const origin of origins) {
+    if (origin.channel !== 'telegram' || !Number.isSafeInteger(origin.chatId)) continue;
+    const key = JSON.stringify([origin.chatId, origin.botId ?? null, origin.threadId ?? null]);
+    recipients.set(key, origin);
+  }
+  if (outcome.notified === 'skipped-no-origin' && recipients.size === 0 && !deps.shadow) return outcome.notified;
+  if (outcome.notified === 'sent' && !outcome.notifyRecipients) return 'sent';
+  const file = outcome.status !== 'failed' && (recipients.size > 0 || deps.shadow) ? localArtifact(outcome, deps) : null;
+  const kind = outcome.status === 'failed' ? 'failure' : file ? 'file' : 'link';
+  let sent = false;
+  if (deps.shadow) {
+    outcome.notified = 'shadow';
+    outcome.notifyPreview = { hasChatId: recipients.size > 0, kind: file ? 'file' : 'link' };
+  } else if (recipients.size === 0) {
+    outcome.notified = 'skipped-no-origin';
+  } else {
+    const title = redactSecrets(outcome.title).replace(/\s+/g, ' ').slice(0, 240);
+    // Say what happened in plain words: an open PR is not a merge, and a run that left nothing is not a failure.
+    const status = outcome.awaitingMerge ? 'PR 열림(병합 대기)' : outcome.status === 'merged' ? '병합됨'
+      : outcome.status === 'completed' ? '완료(병합 없음)' : outcome.status;
+    const pr = outcome.prNumber;
+    const link = outcome.prUrl && /^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+$/.test(outcome.prUrl) &&
+      (pr === undefined || outcome.prUrl.endsWith(`/pull/${pr}`)) ? outcome.prUrl : undefined;
+    const noOutput = outcome.status === 'completed' && !outcome.artifactRef && pr === undefined && !outcome.prUrl;
+    const undeliverable = outcome.status !== 'failed' && !noOutput && !file && !link;
+    const text = outcome.status === 'failed'
+      ? `${title} · 실패 — ${redactSecrets(outcome.reason ?? '런 실패').split(/\r?\n/)[0]?.slice(0, 240) ?? '런 실패'}`
+      : noOutput
+        ? `${title} · ${status} — 남긴 파일·PR 없음`
+        : undeliverable
+        ? `${title} · ${status} · 산출물 전달 불가 — ${outcome.artifactRef ? '파일을 확인할 수 없습니다' : '검증된 PR 링크가 없습니다'}`
+        : `${title} · ${status} · PR ${pr ?? '없음'} · ${link}`;
+    const legacyAttempts = !outcome.notifyRecipients && outcome.notified === 'failed' ? outcome.notifyAttempts ?? 0 : 0;
+    const progress = outcome.notifyRecipients ??= {};
+    for (const [key, origin] of recipients) {
+      const previous = progress[key] ?? (legacyAttempts ? { notified: 'failed' as const, attempts: legacyAttempts } : undefined);
+      if (previous?.notified === 'sent' || (previous?.attempts ?? 0) >= 3) continue;
+      let delivered = false;
+      try {
+        if (!undeliverable || !previous) {
+          delivered = file ? (deps.document ?? notifyMissionDocument)(origin, file, redactSecrets(`${title} · ${status}`))
+            : (deps.message ?? notifyMissionOrigin)(origin, redactSecrets(text));
+        }
+      } catch { /* A failed recipient remains eligible on a later tick. */ }
+      progress[key] = { notified: delivered && !undeliverable ? 'sent' : 'failed', attempts: (previous?.attempts ?? 0) + 1 };
+      sent ||= delivered && !undeliverable;
+    }
+    outcome.notifyAttempts = Math.max(0, ...Object.values(progress).map(item => item.attempts));
+    outcome.notified = [...recipients.keys()].every(key => progress[key]?.notified === 'sent') ? 'sent' : 'failed';
+  }
+  saveLaunchLedger(deps.root, deps.ledger);
+  debug.log('steward.outcome', 'notify', { cardId: `linear:${outcome.issue}`, issue: outcome.issue, kind, sent });
+  return outcome.notified;
+}

package/src/steward/steward-cards.ts

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { CardStore, redactSecrets, type AppendSectionInput, type CreateCardInput, type TaskCard } from '../task-cards/card-store.js';
 import type { ScheduledDecision, TriageIssue } from './triage.js';
+import type { HitlEntry } from './launch.js';
 
 export interface StewardCardStore {
   createCard(input: CreateCardInput): TaskCard;
@@ -33,7 +34,7 @@ export function recordTriageOnCards(decisions: ScheduledDecision[], issues: Tria
         });
       }
       const { rung, dependsOn, priority, disposition, hitlReason, why, owner } = decision;
-      const judgment = { rung, dependsOn, priority, disposition: rung === 'hitl' || hitlReason ? 'hitl' : disposition, hitlReason: hitlReason ?? null, why: redactSecrets(why), ...(owner ? { owner } : {}) };
+      const judgment = { rung, dependsOn, priority, disposition: rung === 'hitl' || hitlReason ? 'hitl' : disposition, hitlReason: hitlReason ?? null, why: redactSecrets(why), ...(owner ? { owner } : {}), ...(decision.capability ? { capability: decision.capability } : {}) };
       const key = `triage:${createHash('sha256').update(JSON.stringify(judgment)).digest('hex')}`;
       if (!card.sections.some(section => section.key === key)) {
         store.appendSection(card.id, { key, owner: 'steward', content: JSON.stringify(judgment) });
@@ -44,7 +45,7 @@ export function recordTriageOnCards(decisions: ScheduledDecision[], issues: Tria
   }
 }
 
-function recordOnCard(section: 'launch' | 'outcome', issue: Pick<TriageIssue, 'identifier' | 'title'>, value: object, deps: StewardCardDeps): void {
+function recordOnCard(section: 'launch' | 'outcome' | 'hitl', issue: Pick<TriageIssue, 'identifier' | 'title'>, value: object, deps: StewardCardDeps): void {
   const store = deps.store ?? new CardStore(deps.root);
   try {
     const content = redactSecrets(JSON.stringify(value));
@@ -67,3 +68,8 @@ export function recordLaunchOnCard(issue: Pick<TriageIssue, 'identifier' | 'titl
 export function recordOutcomeOnCard(issue: Pick<TriageIssue, 'identifier' | 'title'>, outcome: object, deps: StewardCardDeps = {}): void {
   recordOnCard('outcome', issue, outcome, deps);
 }
+
+/** Append a HITL handoff revision (pending → raised/unavailable) to the issue card. */
+export function recordHitlOnCard(issue: Pick<TriageIssue, 'identifier' | 'title'>, entry: HitlEntry, deps: StewardCardDeps = {}): void {
+  recordOnCard('hitl', issue, entry, deps);
+}

package/src/steward/triage-plan.ts

@@ -1,8 +1,33 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
 import { resolveRoleModel } from '../user-config.js';
 import type { HitlReason, Rung, TriageIssue } from './triage.js';
 
 export type StewardAsk = (prompt: string, role: 'classify' | 'planning') => Promise<unknown>;
-export interface ClassifiedIssue { issue: string; rung: Rung; why: string; hitlReason?: HitlReason; duplicateOf?: string }
+export interface ClassifiedIssue { issue: string; rung: Rung; why: string; hitlReason?: HitlReason; duplicateOf?: string; capability?: 'new-capability' | 'existing-capability' }
+export interface CapabilityInventory { graphs: readonly string[]; plugins: readonly string[]; commands: readonly string[] }
+
+/** Read installed names, not promises in documentation. The caller can supply a test-instance root. */
+export function installedCapabilities(root: string = resolve(import.meta.dir, '../..')): CapabilityInventory {
+  const files = (dir: string): string[] => {
+    try { return readdirSync(dir, { withFileTypes: true }).flatMap(entry => entry.isDirectory()
+      ? files(join(dir, entry.name)) : entry.isFile() && /\.ya?ml$/.test(entry.name) ? [join(dir, entry.name)] : []); }
+    catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return []; throw error; }
+  };
+  const graphs = files(join(root, 'graphs')).flatMap(file => {
+    const match = /^graph_id:\s*['"]?([^\s'"#]+)/m.exec(readFileSync(file, 'utf8'));
+    return match ? [match[1]!] : [];
+  });
+  let plugins: string[];
+  try { plugins = readdirSync(join(root, 'plugins'), { withFileTypes: true }).filter(entry => entry.isDirectory() && entry.name !== 'examples').map(entry => entry.name); }
+  catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; plugins = []; }
+  const help = spawnSync(process.execPath, [join(root, 'bin/elanous.mjs'), '--test', '--help'], { cwd: root, encoding: 'utf8', timeout: 15_000 });
+  // An unconfigured test instance cannot start the CLI. Unknown commands must not be treated as installed.
+  const commands = help.status === 0
+    ? [...help.stdout.matchAll(/^\s{2}(?!-)([\w:-]+)(?:\s|$)/gm)].map(match => match[1]!) : [];
+  return { graphs, plugins, commands };
+}
 export interface IssuePlan { issue: string; priority: number; dependsOn: string[]; owner?: string }
 
 const unsafe: Array<[HitlReason, RegExp]> = [
@@ -42,14 +67,17 @@ export async function askSteward(prompt: string, role: 'classify' | 'planning'):
   return parsed(result);
 }
 
-export async function classifyIssue(issue: TriageIssue, ask: StewardAsk = askSteward): Promise<ClassifiedIssue> {
+export async function classifyIssue(issue: TriageIssue, ask: StewardAsk = askSteward, inventory: CapabilityInventory = installedCapabilities()): Promise<ClassifiedIssue> {
   const candidate = unsafeReason(issue);
-  const response = parsed(await ask(`스튜어드 분류. JSON 객체만: {"rung":0|1|2|3|4|5|"hitl","hitlReason":null,"why":"한 문장"}. 0=이미됨, 1=셸, 2=CLI, 3=조사, 4=하니스 골, 5=외부 에이전트. 돈·공개·보안·비가역은 hitl; 그 외 사람 확인은 other. 확인되지 않은 완료를 추측하지 마라. ${candidate ? `안전 후보 ${candidate}: 이유를 확인하라.` : ''}\n이슈: ${JSON.stringify(issue)}`, 'classify'));
+  const response = parsed(await ask(`스튜어드 분류. JSON 객체만: {"rung":0|1|2|3|4|5|"hitl","hitlReason":null,"why":"한 문장","capability":"new-capability"|"existing-capability"}. 0=이미됨, 1=셸, 2=CLI, 3=조사, 4=하니스 골, 5=외부 에이전트. 돈·공개·보안·비가역은 hitl; 그 외 사람 확인은 other. 새 능력인지 기존 그래프·플러그인·명령으로 되는 일인지 판정하라. 존재만으로 그 기능이 소원을 충족한다고 추측하지 마라. 확인되지 않은 완료를 추측하지 마라. ${candidate ? `안전 후보 ${candidate}: 이유를 확인하라.` : ''}\n설치된 능력: ${JSON.stringify(inventory)}\n이슈: ${JSON.stringify(issue)}`, 'classify'));
   if (![0, 1, 2, 3, 4, 5, 'hitl'].includes(response.rung as Rung) || typeof response.why !== 'string' || !response.why.trim()) throw new Error(`Invalid steward classification: ${issue.identifier}`);
   const reason = candidate ?? (unsafe.some(([name]) => name === response.hitlReason) ? response.hitlReason as HitlReason : undefined)
     ?? (response.rung === 'hitl' ? 'other' : undefined);
+  // A missing or unknown verdict does not block triage; working-backwards drafting is simply skipped for that issue.
+  const capability = response.capability === 'new-capability' || response.capability === 'existing-capability' ? response.capability : undefined;
   return { issue: issue.identifier, rung: reason ? 'hitl' : response.rung as Rung,
-    ...(reason ? { hitlReason: reason } : {}), why: response.why.trim().replace(/\s+/g, ' ') };
+    ...(reason ? { hitlReason: reason } : {}), why: response.why.trim().replace(/\s+/g, ' '),
+    ...(capability ? { capability } : {}) };
 }
 
 /** One request for the current batch, never one request per issue. */