elanous 0.2.9 → 0.2.10

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. */

package/src/steward/triage.ts

@@ -8,9 +8,13 @@ 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 { recordTriageOnCards, recordLaunchOnCard, recordOutcomeOnCard, recordHitlOnCard, type StewardCardDeps } from './steward-cards.js';
+import { planLaunches, launch, collectOutcomes, raiseHitl, readLaunchLedger, saveLaunchLedger, type LaunchDeps } from './launch.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,6 +28,7 @@ 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 {
@@ -32,6 +37,9 @@ export interface StewardSettings {
   budget?: number;
   tracks?: Record<string, string>;
   alertAfterFailures?: number;
+  launch?: 'off' | 'shadow' | 'live';
+  maxParallel?: number;
+  podPool?: string;
 }
 export interface StewardDeps {
   fetch?: typeof fetch;
@@ -44,6 +52,10 @@ export interface StewardDeps {
   cardStore?: StewardCardDeps['store'];
   warn?: (message: string) => void;
   ask?: StewardAsk;
+  launchSettings?: Pick<StewardSettings, 'launch' | 'maxParallel' | 'podPool'>;
+  launchCommand?: LaunchDeps['command'];
+  spawnLaunch?: LaunchDeps['spawn'];
+  outcomeNotify?: Pick<OutcomeNotifyDeps, 'document' | 'message' | 'worktreeCommand' | 'loadOrigin' | 'loadOrigins'>;
   /** Internal command boundary: the current sync has already claimed this pid. */
   stageOwnedByCommand?: boolean;
 }
@@ -89,6 +101,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 +113,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 +125,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,9 +247,9 @@ 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. Only the launch setting permits spawn; 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();
+  const settings = { ...stewardSettings(), ...deps.launchSettings };
   if ((settings.mode ?? 'observe') !== 'observe') throw new Error('steward act mode is out of scope');
   const root = deps.root ?? effectiveInstanceRoot();
   if (stage === 'sync' && !deps.stageOwnedByCommand) {
@@ -286,7 +301,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 +313,46 @@ 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 };
+    const cardDeps = { root, store: deps.cardStore, now: deps.now };
+    collectOutcomes(ledger, launchDeps);
+    const plan = planLaunches(rows, issues, ledger, settings);
+    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 +360,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 +385,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.launch !== '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.launch !== 'live' && outcome.status === 'shadow' && !outcome.notified) ||
+          (settings.launch === '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.launch === 'live' && outcome.awaitingMerge === true && !outcome.reported && outcome.notified !== 'sent')) {
+        notifyOutcome(outcome, { root, ledger, shadow: settings.launch !== 'live', ...deps.outcomeNotify });
+      }
+    }
     const day = at.slice(0, 10);
     if (state.digestDay !== day) {
       const send = deps.sendDigest ?? sendStewardDigest;

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

package/src/storyboard/storyboard.ts

@@ -0,0 +1,141 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+export const STORYBOARD_ROOT = resolve(import.meta.dir, '../..');
+const DIR = join(STORYBOARD_ROOT, 'storyboards');
+
+type Text = { text: string; source: string; ref?: string };
+type Shot = {
+  id: string; t: [number, number]; stage: string; layer?: string; persona?: string; purpose: string; subject?: string; action?: string;
+  camera?: { move?: string; lens_mm?: number; angle?: string; framing?: string }; lighting?: string; color?: string;
+  transition_in?: { type: string; intent: string }; on_screen_text?: Text[]; audio?: { vo?: string; sfx?: string; bgm?: string };
+  generation?: { tool: string; model?: string; prompt?: string; asset?: string }; real_or_staged: string; state: string; notes?: string;
+};
+/** kind: site — a site's page structure, menu and copy draft, planned like a storyboard (SITE2 · 10-02). */
+type Section = { id: string; title: string; purpose: string; change: string; copy?: Text[]; notes?: string };
+type Site = { domain: string; role: string; preview?: string; branch?: string; nav: Array<{ label: string; href: string }>; pages: Array<{ path: string; sections: Section[] }> };
+export type Storyboard = {
+  id: string; kind: string; title: string; version: number; status: string; approved?: { by: string; at: string; note?: string } | null;
+  supersedes?: string; owner: string; directive?: string; format: { aspects: string[]; duration_s: number; fps?: number; loop?: boolean; surface?: string };
+  scqa?: { s?: string; c?: string; q?: string; a?: string }; principles?: string[]; layers?: Record<string, string>; shots: Shot[]; sites?: Site[];
+  references?: string[]; open_questions?: string[];
+};
+
+const KINDS = ['teaser', 'site-hero', 'event-demo', 'persona-scene', 'explainer', 'ad', 'site'];
+const CHANGES = ['keep', 'move', 'new', 'replace', 'remove'];
+const STAGES = ['hook', 'buildup', 'climax', 'transition', 'end', 'loop'];
+const SOURCES = ['real-ui', 'real-cli', 'real-output', 'copy', 'example'];
+
+export function lint(sb: Storyboard, file = ''): { errors: string[]; warnings: string[] } {
+  const errors: string[] = [], warnings: string[] = [];
+  const need = (cond: unknown, msg: string) => { if (!cond) errors.push(msg); };
+  need(/^[a-z0-9][a-z0-9-]{2,80}$/.test(sb.id ?? ''), 'id: 소문자·숫자·하이픈 3~80자');
+  need(KINDS.includes(sb.kind), `kind: ${KINDS.join('|')}`);
+  need(Number.isInteger(sb.version) && sb.version >= 1, 'version: 1 이상 정수');
+  need(['draft', 'approved', 'superseded'].includes(sb.status), 'status: draft|approved|superseded');
+  need(sb.owner, 'owner 필요');
+  if (sb.status === 'approved') need(sb.approved?.by && sb.approved?.at, '승인본은 approved.by·at 필요');
+  if (file && sb.kind && !file.includes(`/${sb.kind}/`)) errors.push(`파일 위치가 kind(${sb.kind}) 폴더가 아니다`);
+  if (sb.kind === 'site') return lintSite(sb, errors, warnings);
+  need(sb.format?.aspects?.length && sb.format.duration_s > 0, 'format.aspects ⊕ duration_s 필요');
+  if (!Array.isArray(sb.shots) || !sb.shots.length) { errors.push('shots 가 비었다'); return { errors, warnings }; }
+  const ids = new Set<string>();
+  sb.shots.forEach((s, i) => {
+    const at = `shots[${i}](${s.id ?? '?'})`;
+    need(s.id && !ids.has(s.id), `${at}: id 없음·중복`); ids.add(s.id);
+    need(Array.isArray(s.t) && s.t.length === 2 && s.t[0] < s.t[1], `${at}: t = [시작, 끝] 이고 시작 < 끝`);
+    need(STAGES.includes(s.stage), `${at}: stage ${STAGES.join('|')}`);
+    need(s.purpose, `${at}: purpose(이 비트의 한 가지) 필요`);
+    need(['real', 'staged', 'composite'].includes(s.real_or_staged), `${at}: real_or_staged 필요`);
+    need(['planned', 'shot', 'approved'].includes(s.state), `${at}: state planned|shot|approved`);
+    if (s.transition_in && !s.transition_in.intent) errors.push(`${at}: 전환에는 의도 한 줄(«그냥 컷»은 설계가 아니다)`);
+    for (const txt of s.on_screen_text ?? []) {
+      need(SOURCES.includes(txt.source), `${at}: 화면 문구 «${txt.text}» 의 source 가 ${SOURCES.join('|')} 가 아니다`);
+      if (txt.source?.startsWith('real-') && !txt.ref) warnings.push(`${at}: 실제 문면 «${txt.text}» 에 ref(출처) 가 없다`);
+      if (/\d/.test(txt.text) && txt.source === 'copy') warnings.push(`${at}: 마케팅 문구에 숫자 «${txt.text}» — 실측 근거나 «example» 로`);
+    }
+    if (s.generation?.tool === 'higgsfield' && !s.generation.prompt) warnings.push(`${at}: 힉스필드 샷에 prompt 가 없다`);
+    if (s.real_or_staged !== 'real' && !/연출/.test(JSON.stringify(sb))) warnings.push(`${at}: 연출 샷이 있는데 문서 어디에도 «연출 장면» 표기가 없다`);
+  });
+  const end = Math.max(...sb.shots.map((s) => s.t?.[1] ?? 0));
+  if (sb.format?.duration_s && Math.abs(end - sb.format.duration_s) > 0.5) warnings.push(`마지막 샷 끝(${end}s) ≠ format.duration_s(${sb.format.duration_s}s)`);
+  return { errors, warnings };
+}
+
+/** A site plan has pages instead of shots: every section says why it is there and what changes; copy names its source. */
+function lintSite(sb: Storyboard, errors: string[], warnings: string[]): { errors: string[]; warnings: string[] } {
+  if (!Array.isArray(sb.sites) || !sb.sites.length) { errors.push('site 종류는 sites 가 필요하다'); return { errors, warnings }; }
+  for (const site of sb.sites) {
+    const at = `sites(${site.domain ?? '?'})`;
+    if (!site.domain || !site.role) errors.push(`${at}: domain ⊕ role(이 사이트가 맡는 것) 필요`);
+    if (!site.nav?.length) errors.push(`${at}: nav(메뉴) 필요`);
+    if (!site.pages?.length) errors.push(`${at}: pages 필요`);
+    if (!site.preview) warnings.push(`${at}: preview(미리보기 주소) 없음`);
+    const ids = new Set<string>();
+    for (const page of site.pages ?? []) for (const sec of page.sections ?? []) {
+      const where = `${at}${page.path} #${sec.id ?? '?'}`;
+      if (!sec.id || ids.has(`${page.path}#${sec.id}`)) errors.push(`${where}: id 없음·중복`);
+      ids.add(`${page.path}#${sec.id}`);
+      if (!sec.purpose) errors.push(`${where}: purpose(이 칸이 하는 한 가지) 필요`);
+      if (!CHANGES.includes(sec.change)) errors.push(`${where}: change ${CHANGES.join('|')}`);
+      for (const txt of sec.copy ?? []) {
+        if (!SOURCES.includes(txt.source)) errors.push(`${where}: 문구 «${txt.text}» 의 source 가 ${SOURCES.join('|')} 가 아니다`);
+        if (/\d/.test(txt.text) && txt.source === 'copy' && !txt.ref) warnings.push(`${where}: 마케팅 문구에 숫자 «${txt.text}» — ref(실측 근거) 를 단다`);
+      }
+    }
+  }
+  return { errors, warnings };
+}
+
+function renderSites(sb: Storyboard): string[] {
+  return (sb.sites ?? []).flatMap((site) => [
+    `## ${site.domain} — ${site.role}`, '',
+    ...(site.preview ? [`- 미리보기: ${site.preview}${site.branch ? ` (가지 \`${site.branch}\`)` : ''}`] : []),
+    `- 메뉴: ${site.nav.map((n) => `${n.label}(${n.href})`).join(' · ')}`, '',
+    ...site.pages.flatMap((page) => [
+      `### ${page.path}`, '', '| # | 칸 | 제목 | 목적 | 바뀜 | 문구(출처) | 메모 |', '|---|---|---|---|---|---|---|',
+      ...page.sections.map((sec, i) => `| ${i + 1} | ${md(sec.id)} | ${md(sec.title)} | ${md(sec.purpose)} | ${sec.change} | ${md((sec.copy ?? []).map((x) => `«${x.text}»(${x.source}${x.ref ? ` · ${x.ref}` : ''})`).join(' / '))} | ${md(sec.notes)} |`),
+      '',
+    ]),
+  ]);
+}
+
+const md = (v: unknown) => String(v ?? '').replace(/\|/g, '\\|').replace(/\n+/g, ' ');
+export function render(sb: Storyboard, file: string): string {
+  const head = [
+    `# STORYBOARD — ${sb.title} (v${sb.version} · ${sb.status}${sb.approved ? ` · 승인 ${sb.approved.by} ${sb.approved.at}` : ''})`,
+    '',
+    `> ⛔ 자동 생성 — 손으로 고치지 않는다. 정본 = \`${file}\` · 다시 뽑기 = \`bun scripts/storyboard/storyboard.ts render ${file}\`.`,
+    `> 종류 ${sb.kind} · 소유 ${sb.owner}${sb.format ? ` · ${sb.format.aspects.join(' · ')} · ${sb.format.duration_s}초${sb.format.loop ? ' · 반복' : ''}${sb.format.surface ? ` · ${sb.format.surface}` : ''}` : ''}${sb.supersedes ? ` · 앞 판 ${sb.supersedes}` : ''}`,
+    ...(sb.directive ? [`> 지시: ${sb.directive}`] : []),
+    '',
+  ];
+  const scqa = sb.scqa ? ['## SCQA', ...(['s', 'c', 'q', 'a'] as const).filter((k) => sb.scqa?.[k]).map((k) => `- **${k.toUpperCase()}** — ${sb.scqa![k]}`), ''] : [];
+  const pr = sb.principles?.length ? ['## 원칙', ...sb.principles.map((p, i) => `${i + 1}. ${p}`), ''] : [];
+  const layers = sb.layers ? ['## 층', ...Object.entries(sb.layers).map(([k, v]) => `- **${k}** — ${v}`), ''] : [];
+  const table = sb.kind === 'site' ? renderSites(sb) : [
+    '## 샷 구조표',
+    '| # | 초 | 단계 | 층·인물 | 목적 | 화면(피사체·행동) | 카메라 | 빛·색 | 전환(의도) | 화면 문구(출처) | 소리 | 만들기 | 실물/연출 · 상태 |',
+    '|---|---|---|---|---|---|---|---|---|---|---|---|---|',
+    ...sb.shots.map((s) => `| ${md(s.id)} | ${s.t[0]}–${s.t[1]} | ${s.stage} | ${md([s.layer, s.persona].filter(Boolean).join(' · '))} | ${md(s.purpose)} | ${md([s.subject, s.action].filter(Boolean).join(' — '))} | ${md(s.camera ? [s.camera.move, s.camera.lens_mm ? `${s.camera.lens_mm}mm` : '', s.camera.angle, s.camera.framing].filter(Boolean).join(' · ') : '')} | ${md([s.lighting, s.color].filter(Boolean).join(' · '))} | ${md(s.transition_in ? `${s.transition_in.type} — ${s.transition_in.intent}` : '')} | ${md((s.on_screen_text ?? []).map((x) => `«${x.text}»(${x.source}${x.ref ? ` · ${x.ref}` : ''})`).join(' / '))} | ${md(s.audio ? [s.audio.vo && `VO ${s.audio.vo}`, s.audio.sfx && `SFX ${s.audio.sfx}`, s.audio.bgm && `BGM ${s.audio.bgm}`].filter(Boolean).join(' · ') : '')} | ${md(s.generation ? [s.generation.tool, s.generation.model].filter(Boolean).join(' · ') : '')} | ${s.real_or_staged} · ${s.state} |`),
+    '',
+  ];
+  const shots = sb.shots ?? [];
+  const prompts = shots.filter((s) => s.generation?.prompt);
+  const pblock = prompts.length ? ['## 생성 프롬프트', ...prompts.flatMap((s) => [`### ${s.id} · ${s.generation!.tool}${s.generation!.model ? ` · ${s.generation!.model}` : ''}`, '```', s.generation!.prompt!.trim(), '```', ...(s.generation!.asset ? [`결과: \`${s.generation!.asset}\``] : []), ''])] : [];
+  const notes = shots.filter((s) => s.notes).map((s) => `- ${s.id}: ${s.notes}`);
+  const tail = [
+    ...(notes.length ? ['## 샷 메모', ...notes, ''] : []),
+    ...(sb.open_questions?.length ? ['## 열린 물음', ...sb.open_questions.map((q) => `- ${q}`), ''] : []),
+    ...(sb.references?.length ? ['## 참고', ...sb.references.map((r) => `- ${r}`), ''] : []),
+  ];
+  return [...head, ...scqa, ...pr, ...layers, ...table, ...pblock, ...tail].join('\n');
+}
+
+export function files(args: string[]): string[] {
+  if (args.length) return args.map((a) => resolve(a));
+  const out: string[] = [];
+  const walk = (d: string) => { for (const f of readdirSync(d)) { const p = join(d, f); if (statSync(p).isDirectory()) walk(p); else if (/\.ya?ml$/.test(f) && !f.startsWith('_')) out.push(p); } };
+  walk(DIR);
+  return out.sort();
+}

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

@@ -38,10 +38,10 @@ type CardEvent =
  *  A key is `<section>` or `<section>:<idempotency key>`: the same section can be appended many times over a
  *  task's life (e.g. workspace diff updates), and the same full key is written once. `incidents` is open to any loop. */
 export const SECTION_OWNERS: Readonly<Record<string, string | null>> = {
-  intake: 'steward', triage: 'steward', launch: 'steward', outcome: 'steward',
+  intake: 'steward', triage: 'steward', prfaq: 'steward', manual: 'steward', launch: 'steward', outcome: 'steward', hitl: 'steward',
   gates: 'execution-loop', relations: 'execution-loop', memory: 'execution-loop',
   workspace: 'executor', run: 'executor',
-  landing: 'landing-loop', release: 'release-loop',
+  landing: 'landing-loop', release: 'release-loop', 'test-diet': 'test-diet',
   incidents: null,
 };