elanous 0.2.9 → 0.2.11

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;
@@ -14,6 +15,22 @@ export interface StewardCardDeps {
   now?: () => Date;
 }
 
+/** Record the first intake for each polled issue, independently of LLM triage. */
+export function recordIntakeOnCards(store: StewardCardStore, issues: TriageIssue[], now: () => Date = () => new Date()): void {
+  for (const issue of issues) {
+    const card = store.createCard({ goalId: `linear:${issue.identifier}`, title: redactSecrets(issue.title) });
+    const intakeKey = `intake:${issue.identifier}`;
+    if (!card.sections.some(section => section.key === intakeKey)) {
+      const directiveSource = /^출처: (telegram|pwa|tui|cli)$/m.exec(issue.body)?.[1];
+      const directiveTime = /^시각: (\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)$/m.exec(issue.body)?.[1];
+      store.appendSection(card.id, {
+        key: intakeKey, owner: 'steward',
+        content: JSON.stringify({ summary: redactSecrets(issue.title), source: directiveSource ?? `linear:${issue.identifier}`, at: directiveTime ?? now().toISOString() }),
+      });
+    }
+  }
+}
+
 /** Record observe-only intake and the latest scheduled judgment without launching any work. */
 export function recordTriageOnCards(decisions: ScheduledDecision[], issues: TriageIssue[], deps: StewardCardDeps = {}): void {
   const store = deps.store ?? new CardStore(deps.root);
@@ -22,18 +39,10 @@ export function recordTriageOnCards(decisions: ScheduledDecision[], issues: Tria
     for (const decision of decisions) {
       const issue = byIssue.get(decision.issue);
       if (!issue) throw new Error(`Missing issue ${decision.issue}`);
+      recordIntakeOnCards(store, [issue], deps.now);
       const card = store.createCard({ goalId: `linear:${issue.identifier}`, title: redactSecrets(issue.title) });
-      const intakeKey = `intake:${issue.identifier}`;
-      if (!card.sections.some(section => section.key === intakeKey)) {
-        const directiveSource = /^출처: (telegram|pwa|tui|cli)$/m.exec(issue.body)?.[1];
-        const directiveTime = /^시각: (\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)$/m.exec(issue.body)?.[1];
-        store.appendSection(card.id, {
-          key: intakeKey, owner: 'steward',
-          content: JSON.stringify({ summary: redactSecrets(issue.title), source: directiveSource ?? `linear:${issue.identifier}`, at: directiveTime ?? (deps.now ?? (() => new Date()))().toISOString() }),
-        });
-      }
       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 +53,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 +76,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. */

package/src/steward/triage.ts

@@ -8,9 +8,14 @@ import { debug, redactSecretText } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { redactSecrets } from '../task-cards/card-store.js';
 import { directiveHash } from './directive.js';
-import { recordTriageOnCards, type StewardCardDeps } from './steward-cards.js';
+import { notifyOutcome, type OutcomeNotifyDeps } from './outcome-notify.js';
+import { recordIntakeOnCards, recordTriageOnCards, recordLaunchOnCard, recordOutcomeOnCard, recordHitlOnCard, type StewardCardDeps } from './steward-cards.js';
+import { planLaunches, launch, collectOutcomes, raiseHitl, readLaunchLedger, saveLaunchLedger, type LaunchDeps } from './launch.js';
+import { listFabricExecutionCandidates } from '../self-dev/fabric-plan-core.js';
+import { InvalidWorkingBackwardsDraft, recordWorkingBackwardsOnCards } from './working-backwards.js';
+import { CardStore } from '../task-cards/card-store.js';
 import { triageWithinBudget } from './triage-budget.js';
-import { askSteward, classifyIssue, planIssues, ruleJudgment, unsafeReason, type ClassifiedIssue, type StewardAsk } from './triage-plan.js';
+import { askSteward, classifyIssue, installedCapabilities, planIssues, ruleJudgment, unsafeReason, type ClassifiedIssue, type StewardAsk } from './triage-plan.js';
 import { failureAlertText, markStageStart, markStageEnd, readFailureStreak, shouldAlert, writeFailureStreak, type FailureStreak, type StewardStage } from './failure-streak.js';
 
 export type Rung = 0 | 1 | 2 | 3 | 4 | 5 | 'hitl';
@@ -24,14 +29,18 @@ export interface TriageDecision {
   owner?: string;
   /** Carried from a previous triage without a current judgment; scheduling must not route it. */
   deferred?: true;
+  capability?: ClassifiedIssue['capability'];
 }
 export interface ScheduledDecision extends TriageDecision { disposition: 'now' | 'wait' | 'hitl' }
 export interface StewardSettings {
-  mode?: 'observe' | 'act'; linearTeam?: string;
+  mode?: 'off' | 'shadow' | 'live'; linearTeam?: string;
   roles?: Record<string, { maxConcurrent?: number }>;
   budget?: number;
   tracks?: Record<string, string>;
   alertAfterFailures?: number;
+  launch?: 'off' | 'shadow' | 'live';
+  maxParallel?: number;
+  podPool?: string;
 }
 export interface StewardDeps {
   fetch?: typeof fetch;
@@ -44,14 +53,28 @@ export interface StewardDeps {
   cardStore?: StewardCardDeps['store'];
   warn?: (message: string) => void;
   ask?: StewardAsk;
+  launchSettings?: Pick<StewardSettings, 'mode' | 'launch' | 'maxParallel' | 'podPool'>;
+  launchCommand?: LaunchDeps['command'];
+  spawnLaunch?: LaunchDeps['spawn'];
+  launchGate?: LaunchDeps['gate'];
+  outcomeNotify?: Pick<OutcomeNotifyDeps, 'document' | 'message' | 'worktreeCommand' | 'loadOrigin' | 'loadOrigins'>;
   /** Internal command boundary: the current sync has already claimed this pid. */
   stageOwnedByCommand?: boolean;
 }
 
 export function stewardSettings(): StewardSettings {
-  return getUserConfig().loops?.steward ?? {};
+  return getUserConfig().loops?.steward ?? { mode: 'shadow' };
 }
 
+function effectiveStewardMode(settings: StewardSettings): 'off' | 'shadow' | 'live' {
+  return settings.mode ?? settings.launch ?? 'shadow';
+}
+
+function resolvedStewardSettings(override?: StewardDeps['launchSettings']): StewardSettings {
+  const settings = { ...stewardSettings(), ...override };
+  if (override?.launch !== undefined && override.mode === undefined) settings.mode = override.launch;
+  return { ...settings, mode: effectiveStewardMode(settings) };
+}
 
 function parseJudgment(issue: TriageIssue, raw: unknown, tracks?: Record<string, string>): TriageDecision {
   const value = typeof raw === 'string' ? JSON.parse(raw) as unknown : raw;
@@ -89,6 +112,8 @@ export async function triageIssues(issues: TriageIssue[], judge?: NonNullable<St
   const classified: ClassifiedIssue[] = [];
   const classifiedIds = new Set<string>();
   const counts = { rule: 0, classify: 0, planning: 0 };
+  // 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 => {
     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 } });
@@ -99,7 +124,7 @@ export async function triageIssues(issues: TriageIssue[], judge?: NonNullable<St
       const byRule = ruleJudgment(issue, observedIssues ?? issues);
       if (byRule) { counts.rule++; return { ...byRule, dependsOn: [], priority: 0 }; }
       counts.classify++;
-      const row = await classifyIssue(issue, ask);
+      const row = await classifyIssue(issue, ask, inventory ??= installedCapabilities());
       return { ...row, dependsOn: [], priority: 0 };
     } catch (error) {
       try { debug.log('steward.stage', 'judgment-invalid', { issue: issue.identifier, reason: redactSecrets(String(error)) }); } catch { /* fail-soft */ }
@@ -111,6 +136,7 @@ export async function triageIssues(issues: TriageIssue[], judge?: NonNullable<St
         result.why !== 'triage judgment timed out — human review' &&
         result.why !== 'triage deferred — deadline') {
       classified.push({ issue: result.issue, rung: result.rung, why: result.why,
+        ...(result.capability ? { capability: result.capability } : {}),
         ...(result.hitlReason ? { hitlReason: result.hitlReason } : {}) });
       classifiedIds.add(result.issue);
     } else signal(result);
@@ -232,10 +258,10 @@ function readState(path: string): { issues: Record<string, string>; digestDay?:
   catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { issues: {} }; throw error; }
 }
 
-/** Each command node invokes one stage. No stage can spawn, launch, merge or approve. */
+/** Each command node invokes one stage. Live launch still requires the launch gate; merge and approval remain with the harness and human. */
 export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'report', deps: StewardDeps = {}): Promise<void> {
-  const settings = stewardSettings();
-  if ((settings.mode ?? 'observe') !== 'observe') throw new Error('steward act mode is out of scope');
+  const settings = resolvedStewardSettings(deps.launchSettings);
+  if (settings.mode === 'off') return;
   const root = deps.root ?? effectiveInstanceRoot();
   if (stage === 'sync' && !deps.stageOwnedByCommand) {
     return withStageSlot(root, async () => {
@@ -257,7 +283,25 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
   if (!key) throw new Error('connector.linear.apiKey missing');
   if (stage === 'sync') {
     const events = await fetchLinearIssues({ apiKey: key, teamKey: settings.linearTeam ?? 'ELA', fetch: fetchFn });
-    writeFileSync(snapshot, JSON.stringify(events.map(e => ({ identifier: e.identifier, ref: e.ref, title: e.title, body: e.body }))));
+    const issues = events.map(e => ({ identifier: e.identifier, ref: e.ref, title: e.title, body: e.body }));
+    writeFileSync(snapshot, JSON.stringify(issues));
+    const cardIssues = issues.filter((issue): issue is TriageIssue => typeof issue.identifier === 'string');
+    if (cardIssues.length) {
+      const observeCardFailure = (error: unknown, issue?: string): void => {
+        const message = `steward sync: card write failed${issue ? ` (${issue})` : ''}: ${redactSecrets(error instanceof Error ? error.message : String(error))}`;
+        try { debug.log('steward.cards', 'write-failed', { error: message }); } catch { /* observation must not fail sync */ }
+        try { (deps.warn ?? console.warn)(message); } catch { /* observation must not fail sync */ }
+      };
+      try {
+        const store = deps.cardStore ?? new CardStore(root);
+        try {
+          for (const issue of cardIssues) {
+            try { recordIntakeOnCards(store, [issue], deps.now); }
+            catch (error) { observeCardFailure(error, issue.identifier); }
+          }
+        } finally { if (!deps.cardStore) store.close(); }
+      } catch (error) { observeCardFailure(error); }
+    }
   } else if (stage === 'triage') {
     const issues = JSON.parse(readFileSync(snapshot, 'utf8')) as TriageIssue[];
     const judge = deps.judge;
@@ -286,7 +330,8 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
         let cursor: string | null = null;
         do {
           const data: { issues: { nodes: Array<{ identifier: string; state?: { type: string } }>; pageInfo: { hasNextPage: boolean; endCursor: string | null } } } = await linear(key,
-            'query($ids:[String!]!,$after:String){issues(filter:{identifier:{in:$ids}},first:250,after:$after){nodes{identifier state{type}} pageInfo{hasNextPage endCursor}}}',
+            // IssueFilter has no `identifier` field (HTTP 400 GRAPHQL_VALIDATION_FAILED · 10-02 measured); `id` accepts identifiers like ELA-1.
+            'query($ids:[ID!]!,$after:String){issues(filter:{id:{in:$ids}},first:250,after:$after){nodes{identifier state{type}} pageInfo{hasNextPage endCursor}}}',
             { ids: batch, after: cursor }, fetchFn);
           if (!Array.isArray(data.issues?.nodes) || !data.issues.pageInfo ||
               (data.issues.pageInfo.hasNextPage && (!data.issues.pageInfo.endCursor || data.issues.pageInfo.endCursor === cursor))) {
@@ -297,7 +342,48 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
         } while (cursor);
       }
     }
-    writeFileSync(schedule, JSON.stringify(scheduleTriage(decisions, settings, {}, completed)));
+    let rows = scheduleTriage(decisions, settings, {}, completed);
+    const issues = existsSync(snapshot) ? JSON.parse(readFileSync(snapshot, 'utf8')) as TriageIssue[] : [];
+    // L2 — a new-capability wish gets its PR/FAQ and manual drafts on the card before any launch is recorded.
+    // Only new-capability rows: triage sections are written first so the card reads intake → triage → prfaq → manual → launch;
+    // the report stage repeats both calls idempotently. A wish whose draft is invalid goes to hitl on its own —
+    // the other rows (and the shadow ledger) still proceed this tick.
+    {
+      const present = new Set(issues.map(issue => issue.identifier));
+      const wishes = rows.filter(row => present.has(row.issue) && row.capability === 'new-capability' && row.rung !== 'hitl');
+      const store = wishes.length ? deps.cardStore ?? new CardStore(root) : undefined;
+      const invalid = new Set<string>();
+      if (store) try {
+        recordTriageOnCards(wishes, issues, { root, store, now: deps.now });
+        for (const wish of wishes) {
+          try { await recordWorkingBackwardsOnCards([wish], issues, store, deps.ask ?? askSteward); }
+          catch (error) {
+            if (!(error instanceof InvalidWorkingBackwardsDraft)) throw error;
+            invalid.add(wish.issue);
+            debug.log('steward.stage', 'draft-invalid', { issue: wish.issue });
+          }
+        }
+      } finally { if (!deps.cardStore) store.close(); }
+      if (invalid.size) rows = rows.map(row => invalid.has(row.issue)
+        ? { ...row, rung: 'hitl' as const, disposition: 'hitl' as const, hitlReason: 'other' as const, why: 'working-backwards draft invalid' }
+        : row);
+    }
+    writeFileSync(schedule, JSON.stringify(rows));
+    const ledger = readLaunchLedger(root);
+    const launchDeps: LaunchDeps = { root, settings, ledger, command: deps.launchCommand, spawn: deps.spawnLaunch, gate: deps.launchGate };
+    const cardDeps = { root, store: deps.cardStore, now: deps.now };
+    collectOutcomes(ledger, launchDeps);
+    const plan = planLaunches(rows, issues, ledger, settings);
+    // Keep fabric candidates distinct from Linear launches until a fabric executor is wired.
+    writeFileSync(join(dir, 'fabric-candidates.json'), JSON.stringify(listFabricExecutionCandidates(root)));
+    for (const { issue, row } of plan.hitl) {
+      const entry = raiseHitl(issue, row, launchDeps);
+      recordHitlOnCard(issue, entry, cardDeps);
+    }
+    for (const item of plan.launches) {
+      const entry = launch(item, launchDeps);
+      recordLaunchOnCard(item.issue, entry, cardDeps);
+    }
   } else {
     const rows = JSON.parse(readFileSync(schedule, 'utf8')) as ScheduledDecision[];
     const path = reportPath(root);
@@ -305,15 +391,23 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
     const at = (deps.now ?? (() => new Date()))().toISOString();
     const issues = JSON.parse(readFileSync(snapshot, 'utf8')) as TriageIssue[];
     try {
-      recordTriageOnCards(rows, issues, { root, store: deps.cardStore, now: deps.now });
+      const present = new Set(issues.map(issue => issue.identifier));
+      const known = rows.filter(row => present.has(row.issue));
+      const store = deps.cardStore ?? new CardStore(root);
+      try {
+        recordTriageOnCards(known, issues, { root, store, now: deps.now });
+        // Rows without a capability verdict (legacy, injected or unjudged) proceed; only drafting is skipped for them.
+        await recordWorkingBackwardsOnCards(known, issues, store, deps.ask ?? askSteward);
+      } finally { if (!deps.cardStore) store.close(); }
     } catch (error) {
       const message = `steward report: card write failed: ${redactSecrets(error instanceof Error ? error.message : String(error))}`;
       debug.log('steward.cards', 'write-failed', { error: message });
       (deps.warn ?? console.warn)(message);
+      if (error instanceof InvalidWorkingBackwardsDraft) throw error;
     }
     for (const row of rows) {
       const issue = issues.find(item => item.identifier === row.issue);
-      if (!issue) throw new Error(`Missing issue ${row.issue}`);
+      if (!issue) continue;
       const body = `스튜어드 observe · ${row.disposition} · rung ${row.rung} · 우선순위 ${row.priority} · 의존 ${row.dependsOn.join(', ') || '없음'}${row.duplicateOf ? ` · 중복 ${row.duplicateOf}` : ''} · ${row.why}${row.hitlReason ? ` · HITL ${row.hitlReason}` : ''}`;
       const hash = directiveHash(body);
       if (state.issues[row.issue] === hash) continue;
@@ -322,6 +416,27 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       state.issues[row.issue] = hash;
       writeFileSync(path, JSON.stringify(state));
     }
+    const ledger = readLaunchLedger(root);
+    const outcomes = collectOutcomes(ledger, { root, settings, ledger, command: deps.launchCommand, spawn: deps.spawnLaunch });
+    for (const outcome of outcomes) {
+      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 });
+      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;
+      saveLaunchLedger(root, ledger);
+    }
+    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') ||
+          // 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 });
+      }
+    }
     const day = at.slice(0, 10);
     if (state.digestDay !== day) {
       const send = deps.sendDigest ?? sendStewardDigest;
@@ -371,6 +486,7 @@ async function withStageSlot<T>(root: string, run: () => Promise<T>, onBusy?: ()
 
 /** The command-node boundary records both normal exits and an unclosed stage from a killed process. */
 export async function runStewardStageCommand(stage: StewardStage, deps: StewardCommandDeps = {}): Promise<0 | 1> {
+  if (resolvedStewardSettings(deps.launchSettings).mode === 'off') return 0;
   const root = deps.root ?? effectiveInstanceRoot();
   if (stage !== 'sync' && existsSync(skippedPath(root))) return 0;
   return withStageSlot(root, async () => {

package/src/steward/working-backwards.ts

@@ -0,0 +1,64 @@
+import { createHash } from 'node:crypto';
+import { debug } from '../debug/log.js';
+import { redactSecrets } from '../task-cards/card-store.js';
+import type { ScheduledDecision, TriageIssue } from './triage.js';
+import type { StewardAsk } from './triage-plan.js';
+import type { StewardCardStore } from './steward-cards.js';
+
+export interface WorkingBackwardsDraft {
+  prfaq: string;
+  manual: string;
+}
+
+export class InvalidWorkingBackwardsDraft extends Error {
+  constructor() { super('Invalid working-backwards draft'); }
+}
+
+/** Draft promises before implementation; no document, site, or channel is written here. */
+export async function draftWorkingBackwards(issue: TriageIssue, ask: StewardAsk): Promise<WorkingBackwardsDraft> {
+  const raw = await ask(`새 능력 소원의 구현 전 워킹 백워드 초안을 JSON 객체 {"prfaq":"...","manual":"...","signals":["판정 신호: 조건 = ...; 관측 = ...; 기대 = ..."]} 로만 써라. PR/FAQ 는 docs/marketing/TEMPLATE-prfaq-2026-09-29.md 모양의 ① 한 줄, 부제(누가), ② 문제(왜), ③ 해결(무엇), ④ 대표의 말(없는 인용은 확인 대기), ⑤ 시작하기, ⑥ 고객 FAQ(질문·답 셋 이상), ⑦ 내부 FAQ, ⑧ 판정 기준을 포함한다. 매뉴얼은 docs/marketing/TEMPLATE-manual-2026-10-02.md 모양으로 사용자가 칠 명령과 볼 화면을 제안하되 구현 전 가설이라고 명시한다. 아직 구현된 명령·화면이라고 주장하지 마라. 판정 신호 한두 문장은 PR/FAQ ⑧ 에 그대로 포함시켜라.\n소원: ${JSON.stringify(issue)}`, 'planning');
+  let value: unknown = raw;
+  if (typeof raw === 'string') {
+    // A draft that is not JSON is as invalid as one with missing sections — the report must stop on it too.
+    try { value = JSON.parse(raw.replace(/^```(?:json)?\s*|\s*```$/g, '').trim()); }
+    catch { throw new InvalidWorkingBackwardsDraft(); }
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new InvalidWorkingBackwardsDraft();
+  const row = value as Record<string, unknown>;
+  const prfaq = row.prfaq;
+  const manual = row.manual;
+  const faq = typeof prfaq === 'string' ? prfaq.split('⑥ 고객 FAQ')[1]?.split('⑦ 내부 FAQ')[0] ?? '' : '';
+  const criteria = typeof prfaq === 'string' ? prfaq.split('⑧ 판정 기준')[1] ?? '' : '';
+  const answered = faq.split('\n').filter(line => /^\|\s*[^|?]+\?\s*\|\s*[^|\s][^|]*\|/.test(line));
+  if (typeof prfaq !== 'string' || typeof manual !== 'string' ||
+      !Array.isArray(row.signals) || row.signals.length < 1 || row.signals.length > 2 ||
+      !row.signals.every(signal => typeof signal === 'string' && /^판정 신호: 조건 = .+; 관측 = .+; 기대 = .+\.$/.test(signal) && criteria.includes(signal)) ||
+      !['①', '②', '③', '④', '⑤', '⑥', '⑦', '⑧'].every(section => prfaq.includes(section)) ||
+      answered.length < 3 ||
+      !/elanous\s+\S+/.test(manual) || !/화면/.test(manual)) throw new InvalidWorkingBackwardsDraft();
+  return { prfaq: redactSecrets(prfaq), manual: redactSecrets(manual) };
+}
+
+/** Called during the steward report, after triage and before a launch can be recorded. */
+export async function recordWorkingBackwardsOnCards(
+  decisions: ScheduledDecision[], issues: TriageIssue[], store: StewardCardStore, ask: StewardAsk,
+): Promise<void> {
+  const byId = new Map(issues.map(issue => [issue.identifier, issue]));
+  for (const decision of decisions) {
+    const issue = byId.get(decision.issue);
+    if (!issue) throw new Error(`Missing issue ${decision.issue}`);
+    if (decision.capability !== 'new-capability' || decision.deferred || decision.duplicateOf || decision.rung === 'hitl') {
+      debug.log('steward.working-backwards', 'skipped-existing', { issueId: issue.identifier, verdict: decision.capability ?? 'unknown' });
+      continue;
+    }
+    const card = store.createCard({ goalId: `linear:${issue.identifier}`, title: redactSecrets(issue.title) });
+    if (card.sections.some(section => section.key.startsWith('prfaq:')) && card.sections.some(section => section.key.startsWith('manual:'))) continue;
+    if (card.sections.some(section => section.key.startsWith('launch:'))) throw new Error(`Working-backwards draft follows launch: ${issue.identifier}`);
+    const draft = await draftWorkingBackwards(issue, ask);
+    for (const [section, content] of [['prfaq', draft.prfaq], ['manual', draft.manual]] as const) {
+      const key = `${section}:${createHash('sha256').update(content).digest('hex')}`;
+      if (!card.sections.some(item => item.key === key)) store.appendSection(card.id, { key, owner: 'steward', content });
+    }
+    debug.log('steward.working-backwards', 'drafted', { issueId: issue.identifier, verdict: decision.capability });
+  }
+}