elanous 0.2.10 → 0.2.11

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

package/src/task-orchestrator/store.ts

@@ -138,6 +138,7 @@ interface MissionRow {
   priority: MissionPriority | null;
   task_ids_json: string;   // JSON array of taskId
   goal_slug: string | null;
+  project_id: string | null;
   notes_json: string;      // JSON array of string
   autopilot_json: string | null;  // JSON MissionAutopilot | null (U1)
 }
@@ -309,6 +310,8 @@ export class TaskStore {
     // Mission Fabric 통합 U1 (v3) — tox_missions.autopilot_json:
     // PFC Layer2 자율 메타(apm Mission 흡수). NULL = 일반 Mission.
     this.addColumnIfMissing('tox_missions', 'autopilot_json', 'TEXT');
+    this.addColumnIfMissing('tox_missions', 'project_id', 'TEXT');
+    this.db.exec('CREATE INDEX IF NOT EXISTS idx_tox_missions_project ON tox_missions(project_id)');
     this.addColumnIfMissing('tox_executions', 'host_id', 'TEXT');
     this.addColumnIfMissing('tox_executions', 'hostname', 'TEXT');
     this.db.exec('CREATE INDEX IF NOT EXISTS idx_tox_executions_host ON tox_executions(host_id, started_at)');
@@ -587,8 +590,8 @@ export class TaskStore {
         `INSERT OR REPLACE INTO tox_missions (
           id, created_at, updated_at, closed_at, title, description, intent,
           source_json, status, priority, task_ids_json, goal_slug, notes_json,
-          autopilot_json
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+          autopilot_json, project_id
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       )
       .run(
         mission.id,
@@ -605,6 +608,7 @@ export class TaskStore {
         mission.goalSlug ?? null,
         JSON.stringify([...mission.notes]),
         mission.autopilot ? JSON.stringify(mission.autopilot) : null,
+        mission.projectId ?? null,
       ));
   }
 
@@ -616,7 +620,7 @@ export class TaskStore {
     return this.rowToMission(row);
   }
 
-  listMissions(opts: { status?: MissionStatus; goalSlug?: string } = {}): Mission[] {
+  listMissions(opts: { status?: MissionStatus; goalSlug?: string; projectId?: string } = {}): Mission[] {
     const where: string[] = [];
     const params: Array<string | number | null> = [];
     if (opts.status !== undefined) {
@@ -627,6 +631,10 @@ export class TaskStore {
       where.push('goal_slug = ?');
       params.push(opts.goalSlug);
     }
+    if (opts.projectId !== undefined) {
+      where.push('project_id = ?');
+      params.push(opts.projectId);
+    }
     const sql =
       'SELECT * FROM tox_missions' +
       (where.length > 0 ? ' WHERE ' + where.join(' AND ') : '') +
@@ -729,6 +737,7 @@ export class TaskStore {
       priority: row.priority ?? undefined,
       taskIds: Object.freeze(JSON.parse(row.task_ids_json) as string[]),
       goalSlug: row.goal_slug ?? undefined,
+      ...(row.project_id != null ? { projectId: row.project_id } : {}),
       notes: Object.freeze(JSON.parse(row.notes_json) as string[]),
       autopilot: row.autopilot_json
         ? (JSON.parse(row.autopilot_json) as Mission['autopilot'])

package/src/task-orchestrator/surfaces/pod-command-job.ts

@@ -7,14 +7,14 @@
 
 import { randomBytes } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
-import { isAbsolute } from 'node:path';
+import { isAbsolute, resolve } from 'node:path';
 import { getUserConfig } from '../../user-config.js';
 import { debug } from '../../debug/log.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { collectPodArtifacts } from './pod-artifact-return.js';
 import { podBunCacheVolume } from './pod-bun-cache.js';
 import { type PodPoolMember, PodPoolScheduler, resolvePodPoolSpec, parsePodPool, checkPodPool, syncPoolImages, type PoolKubectl } from './pod-pool.js';
-import { readSkillEnvFiles } from './pod-skills.js';
+import { podSkillsDigest, readSkillEnvFiles, resolvePodSkills } from './pod-skills.js';
 import { podSourceScript, type PodSource } from './pod-source-receive.js';
 import {
   POD_CHILD_REQUESTS,
@@ -30,6 +30,24 @@ import {
 /** CLI `--deadline` 생략 시 — 기존 Pod Job 수명 상한과 같다. */
 export const POD_COMMAND_DEADLINE_SECONDS = POD_JOB_DEADLINE_SECONDS;
 
+export const POD_NETWORK_SKILLS = ['omni-crawl', 'omni-digest'] as const;
+export const POD_LITE_IMAGE = 'elanous-harness-lite:local';
+
+export const POD_LITE_MEMORY_LIMIT = '2Gi';
+
+/** POD7 must-fix: the skill list alone can't tell a network-only job from one that needs ffmpeg/browser — so lite is
+ *  only ever chosen when the caller says so (`lite`), and then only for network skills without a clone. Anything we
+ *  can't judge keeps the full image. A lite request that doesn't fit is refused with the reason, not silently widened. */
+export function podCommandImageFor(skills: readonly string[], clone: boolean, lite = false): string {
+  if (!lite) return 'elanous-harness:local';
+  if (clone) throw new Error('pod command: --lite 는 clone 없는 명령만 받는다(lite 이미지는 git·빌드 도구가 적다)');
+  const outside = skills.filter((skill) => !(POD_NETWORK_SKILLS as readonly string[]).includes(skill));
+  if (skills.length === 0 || outside.length > 0) {
+    throw new Error(`pod command: --lite 는 네트워크 스킬(${POD_NETWORK_SKILLS.join('·')})만 받는다${outside.length ? ` — 벗어난 스킬: ${outside.join(', ')}` : ' — --skill 이 없다'}`);
+  }
+  return POD_LITE_IMAGE;
+}
+
 const COMMAND_LOG_CHARS = 80;
 
 const GATE = `ok=0
@@ -212,8 +230,10 @@ export interface RunPodCommandOptions {
   clone?: boolean;
   hostMirror?: string;
   bunCache?: string;
-  /** 컨테이너 메모리 한도(기본 16Gi). */
+  /** 컨테이너 메모리 한도(기본 16Gi · lite 면 2Gi). */
   memoryLimit?: string;
+  /** POD7: 호출부가 «네트워크 스킬만 쓰는 명령»이라고 말할 때만 lite 이미지 ⊕ 2Gi. */
+  lite?: boolean;
   source?: PodSource;
   ghToken?: () => string;
   deadlineSeconds?: number;
@@ -266,7 +286,8 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
   const baseKubectl = options.kubectl ?? defaultKubectl;
   const sleep = options.sleep ?? ((ms: number) => new Promise<void>((r) => setTimeout(r, ms)));
   const namespace = options.namespace ?? 'elanous-test';
-  const image = options.image ?? 'elanous-harness:local';
+  const image = options.image ?? podCommandImageFor(skills, options.clone === true, options.lite === true);
+  const memoryLimit = options.memoryLimit ?? (image === POD_LITE_IMAGE ? POD_LITE_MEMORY_LIMIT : undefined);
   const repoUrl = options.repoUrl ?? 'https://github.com/ElanvitalAI/elanous';
   const deadlineSeconds = options.deadlineSeconds ?? POD_COMMAND_DEADLINE_SECONDS;
   // POD1 (10-01): two launches in the same moment got the same `si-cmd-<time>` and the failing one's cleanup
@@ -328,8 +349,9 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
           localImageCommit: () => podImageFreshness({ image }).imageCommit,
         });
     if (pool && member) {
-      const { podSkillsDigest, resolvePodSkills } = await import('./pod-skills.js');
-      const localSkillsDigest = options.kubectl ? null : podSkillsDigest(resolvePodSkills(env).skills).digest;
+      const localSkillsDigest = options.kubectl ? null : image === POD_LITE_IMAGE
+        ? podSkillsDigest(POD_NETWORK_SKILLS, resolve(import.meta.dir, '../../../skills')).digest
+        : podSkillsDigest(resolvePodSkills(env).skills).digest;
       const syncs = await (options.syncImages ?? syncPoolImages)([member], image, imageCommit, { localSkillsDigest });
       const synced = syncs.get(member.context);
       if (synced && !synced.ok) throw new Error(`pod command: 이미지 판을 못 맞췄다: ${synced.detail}`);
@@ -345,7 +367,7 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       name, namespace, launch, image: member?.imageRef ?? image,
       ...(member?.imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}),
       repoUrl, command, skills, ...(llm ? { llm } : {}), ...(options.clone ? { clone: true } : {}),
-      ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), ...(bunCache ? { bunCache } : {}), ...(options.memoryLimit ? { memoryLimit: options.memoryLimit } : {}), deadlineSeconds,
+      ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), ...(bunCache ? { bunCache } : {}), ...(memoryLimit ? { memoryLimit } : {}), deadlineSeconds,
       ...(options.runId ? { runId: options.runId } : {}),
     });
     kubectl(['-n', namespace, 'delete', 'job', '-l', own, '--ignore-not-found']);