elanous 0.2.22 → 0.2.23

package/src/briefing/brief-items.ts

@@ -20,6 +20,7 @@ export interface BriefWeeklyActions extends BriefActionCount {
 export type BriefDomain = (typeof BRIEF_DOMAINS)[number];
 export type BriefPriority = (typeof BRIEF_PRIORITIES)[number];
 export type BriefSlot = (typeof BRIEF_SLOTS)[number];
+export type BriefSendSlot = BriefSlot | 'realtime';
 
 const KST = 'Asia/Seoul';
 
@@ -95,6 +96,12 @@ function needsDecision(item: BriefItem, today: string): boolean {
   return item.priority === 'P0' || (item.deadline !== null && deadlineDate(item.deadline) === today);
 }
 
+/** Unsent decisions needing immediate delivery, using the same KST deadline rule as slot pages. */
+export function pendingRealtime(items: readonly BriefItem[], now: Date): BriefItem[] {
+  const today = dateKey(now, { timeZone: KST });
+  return items.filter(item => item.sent_at === null && needsDecision(item, today));
+}
+
 /**
  * One briefing page. Item text is copied verbatim.
  * Order: decisions due (P0, then a deadline of today) → domain groups →
@@ -105,13 +112,13 @@ export function composeBriefMarkdown(items: readonly BriefItem[], slot: BriefSlo
 }
 
 /** The ids are exactly the rows represented by the composed page, after deduplication. */
-export function composeBriefPage(items: readonly BriefItem[], slot: BriefSlot, now: Date): { markdown: string; ids: number[] } {
+export function composeBriefPage(items: readonly BriefItem[], slot: BriefSendSlot, now: Date): { markdown: string; ids: number[] } {
   const today = dateKey(now, { timeZone: KST });
   // A duplicate left out of a delivered page stays unsent in the ledger, but must not reappear on a later page.
   // A new undeliverable observation after a sent page is a new occurrence, not an old duplicate.
   const deliveredClaims = new Set(items.filter(item => item.sent_at !== null).map(item => normalizeClaim(item.text)));
-  const eligible = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now)
-    && (item.source === 'outbound.undeliverable' || !deliveredClaims.has(normalizeClaim(item.text))));
+  const candidates = slot === 'realtime' ? pendingRealtime(items, now) : items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now));
+  const eligible = candidates.filter(item => item.source === 'outbound.undeliverable' || !deliveredClaims.has(normalizeClaim(item.text)));
   // Duplicate claims keep the copy that needs a decision today (P0 or due today), then the higher priority, then the earliest (ACP must-fix).
   const rank = (item: BriefItem) => [needsDecision(item, today) ? 0 : 1, BRIEF_PRIORITIES.indexOf(item.priority), item.id];
   const better = (a: BriefItem, b: BriefItem) => { const x = rank(a), y = rank(b); return x[0]! - y[0]! || x[1]! - y[1]! || x[2]! - y[2]!; };
@@ -354,6 +361,7 @@ export class BriefItemsLedger {
    * requirement funnel contributes ephemeral lines without adding ledger rows.
    */
   compose(slot: string): string {
+    if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
     return this.composeWithIds(slot).markdown;
   }
 
@@ -361,7 +369,7 @@ export class BriefItemsLedger {
     return db.query('SELECT id, text, domain, priority, deadline, evidence, source, created_at, (SELECT MIN(sent_at) FROM sends WHERE sends.item_id = items.id) AS sent_at FROM items ORDER BY id').all() as BriefItem[];
   }
 
-  private pageFromDb(db: Database, slot: BriefSlot): { markdown: string; ids: number[] } {
+  private pageFromDb(db: Database, slot: BriefSendSlot): { markdown: string; ids: number[] } {
     const items = this.itemsFromDb(db);
     const now = this.now();
     const morningCutoff = Date.parse(`${dateKey(now, { timeZone: KST })}T08:30:00+09:00`);
@@ -383,26 +391,26 @@ export class BriefItemsLedger {
     const composed = composeBriefPage([...items, ...funnelItems], slot, now);
     // Ephemeral funnel lines appear on the page but have no ledger row to mark sent.
     const page = { markdown: composed.markdown, ids: composed.ids.filter(id => id > 0) };
-    const candidates = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now)).length;
+    const candidates = (slot === 'realtime' ? pendingRealtime(items, now) : items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now))).length;
     this.log('briefing.items', 'composed', { slot, candidates, bytes: Buffer.byteLength(page.markdown) });
     return page;
   }
 
   /** Read-only page and the exact ledger item ids printed on it (after deduplication). */
   composeWithIds(slot: string): { markdown: string; ids: number[] } {
-    if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
-    return this.using(db => this.pageFromDb(db, slot as BriefSlot));
+    if (slot !== 'realtime' && !(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
+    return this.using(db => this.pageFromDb(db, slot as BriefSendSlot));
   }
 
   /** Hold the ledger's SQLite writer lock from selecting unsent rows through delivery and marking.
    * A failed delivery rolls back and releases the lock; the next sender can retry.
    */
-  withSendLock<T>(slot: string, work: (page: { markdown: string; ids: number[] }, markSent: (ids: readonly number[], slot: BriefSlot) => number) => T): T {
-    if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
+  withSendLock<T>(slot: string, work: (page: { markdown: string; ids: number[] }, markSent: (ids: readonly number[], slot: BriefSendSlot) => number) => T): T {
+    if (slot !== 'realtime' && !(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
     return this.using(db => {
       db.exec('BEGIN IMMEDIATE');
       try {
-        const page = this.pageFromDb(db, slot as BriefSlot);
+        const page = this.pageFromDb(db, slot as BriefSendSlot);
         const result = work(page, (ids, sentSlot) => {
           if (sentSlot !== slot || ids.length !== page.ids.length || ids.some((id, index) => id !== page.ids[index])) {
             throw new BriefItemsInputError('marked ids must match composed page');
@@ -418,7 +426,7 @@ export class BriefItemsLedger {
     });
   }
 
-  private markSentInDb(db: Database, ids: readonly number[], slot: BriefSlot): number {
+  private markSentInDb(db: Database, ids: readonly number[], slot: BriefSendSlot): number {
     const at = this.now().toISOString();
     const insert = db.query('INSERT INTO sends (item_id, slot, sent_at) VALUES (?, ?, ?)');
     let count = 0;
@@ -431,8 +439,8 @@ export class BriefItemsLedger {
    * Records that these items went out in a slot (append-only); later composes leave them out (ACP must-fix).
    * Only an actual sender calls this — compose itself stays read-only (no flag marks items it did not send).
    */
-  markSent(ids: readonly number[], slot: BriefSlot): number {
-    if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
+  markSent(ids: readonly number[], slot: BriefSendSlot): number {
+    if (slot !== 'realtime' && !(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
     return this.using(db => db.transaction(() => this.markSentInDb(db, ids, slot))());
   }
 }

package/src/chat/index.ts

@@ -55,7 +55,8 @@ export interface CursorSink {
  *  tests can inject a fake. */
 export interface ModalSink {
   pushModal(surface: ModalSurface): { id: string; dispose: () => void };
-  /** F-E2 — force the coordinator to repaint the modal overlay. Chat
+  /** F-E2 — ask the coordinator to repaint the modal overlay (a plain
+   *  dirty frame — NOT force; see TUI-SLASH-FLICKER). Chat
    *  calls this after every keystroke so the picker's paint closure
    *  re-evaluates `getFiltered()` / `getItems()` — without it, the
    *  picker handle stays mounted but its filter output doesn't flow
@@ -345,11 +346,19 @@ export function createTextInputRenderActions(opts: {
     if (opts.shouldRequestModalRender?.() === false) return;
     if (debug.enabled) {
       debug.log('chat.modal.requestRender', 'user-mutation', {
-        force: true,
+        force: false,
         painted,
       });
     }
-    opts.modalSink?.requestRender?.({ force: true });
+    // TUI-SLASH-FLICKER (2026-10-09) — ⛔ NOT `force: true`. A forced
+    // frame reaches tui.ts::render as `\x1b[1;1H\x1b[J` + every row, so
+    // each keystroke / ↑↓ in the picker erased and repainted the WHOLE
+    // screen (visible flicker). The picker surfaces carry no paint-cache
+    // `generation`, so a plain dirty frame already re-runs their paint
+    // closure and the dashboard frame re-emits the overlay every flush;
+    // rows the picker vacates are invalidated by the coordinator's
+    // region tracking. Regression: src/ux-sim/slash-menu-frames.test.ts.
+    opts.modalSink?.requestRender?.();
   };
   return { repaintHost, repaintUserMutation };
 }

package/src/cli/agent-cli.ts

@@ -668,6 +668,26 @@ export function buildCliAgentTools(
   const shared = (require('../agent/shared-app-tools.js') as typeof import('../agent/shared-app-tools.js')).buildSharedAppTools(cfg);
   for (const s of shared.specs) specs.push(s);
   for (const name of shared.names) dispatchByName.set(name, async (args) => shared.dispatch(name, args));
+  // Installed knowledge is queryable in CLI chat as well as the dashboard runtime.
+  // No installed packs => preserve the existing CLI tool list and avoid creating a KGS database.
+  const { kgsDefaultDbPath } = require('../knowledge/kgs/sqlite-store.js') as typeof import('../knowledge/kgs/sqlite-store.js');
+  const { existsSync } = require('node:fs') as typeof import('node:fs');
+  let hasInstalledPacks = false;
+  try {
+    if (existsSync(kgsDefaultDbPath())) {
+      const { listInstalledPacks } = require('../knowledge/query.js') as typeof import('../knowledge/query.js');
+      hasInstalledPacks = listInstalledPacks().length > 0;
+    }
+  } catch (err) {
+    // An unreadable/corrupt KGS store must not break chat tool assembly for turns that never query knowledge.
+    debug.log('cli.agent', 'knowledge-query.tool-skipped', { reason: err instanceof Error ? err.message : String(err) });
+  }
+  if (hasInstalledPacks) {
+    const { buildKnowledgeQueryTool, dispatchKnowledgeQuery } = require('../knowledge/tools/knowledge-query.js') as typeof import('../knowledge/tools/knowledge-query.js');
+    const knowledgeSpec = buildKnowledgeQueryTool();
+    specs.push(knowledgeSpec);
+    dispatchByName.set(knowledgeSpec.name, async (args) => dispatchKnowledgeQuery(args));
+  }
   if (harnessPlan) {
     specs.push(buildPlanTool(), buildMarkStepDoneTool());
     const planCtx = {

package/src/cli/brief-cli.ts

@@ -1,5 +1,5 @@
 import type { Command } from 'commander';
-import { BRIEF_DOMAINS, BRIEF_PRIORITIES, BRIEF_REACTIONS, BRIEF_SLOTS, BriefItemsInputError, BriefItemsLedger, type BriefDomain, type BriefPriority, type BriefReaction, type BriefSlot } from '../briefing/brief-items.js';
+import { BRIEF_DOMAINS, BRIEF_PRIORITIES, BRIEF_REACTIONS, BRIEF_SLOTS, BriefItemsInputError, BriefItemsLedger, type BriefDomain, type BriefPriority, type BriefReaction, type BriefSendSlot } from '../briefing/brief-items.js';
 import { kindRouteTarget } from '../domains/telegram-kind-route.js';
 import { sendTelegramReturningId } from '../autopilot/mission-notify.js';
 import { getUserConfig } from '../user-config.js';
@@ -31,6 +31,20 @@ export function registerBriefCommands(program: Command, deps: BriefCliDeps = {})
         output(`이번 주 브리핑 중 대표가 움직인 것 ${acted}/${total}`);
       } catch (cause) { fail('', cause); }
     });
+  const deliver = (slot: BriefSendSlot): string => ledger().withSendLock(slot, ({ markdown, ids }, markSent) => {
+    if (ids.length === 0) return '(보낼 항목 없음)';
+    const send = deps.send ?? ((text: string) => {
+      const target = kindRouteTarget(getUserConfig(), 'ops-report');
+      if (!target) return null;
+      return sendTelegramReturningId(target.botToken, target.chatId, text);
+    });
+    const messageId = send(markdown);
+    if (typeof messageId !== 'number' || !Number.isFinite(messageId) || messageId <= 0) {
+      throw new Error('발송 실패: 양수 메시지 id 없음');
+    }
+    markSent(ids, slot);
+    return `sent ${messageId} (${ids.length} items)`;
+  });
 
   brief.command('add')
     .description('주장 한 줄을 원장에 추가한다 (원문 그대로)')
@@ -41,9 +55,11 @@ export function registerBriefCommands(program: Command, deps: BriefCliDeps = {})
     .option('--deadline <deadline>', '마감 (YYYY-MM-DD 또는 ISO)')
     .option('--evidence <evidence>', '근거 링크')
     .option('--created-at <iso>', '작성 시각 (ISO, 생략 시 지금)')
+    .option('--send-now', 'P0 추가 직후 실시간 발송')
     .option('--json', 'JSON 출력')
-    .action((opts: { text: string; domain: string; priority: string; source: string; deadline?: string; evidence?: string; createdAt?: string; json?: boolean }) => {
+    .action((opts: { text: string; domain: string; priority: string; source: string; deadline?: string; evidence?: string; createdAt?: string; sendNow?: boolean; json?: boolean }) => {
       try {
+        if (opts.sendNow && opts.priority !== 'P0') throw new BriefItemsInputError('--send-now requires --priority P0');
         const item = ledger().add({
           text: opts.text,
           domain: opts.domain as BriefDomain,
@@ -54,6 +70,7 @@ export function registerBriefCommands(program: Command, deps: BriefCliDeps = {})
           ...(opts.createdAt !== undefined ? { createdAt: opts.createdAt } : {}),
         });
         output(opts.json ? JSON.stringify(item) : `added ${item.id} [${item.priority}] ${item.domain}`);
+        if (opts.sendNow) output(deliver('realtime'));
       } catch (cause) { fail('add', cause); }
     });
 
@@ -95,31 +112,20 @@ export function registerBriefCommands(program: Command, deps: BriefCliDeps = {})
 
   brief.command('send')
     .description('슬롯 이전의 미발송 항목을 한 장 발송하고 성공한 항목만 표시한다')
-    .requiredOption('--slot <slot>', `슬롯 (${BRIEF_SLOTS.join('|')})`)
+    .option('--slot <slot>', `슬롯 (${BRIEF_SLOTS.join('|')}, --realtime 시 불필요)`)
+    .option('--realtime', '미발송 P0 및 오늘 마감 항목을 즉시 한 장 발송한다')
     .option('--dry-run', '한 장만 출력하고 발송·표시하지 않는다')
-    .action((opts: { slot: string; dryRun?: boolean }) => {
+    .action((opts: { slot?: string; realtime?: boolean; dryRun?: boolean }) => {
       try {
-        const store = ledger();
+        if (opts.realtime && opts.slot !== undefined) throw new BriefItemsInputError('--realtime cannot be combined with --slot');
+        if (!opts.realtime && opts.slot === undefined) throw new BriefItemsInputError('--slot is required unless --realtime');
+        const slot = opts.realtime ? 'realtime' : opts.slot!;
         if (opts.dryRun) {
-          const { markdown, ids } = store.composeWithIds(opts.slot);
+          const { markdown, ids } = ledger().composeWithIds(slot);
           output(ids.length === 0 ? '(보낼 항목 없음)' : markdown);
           return;
         }
-        const result = store.withSendLock(opts.slot, ({ markdown, ids }, markSent) => {
-          if (ids.length === 0) return '(보낼 항목 없음)';
-          const send = deps.send ?? ((text: string) => {
-            const target = kindRouteTarget(getUserConfig(), 'ops-report');
-            if (!target) return null;
-            return sendTelegramReturningId(target.botToken, target.chatId, text);
-          });
-          const messageId = send(markdown);
-          if (typeof messageId !== 'number' || !Number.isFinite(messageId) || messageId <= 0) {
-            throw new Error('발송 실패: 양수 메시지 id 없음');
-          }
-          markSent(ids, opts.slot as BriefSlot);
-          return `sent ${messageId} (${ids.length} items)`;
-        });
-        output(result);
+        output(deliver(slot as BriefSendSlot));
       } catch (cause) { fail('send', cause); }
     });
 }

package/src/cli/cli-user-error.ts

@@ -1,5 +1,3 @@
-import { HarnessCliInputError } from '../harness/harness-cli-command.js';
-
 const cliUserErrorBrand = Symbol.for('elanous.cli.CliUserError');
 const harnessCliInputErrorBrand = Symbol.for('elanous.cli.HarnessCliInputError');
 
@@ -11,6 +9,15 @@ export class CliUserError extends Error {
   }
 }
 
+/** A command-line value was rejected before any harness work began. */
+export class HarnessCliInputError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'HarnessCliInputError';
+    Object.defineProperty(this, harnessCliInputErrorBrand, { value: true });
+  }
+}
+
 export function isCliUserError(err: unknown): err is Error & { hint?: string } {
   return err instanceof HarnessCliInputError || err instanceof CliUserError || (
     err instanceof Error && (

package/src/cli/log-event-names.ts

@@ -703,6 +703,9 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "install-start",
   "installed",
   "instantiated",
+  "intent-stall-exhausted",
+  "intent-stall-provider-unresolved",
+  "intent-stall-reprompt",
   "interceptor",
   "interrupt",
   "interview-round-classified",

package/src/cli/logs-cli.ts

@@ -36,6 +36,7 @@ import { LOG_LEVEL_ORDER, type LogLevel } from '../mss/logging/record.js';
 import { isRenderCategory, RENDER_ORIENTED_PREFIXES } from '../mss/logging/render-categories.js';
 import { readScopedRenderLogs } from '../mss/logging/scoped-level.js';
 import { formatClock } from '../time/format.js';
+import '../user-config.js'; // Register the saved timezone for standalone logs CLI formatting.
 import { HARNESS_SPACE_KINDS } from '../harness/harness-space.js';
 import { LOG_RETENTION_DEFAULTS, LogCursorNotFoundError, STORE_SAFETY_MAX } from '../mss/logging/log-store.js';
 import { resolveDaemonEndpoint } from '../nexus/daemon-endpoint.js';

package/src/cli/mcp-login.ts

@@ -5,9 +5,11 @@ import { getUserConfig, reloadUserConfig, saveUserConfig, type McpServerSpec } f
 import {
   discoverMcpOAuth,
   exchangeAuthorizationCode,
+  ensureClientRegistration,
   loadStoredRegistration,
   loopbackRedirectPort,
   prepareMcpOAuthAuthorization,
+  authorizeMcpDevice,
   type McpOAuthFetch,
 } from '../mcp/mcp-oauth.js';
 import { parseWwwAuthenticate } from '../mcp/client.js';
@@ -31,7 +33,15 @@ export interface McpLoginOpts {
   out?: Output;
   readConfigFn?: () => { mcp?: { servers: McpServerSpec[] } };
   fetch?: McpOAuthFetch;
+  storePath?: string;
   openBrowser?: (url: string) => Promise<void>;
+  /** Aside browser agent; failures fall back to the existing browser flow. */
+  approveBrowser?: (url: string) => Promise<void>;
+  /** How long to wait for the approval callback after aside returns before falling back to the browser. */
+  asideCallbackGraceMs?: number;
+  /** Device-poll timing seam (test only). */
+  deviceSleep?: (ms: number) => Promise<void>;
+  deviceNow?: () => number;
   browserEnv?: NodeJS.ProcessEnv;
   browserPlatform?: NodeJS.Platform;
   createListener?: (handler: (req: IncomingMessage, res: ServerResponse) => void) => Server;
@@ -69,21 +79,58 @@ export async function runMcpLogin(opts: McpLoginOpts): Promise<McpLoginResult> {
 
   let server: Server | undefined;
   try {
-    const early = await listenForCallback(opts.createListener, 0);
-    server = early.server;
+    const why = browserUnavailableReason(opts.browserEnv ?? process.env, opts.browserPlatform ?? process.platform);
+    const oauthOpts = { ...(opts.fetch ? { fetch: opts.fetch } : {}), ...(opts.storePath ? { storePath: opts.storePath } : {}) };
+    const early = why && !opts.createListener ? undefined : await listenForCallback(opts.createListener, 0);
+    server = early?.server;
     const challenge = await requestChallenge(spec.url, opts.fetch);
     if (!challenge.resourceMetadata) {
       out.error(`✗ server '${opts.serverId}' did not provide a 401 Bearer resource_metadata challenge`);
       return { exitCode: 1 };
     }
+    const discovered = await discoverMcpOAuth(challenge.resourceMetadata, {
+      resourceUrl: spec.url, ...oauthOpts,
+    });
+    if ((why || !discovered.metadata.authorizationEndpoint) && discovered.metadata.deviceAuthorizationEndpoint) {
+      if (early?.server.listening) await closeServer(early.server);
+      if (why) out.log(why);
+      const stored = loadStoredRegistration(discovered.metadata.issuer, oauthOpts);
+      const deviceRegistration = await ensureClientRegistration(discovered.metadata, { ...oauthOpts, deviceCode: true });
+      const authorizeDevice = (registration: typeof deviceRegistration) => authorizeMcpDevice(discovered.metadata, registration, {
+        scope: challenge.scope,
+        resource: discovered.resource.resource,
+        ...oauthOpts,
+        ...(opts.deviceSleep ? { sleep: opts.deviceSleep } : {}),
+        ...(opts.deviceNow ? { now: opts.deviceNow } : {}),
+        onDeviceCode: ({ userCode, verificationUri, verificationUriComplete }) => {
+          out.log(`Authorize '${opts.serverId}' at ${verificationUriComplete ?? verificationUri}`);
+          out.log(`Device code: ${userCode}`);
+        },
+      });
+      try {
+        await authorizeDevice(deviceRegistration);
+      } catch (error) {
+        // A reused client the server does not accept for the device grant (e.g. an old browser client stored
+        // without its loopback URI) gets one fresh device registration; anything else fails as before.
+        const reused = stored?.clientId === deviceRegistration.clientId;
+        if (!reused || !discovered.metadata.registrationEndpoint || !/\((?:unauthorized_client|invalid_client)\)/.test(String(error))) throw error;
+        await authorizeDevice(await ensureClientRegistration(discovered.metadata, { ...oauthOpts, deviceCode: true, forceReregister: true }));
+      }
+      out.log(`✓ credentials saved for '${opts.serverId}' (${discovered.metadata.issuer})`);
+      persistLoginDiscovery(opts, discovered.metadata, out);
+      return { exitCode: 0 };
+    }
+    const callbackListener = early ?? await listenForCallback(opts.createListener, 0);
+    server = callbackListener.server;
     const opened = await openLoginListener({
-      early,
+      early: callbackListener,
       serverId: opts.serverId,
       resourceMetadataUrl: challenge.resourceMetadata,
       ...(challenge.scope ? { scope: challenge.scope } : {}),
       resourceUrl: spec.url,
-      ...(opts.fetch ? { fetch: opts.fetch } : {}),
+      ...oauthOpts,
       ...(opts.createListener ? { createListener: opts.createListener } : {}),
+      onListener: (openedServer) => { server = openedServer; },
     });
     const listener = opened.listener;
     server = listener.server;
@@ -94,47 +141,39 @@ export async function runMcpLogin(opts: McpLoginOpts): Promise<McpLoginResult> {
     void callbackPromise.catch(() => undefined);
     out.log(`Open this URL to authorize '${opts.serverId}':`);
     out.log(authorization.request.url);
-    const why = browserUnavailableReason(opts.browserEnv ?? process.env, opts.browserPlatform ?? process.platform);
     if (why) {
       out.log(why);
       debug.log('browser.open', 'skipped', { reason: why.includes('ssh') ? 'ssh' : 'no-display' });
     } else {
       try {
-        await (opts.openBrowser ?? openDefaultBrowser)(authorization.request.url);
+        if (opts.approveBrowser || !opts.openBrowser) {
+          await (opts.approveBrowser ?? approveWithAside)(authorization.request.url);
+          // A clean aside exit is not an approval: only the loopback callback is. If it has not arrived
+          // shortly after aside finished, fall back to the browser (the listener stays open for it).
+          let timer: ReturnType<typeof setTimeout> | undefined;
+          const arrived = await Promise.race([
+            callbackPromise.then(() => true, () => true),
+            new Promise<boolean>((resolve) => { timer = setTimeout(() => resolve(false), opts.asideCallbackGraceMs ?? 15_000); }),
+          ]);
+          if (timer) clearTimeout(timer);
+          if (!arrived) throw new Error('aside finished without an approval callback');
+        } else await opts.openBrowser(authorization.request.url);
       } catch {
-        out.error('Could not open the default browser; open the URL above manually.');
+        if (!opts.approveBrowser && opts.openBrowser) {
+          out.error('Could not open the default browser; open the URL above manually.');
+        } else {
+          try {
+            await (opts.openBrowser ?? openDefaultBrowser)(authorization.request.url);
+          } catch {
+            out.error('Could not open the default browser; open the URL above manually.');
+          }
+        }
       }
     }
     const callback = await callbackPromise;
-    await exchangeAuthorizationCode(authorization.metadata, authorization.request, callback, {
-      ...(opts.fetch ? { fetch: opts.fetch } : {}),
-    });
+    await exchangeAuthorizationCode(authorization.metadata, authorization.request, callback, oauthOpts);
     out.log(`✓ credentials saved for '${opts.serverId}' (${authorization.metadata.issuer})`);
-    // ⭐⭐ 🔴 여기가 이 파일의 «가장 중요한» 여덟 줄이다 (대표 2026-09-10).
-    //
-    //   초판은 issuer 를 «화면에 찍고 끝»이었다. 그런데 자격증명 저장소는
-    //   issuer 를 «키»로 쓰고(`getValidAccessToken(issuer, …)`), 데몬은 그
-    //   issuer 를 오직 config 의 `mcp.servers[].oauthIssuer` 에서만 얻는다
-    //   (`register-mcp-clients.ts` 는 spec 에 «있을 때만» 넘기고,
-    //    `McpClient.oauthAccessToken()` 은 `if (!this.oauthIssuer) return null`).
-    //
-    //   ⇒ 그래서 `mcp login` 이 «성공하고 ✓ 를 찍어도» 사람이 config 를 손으로
-    //      고치지 않으면 그 토큰은 영영 안 쓰인다. 2026-09-10 에 krea 를 붙이며
-    //      실제로 그 두 줄을 손으로 박았다. 「로그인했는데 도구가 0개」의 원인이다.
-    const persist = (opts.persistDiscoveryFn ?? persistDiscoveredIssuer)({
-      serverId: opts.serverId,
-      issuer: authorization.metadata.issuer,
-      ...(authorization.metadata.tokenEndpoint ? { tokenEndpoint: authorization.metadata.tokenEndpoint } : {}),
-    });
-    if (persist.error) {
-      // ⛔ 자격증명은 «이미 저장됐다» — 되쓰기 실패로 로그인 자체를 실패로 접으면
-      //    사람이 같은 브라우저 왕복을 또 한다. 경고로 내고 손 처방을 같이 준다.
-      out.error(`⚠ config 에 oauthIssuer 를 못 적었습니다: ${persist.error}`);
-      out.error(`  손으로: mcp.servers[] 의 '${opts.serverId}' 칸에 "oauthIssuer": "${authorization.metadata.issuer}" 를 더하세요.`);
-    } else if (persist.written) {
-      out.log(`✓ config 갱신 — '${opts.serverId}'.oauthIssuer = ${authorization.metadata.issuer}`);
-    }
-    out.log(`  도는 데몬에 반영하려면: elanous mcp reload`);
+    persistLoginDiscovery(opts, authorization.metadata, out);
     return { exitCode: 0 };
   } catch (error) {
     const stage = loginFailureStage(error);
@@ -146,8 +185,29 @@ export async function runMcpLogin(opts: McpLoginOpts): Promise<McpLoginResult> {
     out.error(`✗ MCP login failed: ${error instanceof Error ? error.message : String(error)}`);
     return { exitCode: 1 };
   } finally {
-    if (server) await closeServer(server);
+    if (server?.listening) await closeServer(server);
+  }
+}
+
+function persistLoginDiscovery(
+  opts: McpLoginOpts,
+  metadata: { issuer: string; tokenEndpoint: string },
+  out: Output,
+): void {
+  // ⭐⭐ issuer 를 config 에도 적어야 저장한 토큰을 데몬이 찾는다.
+  const persist = (opts.persistDiscoveryFn ?? persistDiscoveredIssuer)({
+    serverId: opts.serverId,
+    issuer: metadata.issuer,
+    tokenEndpoint: metadata.tokenEndpoint,
+  });
+  if (persist.error) {
+    // 자격은 이미 저장됐다. config 쓰기 실패는 경고로 남긴다.
+    out.error(`⚠ config 에 oauthIssuer 를 못 적었습니다: ${persist.error}`);
+    out.error(`  손으로: mcp.servers[] 의 '${opts.serverId}' 칸에 "oauthIssuer": "${metadata.issuer}" 를 더하세요.`);
+  } else if (persist.written) {
+    out.log(`✓ config 갱신 — '${opts.serverId}'.oauthIssuer = ${metadata.issuer}`);
   }
+  out.log(`  도는 데몬에 반영하려면: elanous mcp reload`);
 }
 
 async function requestChallenge(url: string, fetchFn?: McpOAuthFetch): Promise<{ resourceMetadata?: string; scope?: string }> {
@@ -175,7 +235,9 @@ async function openLoginListener(opts: {
   scope?: string;
   resourceUrl: string;
   fetch?: McpOAuthFetch;
+  storePath?: string;
   createListener?: McpLoginOpts['createListener'];
+  onListener?: (server: Server) => void;
   early: Awaited<ReturnType<typeof listenForCallback>>;
 }): Promise<{ listener: Awaited<ReturnType<typeof listenForCallback>>; authorization: Awaited<ReturnType<typeof prepareMcpOAuthAuthorization>> }> {
   const prior = await priorRegistration(opts);
@@ -189,6 +251,7 @@ async function openLoginListener(opts: {
       redirectUri: listener.redirectUri,
       resourceUrl: opts.resourceUrl,
       ...(opts.fetch ? { fetch: opts.fetch } : {}),
+      ...(opts.storePath ? { storePath: opts.storePath } : {}),
     });
     return { listener, authorization };
   }
@@ -196,6 +259,7 @@ async function openLoginListener(opts: {
   if (preferred !== null) {
     try {
       const listener = await listenForCallback(opts.createListener, preferred);
+      opts.onListener?.(listener.server);
       debug.log('mcp.login', 'callback-port', { serverId: opts.serverId, source: 'registered' });
       const authorization = await prepareMcpOAuthAuthorization({
         resourceMetadataUrl: opts.resourceMetadataUrl,
@@ -203,6 +267,7 @@ async function openLoginListener(opts: {
         redirectUri: listener.redirectUri,
         resourceUrl: opts.resourceUrl,
         ...(opts.fetch ? { fetch: opts.fetch } : {}),
+        ...(opts.storePath ? { storePath: opts.storePath } : {}),
       });
       return { listener, authorization };
     } catch (error) {
@@ -210,6 +275,7 @@ async function openLoginListener(opts: {
     }
   }
   const listener = await listenForCallback(opts.createListener, 0);
+  opts.onListener?.(listener.server);
   debug.log('mcp.login', 'callback-port', {
     serverId: opts.serverId,
     source: 'reregistered',
@@ -221,6 +287,7 @@ async function openLoginListener(opts: {
     redirectUri: listener.redirectUri,
     resourceUrl: opts.resourceUrl,
     ...(opts.fetch ? { fetch: opts.fetch } : {}),
+    ...(opts.storePath ? { storePath: opts.storePath } : {}),
     forceReregister: true,
   });
   return { listener, authorization };
@@ -230,13 +297,14 @@ async function priorRegistration(opts: {
   resourceMetadataUrl: string;
   resourceUrl: string;
   fetch?: McpOAuthFetch;
+  storePath?: string;
 }): Promise<ReturnType<typeof loadStoredRegistration>> {
   try {
     const discovered = await discoverMcpOAuth(opts.resourceMetadataUrl, {
       resourceUrl: opts.resourceUrl,
       ...(opts.fetch ? { fetch: opts.fetch } : {}),
     });
-    return loadStoredRegistration(discovered.metadata.issuer);
+    return loadStoredRegistration(discovered.metadata.issuer, opts);
   } catch {
     return null;
   }
@@ -368,6 +436,12 @@ async function closeServer(server: Server): Promise<void> {
   await new Promise<void>((resolve) => server.close(() => resolve()));
 }
 
+async function approveWithAside(url: string): Promise<void> {
+  // Aside decides how to interact with the provider page; only the state-checked
+  // loopback callback (not the agent's answer) can complete this login.
+  await execFileAsync('aside', ['exec', '--effort', 'low', `Open this OAuth authorization URL in your browser and approve access for elanous: ${url}. Do not reveal passwords, codes or tokens in your response.`], { timeout: 90_000 });
+}
+
 async function openDefaultBrowser(url: string): Promise<void> {
   const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
   const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];

package/src/cli/plugin-cli.ts

@@ -6,7 +6,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { userConfigPath } from '../user-config.js';
 import { debug, redactSecretText } from '../debug/log.js';
-import { addMarket, listMarkets, MarketFetchError, updateMarket } from '../plugins/install/market-fetch.js';
+import { addMarket, ensureInternalMarketIndex, listMarkets, MarketFetchError, updateMarket } from '../plugins/install/market-fetch.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { OFFICIAL_INDEX_KEYS } from '../market/official-keys.js';
 import { installPlugin, listInstalledPlugins, PluginInstallError, removePlugin, type InstallEvent } from '../plugins/install/plugin-install.js';
@@ -145,6 +145,26 @@ export function registerPluginCommands(program: Command): void {
       }
     });
   const market = plugin.command('market').description('Manage signed plugin marketplaces');
+  market.command('internal <name> <enterpriseId>').description('Fetch signed entries from a configured internal HTTPS market for an allowed enterprise')
+    .option('--refresh', 'Refresh the signed internal market index')
+    .option('--json', 'Print verified knowledge packs and loop bundles as JSON')
+    .action(async (name: string, enterpriseId: string, opts: { refresh?: boolean; json?: boolean }) => {
+      try {
+        const root = elanousStateRoot();
+        const result = await ensureInternalMarketIndex(name, enterpriseId, {
+          root, marketDir: join(root, 'plugins', 'markets'), refresh: opts.refresh,
+        });
+        const entries = { name: result.market.name, enterpriseId, sequence: result.index.sequence,
+          knowledgePacks: result.index.knowledgePacks ?? [], loopBundles: result.index.loopBundles ?? [] };
+        debug.log('plugin.cli', 'market.internal', { name: result.market.name, sequence: result.index.sequence });
+        if (opts.json) stdout.write(JSON.stringify(entries) + '\n');
+        else console.log(`Fetched internal market ${entries.name} (sequence ${entries.sequence}): ${entries.knowledgePacks.length} knowledge packs, ${entries.loopBundles.length} loop bundles`);
+      } catch (error) {
+        if (opts.json) stdout.write(JSON.stringify({ event: 'failed', cause: safeCause(error) }) + '\n');
+        else console.error(`plugin market internal failed: ${safeCause(error)}`);
+        process.exitCode = 1;
+      }
+    });
   market.command('add <name> <url>').description('Register a marketplace URL')
     .action((name: string, url: string) => {
       try {

package/src/cli/pod-cli.ts

@@ -33,6 +33,27 @@ const HELP = `elanous pod run [--pool <스펙>] [--skill <이름,…>] [--llm gr
   하니스 없이 명령 하나를 Pod 에서 돌리고 산출 경로를 한 줄로 알린다.
   --deadline 생략 시 ${POD_COMMAND_DEADLINE_SECONDS}초(기존 Pod Job 수명 상한).`;
 
+/** clone 트리는 `bun install` 없이 뜨므로 `bun test`·`bun run` 은 «Cannot find package» 로 실패한다
+ *  (실측 2026-10-10 21:47 node-b · `pod run --clone -- bun test src/steward/launch.test.ts` → 1 fail ·
+ *  설치만 붙여 다시 치니 58초 Completed). Pod 문제로 오인하기 쉬워 «발사 전»에 한 줄로 알린다 — 발사는 막지 않는다. */
+export const POD_CLONE_WITHOUT_INSTALL_WARNING =
+  '⚠ --clone 트리에는 node_modules 가 없다 — 시험이면 sh -c "bun install --frozen-lockfile && <명령>" 꼴로 감싸라';
+
+/** `--clone` ⊕ 명령 첫 낱말이 `bun` ⊕ 둘째가 `test`·`run` ⊕ 명령 어디에도 `install` 낱말(토큰)이 없으면 경고 대상이다. */
+export function podCloneWithoutInstallWarning(
+  commandArgs: readonly string[],
+  clone: boolean | undefined,
+): string | null {
+  if (!clone) return null;
+  const [argv0, argv1] = commandArgs;
+  if (argv0 !== 'bun') return null;
+  if (argv1 !== 'test' && argv1 !== 'run') return null;
+  // Exact argv token only: `installation.test.ts` or a single `install helper` argument is not an install
+  // (a shell string like `sh -c "bun install && …"` never reaches here — its argv0 is `sh`).
+  if (commandArgs.includes('install')) return null;
+  return POD_CLONE_WITHOUT_INSTALL_WARNING;
+}
+
 export function registerPodCommands(program: Command, deps: PodCliDeps = {}): void {
   const io = deps.io ?? {
     log: (line: string) => console.log(line),
@@ -148,6 +169,11 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
         }
       }
       const skills = (opts.skill ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+      const cloneWarning = podCloneWithoutInstallWarning(commandArgs, opts.clone);
+      if (cloneWarning !== null) {
+        io.error(cloneWarning);
+        debug.log('pod.run', 'clone-without-install', { argv0: commandArgs[0], argv1: commandArgs[1] });
+      }
       try {
         const result = await run({
           command: commandArgs,