Fix ctrl+c and hypotheses options

Author: lhy0718

src/config.ts

@@ -71,6 +71,7 @@ export async function analyzePaperWithLlm(args: {
   paper: AnalysisCorpusRow;
   source: ResolvedPaperSource;
   maxAttempts?: number;
+  abortSignal?: AbortSignal;
   onProgress?: (message: string) => void;
 }): Promise<PaperAnalysisResult> {
   const maxAttempts = Math.max(1, args.maxAttempts ?? 2);
@@ -81,6 +82,7 @@ export async function analyzePaperWithLlm(args: {
       args.onProgress?.(`Starting LLM analysis attempt ${attempt}/${maxAttempts}.`);
       const completion = await args.llm.complete(buildPaperAnalysisPrompt(args.paper, args.source), {
         systemPrompt: ANALYSIS_SYSTEM_PROMPT,
+        abortSignal: args.abortSignal,
         onProgress: (event) => {
           emitLlmProgress(args.onProgress, event);
         }
@@ -94,6 +96,9 @@ export async function analyzePaperWithLlm(args: {
         rawJson: parsed
       };
     } catch (error) {
+      if (isAbortError(error)) {
+        throw error;
+      }
       lastError = error instanceof Error ? error : new Error(String(error));
       args.onProgress?.(`Analysis attempt ${attempt}/${maxAttempts} failed: ${lastError.message}`);
     }
@@ -140,6 +145,9 @@ export async function analyzePaperWithResponsesPdf(args: {
         rawJson: parsed
       };
     } catch (error) {
+      if (isAbortError(error)) {
+        throw error;
+      }
       lastError = error instanceof Error ? error : new Error(String(error));
       args.onProgress?.(`PDF analysis attempt ${attempt}/${maxAttempts} failed: ${lastError.message}`);
     }
@@ -151,11 +159,15 @@ export async function analyzePaperWithResponsesPdf(args: {
 export function shouldFallbackResponsesPdfToLocalText(error: unknown): boolean {
   const message = error instanceof Error ? error.message : String(error);
   return [
+    /error while downloading/i,
     /timeout while downloading/i,
     /failed to download/i,
     /unable to download/i,
     /unable to fetch/i,
     /could not fetch/i,
+    /upstream status code:\s*40[34]/i,
+    /invalid_request_error/i,
+    /param"\s*:\s*"url"/i,
     /file_url/i,
     /remote file/i
   ].some((pattern) => pattern.test(message));
@@ -181,6 +193,14 @@ function emitLlmProgress(
   }
 }
 
+function isAbortError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  return message.includes("aborted") || message.includes("abort");
+}
+
 export function buildPaperAnalysisPrompt(paper: AnalysisCorpusRow, source: ResolvedPaperSource): string {
   return [
     "Analyze the following paper and extract structured evidence.",

src/core/analysis/paperAnalyzer.ts

@@ -103,6 +103,7 @@ export async function selectPapersForAnalysis(args: {
   corpusRows: AnalysisCorpusRow[];
   request: AnalysisSelectionRequest;
   onProgress?: (message: string) => void;
+  abortSignal?: AbortSignal;
 }): Promise<PaperSelectionResult> {
   args.onProgress?.(
     `Deterministic pre-rank started for ${args.corpusRows.length} paper(s) using title/topic similarity, citation count, recency, and PDF availability.`
@@ -131,7 +132,7 @@ export async function selectPapersForAnalysis(args: {
     };
   }
 
-  const candidatePoolSize = Math.min(totalCandidates, Math.max(args.request.topN * 5, 50));
+  const candidatePoolSize = Math.min(totalCandidates, Math.min(Math.max(args.request.topN * 3, 30), 90));
   const candidatePool = ranked.slice(0, candidatePoolSize);
   args.onProgress?.(
     `Preparing LLM rerank for ${candidatePool.length} candidate(s) to choose top ${args.request.topN}.`
@@ -148,7 +149,8 @@ export async function selectPapersForAnalysis(args: {
     args.runTopic,
     args.request.topN,
     candidatePool,
-    args.onProgress
+    args.onProgress,
+    args.abortSignal
   );
   const rerankedIds = rerank.orderedPaperIds;
   const rerankOrder = new Map<string, number>(rerankedIds.map((paperId, index) => [paperId, index]));
@@ -253,12 +255,14 @@ async function rerankCandidates(
   runTopic: string,
   topN: number,
   candidates: RankedPaperCandidate[],
-  onProgress?: (message: string) => void
+  onProgress?: (message: string) => void,
+  abortSignal?: AbortSignal
 ): Promise<{ orderedPaperIds: string[]; applied: boolean; fallbackReason?: string }> {
   try {
     onProgress?.(`Submitting rerank request for ${candidates.length} candidate(s).`);
     const response = await llm.complete(buildRerankPrompt(referenceTitle, runTopic, topN, candidates), {
       systemPrompt: RERANK_SYSTEM_PROMPT,
+      abortSignal,
       onProgress: (event) => {
         const text = event.text.trim();
         if (!text) {
@@ -290,6 +294,9 @@ async function rerankCandidates(
       applied: true
     };
   } catch (error) {
+    if (isAbortError(error)) {
+      throw error;
+    }
     onProgress?.(`Rerank request failed: ${error instanceof Error ? error.message : String(error)}`);
     return {
       orderedPaperIds: candidates.map((candidate) => candidate.paper.paper_id),
@@ -299,6 +306,14 @@ async function rerankCandidates(
   }
 }
 
+function isAbortError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  return message.includes("aborted") || message.includes("abort");
+}
+
 function buildRerankPrompt(
   referenceTitle: string,
   runTopic: string,

src/core/analysis/paperSelection.ts

@@ -1,5 +1,9 @@
 import { GraphNodeId, RunRecord } from "../../types.js";
-import { buildCollectSlashCommand } from "./naturalDeterministic.js";
+import {
+  buildCollectSlashCommand,
+  extractCollectRequestFromNatural,
+  resolveNodeAlias
+} from "./naturalDeterministic.js";
 import { CollectCommandRequest } from "./collectOptions.js";
 
 export interface NaturalActionTextClient {
@@ -8,6 +12,7 @@ export interface NaturalActionTextClient {
     sandboxMode?: string;
     approvalPolicy?: string;
     systemPrompt?: string;
+    reasoningEffort?: string;
     abortSignal?: AbortSignal;
   }): Promise<string>;
 }
@@ -62,7 +67,7 @@ interface StructuredAction {
   title?: string;
 }
 
-const ACTION_EXTRACTION_TIMEOUT_MS = 30000;
+const ACTION_EXTRACTION_TIMEOUT_MS = 12000;
 
 const ACTION_HINT_PATTERNS = [
   /(?:collect|gather|fetch|search|lookup|find|research|investigate|analy[sz]e|clear|remove|delete|jump|go\s+to|move\s+to|rename|change)/iu,
@@ -104,6 +109,11 @@ export function looksLikeStructuredActionRequest(text: string): boolean {
 export async function extractStructuredActionPlan(
   ctx: StructuredNaturalActionContext
 ): Promise<StructuredNaturalActionPlan | undefined> {
+  const fastPlan = extractFastStructuredActionPlan(ctx.input, ctx.runs, ctx.activeRunId);
+  if (fastPlan) {
+    return fastPlan;
+  }
+
   const activeRun = resolveActiveRun(ctx.runs, ctx.activeRunId);
   const prompt = buildStructuredActionPrompt(ctx.input, ctx.runs, activeRun?.id);
   ctx.onProgress?.("Extracting structured action intent...");
@@ -144,6 +154,174 @@ export async function extractStructuredActionPlan(
   };
 }
 
+function extractFastStructuredActionPlan(
+  input: string,
+  runs: RunRecord[],
+  activeRunId?: string
+): StructuredNaturalActionPlan | undefined {
+  const targetRun = resolveActiveRun(runs, activeRunId);
+  const clearThenFollowUp = extractFastClearThenFollowupActions(input, targetRun);
+  const actions: StructuredAction[] =
+    clearThenFollowUp ??
+    (() => {
+      const analyzeAction = extractFastAnalyzeAction(input);
+      if (analyzeAction) {
+        return [analyzeAction];
+      }
+      const collectRequest = extractCollectRequestFromNatural(input);
+      if (collectRequest) {
+        const collectAction = convertCollectRequestToStructuredAction(collectRequest, targetRun);
+        return collectAction ? [collectAction] : [];
+      }
+      const clearAction = extractFastClearAction(input);
+      if (clearAction) {
+        return [clearAction];
+      }
+      const jumpAction = extractFastJumpAction(input);
+      return jumpAction ? [jumpAction] : [];
+    })();
+
+  if (actions.length === 0) {
+    return undefined;
+  }
+  const commands = actions
+    .map((action) => buildCommandForStructuredAction(action, targetRun?.id))
+    .filter(Boolean) as string[];
+  if (commands.length === 0) {
+    return undefined;
+  }
+  return {
+    lines: buildSummaryLines(actions, detectLanguage(input)),
+    commands,
+    displayActions: actions.map((action) => summarizeAction(action, detectLanguage(input))),
+    targetRunId: targetRun?.id
+  };
+}
+
+function extractFastClearThenFollowupActions(
+  raw: string,
+  targetRun?: RunRecord
+): StructuredAction[] | undefined {
+  const clearAction = extractFastClearAction(raw);
+  if (!clearAction) {
+    return undefined;
+  }
+  const remainder = extractFollowupAfterClear(raw);
+  if (!remainder) {
+    return undefined;
+  }
+  const analyzeAction = extractFastAnalyzeAction(remainder);
+  if (analyzeAction) {
+    return [clearAction, analyzeAction];
+  }
+  const collectRequest = extractCollectRequestFromNatural(remainder);
+  if (collectRequest) {
+    const collectAction = convertCollectRequestToStructuredAction(collectRequest, targetRun);
+    if (collectAction) {
+      return [clearAction, collectAction];
+    }
+  }
+  const jumpAction = extractFastJumpAction(remainder);
+  if (jumpAction) {
+    return [clearAction, jumpAction];
+  }
+  return undefined;
+}
+
+function extractFollowupAfterClear(raw: string): string | undefined {
+  const normalized = raw.trim();
+  const match = normalized.match(
+    /(?:지우고|삭제하고|제거하고|없애고|clear(?:\s+out)?|remove(?:\s+all)?|delete(?:\s+all)?)([\s\S]+)/iu
+  );
+  const remainder = match?.[1]?.trim();
+  if (!remainder || remainder === normalized) {
+    return undefined;
+  }
+  return remainder.replace(/^(?:다시|then|and\s+then)\s+/iu, "").trim() || undefined;
+}
+
+function convertCollectRequestToStructuredAction(
+  request: CollectCommandRequest,
+  targetRun?: RunRecord
+): StructuredAction | undefined {
+  return {
+    type: "collect",
+    query: normalizeCollectQueryReference(request.query, targetRun),
+    limit: request.limit,
+    additional: request.additional,
+    filters: {
+      last_years: request.filters.lastYears,
+      year: request.filters.year,
+      date_range: request.filters.dateRange,
+      fields: request.filters.fieldsOfStudy,
+      venues: request.filters.venues,
+      publication_types: request.filters.publicationTypes,
+      min_citations: request.filters.minCitationCount,
+      open_access: request.filters.openAccessPdf
+    },
+    sort: {
+      field: request.sort.field,
+      order: request.sort.order
+    },
+    bibtex_mode: request.bibtexMode,
+    dry_run: request.dryRun
+  };
+}
+
+function normalizeCollectQueryReference(query: string | undefined, targetRun?: RunRecord): string | undefined {
+  const trimmed = query?.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  if (/^(?:title|run title|현재 title|현재 제목|제목)$/iu.test(trimmed)) {
+    return targetRun?.title ?? trimmed;
+  }
+  if (/^(?:topic|run topic|현재 topic|현재 주제|주제)$/iu.test(trimmed)) {
+    return targetRun?.topic ?? trimmed;
+  }
+  return trimmed;
+}
+
+function extractFastAnalyzeAction(raw: string): StructuredAction | undefined {
+  const normalized = raw.trim();
+  const lower = normalized.toLowerCase();
+  const hasAnalyzeVerb = /분석|analy[sz]e/u.test(normalized);
+  if (!hasAnalyzeVerb) {
+    return undefined;
+  }
+  const topMatch =
+    normalized.match(/상위\s*(\d+)\s*(?:개|편|건)?/u) ||
+    lower.match(/\btop\s+(\d+)\b/u) ||
+    normalized.match(/(\d+)\s*(?:개|편|건|papers?)\s*(?:만)?[^.\n]{0,40}분석/u) ||
+    normalized.match(/분석[^.\n]{0,40}(\d+)\s*(?:개|편|건|papers?)/u);
+  const topN = toPositiveInt(topMatch?.[1]);
+  return topN ? { type: "analyze_papers", top_n: topN } : undefined;
+}
+
+function extractFastClearAction(raw: string): StructuredAction | undefined {
+  const normalized = raw.trim();
+  const hasPaperWord = /논문|paper|papers/u.test(normalized);
+  const hasClearVerb =
+    /삭제|제거|지워|지우|없애|clear|remove|delete/u.test(normalized) &&
+    /모두|전부|전체|all/u.test(normalized);
+  if (!hasPaperWord || !hasClearVerb) {
+    return undefined;
+  }
+  return { type: "clear", node: "collect_papers" };
+}
+
+function extractFastJumpAction(raw: string): StructuredAction | undefined {
+  const node = resolveNodeAlias(raw);
+  if (!node) {
+    return undefined;
+  }
+  const hasMoveVerb = /이동|점프|돌아가|되돌아가|go\s+to|move\s+to|jump/u.test(raw);
+  if (!hasMoveVerb) {
+    return undefined;
+  }
+  return { type: "jump", node, force: false };
+}
+
 function buildStructuredActionPrompt(input: string, runs: RunRecord[], activeRunId?: string): string {
   const runsSnapshot = runs.slice(0, 8).map((run) => ({
     id: run.id,
@@ -537,6 +715,7 @@ async function runForTextWithTimeout(
     sandboxMode?: string;
     approvalPolicy?: string;
     systemPrompt?: string;
+    reasoningEffort?: string;
     abortSignal?: AbortSignal;
   },
   timeoutMs: number

src/core/commands/naturalActionIntent.ts

@@ -121,6 +121,7 @@ function buildConstraintPrompt(run: RunRecord): string {
     "",
     "Normalization rules:",
     "- Keep collect defaults generic. Explicit slash options will override these defaults later.",
+    "- Do not set publicationTypes for generic phrases like 'papers', 'recent papers', or 'articles'. Only set specific types such as Review when explicitly requested.",
     "- Use targetVenue only for actual venue or paper-style constraints.",
     "- Use toneHint and lengthHint only when clearly stated.",
     "- Put practical downstream implications into experiment.designNotes / implementationNotes / evaluationNotes.",