elanous 0.2.10 → 0.2.12

package/src/skills/gift-install.ts

@@ -0,0 +1,215 @@
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { cpSync, existsSync, lstatSync, mkdtempSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+
+export interface GiftInstallOptions {
+  pack: string;
+  code?: string;
+  email?: string;
+  agree?: boolean;
+  endpoint?: string;
+  fetch?: typeof fetch;
+  targets?: string[];
+  /** Caps (defaults below); tests pass small values. */
+  maxDownloadBytes?: number;
+  maxUnpackedBytes?: number;
+  maxEntries?: number;
+}
+
+export type GiftInstallResult =
+  | { ok: true; names: string[]; paths: string[]; collisions: string[]; needsKeys: boolean; message: string }
+  | { ok: false; reason: string; message: string };
+
+// GK1 public bundle: packs/elanous-essentials/plugin.json extensions.ai.elanous.bundle.
+const ESSENTIAL_SKILLS = ['youtube-master', 'omni-crawl', 'omni-digest', 'diagram-master', 'lecture-note-digitizer'];
+// A malicious or broken gift must not exhaust the temp disk: cap the download, the unpacked total and the entry count.
+export const MAX_DOWNLOAD_BYTES = 20 * 1024 * 1024;
+export const MAX_UNPACKED_BYTES = 100 * 1024 * 1024;
+export const MAX_ENTRIES = 5000;
+const CONSENT_NOTICE = '선물 스킬 전달과 안내 메일을 위해 이메일을 받습니다 · 보관은 알림 신청과 같은 기간 · 동의하면 --agree 를 붙여 다시 시도해 주세요.';
+const ERROR_MESSAGES: Record<string, string> = {
+  'email-required': CONSENT_NOTICE,
+  'consent-required': CONSENT_NOTICE,
+  'unknown-code': '코드를 다시 확인해 주세요.',
+  'used-up': '이미 다 쓴 코드예요 · 업데이트 소식 신청을 확인해 주세요.',
+  expired: '만료된 코드예요.',
+};
+
+/** Redeem, verify and install a gift without modifying an existing skill directory. */
+export async function installGiftPack({
+  pack, code, email, agree, endpoint = 'https://elanous.ai', fetch: fetchImpl = fetch,
+  targets = [join(homedir(), '.agents', 'skills'), join(homedir(), '.claude', 'skills')],
+  maxDownloadBytes = MAX_DOWNLOAD_BYTES, maxUnpackedBytes = MAX_UNPACKED_BYTES, maxEntries = MAX_ENTRIES,
+}: GiftInstallOptions): Promise<GiftInstallResult> {
+  const codePrefix = code && code.length > 4 ? code.slice(0, 4) : undefined;
+  const reject = (reason: string, message: string): GiftInstallResult => {
+    debug.log('skills.gift', 'rejected', { pack, reason, count: 0, codePrefix });
+    return { ok: false, reason, message };
+  };
+  if (!email?.trim() || !agree) return reject(!email?.trim() ? 'email-required' : 'consent-required', CONSENT_NOTICE);
+  if (!code?.trim()) return reject('unknown-code', ERROR_MESSAGES['unknown-code']!);
+  let gift: Record<string, unknown>;
+  try {
+    const response = await fetchImpl(`${endpoint.replace(/\/$/, '')}/api/gift`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ code, email, consent: true }),
+    });
+    // The gift API assigns these reasons by HTTP status; error bodies may be absent or malformed.
+    const statusReason = ({ 404: 'unknown-code', 409: 'used-up', 410: 'expired' } as Record<number, string | undefined>)[response.status];
+    if (statusReason) return reject(statusReason, ERROR_MESSAGES[statusReason]!);
+    const payload: unknown = await response.json();
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+      return reject('invalid-response', '선물 응답을 확인할 수 없습니다. 다시 시도해 주세요.');
+    }
+    gift = payload as Record<string, unknown>;
+    if (!response.ok) {
+      const reason = response.status === 400 && (gift.reason === 'email-required' || gift.reason === 'consent-required')
+        ? gift.reason : 'request-rejected';
+      return reject(reason, ERROR_MESSAGES[reason] ?? '선물을 받을 수 없습니다. 다시 시도해 주세요.');
+    }
+  } catch {
+    return reject('network-error', '네트워크에 연결할 수 없습니다. 다시 시도해 주세요.');
+  }
+  if (gift.ok !== true || gift.pack !== pack || typeof gift.zipUrl !== 'string' || !/^https?:\/\//.test(gift.zipUrl)
+    || typeof gift.sha256 !== 'string' || !/^[a-f0-9]{64}$/i.test(gift.sha256)) {
+    return reject('invalid-response', '선물 응답을 확인할 수 없습니다. 다시 시도해 주세요.');
+  }
+  let zip: Buffer;
+  const tooLarge = () => reject('too-large', '선물 zip 이 허용 크기를 넘습니다. 설치하지 않았습니다.');
+  try {
+    const response = await fetchImpl(gift.zipUrl, { redirect: 'error' });
+    if (!response.ok) throw new Error('download-failed');
+    const declared = Number(response.headers.get('content-length'));
+    if (Number.isFinite(declared) && declared > maxDownloadBytes) return tooLarge();
+    // Count the bytes actually received too — a missing or lying Content-Length must not bypass the cap.
+    const chunks: Uint8Array[] = [];
+    let received = 0;
+    if (response.body) {
+      const reader = response.body.getReader();
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        received += value.byteLength;
+        if (received > maxDownloadBytes) { await reader.cancel().catch(() => {}); return tooLarge(); }
+        chunks.push(value);
+      }
+    }
+    zip = Buffer.concat(chunks);
+  } catch {
+    return reject('network-error', '다운로드에 실패했습니다. 다시 시도해 주세요.');
+  }
+  if (createHash('sha256').update(zip).digest('hex').toLowerCase() !== gift.sha256.toLowerCase()) {
+    debug.log('skills.gift', 'checksum-mismatch', { pack, reason: 'sha256', count: 0, codePrefix });
+    return { ok: false, reason: 'checksum-mismatch', message: '다운로드 검증(sha256)에 실패했습니다. 설치하지 않았습니다.' };
+  }
+  const temp = mkdtempSync(join(tmpdir(), 'elanous-gift-'));
+  const created: string[] = [];
+  let incomplete: string | undefined;
+  try {
+    const zipPath = join(temp, 'gift.zip');
+    const extracted = join(temp, 'extracted');
+    mkdirSync(extracted);
+    writeFileSync(zipPath, zip);
+    // Reject archive symlinks and traversal paths before extracting any entry.
+    execFileSync('python3', ['-c', `import os, stat, sys, zipfile
+root = sys.argv[2]
+max_unpacked = int(sys.argv[3]); max_entries = int(sys.argv[4])
+with zipfile.ZipFile(sys.argv[1]) as archive:
+    entries = archive.infolist()
+    if len(entries) > max_entries or sum(entry.file_size for entry in entries) > max_unpacked:
+        sys.exit(3)
+    for entry in entries:
+        parts = entry.filename.split('/')
+        mode = entry.external_attr >> 16
+        if (not entry.filename or entry.filename.startswith('/') or '\\u005c' in entry.filename
+            or any(part in ('', '.', '..') for part in parts[:-1])
+            or parts[-1] in ('.', '..') or (not entry.is_dir() and not parts[-1])
+            or stat.S_ISLNK(mode)):
+            raise ValueError('invalid archive entry')
+    written = 0
+    for entry in entries:
+        path = os.path.join(root, entry.filename)
+        if entry.is_dir():
+            os.makedirs(path, exist_ok=True)
+        else:
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            with archive.open(entry) as source, open(path, 'xb') as target:
+                while True:
+                    block = source.read(65536)
+                    if not block:
+                        break
+                    written += len(block)
+                    if written > max_unpacked:
+                        sys.exit(3)
+                    target.write(block)
+`, zipPath, extracted, String(maxUnpackedBytes), String(maxEntries)], { stdio: 'pipe' });
+    const skillDirs = (root: string) => readdirSync(root, { withFileTypes: true })
+      // SKILL.md must be a regular file — a `SKILL.md/` directory or a symlink is not a skill.
+      .filter((entry) => entry.isDirectory() && lstatSync(join(root, entry.name, 'SKILL.md'), { throwIfNoEntry: false })?.isFile() === true)
+      .map((entry) => ({ name: entry.name, path: join(root, entry.name) }));
+    let skills = skillDirs(extracted);
+    if (!skills.length) {
+      const roots = readdirSync(extracted, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory()).map((entry) => join(extracted, entry.name));
+      if (roots.length === 1) {
+        skills = skillDirs(roots[0]!);
+        if (!skills.length && existsSync(join(roots[0]!, 'skills'))) skills = skillDirs(join(roots[0]!, 'skills'));
+      }
+    }
+    // Directory listing order differs between filesystems — keep the bundle order, then names.
+    const rank = (name: string) => { const i = ESSENTIAL_SKILLS.indexOf(name); return i < 0 ? ESSENTIAL_SKILLS.length : i; };
+    skills = [...skills].sort((a, b) => rank(a.name) - rank(b.name) || a.name.localeCompare(b.name));
+    if (!skills.length || !targets.length) return reject('invalid-pack', '설치할 스킬 폴더나 대상 경로를 찾지 못했습니다.');
+    if (pack === 'essential' && (skills.length !== ESSENTIAL_SKILLS.length
+      || ESSENTIAL_SKILLS.some((name) => !skills.some((skill) => skill.name === name)))) {
+      return reject('invalid-pack', '필수 스킬 다섯이 모두 들어 있지 않습니다. 설치하지 않았습니다.');
+    }
+    const paths: string[] = [];
+    const collisions: string[] = [];
+    const date = new Date().toISOString().slice(0, 10);
+    for (const target of targets) {
+      mkdirSync(target, { recursive: true });
+      for (const skill of skills) {
+        const desired = join(target, skill.name);
+        let dest = desired;
+        if (lstatSync(desired, { throwIfNoEntry: false })) {
+          dest = `${desired}.gift-${date}`;
+          let n = 2;
+          while (lstatSync(dest, { throwIfNoEntry: false })) dest = `${desired}.gift-${date}-${n++}`;
+          collisions.push(`${skill.name} → ${dest}`);
+        }
+        // Reserve the destination exclusively: a concurrent installer must not be overwritten.
+        mkdirSync(dest);
+        incomplete = dest;
+        for (const entry of readdirSync(skill.path)) {
+          cpSync(join(skill.path, entry), join(dest, entry), { recursive: true, errorOnExist: true, force: false });
+        }
+        created.push(dest);
+        incomplete = undefined;
+        paths.push(dest);
+      }
+    }
+    const names = skills.map((skill) => skill.name);
+    const needsKeys = skills.some((skill) => existsSync(join(skill.path, '.env.example')));
+    const message = `${collisions.length ? `기존 폴더는 그대로 두고 옆에 설치했습니다: ${collisions.join(', ')}\n` : ''}${needsKeys ? '.env.example 이 있습니다 — 키는 가이드대로 설정해 주세요.\n' : ''}설치한 스킬: ${names.join(', ')}`;
+    debug.log('skills.gift', 'installed', { pack, reason: 'ok', count: paths.length, codePrefix });
+    return { ok: true, names, paths, collisions, needsKeys, message };
+  } catch (error) {
+    if ((error as { status?: number }).status === 3 && !created.length) return tooLarge();
+    const remaining: string[] = [];
+    for (const path of [...(incomplete ? [incomplete] : []), ...created.reverse()]) {
+      try { rmSync(path, { recursive: true }); }
+      catch { remaining.push(path); }
+    }
+    if (remaining.length) {
+      debug.log('skills.gift', 'rejected', { pack, reason: 'partial-install', count: remaining.length, codePrefix });
+      return { ok: false, reason: 'partial-install', message: `일부 설치된 스킬을 되돌리지 못했습니다: ${remaining.join(', ')}` };
+    }
+    return reject('invalid-pack', '선물 zip 을 안전하게 풀 수 없습니다. 설치하지 않았습니다.');
+  } finally {
+    rmSync(temp, { recursive: true, force: true });
+  }
+}

package/src/skills/tools/web-search.ts

@@ -101,7 +101,10 @@ export async function dispatchWebSearch(args: Record<string, unknown>, ctx: { si
   });
 
   const notePrefix = result.note ? `\n\n${result.note}\n` : '';
-  const output = [header, notePrefix.trim(), ...hitLines].filter(Boolean).join('\n\n');
+  const xStatus = result.xSearch === 'unavailable'
+    ? 'X search unavailable: these results do not establish reactions on X; do not cite them as X posts.'
+    : '';
+  const output = [header, xStatus, notePrefix.trim(), ...hitLines].filter(Boolean).join('\n\n');
 
   return {
     output,

package/src/steward/launch.ts

@@ -2,11 +2,14 @@ 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 { publishInsideEvent } from '../nexus/api/inside-events.js';
 import { redactSecrets } from '../task-cards/card-store.js';
+import { preLaunchGate, type PreLaunchGateDecision } from '../execution-loop/launch-gate.js';
+import type { BudgetDecision } from '../self-implement/budget-gate.js';
 import type { ScheduledDecision, StewardSettings, TriageIssue } from './triage.js';
 
 /** `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 type LaunchStatus = 'shadow' | 'launched' | 'skipped-budget' | 'blocked-duplicate' | 'blocked-location' | 'failed' | 'running' | 'merged' | 'completed';
 export interface LaunchEntry {
   issue: string;
   title: string;
@@ -40,12 +43,14 @@ export interface LaunchDeps {
   /** 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 };
+  gate?: (goalId: string, budget: BudgetDecision | 'unknown') => PreLaunchGateDecision;
 }
 
 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 launchMode = (settings: StewardSettings): 'off' | 'shadow' | 'live' => settings.mode ?? settings.launch ?? 'shadow';
 const cli = (args: string[]) => ['bun', 'bin/elanous.mjs', ...(process.env.NODE_ENV === 'test' ? ['--test'] : []), ...args];
 const sourceOf = (issue: TriageIssue): string => /^출처: (telegram|pwa|tui|cli)$/m.exec(issue.body)?.[1] ?? `linear:${issue.identifier}`;
 const promptOf = (issue: TriageIssue): string => `${issue.title}\n${issue.body.slice(0, 1500)}`;
@@ -83,10 +88,10 @@ export function planLaunches(rows: ScheduledDecision[], issues: TriageIssue[], l
     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 });
+      if (launchMode(settings) !== 'off' && (!ledger.hitl[row.issue] || launchMode(settings) === '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;
+    if (launchMode(settings) === 'off' || row.disposition !== 'now' || row.rung !== 4 || (ledger.launches[row.issue] && !['skipped-budget', 'blocked-duplicate', 'blocked-location'].includes(ledger.launches[row.issue].status) && !(launchMode(settings) === '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(' ') });
   }
@@ -118,37 +123,46 @@ function lastJson(stdout: string): 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');
+  if (item.row.rung !== 4 || item.row.hitlReason || item.row.disposition !== 'now' || (ledger.launches[item.issue.identifier] && !['skipped-budget', 'blocked-duplicate', 'blocked-location'].includes(ledger.launches[item.issue.identifier].status) && !(launchMode(settings) === 'live' && ledger.launches[item.issue.identifier].status === 'shadow'))) throw new Error('steward launch is not eligible');
+  if (launchMode(settings) === 'off') throw new Error('steward launch is off');
   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') {
+  if (launchMode(settings) !== 'live') {
     ledger.launches[key] = entry;
     saveLaunchLedger(root, ledger);
     debug.log('steward.launch', 'shadow', { issue: key, command: entry.command });
+    publishInsideEvent({ kind: 'steward', issue: key, status: entry.status });
     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));
+  const blocked = (status: LaunchStatus, reason: string): LaunchEntry => {
+    entry.status = status;
+    entry.reason = redactSecrets(reason);
     ledger.launches[key] = entry;
     saveLaunchLedger(root, ledger);
-    debug.log('steward.launch', 'skipped-budget', { issue: key, reason: entry.reason });
+    debug.log('steward.launch', status, { issue: key, reason: entry.reason });
+    publishInsideEvent({ kind: 'steward', issue: key, status: entry.status, reason: entry.reason });
     return entry;
+  };
+  // L6: a launch must remain on the isolated Pod pool, never fall back to the host or another substrate.
+  if (!/^[a-zA-Z0-9_-]+(?:@[a-zA-Z0-9._-]+(?::[1-9][0-9]*)?)?$/.test(settings.podPool ?? DEFAULT_POOL))
+    return blocked('blocked-location', 'invalid steward pod pool');
+  let budget: BudgetDecision | 'unknown' = 'unknown';
+  try {
+    const result = command(cli(['harness', 'budget', '--json']));
+    const decision = result.exitCode === 0 ? lastJson(result.stdout) : {};
+    if (!BUDGET_PROCEED.includes(String(decision.outcome)))
+      return blocked('skipped-budget', result.exitCode === 0 ? JSON.stringify(decision.reasons ?? ['budget unavailable']) : result.stderr ?? 'budget unavailable');
+    budget = { action: decision.outcome as 'proceed' | 'next-provider', reasons: Array.isArray(decision.reasons) ? decision.reasons.map(String) : [] };
+  } catch (error) {
+    return blocked('skipped-budget', String(error));
   }
+  // L6: the shared gate checks active same-goal runs and the budget decision immediately before spawn.
+  let gate: PreLaunchGateDecision;
+  try { gate = (deps.gate ?? ((goalId, decision) => preLaunchGate({ goalId, budget: decision })))(`linear:${key}`, budget); }
+  catch (error) { return blocked('blocked-duplicate', `launch gate unavailable: ${String(error)}`); }
+  if (gate.action !== 'proceed' || gate.sameGoalActiveRuns === 'unknown')
+    return blocked(gate.action === 'blocked-budget' || gate.action === 'wait-reset' ? 'skipped-budget' : 'blocked-duplicate', gate.sameGoalActiveRuns === 'unknown' ? 'active runs unknown' : gate.reason);
   entry.status = 'launched';
   entry.log = join(root, 'steward', 'launch', `${key.replace(/[^a-zA-Z0-9_-]/g, '_')}.log`);
   mkdirSync(join(root, 'steward', 'launch'), { recursive: true });
@@ -166,15 +180,16 @@ export function launch(item: LaunchItem, deps: LaunchDeps): LaunchEntry {
   }
   saveLaunchLedger(root, ledger);
   debug.log('steward.launch', 'launched', { issue: key, runId: entry.runId, pid: entry.pid, status: entry.status });
+  publishInsideEvent({ kind: 'steward', issue: key, status: entry.status, ...(entry.runId ? { runId: entry.runId } : {}) });
   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;
+  if (old && (old.attempted || launchMode(deps.settings) !== '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') {
+  if (launchMode(deps.settings) !== 'live') {
     saveLaunchLedger(deps.root, deps.ledger);
     return entry;
   }
@@ -199,10 +214,10 @@ function alive(pid: number | undefined): boolean {
 }
 
 export function collectOutcomes(ledger: LaunchLedger, deps: LaunchDeps): LaunchEntry[] {
-  if (deps.settings.launch !== 'live') return [];
+  if (launchMode(deps.settings) !== '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.reported || entry.status === 'shadow' || entry.status === 'skipped-budget' || entry.status === 'blocked-duplicate' || entry.status === 'blocked-location') continue;
     if (!entry.runId && entry.log) {
       try { entry.runId = readFileSync(entry.log, 'utf8').match(RUN_ID)?.[0]; } catch { /* Wait for log. */ }
     }
@@ -244,6 +259,7 @@ export function collectOutcomes(ledger: LaunchLedger, deps: LaunchDeps): LaunchE
     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 });
+    publishInsideEvent({ kind: 'steward', issue: entry.issue, status: entry.status, ...(entry.runId ? { runId: entry.runId } : {}) });
   }
   saveLaunchLedger(deps.root, ledger);
   return done;

package/src/steward/steward-cards.ts

@@ -15,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);
@@ -23,16 +39,8 @@ 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 } : {}), ...(decision.capability ? { capability: decision.capability } : {}) };
       const key = `triage:${createHash('sha256').update(JSON.stringify(judgment)).digest('hex')}`;

package/src/steward/triage.ts

@@ -9,8 +9,9 @@ import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { redactSecrets } from '../task-cards/card-store.js';
 import { directiveHash } from './directive.js';
 import { notifyOutcome, type OutcomeNotifyDeps } from './outcome-notify.js';
-import { recordTriageOnCards, recordLaunchOnCard, recordOutcomeOnCard, recordHitlOnCard, type StewardCardDeps } from './steward-cards.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';
@@ -32,7 +33,7 @@ export interface TriageDecision {
 }
 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>;
@@ -52,18 +53,28 @@ export interface StewardDeps {
   cardStore?: StewardCardDeps['store'];
   warn?: (message: string) => void;
   ask?: StewardAsk;
-  launchSettings?: Pick<StewardSettings, 'launch' | 'maxParallel' | 'podPool'>;
+  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;
@@ -247,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. Only the launch setting permits spawn; merge and approval remain with the harness and human. */
+/** 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(), ...deps.launchSettings };
-  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 () => {
@@ -272,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;
@@ -341,10 +370,12 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
     }
     writeFileSync(schedule, JSON.stringify(rows));
     const ledger = readLaunchLedger(root);
-    const launchDeps: LaunchDeps = { root, settings, ledger, command: deps.launchCommand, spawn: deps.spawnLaunch };
+    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);
@@ -391,7 +422,7 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       const issue = issues.find(item => item.identifier === outcome.issue) ??
         { identifier: outcome.issue, title: outcome.title, ref: '', body: '' };
       recordOutcomeOnCard(issue, outcome, { root, store: deps.cardStore, now: deps.now });
-      notifyOutcome(outcome, { root, ledger, shadow: settings.launch !== 'live', ...deps.outcomeNotify });
+      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;
@@ -399,11 +430,11 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
     }
     const justCollected = new Set(outcomes.map(outcome => outcome.issue));
     for (const outcome of Object.values(ledger.launches)) {
-      if ((settings.launch !== 'live' && outcome.status === 'shadow' && !outcome.notified) ||
-          (settings.launch === 'live' && !justCollected.has(outcome.issue) && outcome.reported && outcome.notified !== 'shadow') ||
+      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.launch === 'live' && outcome.awaitingMerge === true && !outcome.reported && outcome.notified !== 'sent')) {
-        notifyOutcome(outcome, { root, ledger, shadow: settings.launch !== 'live', ...deps.outcomeNotify });
+          (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);
@@ -455,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/task-cards/card-cli.ts

@@ -1,4 +1,6 @@
 import type { Command } from 'commander';
+import { join, resolve } from 'node:path';
+import { scanWishFolder } from '../intake-plane/wish-folder.js';
 import { CardStore, type TaskCard } from './card-store.js';
 
 export interface CardCliDeps {
@@ -20,7 +22,7 @@ function formatCard(card: TaskCard): string {
   return lines.join('\n') + '\n';
 }
 
-/** Register read-only card inspection commands without changing other task commands. */
+/** Register card inspection and Wish note import commands. */
 export function registerCardCommand(program: Command, deps: CardCliDeps = {}): Command {
   const createStore = deps.createStore ?? (() => new CardStore());
   const write = deps.write ?? ((text: string) => { process.stdout.write(text); });
@@ -60,5 +62,27 @@ export function registerCardCommand(program: Command, deps: CardCliDeps = {}): C
       }
     });
 
+  card.command('wish-scan')
+    .description('Create task cards from Obsidian Wish notes')
+    .option('--dir <path>', 'Wish folder path')
+    .option('--json', 'Output JSON')
+    .action((options: { dir?: string; json?: boolean }) => {
+      const dir = resolve(options.dir ?? join(process.env.OBSIDIAN_VAULT_ROOT ?? '', '00. Inbox', '00. Wish'));
+      let store: CardStore | undefined;
+      try {
+        const result = scanWishFolder({ dir, store: (store = createStore()) });
+        write(options.json ? `${JSON.stringify(result)}\n` : `추가 ${result.added} · 갱신 ${result.updated} · 건너뜀 ${result.skipped}\n`);
+      } catch (error) {
+        if (error instanceof Error && error.message.startsWith('Wish 폴더를 찾지 못했습니다: ')) {
+          process.stderr.write(`${error.message}\n`);
+          process.exitCode = 2;
+          return;
+        }
+        throw error;
+      } finally {
+        store?.close();
+      }
+    });
+
   return card;
 }

package/src/task-orchestrator/mission.ts

@@ -264,6 +264,8 @@ export interface Mission {
 
   /** Optional bind to an existing goal (S2 auto-research / PFC). */
   goalSlug?: string;
+  /** Project association; absent on legacy and unassigned missions. */
+  projectId?: string;
 
   /** Free-form notes (append-only). */
   notes: readonly string[];
@@ -296,6 +298,7 @@ export interface MissionInit {
   priority?: MissionPriority;
   taskIds?: readonly string[];
   goalSlug?: string;
+  projectId?: string;
   notes?: readonly string[];
   /** Cascade-zyu Z0 — see {@link Mission.showroomSessionId}. */
   showroomSessionId?: string;
@@ -370,6 +373,7 @@ export function createMission(
     priority: init.priority,
     taskIds: Object.freeze([...(init.taskIds ?? [])]),
     goalSlug: init.goalSlug,
+    ...(init.projectId !== undefined ? { projectId: init.projectId } : {}),
     notes: Object.freeze([...(init.notes ?? [])]),
     showroomSessionId: init.showroomSessionId,
     autopilot: init.autopilot ? { ...init.autopilot } : undefined,
@@ -471,6 +475,7 @@ export function serializeMission(m: Mission): Record<string, unknown> {
     priority: m.priority,
     taskIds: [...m.taskIds],
     goalSlug: m.goalSlug,
+    ...(m.projectId !== undefined ? { projectId: m.projectId } : {}),
     notes: [...m.notes],
     showroomSessionId: m.showroomSessionId,
   };