elanous 0.2.9 → 0.2.11

package/src/autopilot/tool-registry.ts

@@ -266,4 +266,6 @@ export const AUTOPILOT_TOOL_IDS = [
   'memory_recall',
   'ops_status',
   'self_recall',
+  // CTX2 #23185 — 맥락 한 문(READ-ONLY 자기관측 원장에 더해졌다).
+  'context_now',
 ] as const;

package/src/boot/daemon-prompt-turn.ts

@@ -107,6 +107,8 @@ export async function runDaemonPromptTurn(opts: {
   surfaceResolutionReason?: SurfaceKindResolutionReason;
   /** Optional confirm channels for the triggering chat surface. */
   surfaceHitlChannels?: ConfirmChannel[];
+  /** Server-authenticated human owner for this request; absent for delegated or unverified callers. */
+  verifiedOwner?: { id: string };
   /** Optional structured-question channels for the triggering chat surface. */
   surfaceQuestionChannels?: QuestionChannel[];
   /** CWD for fs-bound tool dispatch (Read / Grep). Defaults to
@@ -114,6 +116,8 @@ export async function runDaemonPromptTurn(opts: {
    *  `--tool-cwd` / `ELANOUS_TOOL_CWD` to keep `/v1/prompt` and ACP WS
    *  on the same path-guard boundary. */
   toolCwd?: string;
+  /** Per-turn project instructions; unlike the base system preamble these must survive subsequent turns. */
+  projectInstructions?: string;
   /** Phase 4 (WT-A-3b) — external abort signal. When provided and
    *  fired, the internal AbortController fans the abort through to
    *  `runCoreTurn` (LLM stream + tool dispatch). Callers without an
@@ -226,6 +230,7 @@ export async function runDaemonPromptTurn(opts: {
             ...(request.source?.kind === 'daemon-api' && request.source.route === '/a2a'
               ? { requestOrigin: 'external-agent' as const } : {}),
             ...(request.userText ? { userText: request.userText } : {}),
+            ...(opts.verifiedOwner ? { verifiedOwner: opts.verifiedOwner } : {}),
             ...(opts.surface !== undefined || sourceResolution.surface !== 'unknown' ? { surface } : {}),
             ...(opts.surfaceHitlChannels ? { surfaceHitlChannels: opts.surfaceHitlChannels } : {}),
             ...(opts.surfaceQuestionChannels ? { surfaceQuestionChannels: opts.surfaceQuestionChannels } : {}),
@@ -283,6 +288,9 @@ export async function runDaemonPromptTurn(opts: {
   if (fast && !isFirstTurn) {
     messages.unshift({ role: 'system', content: fastPathGuidance });
   }
+  if (!isFirstTurn && opts.projectInstructions) {
+    messages.unshift({ role: 'system', content: opts.projectInstructions });
+  }
   const result = await runCoreTurn({
     sessionId: request.sessionId,
     userText: request.userText,

package/src/boot/daemon-runtime.ts

@@ -53,6 +53,7 @@ import {
 import type { CoreTurnDispatchTool } from '../core-turn/index.js';
 import { elanousSelfAccessPrompt } from '../agent/self-ambient.js';
 import { createToolCwdResolver, type ToolCwdResolver } from './tool-cwd.js';
+import { resolveSessionProjectContext } from '../project/session-context.js';
 import { debug } from '../debug/log.js';
 
 /** C4 (2026-07-12) — arm the non-detached-PTY kill ONCE per turn signal.
@@ -579,7 +580,9 @@ export function createDaemonRunTurn(
     // moved this out of an inline closure to fix the user-message
     // persistence bug uniformly across all daemon paths.
     getMessages: ({ sessionId, userText, promptBlocks, promptMeta }) => {
-      const baseSystemPrompt = composeDaemonSystemPrompt(opts.systemPrompt, promptMeta, sessionId);
+      const projectInstructions = resolveSessionProjectContext(sessionId)?.instructions;
+      const baseSystemPrompt = [composeDaemonSystemPrompt(opts.systemPrompt, promptMeta, sessionId), projectInstructions]
+        .filter(Boolean).join('\n\n');
       // Image-pipeline followup #4 (2026-05-05) — append daemon webterm
       // context (current ACP sessionId + active terminal summary) to
       // the system prompt when the webterm surface is active. Helper
@@ -720,8 +723,11 @@ export function createDaemonRunTurn(
         });
         debugBridge.activate();
       }
-      if (opts.acpSessionCwd) {
-        const resolver = createToolCwdResolver({ tools: opts.tools ?? 'none', toolCwd: turnCtx.cwd });
+      const projectCwd = resolveSessionProjectContext(turnCtx.sessionId)?.cwd;
+      if (projectCwd || opts.acpSessionCwd) {
+        // An ACP session's explicit cwd wins; the project folder is only the default when none was given (IA3 review).
+        const explicitCwd = opts.acpSessionCwd && turnCtx.cwd ? turnCtx.cwd : undefined;
+        const resolver = createToolCwdResolver({ tools: opts.tools ?? 'none', toolCwd: explicitCwd ?? projectCwd ?? turnCtx.cwd });
         await turnToolCwd.run(resolver, () => inner(turnCtx));
       } else {
         await inner(turnCtx);

package/src/boot/daemon-tools/index.ts

@@ -16,6 +16,8 @@ import {
   dispatchBrowserRead,
 } from '../../tool-runtime/browser-runtime.js';
 import { askUserQuestionRuntime } from '../../tool-runtime/ask-user-question-runtime.js';
+import { buildElanousHoldTool, buildPtyControlTool, dispatchElanousHold, dispatchPtyControl } from '../../tool-runtime/elanous-control-runtimes.js';
+import { ptyAvailable } from '../../pty-shell/registry.js';
 import { dispatchToolByName, listToolRuntimes } from '../../tool-runtime/registry.js';
 import { ACP_SESSION_RUNTIMES } from '../../tool-runtime/acp-session-runtime.js';
 import { ClaudeSubscriptionNotAllowedError } from '../../policy/claude-subscription-guard.js';
@@ -340,6 +342,7 @@ export function toolSurface(kind: DaemonToolSurfaceKind, cfg?: import('../../use
     askUserQuestionRuntime.spec,
     ...ACP_SESSION_RUNTIMES.map((runtime) => runtime.spec),
     ...shared.specs, // L2 core + L3 finance(gated) — buildSharedAppTools 단일 출처(전 서피스 공용)
+    ...(ptyAvailable() ? [buildElanousHoldTool(), buildPtyControlTool()] : []),
   ];
 
   /** Shared dispatcher for chat-surface tools. Reused by 'chat' AND
@@ -392,11 +395,16 @@ export function toolSurface(kind: DaemonToolSurfaceKind, cfg?: import('../../use
       // L2 core + L3 finance(gated) — buildSharedAppTools 단일 dispatch · B5: 진행 한 줄(emitFeedback)·세션·호출 id 를 넘긴다.
       return shared.dispatch(name, args, {
         surface: 'tui',
+        ...(ctx.requestOrigin ? { requestOrigin: ctx.requestOrigin } : {}),
+        ...(ctx.verifiedOwner ? { verifiedOwner: ctx.verifiedOwner } : {}),
         ...(ctx.sessionId ? { sessionId: ctx.sessionId } : {}),
+        ...(ctx.surfaceHitlChannels ? { confirmChannels: ctx.surfaceHitlChannels } : {}),
         ...(ctx.toolCallId ? { toolCallId: ctx.toolCallId } : {}),
         ...(ctx.emitFeedback ? { emitFeedback: ctx.emitFeedback } : {}),
       });
     }
+    if (ptyAvailable() && name === 'ElanousHold') return dispatchElanousHold(args);
+    if (ptyAvailable() && name === 'PtyControl') return dispatchPtyControl(args);
     if (name === 'Bash') {
       // PLAN-ios-rich-dev-feedback-hydrate M3 (2026-05-13) — pass
       // sessionId + emitFeedback so dispatchBash emits tool.progress

package/src/boot/daemon-tools/types.ts

@@ -61,6 +61,8 @@ export interface DaemonToolDispatchCtx {
   sessionId?: string;
   /** Trusted server-side classification of the current turn, never supplied as a tool argument. */
   requestOrigin?: RequestOrigin;
+  /** Owner principal verified at the server request boundary, not from input source metadata. */
+  verifiedOwner?: { id: string };
   /** Ingestion entry class. Omit for conservative external-verbatim fallback. */
   entry?: IngestionEntry;
   /** M5 PR 2 (PLAN-rich-dev-feedback-multi-surface · 2026-05-13) —

package/src/boot/daemon-tools/web-search.ts

@@ -23,6 +23,8 @@ export interface DaemonWebSearchArgs {
 export interface DaemonWebSearchResult {
   query: string;
   providerName: string;
+  /** Absent for ordinary searches; signals whether X sources were actually cited. */
+  xSearch?: 'grok' | 'unavailable';
   hits: Array<{
     url: string;
     title: string;
@@ -41,6 +43,7 @@ export function buildWebSearchTool(): LLMToolSpec {
       'Search the public web via the daemon\'s configured provider (Grok / ' +
       'Firecrawl / etc.). When no key is available, falls back to keyless DuckDuckGo. ' +
       'Returns a ranked list of URLs + titles + snippets. ' +
+      'For fact questions, answer directly from the snippets and URLs; read the full body only when insufficient. ' +
       'Pair with a follow-up Read or external WebFetch when the model needs ' +
       'the full article body.',
     parameters: {
@@ -89,6 +92,7 @@ export async function dispatchWebSearch(
     return {
       query,
       providerName: result.providerName,
+      ...(result.xSearch ? { xSearch: result.xSearch } : {}),
       hits: result.hits.map((h) => ({
         url: h.url,
         title: h.title,

package/src/card-followup/core.ts

@@ -0,0 +1,109 @@
+import { chmodSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { join, resolve } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { lastJsonObject, runGraph as defaultRunGraph, type GraphRunState } from '../graph-runner/runner.js';
+
+const GRAPH = resolve(import.meta.dir, '../../plugins/card-followup/graphs/card-followup.yaml');
+export type CardDetectDecision = 'card' | 'skip' | 'ambiguous';
+
+export function cardShape(width?: number, height?: number): { decision: 'skip' | 'pass'; signal: string } {
+  if (!width || !height) return { decision: 'pass', signal: 'ratio:unknown' };
+  const ratio = Math.max(width, height) / Math.min(width, height);
+  if (ratio < 1.15) return { decision: 'skip', signal: 'ratio:square' };
+  if (ratio > 2.0) return { decision: 'skip', signal: 'ratio:screenshot' };
+  return { decision: 'pass', signal: `ratio:${ratio.toFixed(2)}` };
+}
+const EMAIL = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i;
+const PHONE = /(?:\+?\d{1,3}[\s.-]?)?\(?\d{2,4}\)?[\s.-]?\d{3,4}[\s.-]?\d{4}/;
+const WEB = /\b(?:https?:\/\/|www\.)\S+|\b[a-z0-9-]+\.(?:com|co\.kr|kr|io|ai|net|org)\b/i;
+const TITLE = /대표|이사|팀장|부장|과장|실장|매니저|주식회사|\(주\)|\b(?:CEO|CTO|COO|CFO|Director|Manager|Founder|Inc|Ltd|Corp)\b/i;
+export function cardText(ocr: string | null): { decision: CardDetectDecision; signal: string } {
+  if (ocr === null) return { decision: 'ambiguous', signal: 'ocr:unavailable' };
+  const chars = ocr.replace(/\s+/g, '').length;
+  if (chars < 15) return { decision: 'ambiguous', signal: 'ocr:chars<15' };
+  if (chars > 700) return { decision: 'skip', signal: 'ocr:document' };
+  const hits = ([['email', EMAIL], ['phone', PHONE], ['web', WEB], ['title', TITLE]] as const).filter(([, re]) => re.test(ocr)).map(([name]) => name);
+  const signal = `ocr:${hits.join(',') || 'none'}`;
+  if (hits.length >= 2) return { decision: 'card', signal };
+  return { decision: hits.length === 0 ? 'skip' : 'ambiguous', signal };
+}
+export function detectCard({ width, height, ocrText }: { width?: number; height?: number; ocrText: string | null }): { decision: CardDetectDecision; signal: string } {
+  const shape = cardShape(width, height);
+  return shape.decision === 'skip' ? { decision: 'skip', signal: shape.signal } : cardText(ocrText);
+}
+
+const obj = (value: unknown): Record<string, unknown> => value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+const text = (value: unknown): string => typeof value === 'string' ? value.trim() : '';
+const line = (value: unknown): string => (typeof value === 'number' && Number.isFinite(value) ? String(value) : text(value)).replace(/[\r\n]+/g, ' ') || '—';
+
+export class NotACardError extends Error {}
+function isNotACard(state: GraphRunState): boolean {
+  if (state.status !== 'failed') return false;
+  const read = state.nodes.find((node) => node.nodeId === 'read-card');
+  if (!read || !read.ok) return false;
+  const output = lastJsonObject(read.output);
+  if (output?.outcome === 'ok' && output.card && typeof output.card === 'object') {
+    const card = obj(output.card);
+    return !['name', 'company', 'title', 'email', 'phone', 'url', 'linkedin'].some((field) => text(card[field]));
+  }
+  return output?.outcome === 'fail' && typeof output.reason === 'string'
+    && /\bnot a (?:business )?card\b|명함이?\s*아님|명함이?\s*아닙니다/i.test(output.reason);
+}
+function validateReport(report: Record<string, unknown>): void {
+  const card = obj(report.card), fit = obj(report.fit), approach = obj(report.approach);
+  const next = obj(report.nextAction), draft = obj(report.draft);
+  const score = fit.score;
+  if (report.sent !== false || !text(card.name) || !text(card.company)
+    || !(score === null || (typeof score === 'number' && Number.isFinite(score)))
+    || !text(fit.label) || !text(approach.problem) || !text(approach.proposal)
+    || !text(approach.channel) || !text(next.what) || !text(next.due)
+    || !text(draft.subject) || !text(draft.body)) {
+    throw new Error('incomplete or sent card report');
+  }
+}
+
+export async function runCardFollowup({ imagePath, ocrText, runGraph = defaultRunGraph, rootDir = effectiveInstanceRoot(), outDir, runId = randomUUID(), context }: {
+  imagePath: string;
+  ocrText: string | null;
+  runGraph?: typeof defaultRunGraph;
+  rootDir?: string;
+  outDir?: string;
+  runId?: string;
+  context?: string;
+}): Promise<{ replies: [string, string, string]; followupPath?: string }> {
+  if (ocrText !== null && cardText(ocrText).decision !== 'card') throw new NotACardError('not a card');
+  const base = join(rootDir, 'graph-runs', 'card-followup');
+  const dir = outDir ?? join(base, runId);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  chmodSync(base, 0o700);
+  chmodSync(dir, 0o700);
+  const statePath = join(base, `${runId}.json`);
+  const sealState = () => {
+    try { chmodSync(statePath, 0o600); } catch { /* runner may not have written state */ }
+    const contexts = `${statePath}.contexts`;
+    try {
+      chmodSync(contexts, 0o700);
+      for (const file of readdirSync(contexts)) chmodSync(join(contexts, file), 0o600);
+    } catch { /* no contexts yet */ }
+  };
+  try {
+    const state = await runGraph(GRAPH, { runId, deps: { root: rootDir }, input: {
+      image: imagePath, outDir: dir, ...(context ? { context } : {}),
+    } });
+    if (isNotACard(state)) throw new NotACardError('not a card');
+    if (state.status !== 'done') throw new Error('graph did not finish');
+    const report = obj(JSON.parse(readFileSync(join(dir, 'followup.json'), 'utf8')));
+    validateReport(report);
+    const card = obj(report.card), fit = obj(report.fit), approach = obj(report.approach);
+    const next = obj(report.nextAction), draft = obj(report.draft);
+    const summary = `① 요약\n${line(card.name)} · ${line(card.company)} · ${line(card.title)}\n타겟 판정: ${line(fit.score)} · ${line(fit.label)}`;
+    const strategy = `② 전략\n${[approach.problem, approach.proposal, approach.channel].map(line).join('\n')}\n다음 행동: ${line(next.what)} · ${line(next.due)}`;
+    const mail = `③ 팔로업 초안 (보내지 않았습니다)\n제목: ${line(draft.subject)}\n${text(draft.body)}`;
+    const followupPath = join(dir, 'followup.md');
+    readFileSync(followupPath);
+    return { replies: [summary, strategy, mail], followupPath };
+  } finally {
+    if (runGraph === defaultRunGraph) sealState();
+  }
+}

package/src/chat/ctrl-c-in-input.ts

@@ -0,0 +1,14 @@
+/** U1a — how long an empty-input Ctrl+C stays armed (and its hint stays on screen). */
+export const CTRL_C_ARM_MS = 2_000;
+
+export function resolveCtrlCInInput({ text, now, armedAt }: {
+  text: string;
+  now: number;
+  armedAt: number | null;
+}): { action: 'clear-input' | 'arm-exit' | 'exit'; armedAt: number | null; hint: string | null } {
+  if (text.length > 0) return { action: 'clear-input', armedAt: null, hint: null };
+  if (armedAt !== null && now >= armedAt && now - armedAt <= CTRL_C_ARM_MS) {
+    return { action: 'exit', armedAt: null, hint: null };
+  }
+  return { action: 'arm-exit', armedAt: now, hint: '한 번 더 누르면 나갑니다 · /quit' };
+}

package/src/chat/index.ts

@@ -19,6 +19,7 @@ import type { ModalSurface } from '../display/modal-stack.js';
 import type { ContentBlock } from '../llm.js';
 import { debug } from '../debug/log.js';
 import { matchTextInputGlobalAction } from './global-actions.js';
+import { CTRL_C_ARM_MS, resolveCtrlCInInput } from './ctrl-c-in-input.js';
 import { isTextInputQuitChord } from './input-quit-chord.js';
 // P5 — leader-chord pass-through from input focus. chat.ts swallows
 // plain letters into its textarea buffer, so the resolver never sees
@@ -436,6 +437,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'model',     aliases: ['m'],           description: '모델 바꾸기 — /model <codex|terra|sol|luna|opus|sonnet|grok> (list + current when no arg). OpenAI 는 Codex(Responses API)만. effort 는 /reasoning.', subcommands: ['codex', 'terra', 'sol', 'luna', 'opus', 'sonnet', 'grok'] },
   { name: 'clear', aliases: ['cls'],       description: '대화 기록 지우기' },
   { name: 'status', aliases: ['st'], description: '지금 상태 — 모델 · 연결 · 계정' },
+  { name: 'now', aliases: [], description: '현재 맥락과 출처 표 — /now [주제]' },
   { name: 'remaining', aliases: [], description: '계정별 남은 사용량' },
   { name: 'setup', aliases: [], description: '상세 설정 — /setup · /setup reset(다음 실행 때 마법사 다시)', subcommands: ['help', 'reset'] },
   { name: 'quit',  aliases: ['q', 'exit'], description: '나가기' },
@@ -896,6 +898,10 @@ export async function textInput(opts: {
   let lastReportedLines = -1;
   let lineIdx = 0;   // current line
   let colIdx = lines[0]!.length;  // cursor at end of initial text
+  let ctrlCArmedAt: number | null = null;
+  let ctrlCHintTimer: ReturnType<typeof setTimeout> | null = null;
+  let ctrlCHint: string | null = null;
+  let ctrlCHintPainted = false;
 
   // KX2 — picker selection / navigation / async fetch caches live in
   // the shared state machine (chat-picker-state.ts). textInput keeps
@@ -1173,6 +1179,14 @@ export async function textInput(opts: {
     }
     prevDrawnLines = visibleLines;
 
+    if (ctrlCHint) {
+      writeTerminal(ansi.moveTo(row + 2, col) + '\x1b[2K' + C.muted(truncate(ctrlCHint, width)));
+      ctrlCHintPainted = true;
+    } else if (ctrlCHintPainted) {
+      writeTerminal(ansi.moveTo(row + 2, col) + '\x1b[2K');
+      ctrlCHintPainted = false;
+    }
+
     // Cursor — its buffer line is `lineIdx`; its screen row is the
     // bottom-anchored offset within the visible window. Critically,
     // `textBeforeCursor` reads from `lines[lineIdx]` (the buffer), not
@@ -1468,6 +1482,11 @@ export async function textInput(opts: {
       process.exit(0);
     }
 
+    if (!(key.ctrl && (key.name === 'c' || key.name === 'ㅊ') && !key.shift && !key.alt)) {
+      ctrlCArmedAt = null;
+      ctrlCHint = null;
+    }
+
     // A bracketed-paste envelope is one atomic event. Handle it before
     // host routing so embedded newlines cannot reach a submit handler.
     if (key.name === 'paste') {
@@ -1571,6 +1590,40 @@ export async function textInput(opts: {
       continue;
     }
 
+    if (key.ctrl && (key.name === 'c' || key.name === 'ㅊ') && !key.shift && !key.alt) {
+      const text = lines.join('\n');
+      const result = resolveCtrlCInInput({ text, now: Date.now(), armedAt: ctrlCArmedAt });
+      debug.log('chat.input', 'ctrl-c', { action: result.action, length: text.length });
+      ctrlCArmedAt = result.armedAt;
+      ctrlCHint = result.hint;
+      if (ctrlCHintTimer) clearTimeout(ctrlCHintTimer);
+      ctrlCHintTimer = null;
+      if (result.action === 'arm-exit') {
+        // U1a — the hint promises «one more press exits» only while that is true.
+        const armedAt = result.armedAt;
+        ctrlCHintTimer = setTimeout(() => {
+          ctrlCHintTimer = null;
+          if (ctrlCArmedAt !== armedAt) return;
+          ctrlCArmedAt = null;
+          ctrlCHint = null;
+          drawAll();
+        }, CTRL_C_ARM_MS + 50);
+        ctrlCHintTimer.unref?.();
+      }
+      if (result.action === 'exit') return submitBufferResult('/quit');
+      if (result.action === 'clear-input') {
+        lines = [''];
+        lineIdx = 0;
+        colIdx = 0;
+        historyIdx = -1;
+        savedCurrentInput = '';
+        onUserBufferEdit();
+        await picker.refresh(bufView());
+      }
+      drawAll();
+      continue;
+    }
+
     const globalDispatcher = dispatchGlobalAction;
     const globalAction = globalDispatcher
       ? matchTextInputGlobalAction(key, {

package/src/chat/pickers/state.ts

@@ -33,6 +33,7 @@ import type {
 } from '../index.js';
 import { filterSlashCommands } from '../index.js';
 import { filterInputMatches } from '../../input/query-match.js';
+import { readTuiSlashAudience, slashMaturity, slashVisibleFor } from '../../maturity/tui-slash-maturity.js';
 
 /** Read-only snapshot of the textInput buffer handed to state on
  *  every public call. The state machine never mutates it; it only
@@ -234,8 +235,11 @@ export function createPickerState(deps: PickerDeps): PickerState {
   let currentAtItems: AtCandidate[] = [];
   let currentSkillItems: SkillCandidate[] = [];
 
-  const filteredSlash = (buf: PickerBufferView): SlashCommand[] =>
-    filterSlashCommands((buf.lines[0] ?? '').slice(1), deps.commands);
+  const filteredSlash = (buf: PickerBufferView): SlashCommand[] => {
+    const { role, showBeta } = readTuiSlashAudience();
+    return filterSlashCommands((buf.lines[0] ?? '').slice(1), deps.commands)
+      .filter((cmd) => (role === 'owner' && slashMaturity(cmd.name) === undefined) || slashVisibleFor(cmd.name, role, { showBeta }));
+  };
 
   const refreshArgs = async (buf: PickerBufferView): Promise<ArgSuggestion[]> => {
     const ctx = parseArgContext(buf, deps.commands);

package/src/cli/agent-cli.ts

@@ -3,6 +3,7 @@ import { resolve } from 'node:path';
 import { getUserConfig, reloadUserConfig } from '../user-config.js';
 import { handleOnboardingRefusal, needsOnboarding, runOnboarding } from '../onboarding.js';
 import { runTurn, ensureCliSession, sessionBudget } from '../session/chat.js';
+import { suggestProjectForFolder } from '../project/project-store.js';
 import { NoLlmProviderAvailableError, noProviderAvailableMessage } from '../llm.js';
 import { resolveSessionId, getActiveSessionId, setActiveSessionId } from '../session/index.js';
 import { getHarnessSpace } from '../harness/harness-space.js';
@@ -433,6 +434,12 @@ export async function runChatTurnCli(opts: {
   }
   const session = ensureCliSession(opts.cfg, resolvedSessionIdHint);
   setActiveSessionId(session.id);
+  if (!opts.json && (!resolvedSessionIdHint || session.id !== resolvedSessionIdHint)) {
+    try {
+      const project = suggestProjectForFolder(process.cwd());
+      if (project) console.log(`Project suggestion: ${project.name} (${project.id})`);
+    } catch { /* suggestions must not interrupt a CLI conversation */ }
+  }
   const harnessSpace = getHarnessSpace();
   // Tag the debug log with this session id so every event in this
   // process attributes correctly. enrichDebugRecord picks up the

package/src/cli/decisions-cli.ts

@@ -1,4 +1,5 @@
 import type { Command } from 'commander';
+import { projectDecisionsToLinear } from '../decisions/decision-linear-projection.js';
 import { DecisionLedger, importDecisionMarkdown, type DecisionCategory, type DecisionLedgerOptions, type DecisionOption, type DecisionTrack, type DecisionEntry } from '../decisions/decision-ledger.js';
 
 const repeat = (value: string, values: string[]) => [...values, value];
@@ -49,22 +50,31 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
   const root = program.command('decisions').description('대표 결정 원장 · 로컬 전용');
   const emit = (value: unknown, json?: boolean, text?: string) => out.log(json ? JSON.stringify(value) : text ?? JSON.stringify(value));
   const fail = (action: () => void) => { try { action(); } catch (e) { throw new Error(`decisions: ${e instanceof Error ? e.message : String(e)}`); } };
+  root.command('linear-sync').description('열린 결정을 COO Linear 프로젝트에 투영하고 닫힌 결정을 동기화한다')
+    .option('--dry-run').option('--json')
+    .action(async (o: { dryRun?: boolean; json?: boolean }) => {
+      const result = await projectDecisionsToLinear({ stateDir: config.stateDir, dryRun: o.dryRun });
+      emit(result, o.json, result.reason ?? `생성 ${result.created} · 닫음 ${result.closed} · 건너뜀 ${result.skipped} · 실패 ${result.failed}${result.plan?.length ? `\n${result.plan.map(p => `${p.action} ${p.decisionId}${p.issue ? ` ${p.issue}` : ''}`).join('\n')}` : ''}`);
+    });
   root.command('raise').description('SCQA·선택지와 권고로 결정 항목을 올린다')
     .requiredOption('--title <text>').requiredOption('--category <category>')
     .requiredOption('--s <text>').requiredOption('--c <text>').option('--q <text>').option('--a <text>')
     .requiredOption('--option <key=label:consequence>', '선택지 (두 번 이상)', repeat, [] as string[])
     .option('--recommend <key>').option('--why <text>').option('--skip-recommend <reason>')
     .option('--track <track>').option('--agent <agent>').option('--session <id>')
+    .option('--resume-question <qid>').option('--run <runId>')
     .option('--ref <url>', '참조 (반복)', repeat, [] as string[])
     .option('--due <when>', '기한 — UTC ISO(2026-10-04T09:00:00Z) 또는 +Nh(지금부터 N시간) · 기한 2시간 전 텔레그램·디스코드로 다시 알린다')
     .option('--json')
-    .action((o: { due?: string; title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; track?: DecisionTrack; agent?: string; session?: string; ref: string[]; json?: boolean }) => fail(() => {
+    .action((o: { due?: string; title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; track?: DecisionTrack; agent?: string; session?: string; resumeQuestion?: string; run?: string; ref: string[]; json?: boolean }) => fail(() => {
+      if (o.run !== undefined && o.resumeQuestion === undefined) throw new Error('--run requires --resume-question');
       if (o.skipRecommend !== undefined && (o.recommend !== undefined || o.why !== undefined)) throw new Error('choose recommendation or skip, not both');
       if (o.skipRecommend === undefined && (!o.recommend || !o.why)) throw new Error('--recommend and --why required, or --skip-recommend <reason>');
       const options: DecisionOption[] = o.option.map(parseOption);
       const entry = new DecisionLedger(config).raise({ title: o.title, category: o.category, scqa: { s: o.s, c: o.c, ...(o.q ? { q: o.q } : {}), ...(o.a ? { a: o.a } : {}) }, options,
         recommendation: o.skipRecommend !== undefined ? { skipped: true, reason: o.skipRecommend } : { option: o.recommend!, why: o.why! },
         raisedBy: { agent: agent(o.agent), ...(o.track ? { track: o.track } : {}), ...(o.session ? { session: o.session } : {}) }, ...(o.ref.length ? { refs: o.ref } : {}),
+        ...(o.resumeQuestion !== undefined ? { resume: { questionId: o.resumeQuestion, ...(o.run !== undefined ? { runId: o.run } : {}) } } : {}),
         ...(o.due ? { dueAt: dueAt(o.due) } : {}) });
       emit(entry, o.json, `올림: ${formatDecisionRow(entry)}`);
     }));
@@ -83,8 +93,20 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       if (o.auto && !o.delegation?.trim()) throw new Error('--auto requires --delegation');
       if (!o.auto && (o.delegation || o.track || o.agent)) throw new Error('delegation/track/agent require --auto');
       const by = o.auto ? { kind: 'auto' as const, agent: agent(o.agent), delegation: o.delegation!, ...(o.track ? { track: o.track } : {}) } : { kind: 'human' as const };
-      const entry = new DecisionLedger(config).decide(id, choice, by, o.note);
-      emit(entry, o.json, `결정: ${formatDecisionDetail(entry)}`);
+      const { entry, delivery } = new DecisionLedger(config).decideWithDelivery(id, choice, by, o.note);
+      if (delivery && !delivery.ok) {
+        // The decision is recorded; only the answer to the waiting run failed — say so and how to retry, never «success».
+        const hint = `⚠ 답 전달 실패(${delivery.questionId} · ${delivery.reason}) — 결정은 기록됐다 · 다시: elanous decisions retry-answer ${entry.id}`;
+        emit({ ...entry, delivery }, o.json, `결정: ${formatDecisionDetail(entry)}\n${hint}`);
+        process.exitCode = 3;
+        return;
+      }
+      emit(delivery ? { ...entry, delivery } : entry, o.json, `결정: ${formatDecisionDetail(entry)}`);
+    }));
+  root.command('retry-answer <id>').description('기록된 결정의 대기 질문 답 전달만 재시도한다').option('--json')
+    .action((id: string, o: { json?: boolean }) => fail(() => {
+      const entry = new DecisionLedger(config).retryAnswer(id);
+      emit(entry, o.json, `답 전달: ${entry.id} → ${entry.resume?.questionId}`);
     }));
   root.command('add-options <id>').description('선택지가 미기재된 과거 항목에 확인된 선택지를 추가')
     .requiredOption('--option <key=label:consequence>', '선택지 (두 번 이상)', repeat, [] as string[])

package/src/cli/doctor-bundle-upload.ts

@@ -0,0 +1,68 @@
+import { readFileSync, statSync } from 'node:fs';
+import { debug } from '../debug/log.js';
+
+export interface DoctorBundleUploadOptions {
+  path: string;
+  files: readonly string[];
+  uploadUrl?: string;
+  confirm: (message: string) => Promise<boolean>;
+  fetch: typeof globalThis.fetch;
+  yes?: boolean;
+  /** Present the inventory before either consent or transport; JSON callers can use stderr. */
+  announce?: (contents: string) => void;
+  /** Pass the size returned by buildDoctorBundle, if available. */
+  bytes?: number;
+}
+
+export interface DoctorBundleUploadResult {
+  path: string;
+  uploaded: boolean;
+  code?: string;
+  reason?: string;
+  exitCode: number;
+  message: string;
+}
+
+/** The bundle is local until both an HTTPS destination and affirmative consent exist. */
+export async function uploadDoctorBundle({ path, files, uploadUrl, confirm, fetch, yes = false, bytes, announce = console.log }: DoctorBundleUploadOptions): Promise<DoctorBundleUploadResult> {
+  const size = bytes ?? (() => { try { return statSync(path).size; } catch { return undefined; } })();
+  const skipped = (reason: string, message: string): DoctorBundleUploadResult => {
+    debug.log('doctor.bundle', 'upload-skipped', { bytes: size, reason });
+    return { path, uploaded: false, reason, exitCode: 0, message };
+  };
+  if (!uploadUrl?.trim()) return skipped('no-recipient', `수신처가 아직 정해지지 않았습니다 — 파일을 지원에 직접 보내 주세요: ${path}`);
+  let destination: URL;
+  try {
+    destination = new URL(uploadUrl.trim());
+    if (destination.protocol !== 'https:' || !destination.hostname || destination.username || destination.password) throw new Error('invalid destination');
+  } catch {
+    return skipped('invalid-recipient', `수신처가 유효한 HTTPS 주소가 아닙니다 — 파일을 지원에 직접 보내 주세요: ${path}`);
+  }
+  const contents = `내용 목록 (${size === undefined ? '크기 확인 불가' : `${size} bytes`}):\n${files.map((file) => `  ${file}`).join('\n')}`;
+  announce(contents);
+  if (!yes) {
+    let agreed = false;
+    try { agreed = await confirm('올릴까요? (y/N) '); } catch { /* An unavailable prompt is a refusal. */ }
+    if (!agreed) {
+      debug.log('doctor.bundle', 'declined', { bytes: size, reason: 'consent-declined' });
+      return { path, uploaded: false, reason: 'consent-declined', exitCode: 0, message: `업로드하지 않았습니다: ${path}` };
+    }
+  }
+  const failed = (reason: string): DoctorBundleUploadResult => {
+    debug.log('doctor.bundle', 'upload-failed', { bytes: size, reason });
+    return { path, uploaded: false, reason, exitCode: 1, message: `업로드 실패 (${reason}) — 파일: ${path} — 다시 시도해 주세요.` };
+  };
+  try {
+    const response = await fetch(destination.href, {
+      method: 'POST', headers: { 'Content-Type': 'application/gzip' }, body: readFileSync(path), redirect: 'manual',
+    });
+    if (!response.ok) return failed(`HTTP ${response.status}`);
+    const data: unknown = await response.json();
+    const code = data && typeof data === 'object' && !Array.isArray(data) ? (data as { code?: unknown }).code : undefined;
+    if (typeof code !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(code)) return failed('진단 코드 응답이 올바르지 않습니다');
+    debug.log('doctor.bundle', 'uploaded', { bytes: size, reason: 'success' });
+    return { path, uploaded: true, code, exitCode: 0, message: `진단 코드: ${code} — 이 코드만 지원에 알려 주세요` };
+  } catch {
+    return failed('네트워크 또는 파일 읽기 오류');
+  }
+}

package/src/cli/doctor-cli.ts

@@ -38,6 +38,7 @@ import { describeModes, formatModeLine, type DoctorMode } from './doctor-modes.j
 import { formatDoctorLocalLlm, probeDoctorLocalLlm, type DoctorLocalLlm } from './doctor-local-llm.js';
 import type { LlmInventory } from '../llm/local-manager/types.js';
 import { buildDoctorBundle } from './doctor-bundle.js';
+import { uploadDoctorBundle } from './doctor-bundle-upload.js';
 
 function defaultCheckPythonEnv(): { status: 'ok' | 'fixable' | 'manual'; evidence: string; remedy?: string } {
   const c = checkPythonEnv(false);
@@ -193,6 +194,9 @@ export interface DoctorCliDeps extends DoctorOptions, Pick<DoctorFixDeps, 'home'
   adviceInteractive?: boolean;
   /** Local-manager inventory seam; default calls getInventory(). */
   localLlmInventory?: () => Promise<LlmInventory>;
+  /** Inject the upload transport and consent for isolated CLI tests. */
+  uploadFetch?: typeof globalThis.fetch;
+  confirmBundleUpload?: (message: string) => Promise<boolean>;
 }
 
 const repositoryRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
@@ -1217,15 +1221,21 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
     .option('--json', 'structured output')
     .option('--credentials', 'show per-credential details in human-readable output')
     .option('--bundle', 'write a redacted diagnostics archive for support')
+    .option('--upload', 'send the bundle to diagnostics.uploadUrl after consent (requires --bundle)')
     .option('--out <dir>', 'output directory for --bundle')
     .option('--fix', 'show repairs; git installation asks on a TTY (other repairs require --yes)')
     .option('--advise', 'ask the configured LLM to rank catalog repairs (read-only advice)')
-    .option('--yes', 'apply planned doctor repairs (requires --fix)')
+    .option('--yes', 'apply planned doctor repairs (--fix), or confirm bundle upload (--bundle --upload)')
     .option('--sudo', 'also run the planned sudo install lines — only where `sudo -n true` works (requires --fix --yes)')
     .option('--restart', 'restart the nexus service when it runs a different version than this installed copy, then verify it (requires --fix --yes · interrupts bots, terminals and running turns)')
-    .action(async (opts: { json?: boolean; credentials?: boolean; bundle?: boolean; out?: string; fix?: boolean; advise?: boolean; yes?: boolean; sudo?: boolean; restart?: boolean }) => {
+    .action(async (opts: { json?: boolean; credentials?: boolean; bundle?: boolean; upload?: boolean; out?: string; fix?: boolean; advise?: boolean; yes?: boolean; sudo?: boolean; restart?: boolean }) => {
+      if (opts.upload && !opts.bundle) {
+        err.error('--upload requires --bundle');
+        setExitCode(1);
+        return;
+      }
       if (opts.bundle) {
-        if (opts.fix || opts.advise || opts.yes || opts.sudo || opts.restart) {
+        if (opts.fix || opts.advise || opts.sudo || opts.restart || (opts.yes && !opts.upload)) {
           err.error('--bundle cannot be combined with repair or advice options');
           setExitCode(1);
           return;
@@ -1235,7 +1245,31 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
           const doctorReport = runDoctor(deps);
           if (doctorReport.ok) doctorReport.localLlm = await probeDoctorLocalLlm(deps.localLlmInventory);
           const result = buildDoctorBundle({ outDir: opts.out ?? process.cwd(), doctorOptions: deps, doctorReport });
-          out.log(opts.json ? JSON.stringify(result) : [`Diagnostics: ${result.path} (${result.bytes} bytes)`, 'Contents:', ...result.files.map((file) => `  ${file}`)].join('\n'));
+          if (opts.upload) {
+            let uploadUrl: string | undefined;
+            try { uploadUrl = (deps.userConfig ?? (deps.getUserConfig ?? getUserConfig)()).diagnostics?.uploadUrl; }
+            catch {
+              const reason = '설정을 읽을 수 없습니다';
+              debug.log('doctor.bundle', 'upload-failed', { bytes: result.bytes, reason: 'config-read-failed' });
+              if (opts.json) out.log(JSON.stringify({ path: result.path, uploaded: false, reason }));
+              else err.error(`업로드 실패 (${reason}) — 파일: ${result.path} — 다시 시도해 주세요.`);
+              setExitCode(1);
+              return;
+            }
+            const uploaded = await uploadDoctorBundle({
+              ...result,
+              uploadUrl,
+              yes: opts.yes,
+              announce: (contents) => { if (opts.json) err.error(contents); else out.log(contents); },
+              confirm: deps.confirmBundleUpload ?? ((message) => confirmDoctorAdvice(message, opts.json === true)),
+              fetch: deps.uploadFetch ?? globalThis.fetch,
+            });
+            if (opts.json) out.log(JSON.stringify({ path: uploaded.path, uploaded: uploaded.uploaded, ...(uploaded.code ? { code: uploaded.code } : {}), ...(uploaded.reason ? { reason: uploaded.reason } : {}) }));
+            else out.log(uploaded.message);
+            if (uploaded.exitCode) setExitCode(uploaded.exitCode);
+          } else {
+            out.log(opts.json ? JSON.stringify(result) : [`Diagnostics: ${result.path} (${result.bytes} bytes)`, 'Contents:', ...result.files.map((file) => `  ${file}`)].join('\n'));
+          }
         } catch {
           err.error('Could not create diagnostics archive.');
           setExitCode(1);