elanous 0.2.42 → 0.2.43

package/src/dashboard/mission-cli-consumer.ts

@@ -2,6 +2,7 @@ import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { spawnElanous } from '../instance/spawn-elanous.js';
+import type { AgentCliPreparation } from '../agent-mission/tool-install.js';
 
 export interface ClassicMissionCliResult {
   ok: boolean;
@@ -58,6 +59,7 @@ export interface MissionCliConsumerDeps {
   runCli?: typeof runCli;
   delay?: (ms: number) => Promise<void>;
   now?: () => number;
+  prepareAgentCli?: (agent: 'codex' | 'claude') => Promise<AgentCliPreparation>;
 }
 
 export interface StartedClassicMissionCliJob {
@@ -92,11 +94,20 @@ export async function cancelClassicMissionCli(interactionId: string, executeCli:
 export async function startClassicMissionCli(input: {
   agent: 'codex' | 'claude';
   prompt: string;
+  linearIssueId?: string;
   onInteractionId?: (interactionId: string) => void;
 }, deps: MissionCliConsumerDeps = {}): Promise<StartClassicMissionCliResult> {
   const executeCli = deps.runCli ?? runCli;
   const wait = deps.delay ?? delay;
   const now = deps.now ?? Date.now;
+  if (deps.prepareAgentCli) {
+    try {
+      const prepared = await deps.prepareAgentCli(input.agent);
+      if (!prepared.ready) return { ok: false, status: 'failed', path: '', error: prepared.message };
+    } catch {
+      return { ok: false, status: 'failed', path: '', error: `${input.agent}: 설치·로그인 상태를 확인하지 못했습니다` };
+    }
+  }
   const tempRoot = mkdtempSync(join(tmpdir(), 'elanous-classic-mission-'));
   const promptPath = join(tempRoot, 'prompt.txt');
   const outputPath = join(tempRoot, 'result.md');
@@ -105,7 +116,8 @@ export async function startClassicMissionCli(input: {
   try {
     writeFileSync(promptPath, input.prompt, { encoding: 'utf8', mode: 0o600 });
     const launched = parseJson<{ missionId: string; status: 'running' }>(await executeCli([
-      'mission', 'run', '--agent', input.agent, '--prompt-file', promptPath, '--out', outputPath, '--json',
+      'mission', 'run', '--agent', input.agent, '--prompt-file', promptPath, '--out', outputPath,
+      ...(input.linearIssueId ? ['--linear-issue-id', input.linearIssueId] : []), '--json',
     ]));
     if (!isClassicMissionId(launched.missionId) || launched.status !== 'running') throw new Error('Mission CLI returned an invalid interaction ID');
     interactionId = launched.missionId;
@@ -113,17 +125,17 @@ export async function startClassicMissionCli(input: {
     const completion = (async (): Promise<ClassicMissionCliResult> => {
       try {
         while (now() - startedAt < MAX_WAIT_MS) {
-          const status: MissionStatus = parseJson<MissionStatus>(await executeCli(['mission', 'status', interactionId!, '--json']));
-          if (status.missionId !== interactionId) throw new Error('Mission status did not match its interaction ID');
+          const missionStatus: MissionStatus = parseJson<MissionStatus>(await executeCli(['mission', 'status', interactionId!, '--json']));
+          if (missionStatus.missionId !== interactionId) throw new Error('Mission status did not match its interaction ID');
           // `eln mission status --json` exposes completed records as `done`.
           // Keep `completed` accepted for compatible bridges and existing callers.
-          if (status.status === 'done' || status.status === 'completed') {
-            if (typeof status.result !== 'string' || !status.result.trim()) throw new Error('Mission completed without a final answer');
-            return { ok: true, status: 'completed', interactionId, path: outputPath, content: status.result };
+          if (missionStatus.status === 'done' || missionStatus.status === 'completed') {
+            if (typeof missionStatus.result !== 'string' || !missionStatus.result.trim()) throw new Error('Mission completed without a final answer');
+            return { ok: true, status: 'completed', interactionId, path: outputPath, content: missionStatus.result };
           }
-          if (status.status !== 'running') return {
+          if (missionStatus.status !== 'running') return {
             ok: false,
-            status: status.status === 'cancelled' ? 'cancelled' : 'failed',
+            status: missionStatus.status === 'cancelled' ? 'cancelled' : 'failed',
             interactionId,
             path: outputPath,
             error: 'Mission did not complete successfully',

package/src/dashboard/plugin-wizard-runtime.ts

@@ -0,0 +1,50 @@
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { createTaskPluginWizardHostDeps, type TaskPluginWizardHostResult } from '../cli/task-plugin-wizard-host.js';
+import { defaultTaskLauncher } from '../cli/tasks-cli.js';
+import { handTask, type HandTaskOptions } from '../task-agent/task-hand.js';
+import { TASK_CARD_PREFIX } from '../task-agent/task-card-prefix.js';
+import type { PluginMaker, PluginWizardDeps } from '../graph-wizard/mission-compose.js';
+import { createTuiPluginWizardTool, type TuiPluginWizardTool } from './plugin-wizard-tool.js';
+import type { TuiPluginWizardRequest } from './plugin-wizard-tool.js';
+
+export interface DashboardPluginWizardRuntimePorts {
+  runMissionPair: (request: {
+    runId: string;
+    prompt: string;
+    context?: TuiPluginWizardRequest['context'];
+  }) => Promise<Partial<Record<PluginMaker, TaskPluginWizardHostResult>>>;
+  getWorkspace: () => string;
+  taskHand?: (options: HandTaskOptions) => Promise<unknown>;
+  launcher?: HandTaskOptions['launcher'];
+  onEvent?: PluginWizardDeps['onEvent'];
+}
+
+/** Connect the TUI entry tool to handTask and the existing plugin composer without blocking the ACP turn. */
+export function createDashboardPluginWizardRuntime(ports: DashboardPluginWizardRuntimePorts): TuiPluginWizardTool {
+  return createTuiPluginWizardTool(async (request) => {
+    const pluginWizardDeps = createTaskPluginWizardHostDeps({
+      runMissionPair: ({ prompt }) => ports.runMissionPair({ runId: request.runId, prompt, ...(request.context ? { context: request.context } : {}) }),
+      onEvent: ports.onEvent ?? ((event) => {
+        if (event.step !== 'validate' || !event.detail || typeof event.detail !== 'object') return;
+        const winner = (event.detail as { winner?: unknown }).winner;
+        if (winner) debug.log('wizard.validate', 'winner-adopted', { runId: event.wizardId, ts: event.ts, winner });
+      }),
+    });
+    const runHandTask = ports.taskHand ?? handTask;
+    await runHandTask({
+      id: `${TASK_CARD_PREFIX}plugin-${request.runId.replaceAll('-', '').slice(0, 20)}`,
+      text: request.mission,
+      seat: 'TC',
+      live: true,
+      launcher: ports.launcher ?? defaultTaskLauncher,
+      pluginWizard: {
+        missing: request.missing,
+        root: effectiveInstanceRoot(),
+        workspace: ports.getWorkspace(),
+        wizardId: request.runId,
+      },
+      pluginWizardDeps,
+    });
+  });
+}

package/src/dashboard/plugin-wizard-tool.ts

@@ -0,0 +1,55 @@
+import { randomUUID } from 'node:crypto';
+import { debug } from '../debug/log.js';
+import type { LLMToolSpec } from '../llm.js';
+import type { ClassicSidetabMissionDispatchContext } from './classic-sidetab-mission.js';
+
+export const TUI_PLUGIN_WIZARD_TOOL_NAME = 'StartPluginWizard';
+
+export interface TuiPluginWizardRequest {
+  runId: string;
+  mission: string;
+  missing: string;
+  context?: ClassicSidetabMissionDispatchContext;
+}
+
+export interface TuiPluginWizardTool {
+  getTools(existing: readonly LLMToolSpec[]): LLMToolSpec[];
+  dispatchTool(name: string, args: unknown, context?: ClassicSidetabMissionDispatchContext): Promise<unknown> | undefined;
+}
+
+/** Add a non-blocking TUI entry point; the injected host runs the shared task/plugin-wizard path. */
+export function createTuiPluginWizardTool(start: (request: TuiPluginWizardRequest) => Promise<void>, createId: () => string = randomUUID): TuiPluginWizardTool {
+  const spec: LLMToolSpec = {
+    name: TUI_PLUGIN_WIZARD_TOOL_NAME,
+    description: 'When a needed capability is missing, start the plugin wizard in this TUI session. It asks a short question, searches trusted plugins, and if needed launches the visible Codex and Claude side-tab pair. Returns a run ID immediately; check the task notification for completion.',
+    parameters: {
+      type: 'object',
+      properties: {
+        mission: { type: 'string', minLength: 1, description: 'The active task to complete after installing or creating the tool.' },
+        missing: { type: 'string', minLength: 1, description: 'The missing tool or capability.' },
+      },
+      required: ['mission', 'missing'],
+      additionalProperties: false,
+    },
+  };
+
+  return {
+    getTools: (existing) => [...existing, spec],
+    dispatchTool(name, args, context) {
+      if (name !== TUI_PLUGIN_WIZARD_TOOL_NAME) return undefined;
+      const output = (status: 'running' | 'error', body: string, id: string | null = null) => ({ status, body, artifacts: [], id });
+      if (!args || typeof args !== 'object' || Array.isArray(args)) return Promise.resolve(output('error', 'arguments must be an object'));
+      const input = args as Record<string, unknown>;
+      if (Object.keys(input).some((key) => key !== 'mission' && key !== 'missing')) return Promise.resolve(output('error', 'arguments contain unsupported fields'));
+      const mission = typeof input.mission === 'string' ? input.mission.trim() : '';
+      const missing = typeof input.missing === 'string' ? input.missing.trim() : '';
+      if (!mission || !missing) return Promise.resolve(output('error', 'mission and missing capability are required'));
+      const runId = createId();
+      void Promise.resolve().then(() => start({ runId, mission, missing, ...(context ? { context } : {}) })).catch((error) => {
+        try { debug.log('plugin-wizard.tool', 'start-failed', { runId, reason: error instanceof Error ? error.message : String(error) }, { level: 'error' }); }
+        catch { /* failure reporting must not re-enter the tool boundary */ }
+      });
+      return Promise.resolve(output('running', `Plugin wizard started in the background (run ${runId}).`, runId));
+    },
+  };
+}

package/src/dashboard/sidetab-runtime.ts

@@ -7,7 +7,7 @@ export interface DashboardLocalAgentSession {
   id: string;
   title: string;
   kind: 'shell' | 'coding-agent';
-  agentBrand?: 'claude-code' | 'codex' | 'gemini';
+  agentBrand?: 'claude-code' | 'codex' | 'gemini' | 'grok';
   state: 'foreground' | 'background' | 'exited';
 }
 

package/src/dashboard/terminal-popup-runtime.ts

@@ -1,10 +1,10 @@
 import type { TerminalSession } from '../terminal/session-registry.js';
 
-export type DashboardTerminalPopupAgentBrand = 'claude-code' | 'codex' | 'gemini';
+export type DashboardTerminalPopupAgentBrand = 'claude-code' | 'codex' | 'gemini' | 'grok';
 
 export type DashboardTerminalPopupRequest =
   | { kind: 'shell'; cwd: string; command?: string; env?: Record<string, string> }
-  | { kind: 'coding-agent'; brand: DashboardTerminalPopupAgentBrand; cwd: string; extraArgs?: readonly string[] };
+  | { kind: 'coding-agent'; brand: DashboardTerminalPopupAgentBrand; cwd: string; extraArgs?: readonly string[]; env?: Record<string, string>; id?: string };
 
 export interface DashboardTerminalPopupRuntimeDeps {
   onMissingCwd: () => void;
@@ -15,6 +15,7 @@ export interface DashboardTerminalPopupBuilder {
   cwd(cwd: string): DashboardTerminalPopupBuilder;
   command(command: string): DashboardTerminalPopupBuilder;
   env(env: Record<string, string>): DashboardTerminalPopupBuilder;
+  id(id: string): DashboardTerminalPopupBuilder;
   args(extraArgs: readonly string[]): DashboardTerminalPopupBuilder;
   open(): TerminalSession | null;
 }
@@ -34,11 +35,13 @@ export function createDashboardTerminalPopupRuntime(
     let cwd: string | null = null;
     let command: string | undefined;
     let env: Record<string, string> | undefined;
+    let id: string | undefined;
     let args: readonly string[] | undefined;
     return {
       cwd(next) { cwd = next; return this; },
       command(next) { command = next; return this; },
       env(next) { env = next; return this; },
+      id(next) { id = next; return this; },
       args(next) { args = next; return this; },
       open() {
         if (cwd === null) {
@@ -47,7 +50,7 @@ export function createDashboardTerminalPopupRuntime(
         }
         const req: DashboardTerminalPopupRequest = kind === 'shell'
           ? { kind: 'shell', cwd, command, env }
-          : { kind: 'coding-agent', brand: kind, cwd, extraArgs: args };
+          : { kind: 'coding-agent', brand: kind, cwd, ...(args ? { extraArgs: args } : {}), ...(env ? { env } : {}), ...(id ? { id } : {}) };
         return deps.openInteractiveTerminalPopup(req);
       },
     };

package/src/decisions/linear-progress-summary.ts

@@ -0,0 +1,78 @@
+import type { DecisionEntry } from './decision-ledger.js';
+import type { Checklist, ChecklistHistory, ChecklistItem } from '../release-loop/checklist.js';
+
+const LINEAR_ISSUE = /\bELA-[A-Z0-9]+\b/gi;
+const PULL_URL = /https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/\d+/g;
+
+export interface LinearProgressSummary {
+  issue: string;
+  day: string;
+  body: string;
+}
+
+function issueRefs(text: string): string[] {
+  return [...new Set(text.match(LINEAR_ISSUE) ?? [])].map(value => value.toUpperCase());
+}
+
+function eventIssues(item: ChecklistItem): string[] {
+  return issueRefs(`${item.title}\n${item.evidence ?? ''}\n${item.refs?.join('\n') ?? ''}`);
+}
+
+function short(value: unknown): string {
+  return typeof value === 'string' ? value.replace(/[\r\n]+/g, ' ').trim().slice(0, 80) : '미상';
+}
+
+/** Build non-sensitive daily summaries from local ledgers; this function performs no network or file writes. */
+export function buildLinearProgressSummaries(input: {
+  checklist: Checklist;
+  history: readonly ChecklistHistory[];
+  decisions: readonly DecisionEntry[];
+  since: string;
+  now?: Date;
+}): LinearProgressSummary[] {
+  const since = Date.parse(input.since);
+  if (!Number.isFinite(since)) throw new Error('since must be a valid timestamp');
+  const now = input.now ?? new Date();
+  const day = now.toISOString().slice(0, 10);
+  const cells = new Map(input.checklist.items.map(item => [item.id, item]));
+  const grouped = new Map<string, string[]>();
+  const add = (issue: string, line: string) => {
+    const lines = grouped.get(issue) ?? [];
+    if (!lines.includes(line)) lines.push(line);
+    grouped.set(issue, lines);
+  };
+
+  for (const event of input.history) {
+    if (Date.parse(event.at) < since) continue;
+    const item = cells.get(event.id);
+    if (!item || event.field !== 'status') continue;
+    for (const issue of eventIssues(item)) add(issue, `칸 ${item.id}: ${short(event.from)} → ${short(event.to)}`);
+  }
+
+  for (const decision of input.decisions) {
+    const changed = decision.history.filter(event => event.at && Date.parse(event.at) >= since);
+    if (!changed.length) continue;
+    for (const ref of decision.refs ?? []) for (const issue of issueRefs(ref)) {
+      const latest = changed.at(-1)!;
+      add(issue, `결정 ${decision.id}: ${latest.type === 'decided' ? `확정 ${short(latest.choice)}` : latest.type}`);
+    }
+  }
+
+  for (const item of input.checklist.items) {
+    if (item.status === 'green' || item.status === 'done') continue;
+    for (const issue of eventIssues(item)) add(issue, `다음: ${item.id}`);
+  }
+
+  for (const event of input.history) {
+    if (Date.parse(event.at) < since || !['evidence', 'evidence.add'].includes(event.field)) continue;
+    const item = cells.get(event.id);
+    if (!item) continue;
+    const pulls = String(event.to ?? '').match(PULL_URL) ?? [];
+    for (const issue of eventIssues(item)) for (const url of pulls) add(issue, `PR: ${url}`);
+  }
+
+  return [...grouped].sort(([a], [b]) => a.localeCompare(b)).map(([issue, lines]) => {
+    const body = [`진행 요약 · ${day}`, ...lines].join('\n');
+    return { issue, day, body };
+  });
+}

package/src/decisions/linear-progress-sync.ts

@@ -0,0 +1,152 @@
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync, writeSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { commentLinearIssue } from '../connectors/linear.js';
+import { debug } from '../debug/log.js';
+import { getSecretAsync } from '../nexus/config/secrets/index.js';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import { DecisionLedger } from './decision-ledger.js';
+import { buildLinearProgressSummaries, type LinearProgressSummary } from './linear-progress-summary.js';
+import { checklistHistory, listChecklist } from '../release-loop/checklist.js';
+
+type SentState = Record<string, true>;
+type IssueLookup = { issue?: { id?: string; team?: { key?: string }; comments?: { nodes?: Array<{ body?: string }> } } };
+
+export interface LinearProgressSyncResult {
+  day: string;
+  planned: number;
+  posted: number;
+  skipped: number;
+  failed: number;
+  plan: Array<{ issue: string; body: string; action: 'post' | 'already-posted' | 'team-mismatch' }>;
+}
+
+function readState(path: string): SentState {
+  if (!existsSync(path)) return {};
+  const value: unknown = JSON.parse(readFileSync(path, 'utf8'));
+  const invalid = !value || typeof value !== 'object' || Array.isArray(value)
+    || Object.entries(value).some(([key, row]) => !/^\d{4}-\d{2}-\d{2}:ELA-[A-Z0-9]+$/.test(key)
+      || (row !== true && (!row || typeof row !== 'object' || Array.isArray(row))));
+  if (invalid) {
+    throw new Error('invalid Linear progress sync state');
+  }
+  // Older entries stored write-only fingerprint/postedAt metadata. Normalize them to the marker that skip logic reads.
+  return Object.fromEntries(Object.keys(value).map(key => [key, true]));
+}
+
+function saveState(path: string, state: SentState): void {
+  const temp = `${path}.${process.pid}.tmp`;
+  try {
+    writeFileSync(temp, JSON.stringify(state), { mode: 0o600 });
+    renameSync(temp, path);
+  } finally { if (existsSync(temp)) unlinkSync(temp); }
+}
+
+async function lookupIssue(apiKey: string, identifier: string, fetchFn: typeof fetch): Promise<IssueLookup['issue']> {
+  const response = await fetchFn('https://api.linear.app/graphql', {
+    method: 'POST', headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ query: 'query ProgressIssue($id: String!) { issue(id: $id) { id team { key } comments(first: 100) { nodes { body } } } }', variables: { id: identifier } }),
+  });
+  if (!response.ok) throw new Error(`Linear GraphQL HTTP ${response.status}`);
+  const body = await response.json() as { data?: IssueLookup; errors?: unknown[] };
+  if (body.errors?.length || !body.data) throw new Error('Linear GraphQL issue lookup failed');
+  return body.data.issue;
+}
+
+function marker(summary: LinearProgressSummary): string { return `progress-sync:${summary.day}:${summary.issue}`; }
+
+function summaries(version: string, now: Date): LinearProgressSummary[] {
+  const checklist = listChecklist(version);
+  const history = [...new Set(checklist.items.map(item => item.id))].flatMap(id => checklistHistory(id));
+  const since = `${now.toISOString().slice(0, 10)}T00:00:00.000Z`;
+  return buildLinearProgressSummaries({ checklist, history, decisions: new DecisionLedger().list({ status: 'all' }), since, now });
+}
+
+/** Plan is read-only by default. `live` sends at most one marked comment per issue per UTC day. */
+export async function syncLinearProgress(options: {
+  version: string;
+  live?: boolean;
+  now?: Date;
+  fetch?: typeof fetch;
+  getSecret?: (name: string) => Promise<string | undefined>;
+  ledgerRoot?: string;
+  /** Injection seam for deterministic sync tests; normal callers use the local ledgers. */
+  buildSummaries?: (version: string, now: Date) => LinearProgressSummary[];
+}): Promise<LinearProgressSyncResult> {
+  const now = options.now ?? new Date();
+  const plans = (options.buildSummaries ?? summaries)(options.version, now);
+  const result: LinearProgressSyncResult = { day: now.toISOString().slice(0, 10), planned: plans.length, posted: 0, skipped: 0, failed: 0,
+    plan: plans.map(summary => ({ issue: summary.issue, body: summary.body, action: 'post' })) };
+  if (!options.live) {
+    for (const item of result.plan) debug.log('linear.progress-sync', 'planned', { issue: item.issue, day: result.day });
+    return result;
+  }
+
+  const apiKey = await (options.getSecret ?? getSecretAsync)('connector.linear.apiKey');
+  if (!apiKey) throw new Error('Linear credential missing');
+  const ledgerRoot = options.ledgerRoot ?? releaseLedgerRoot();
+  const directory = join(ledgerRoot, 'release');
+  mkdirSync(directory, { recursive: true });
+  const path = join(directory, 'linear-progress-sync.json');
+  const lockPath = `${path}.lock`;
+  let lock: number | undefined;
+  const deadline = Date.now() + 10_000;
+  for (;;) {
+    try { lock = openSync(lockPath, 'wx', 0o600); writeSync(lock, `${process.pid}`); break; }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+      try {
+        const pid = Number(readFileSync(lockPath, 'utf8'));
+        if (Number.isSafeInteger(pid) && pid > 0 && Date.now() - statSync(lockPath).mtimeMs > 30_000) {
+          try { process.kill(pid, 0); }
+          catch (probe) { if ((probe as NodeJS.ErrnoException).code === 'ESRCH') { unlinkSync(lockPath); continue; } }
+        }
+      } catch (probe) { if ((probe as NodeJS.ErrnoException).code === 'ENOENT') continue; }
+      if (Date.now() >= deadline) throw new Error('Linear progress sync lock timeout');
+      await Bun.sleep(25);
+    }
+  }
+  try {
+    const state = readState(path);
+    const fetchFn = options.fetch ?? fetch;
+    for (const summary of plans) {
+      const key = `${summary.day}:${summary.issue}`;
+      if (state[key]) {
+        result.skipped++;
+        result.plan.find(item => item.issue === summary.issue)!.action = 'already-posted';
+        debug.log('linear.progress-sync', 'skipped', { issue: summary.issue, day: summary.day, reason: 'already-posted' });
+        continue;
+      }
+      try {
+        const issue = await lookupIssue(apiKey, summary.issue, fetchFn);
+        if (!issue?.id) throw new Error('Linear issue not found');
+        if (issue.team?.key !== 'DEMO') {
+          result.skipped++;
+          result.plan.find(item => item.issue === summary.issue)!.action = 'team-mismatch';
+          debug.log('linear.progress-sync', 'skipped', { issue: summary.issue, day: summary.day, reason: 'team-not-allowed' });
+          continue;
+        }
+        if ((issue.comments?.nodes ?? []).some(comment => comment.body?.includes(marker(summary)))) {
+          state[key] = true;
+          saveState(path, state);
+          result.skipped++;
+          result.plan.find(item => item.issue === summary.issue)!.action = 'already-posted';
+          debug.log('linear.progress-sync', 'skipped', { issue: summary.issue, day: summary.day, reason: 'remote-marker-found' });
+          continue;
+        }
+        const body = `${summary.body}\n\n_${marker(summary)}_`;
+        await commentLinearIssue({ apiKey, issueId: issue.id, body, fetch: fetchFn });
+        state[key] = true;
+        saveState(path, state);
+        result.posted++;
+        debug.log('linear.progress-sync', 'posted', { issue: summary.issue, day: summary.day });
+      } catch (error) {
+        result.failed++;
+        const reason = error instanceof Error ? (/^Linear GraphQL HTTP \d{3}$/.test(error.message) ? error.message : error.name) : 'unknown';
+        debug.log('linear.progress-sync', 'failed', { issue: summary.issue, day: summary.day, reason });
+      }
+    }
+    return result;
+  } finally {
+    if (lock !== undefined) { closeSync(lock); unlinkSync(lockPath); }
+  }
+}

package/src/domains/outbound-alert.ts

@@ -119,10 +119,42 @@ export function kstMinutes(now: Date = new Date()): number {
   return ((h ?? 0) % 24) * 60 + (m ?? 0);
 }
 
-/** 야간 무음 창(00:00 ≤ t < 06:30 KST). 아침리포트(06:25)는 별도 경로라 비대상. */
+export const OUTBOUND_QUIET_HOURS_ENV = 'ELANOUS_OUTBOUND_QUIET_HOURS';
+const DEFAULT_QUIET_HOURS = '00:00-06:30';
+type QuietHours = 'off' | { start: number; end: number; label: string };
+
+/** `off` 또는 HH:MM-HH:MM 을 분 범위로 해석한다. 잘못된 설정은 기본값에 맡긴다. */
+function parseQuietHours(value: unknown): QuietHours | null {
+  if (value === 'off') return 'off';
+  if (typeof value !== 'string') return null;
+  const match = /^(\d{2}):(\d{2})-(\d{2}):(\d{2})$/.exec(value.trim());
+  if (!match) return null;
+  const [, sh, sm, eh, em] = match;
+  const startHour = Number(sh), startMinute = Number(sm), endHour = Number(eh), endMinute = Number(em);
+  if (startHour > 23 || endHour > 23 || startMinute > 59 || endMinute > 59) return null;
+  const start = startHour * 60 + startMinute, end = endHour * 60 + endMinute;
+  if (start === end) return null;
+  return { start, end, label: `${sh}:${sm}-${eh}:${em}` };
+}
+
+/** config.outbound.quietHours > ELANOUS_OUTBOUND_QUIET_HOURS > 기존 기본 창. */
+function configuredQuietHours(): QuietHours {
+  try {
+    const configValue = parseQuietHours(getUserConfig().outbound?.quietHours);
+    if (configValue) return configValue;
+  } catch { /* use env/default */ }
+  const envValue = parseQuietHours(process.env[OUTBOUND_QUIET_HOURS_ENV]?.trim());
+  return envValue ?? parseQuietHours(DEFAULT_QUIET_HOURS)!;
+}
+
+/** 야간 무음 창. 기본은 기존 00:00 ≤ t < 06:30 KST. */
 export function inQuietHours(now: Date = new Date()): boolean {
-  const m = kstMinutes(now);
-  return m >= 0 && m < 390;
+  const quiet = configuredQuietHours();
+  if (quiet === 'off') return false;
+  const minute = kstMinutes(now);
+  return quiet.start < quiet.end
+    ? minute >= quiet.start && minute < quiet.end
+    : minute >= quiet.start || minute < quiet.end;
 }
 
 /** 최근 사용자 활동 우회 창(분) — 이 시간 내 genuine 사용자 인텐트가 있으면 무음이어도 즉시 발송. */
@@ -465,11 +497,14 @@ export function flushDeferred(path = DEFERRED_PATH, deps: FlushDeferredDeps = {}
 
 /** TEST-PROD-LEAK — a test process may not reach a real bot or the ops daemon. `external` = a third-party bot API
  *  (refused unless curl is a test double replacing the real one); the local daemon is refused only when ops-routed. */
-function assertTestSendFaked(what: string, external = true): void {
+function assertTestSendFaked(what: string, external = true, injectedTransport?: unknown): void {
   let roots: string[] = [];
   try { roots = [getElanousConfigDir(), dirname(ACP_TOKEN_PATH), effectiveInstanceRoot(), conatusDataDir(), dirname(DEFERRED_PATH)]; }
   catch { roots = [dirname(ACP_TOKEN_PATH), dirname(DEFERRED_PATH)]; }
-  assertNoRealSendFromTest(what, { transportFaked: isTestDouble(childProcess.execFileSync, REAL_EXEC_FILE_SYNC), routingRoots: roots, external });
+  const transportFaked = injectedTransport === undefined
+    ? isTestDouble(childProcess.execFileSync, REAL_EXEC_FILE_SYNC)
+    : isTestDouble(injectedTransport);
+  assertNoRealSendFromTest(what, { transportFaked, routingRoots: roots, external });
 }
 
 /** 동기 curl(POST). body 는 stdin. 파싱 실패/에러 → null. `what` names the send for the test guard (never the URL — it carries the token). */
@@ -509,25 +544,28 @@ export function sendOutbound(text: string, kind = 'alert', origin?: (MissionOrig
     : 'unknown');
   ensureOutboundLogSink();
   let bot = origin?.channel === 'discord' ? 'discord:configured' : 'unknown';
+  const quietConfig = configuredQuietHours();
+  const quietMode = quietConfig === 'off' ? 'off' : `window:${quietConfig.label}`;
   const logOutcome = (event: 'sent' | 'deferred' | 'failed', path?: string): void => {
-    try { debug.log('outbound.send', event, { kind: safeObservationLabel(kind), source: safeObservationLabel(source), chars: text.length, bot, ...(path ? { path } : {}) }); } catch { /* fail-open */ }
+    try { debug.log('outbound.send', event, { kind: safeObservationLabel(kind), source: safeObservationLabel(source), chars: text.length, bot, quietMode, ...(path ? { path } : {}) }); } catch { /* fail-open */ }
   };
   // ★ 무음 우회(대표 2026-07-14) — 사용자가 최근(기본 30분) genuine 인텐트(타이핑/버튼탭)를 냈으면
   //   깨어있으므로 야간 무음이어도 즉시 발송(사용자 발원 흐름의 결과물이 아침까지 묶이지 않게).
   //   우회 시 flushDeferred 로 그간 보류분도 함께 전달(사용자가 지금 볼 수 있음).
-  if (inQuietHours() && !userRecentlyActive()) {
+  const quietNow = inQuietHours();
+  if (quietNow && !userRecentlyActive()) {
     const queued = deferOutbound(text, kind, origin);
     if (queued) recordOutbound(text, kind); // 성공한 보류만 회상 대상
     logOutcome(queued ? 'deferred' : 'failed', queued ? 'deferred' : 'queue-failed');
     return queued; // 적재가 성공했을 때만 보류 수락
   }
-  const bypass = inQuietHours();
+  const bypass = quietNow;
   if (bypass) console.error('[outbound] 야간 무음 우회 — 최근 사용자 활동(깨어있음) → 즉시 발송 + 보류분 flush');
   try { flushDeferred(); } catch { /* fail-soft */ }
   // ★ 발송 관측(대표 지시) — 발송 시각·mode·밀림(burst) 판정을 logs.db 에. burst=최근 2분 5건+
   //   (몰려 나가는 중 = 밀림 의심). `elanous logs --category outbound.send` 로 실시간/밀림 구분.
   const { recentCount, burst } = recentSendBurst();
-  logSend(bypass ? 'quiet-bypass' : 'realtime', kind, { burst, recentCount, ...(burst ? { backlog: true } : {}) });
+  logSend(bypass ? 'quiet-bypass' : 'realtime', kind, { burst, recentCount, quietMode, ...(burst ? { backlog: true } : {}) });
   // ★ origin 되돌림(무음 밖) — 발신 채널로 직접 발송. 성공 시 종료, 실패면 report 폴백.
   if (origin && deliverToOrigin(origin, text, (label) => { bot = label; })) {
     recordOutbound(text, kind);
@@ -706,8 +744,8 @@ export function sendTelegramDirect(
   onBot?: (bot: string) => void,
 ): boolean {
   const sendRaw = (token: string, chatId: string | number, body: string): boolean => {
-    // The transport is checked only after a route is eligible; a test double cannot target the ops universe.
-    assertTestSendFaked('send a real Telegram message', !deps.sendRaw);
+    // The transport is checked only after a route is eligible; injected transports must themselves be test doubles.
+    assertTestSendFaked('send a real Telegram message', true, deps.sendRaw);
     return (deps.sendRaw ?? sendTelegramRaw)(token, chatId, body);
   };
   let cfg: UserConfig | undefined;

package/src/domains/telegram-kind-route.ts

@@ -36,16 +36,23 @@ function operationsBotToken(cfg: UserConfig): string | undefined {
   const tradingTokens = new Set(channels.filter(c => c.roles.includes('report')).map(c => c.botToken));
   // The report (trading) bot is never the operations bot — with or without a channels table (review must-fix · OUT1).
   if (cfg.telegram.reportChannel?.botToken) tradingTokens.add(cfg.telegram.reportChannel.botToken);
+  // An explicit operational channel is authoritative even when env/tokenRef/legacy botToken
+  // resolves first; those older sources can point at a different (or trading) bot.
+  const operationalChannels = channels.filter(c => (c.name === 'ops' && c.roles.includes('system'))
+    || (c.name === 'main' && c.roles.some(r => r === 'system' || r === 'qa' || r === 'default')));
+  if (operationalChannels.length > 0) {
+    const tokens = new Set(operationalChannels.filter(c => !tradingTokens.has(c.botToken)).map(c => c.botToken));
+    if (tokens.size !== 1) return undefined;
+    const explicitToken = tokens.values().next().value;
+    // The explicitly named operational channel outranks the generic tab's tokenRef;
+    // legacy/env conflicts without a trading identity remain ambiguous and fail closed.
+    if (main.source !== 'channels.main' && main.source !== 'tokenRef'
+      && main.token && main.token !== explicitToken && !tradingTokens.has(main.token)) return undefined;
+    return explicitToken;
+  }
+
   if (main.source !== 'channels.main') return main.token && !tradingTokens.has(main.token) ? main.token : undefined;
-  // channels.main may mean "first channel", which can be the trading bot.
-  // Only a named operations channel (or the named main channel) with an
-  // operational role establishes identity; array order and role alone do not.
-  const tokens = new Set(channels
-    .filter(c => (c.name === 'ops' && c.roles.includes('system'))
-      || (c.name === 'main' && c.roles.some(r => r === 'system' || r === 'qa' || r === 'default')))
-    .filter(c => !tradingTokens.has(c.botToken))
-    .map(c => c.botToken));
-  return tokens.size === 1 ? tokens.values().next().value : undefined;
+  return undefined;
 }
 
 function isAllowedBot(cfg: UserConfig, kind: string | undefined, token: string): boolean {

package/src/graph-runner/arg-allowance.ts

@@ -0,0 +1,13 @@
+export type AllowanceDecision =
+  | { readonly kind: 'run'; readonly requested: number; readonly granted: number; readonly clamped: boolean }
+  | { readonly kind: 'needs-human'; readonly requested: number; readonly remaining: 0 };
+
+/** Resolve a child allowance against the parent's remaining steps before spawning the child. */
+export function resolveChildAllowance(requested: number, parentRemaining: number): AllowanceDecision {
+  if (!Number.isSafeInteger(requested) || requested < 1) throw new Error('requested allowance must be a positive safe integer');
+  if (!(parentRemaining === Infinity || (Number.isSafeInteger(parentRemaining) && parentRemaining >= 0)))
+    throw new Error('parent remaining allowance must be a non-negative safe integer or Infinity');
+  if (parentRemaining === 0) return { kind: 'needs-human', requested, remaining: 0 };
+  const granted = Math.min(requested, parentRemaining);
+  return { kind: 'run', requested, granted, clamped: granted < requested };
+}

package/src/graph-runner/graph-run-api.ts

@@ -29,6 +29,8 @@ export interface GraphRunApiDeps {
   root?: string;
   run?: typeof runGraph;
   now?: () => number;
+  /** Allows a host-owned preview/demo request to stop an in-flight editor graph run. */
+  signal?: AbortSignal;
 }
 
 /** 시작 전에 죽은 런(레시피 없음 등)은 원장 파일이 안 생긴다 — 그 이유를 여기 잠깐 들고 있다가 상태 조회에 돌려준다. */
@@ -187,7 +189,7 @@ export function handleGraphRunStart(rawId: string, deps: GraphRunApiDeps = {}):
     return jsonResponse({ error: 'run-workspace-failed', reason: error instanceof Error ? error.message.slice(0, 200) : 'unknown' }, 500);
   }
   debug.log('graphs.run', 'started', { id, runId });
-  void (deps.run ?? runGraph)(join(work, 'graph.yaml'), { runId, input: { source: 'editor' }, deps: { root } })
+  void (deps.run ?? runGraph)(join(work, 'graph.yaml'), { runId, input: { source: 'editor' }, ...(deps.signal ? { signal: deps.signal } : {}), deps: { root } })
     .then((state) => debug.log('graphs.run', 'finished', { id, runId, status: state.status, executed: state.executed }))
     .catch((error: unknown) => {
       const message = error instanceof Error ? error.message : String(error);