research-copilot 0.2.11 → 0.2.14

package/app/out/main/index.mjs

@@ -633,6 +633,43 @@ function registerUsageHandlers(handle, getCtx, loadUsageTotals2, resetUsageTotal
     return resetUsageTotals2(baseDir);
   });
 }
+const LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
+const inFlightLogin = /* @__PURE__ */ new Map();
+function loginErrorMessage(raw, label) {
+  const msg = (raw instanceof Error ? raw.message : String(raw ?? "")).trim();
+  return msg || `${label} OAuth login failed`;
+}
+async function runLoginWithTimeout(key, label, runLogin, onSuccess) {
+  if (inFlightLogin.has(key)) {
+    return { success: false, error: `${label} sign-in is already in progress. Cancel it first.` };
+  }
+  let rejectManual = () => {
+  };
+  const manualPromise = new Promise((_, reject) => {
+    rejectManual = reject;
+  });
+  manualPromise.catch(() => {
+  });
+  const attempt = {
+    abort: (reason) => rejectManual(new Error(reason))
+  };
+  inFlightLogin.set(key, attempt);
+  const timer = setTimeout(() => {
+    attempt.abort(
+      `${label} sign-in timed out after ${Math.round(LOGIN_TIMEOUT_MS / 6e4)} minutes. Please try again.`
+    );
+  }, LOGIN_TIMEOUT_MS);
+  try {
+    const creds = await runLogin(() => manualPromise);
+    onSuccess(creds);
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: loginErrorMessage(err, label) };
+  } finally {
+    clearTimeout(timer);
+    if (inFlightLogin.get(key) === attempt) inFlightLogin.delete(key);
+  }
+}
 function registerAuthHandlers(handleRaw) {
   handleRaw("auth:get-anthropic-status", () => {
     const hasApiKey = !!(process.env.ANTHROPIC_API_KEY || "").trim();
@@ -659,8 +696,10 @@ function registerAuthHandlers(handleRaw) {
   handleRaw("auth:anthropic-sub-login", async () => {
     const { loginAnthropic } = await import("@mariozechner/pi-ai/oauth");
     const { shell: shell2 } = await import("electron");
-    try {
-      const creds = await loginAnthropic({
+    return runLoginWithTimeout(
+      "anthropic-sub",
+      "Anthropic",
+      (onManualCodeInput) => loginAnthropic({
         onAuth: (info) => {
           shell2.openExternal(info.url);
         },
@@ -670,13 +709,17 @@ function registerAuthHandlers(handleRaw) {
         },
         onProgress: (msg) => {
           console.log("[OAuth Anthropic]", msg);
-        }
-      });
-      saveAnthropicSubCredentials(creds);
-      return { success: true };
-    } catch (err) {
-      return { success: false, error: err.message || "Anthropic OAuth login failed" };
-    }
+        },
+        onManualCodeInput
+      }),
+      (creds) => saveAnthropicSubCredentials(creds)
+    );
+  });
+  handleRaw("auth:anthropic-sub-cancel", () => {
+    const attempt = inFlightLogin.get("anthropic-sub");
+    if (!attempt) return { success: false, error: "No Anthropic sign-in in progress" };
+    attempt.abort("Anthropic sign-in cancelled.");
+    return { success: true };
   });
   handleRaw("auth:anthropic-sub-logout", () => {
     clearAnthropicSubCredentials();
@@ -704,8 +747,10 @@ function registerAuthHandlers(handleRaw) {
   handleRaw("auth:openai-codex-login", async () => {
     const { loginOpenAICodex } = await import("@mariozechner/pi-ai/oauth");
     const { shell: shell2 } = await import("electron");
-    try {
-      const creds = await loginOpenAICodex({
+    return runLoginWithTimeout(
+      "openai-codex",
+      "ChatGPT",
+      (onManualCodeInput) => loginOpenAICodex({
         onAuth: (info) => {
           shell2.openExternal(info.url);
         },
@@ -715,13 +760,17 @@ function registerAuthHandlers(handleRaw) {
         },
         onProgress: (msg) => {
           console.log("[OAuth]", msg);
-        }
-      });
-      saveCodexCredentials(creds);
-      return { success: true };
-    } catch (err) {
-      return { success: false, error: err.message || "OAuth login failed" };
-    }
+        },
+        onManualCodeInput
+      }),
+      (creds) => saveCodexCredentials(creds)
+    );
+  });
+  handleRaw("auth:openai-codex-cancel", () => {
+    const attempt = inFlightLogin.get("openai-codex");
+    if (!attempt) return { success: false, error: "No ChatGPT sign-in in progress" };
+    attempt.abort("ChatGPT sign-in cancelled.");
+    return { success: true };
   });
   handleRaw("auth:openai-codex-logout", () => {
     clearCodexCredentials();
@@ -1255,6 +1304,32 @@ function readLatestSessionSummary(projectPath, sessionId) {
   });
   return readJson(join(dir, files[0]), null);
 }
+function readOrphanMessages(projectPath, sessionId, cutoffMs) {
+  const file = join(projectPath, PATHS.sessions, `${sessionId}.jsonl`);
+  if (!existsSync(file)) return [];
+  const result = [];
+  let raw;
+  try {
+    raw = readFileSync(file, "utf-8");
+  } catch {
+    return [];
+  }
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!msg || typeof msg !== "object") continue;
+    if (msg.role !== "user" && msg.role !== "assistant") continue;
+    if (typeof msg.timestamp !== "number" || msg.timestamp <= cutoffMs) continue;
+    if (typeof msg.content !== "string" || msg.content.length === 0) continue;
+    result.push({ role: msg.role, content: msg.content, timestamp: msg.timestamp });
+  }
+  return result;
+}
 function generateCiteKey$1(authors, year, title) {
   const firstAuthor = authors[0] || "unknown";
   const lastName = firstAuthor.split(/\s+/).pop()?.toLowerCase() || "unknown";
@@ -2619,29 +2694,30 @@ If conversation history contains previous literature-search results with coverag
 ## Rules
 
 1. You MUST provide a \`relevanceJustification\` for EVERY paper explaining WHY it received that score
-2. After scoring all papers, perform a FORCED RANKING: cut the bottom 30% — papers in the bottom 30% get excluded from relevantPapers even if their score is above threshold
+2. After scoring all papers, perform a FORCED RANKING: cut the bottom 30% — papers in the bottom 30% get excluded from scoredPapers even if their score is above threshold
 3. Auto-save threshold is **>= 7**. Papers scoring 7+ are saved to the local library. Be decisive: if a paper is meaningfully relevant (not just tangential), score it >= 7.
 4. Approve only if at least 3 papers score >= 7 AND coverage >= 0.5. If confidence is low or critical coverage is missing, request targeted refinement.
 5. If not approved, suggest at most 2-3 **targeted refinement queries** for specific missing sub-topics — NOT broad re-searches. These queries run through the FULL search pipeline again, so be selective. CRITICAL: Your refinement queries MUST be DIFFERENT from the "Queries used" listed at the bottom — the system will reject duplicate queries. Use different terminology, synonyms, or narrower/broader scope to find what the original queries missed
 6. Track cumulative coverage across sub-topics
-7. Output size guard: include AT MOST 25 relevantPapers. If there are any reasonably relevant papers, include at least 3 (do NOT return an empty list unless ZERO papers are even tangentially relevant).
+7. Output size guard: include AT MOST 25 scoredPapers. If there are any reasonably relevant papers, include at least 3 (do NOT return an empty list unless ZERO papers are even tangentially relevant).
 
-## Paper metadata preservation
+## CRITICAL: Compact output contract
 
-IMPORTANT: Preserve ALL paper metadata in relevantPapers. Every paper MUST include ALL fields — copy exactly from input, using null for missing values:
-- id, title, authors (full array), abstract (full text if possible; may truncate if very long), year, url
-- source (e.g. "semantic_scholar", "arxiv", "openalex", "dblp", "local")
-- relevanceScore (your 0-10 rating), relevanceJustification (1-2 sentence explanation)
-- doi (string or null), venue (string or null), citationCount (number or null)
+The caller already holds the full paper metadata (title, authors, abstract, venue, doi, year, url, citationCount, source). You MUST NOT echo any of it back. Your ONLY job is to return scoring decisions keyed by the paper's **index number** — the 1-based number shown at the start of each paper line in the input (e.g. \`1. [semantic_scholar] "Foo..."\` → \`index: 1\`).
 
-If the full abstract is very long, you may truncate it to ~800 characters, but preserve the core meaning. Do NOT omit authors. Do NOT drop any field.
+- Output ONLY integers for \`index\`, integers 0-10 for \`relevanceScore\`, and a short 1-2 sentence \`relevanceJustification\`.
+- Do NOT include title, authors, abstract, venue, doi, year, url, source, or citationCount fields in scoredPapers. Those will be merged by the caller.
+- Every \`index\` MUST refer to a paper actually shown in the input. Do not invent indices.
+- Do not wrap the JSON in markdown fences unless strictly necessary; raw JSON is preferred.
+
+Keeping the output compact is REQUIRED — echoing metadata caused past responses to be truncated, making the entire review unparseable.
 
 ## Output JSON
 
 {
   "approved": boolean,
-  "relevantPapers": [
-    { "id": "...", "title": "...", "authors": [...], "abstract": "full text...", "year": number, "url": "...", "source": "...", "relevanceScore": number, "relevanceJustification": "why this score", "doi": "..." or null, "venue": "..." or null, "citationCount": number or null }
+  "scoredPapers": [
+    { "index": 1, "relevanceScore": 9, "relevanceJustification": "1-2 sentence explanation" }
   ],
   "confidence": number,
   "coverage": {
@@ -3427,20 +3503,46 @@ Additional context: ${extraContext}` : `Research request: ${query}`;
       try {
         const reviewText = await ctx.callLlm(REVIEWER_SYSTEM, reviewInput);
         const parsed = safeJsonParse(reviewText);
-        if (!parsed) {
+        if (!parsed || !Array.isArray(parsed.scoredPapers)) {
+          const fallbackCap = ctx.settings?.researchIntensity?.reviewCap ?? 25;
           review = {
             approved: true,
-            relevantPapers: deduplicated.slice(0, ctx.settings?.researchIntensity?.reviewCap ?? 25).map((p) => ({ ...p, relevanceScore: 5, relevanceJustification: "Review parsing failed; included by default." })),
-            confidence: 0.5,
-            coverage: { score: 0.5, coveredTopics: [], missingTopics: [], gaps: ["Review parsing failed"] },
+            relevantPapers: deduplicated.slice(0, fallbackCap).map((p) => ({
+              ...p,
+              relevanceScore: 7,
+              relevanceJustification: "Review parsing failed; included with default score 7 so the paper is still saved. Re-review manually."
+            })),
+            confidence: 0.3,
+            coverage: { score: 0.3, coveredTopics: [], missingTopics: [], gaps: ["Review parsing failed"] },
             issues: ["Review parsing failed"],
             additionalQueries: null
           };
           pipelineWarnings.push(
-            "LLM review parsing failed — papers included with default relevance score of 5. Relevance scores may not be accurate. Consider re-reviewing the top papers manually."
+            "LLM review parsing failed — papers saved with default relevance score of 7. Relevance scores are NOT accurate. Re-review the saved papers manually."
           );
         } else {
-          review = parsed;
+          const seenIndices = /* @__PURE__ */ new Set();
+          const merged = [];
+          for (const s of parsed.scoredPapers) {
+            const idx = (Number(s?.index) | 0) - 1;
+            if (idx < 0 || idx >= deduplicated.length) continue;
+            if (seenIndices.has(idx)) continue;
+            seenIndices.add(idx);
+            const score = Number(s?.relevanceScore);
+            merged.push({
+              ...deduplicated[idx],
+              relevanceScore: Number.isFinite(score) ? score : 0,
+              relevanceJustification: typeof s?.relevanceJustification === "string" ? s.relevanceJustification : ""
+            });
+          }
+          review = {
+            approved: parsed.approved ?? false,
+            relevantPapers: merged,
+            confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0.5,
+            coverage: parsed.coverage ?? { score: 0.5, coveredTopics: [], missingTopics: [], gaps: [] },
+            issues: Array.isArray(parsed.issues) ? parsed.issues : [],
+            additionalQueries: parsed.additionalQueries ?? null
+          };
         }
       } catch (err) {
         return toAgentResult("literature-search", toolError("EXECUTION_FAILED", `Review step failed: ${err.message}`, {
@@ -6511,6 +6613,7 @@ function getWikiRoot() {
   return join(homedir(), ".research-pilot", "paper-wiki");
 }
 const GENERATOR_VERSION = 3;
+const HASH_SCHEMA_VERSION = 2;
 function isValidArxivId(arxivId) {
   const bare = arxivId.replace(/^https?:\/\/arxiv\.org\/abs\//, "").replace(/v\d+$/, "");
   if (/^\d{4}\.\d{4,}$/.test(bare)) return true;
@@ -6529,6 +6632,18 @@ function computeCanonicalKey(artifact) {
   return { canonicalKey: `title:${title}:${artifact.year ?? "nd"}`, keySource: "title+year" };
 }
 function computeSemanticHash(artifact) {
+  const projection = {
+    title: artifact.title,
+    authors: artifact.authors,
+    abstract: artifact.abstract,
+    year: artifact.year,
+    venue: artifact.venue,
+    doi: artifact.doi,
+    arxivId: artifact.arxivId
+  };
+  return createHash("sha256").update(JSON.stringify(projection)).digest("hex").slice(0, 16);
+}
+function computeSemanticHashV1(artifact) {
   const projection = {
     title: artifact.title,
     authors: artifact.authors,
@@ -6544,6 +6659,10 @@ function computeSemanticHash(artifact) {
   };
   return createHash("sha256").update(JSON.stringify(projection)).digest("hex").slice(0, 16);
 }
+function canSilentRestampLegacyWatermark(priorWatermark, artifact) {
+  if ((priorWatermark.hashSchemaVersion ?? 1) >= HASH_SCHEMA_VERSION) return false;
+  return priorWatermark.semanticHash === computeSemanticHashV1(artifact);
+}
 function canonicalKeyToSlug(canonicalKey) {
   return canonicalKey.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 120);
 }
@@ -6629,6 +6748,25 @@ function markPaperProcessed(entry) {
   const content = Array.from(existing.values()).map((e) => JSON.stringify(e)).join("\n") + "\n";
   safeWriteFile(path2, content);
 }
+function restampProcessedBatch(updates) {
+  if (updates.length === 0) return;
+  const existing = readProcessedWatermark();
+  let changed = 0;
+  for (const upd of updates) {
+    const entry = existing.get(upd.canonicalKey);
+    if (!entry) continue;
+    existing.set(upd.canonicalKey, {
+      ...entry,
+      semanticHash: upd.semanticHash,
+      hashSchemaVersion: upd.hashSchemaVersion
+    });
+    changed++;
+  }
+  if (changed === 0) return;
+  const path2 = processedPath();
+  const content = Array.from(existing.values()).map((e) => JSON.stringify(e)).join("\n") + "\n";
+  safeWriteFile(path2, content);
+}
 function markFulltextFailure(canonicalKey) {
   const existing = readProcessedWatermark();
   const entry = existing.get(canonicalKey);
@@ -8731,6 +8869,14 @@ function buildSessionSummaryContext(summary) {
   ];
   return lines.join("\n");
 }
+function buildRecentConversationContext(messages) {
+  const lines = ["## Recent Conversation (resumed from prior session)", ""];
+  for (const msg of messages) {
+    const speaker = msg.role === "user" ? "User" : "Assistant";
+    lines.push(`**${speaker}:** ${msg.content}`, "");
+  }
+  return lines.join("\n").trimEnd();
+}
 function writeExplainSnapshot(projectPath, snapshot) {
   const explainDir = join(projectPath, PATHS.explainDir);
   mkdirSync(explainDir, { recursive: true });
@@ -8875,12 +9021,13 @@ async function createCoordinator(config) {
   const skillsCatalog = buildSkillsCatalogPrompt(skills);
   const baseSystemPrompt = SYSTEM_PROMPT + (skillsCatalog ? "\n\n" + skillsCatalog : "");
   let compactionSummary;
+  let bootstrapDone = false;
   const agent = new Agent({
     initialState: {
       systemPrompt: baseSystemPrompt,
       model: piModel ?? void 0,
       tools: allTools,
-      thinkingLevel: reasoningEffort === "high" ? "high" : reasoningEffort === "medium" ? "medium" : "low"
+      thinkingLevel: reasoningEffort === "max" ? "xhigh" : reasoningEffort === "high" ? "high" : reasoningEffort === "medium" ? "medium" : "low"
     },
     sessionId,
     getApiKey: resolveApiKey,
@@ -9078,6 +9225,22 @@ ${historyText}`,
         const mentionContext = buildMentionContext(mentions);
         const latestSummary = readLatestSessionSummary(projectPath, sessionId);
         const summaryContext = latestSummary ? buildSessionSummaryContext(latestSummary) : "";
+        let bootstrapContext = "";
+        if (!bootstrapDone) {
+          bootstrapDone = true;
+          try {
+            const cutoffMs = latestSummary ? Date.parse(latestSummary.createdAt) || 0 : 0;
+            const orphans = readOrphanMessages(projectPath, sessionId, cutoffMs);
+            if (orphans.length > 0) {
+              bootstrapContext = buildRecentConversationContext(orphans);
+              if (debug) {
+                console.log(`[Bootstrap] Recovered ${orphans.length} orphan message(s) from prior session`);
+              }
+            }
+          } catch (err) {
+            if (debug) console.warn("[Bootstrap] Failed to read orphan messages:", err);
+          }
+        }
         const persistence = classifyPersistenceDecision(message);
         const explain = {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -9119,6 +9282,7 @@ ${agentMdContent}`;
         agent.state.systemPrompt = enrichedSystem;
         const contextParts = [];
         if (summaryContext) contextParts.push(summaryContext);
+        if (bootstrapContext) contextParts.push(bootstrapContext);
         if (skillSummariesPrompt) contextParts.push(skillSummariesPrompt);
         if (mentionContext) contextParts.push(mentionContext);
         let userMessage = contextParts.length > 0 ? `${contextParts.join("\n\n")}
@@ -9162,6 +9326,23 @@ ${message}` : message;
           }
         }
         writeExplainSnapshot(projectPath, explain);
+        const stopReason = lastMsg && "stopReason" in lastMsg ? lastMsg.stopReason : void 0;
+        const errorMessage = lastMsg && "errorMessage" in lastMsg ? lastMsg.errorMessage : void 0;
+        if (stopReason === "aborted") {
+          return { success: false, error: "Generation stopped by user." };
+        }
+        if (stopReason === "error") {
+          return {
+            success: false,
+            error: errorMessage || "The LLM request failed. This usually indicates an issue on the model server or with authentication. If you are using a Claude or ChatGPT subscription, try signing out and back in via Settings. Otherwise verify your API key, model selection, and network connection."
+          };
+        }
+        if (!responseText && responseImages.length === 0) {
+          return {
+            success: false,
+            error: `The model returned an empty response (stopReason=${stopReason ?? "unknown"}). This usually indicates a transient issue with the LLM server. Please try again. If the problem persists and you are using a Claude or ChatGPT subscription, try signing out and back in via Settings.`
+          };
+        }
         turnCount++;
         turnHistory.push({
           userMessage: message.slice(0, 300),
@@ -11131,6 +11312,7 @@ function scanForNewContent(projectPaths) {
   const processed = readProcessedWatermark();
   const toProcess = [];
   const provenanceOnly = [];
+  const restamps = [];
   const existingProvenance = readProvenance();
   const provenanceIndex = /* @__PURE__ */ new Map();
   for (const entry of existingProvenance) {
@@ -11189,6 +11371,20 @@ function scanForNewContent(projectPaths) {
         provenanceIndex.delete(fallbackKey);
       }
     }
+    const priorWatermark = processed.get(canonicalKey);
+    if (priorWatermark && canSilentRestampLegacyWatermark(priorWatermark, artifact)) {
+      const restamped = {
+        ...priorWatermark,
+        semanticHash,
+        hashSchemaVersion: HASH_SCHEMA_VERSION
+      };
+      processed.set(canonicalKey, restamped);
+      restamps.push({
+        canonicalKey,
+        semanticHash,
+        hashSchemaVersion: HASH_SCHEMA_VERSION
+      });
+    }
     const watermark = processed.get(canonicalKey);
     const knownProvenance = provenanceIndex.get(canonicalKey) || /* @__PURE__ */ new Set();
     const siblings = entries.filter((e) => e.artifact.id !== artifact.id || e.projectPath !== projectPath).map((e) => ({ projectPath: e.projectPath, artifact: e.artifact }));
@@ -11227,6 +11423,9 @@ function scanForNewContent(projectPaths) {
     const bTime = new Date(b.artifact.createdAt).getTime();
     return bTime - aTime;
   });
+  if (restamps.length > 0) {
+    restampProcessedBatch(restamps);
+  }
   return { toProcess, provenanceOnly };
 }
 const ARXIV_RATE_LIMIT_MS = 3e3;
@@ -11347,19 +11546,6 @@ function buildPaperUserContent(artifact, fulltext, existingConceptSlugs) {
   parts.push(`
 Abstract:
 ${artifact.abstract || "(no abstract)"}`);
-  if (artifact.keyFindings?.length) {
-    parts.push(`
-Key Findings:
-${artifact.keyFindings.map((f) => `- ${f}`).join("\n")}`);
-  }
-  if (artifact.relevanceJustification) {
-    parts.push(`
-Relevance: ${artifact.relevanceJustification}`);
-  }
-  if (artifact.subTopic) {
-    parts.push(`
-Sub-topic: ${artifact.subTopic}`);
-  }
   if (fulltext) {
     const truncated = fulltext.length > 3e4 ? fulltext.slice(0, 3e4) + "\n\n[... truncated for length ...]" : fulltext;
     parts.push(`
@@ -11642,6 +11828,7 @@ function createWikiAgent(config) {
     let errors = 0;
     if (!acquireProcessLock()) {
       log("process lock held by another instance, skipping");
+      emitStatus(0);
       return { processed: 0, errors: 0, pendingRemaining: 0 };
     }
     try {
@@ -11650,6 +11837,7 @@ function createWikiAgent(config) {
         const projectPaths = config.projectPaths();
         if (projectPaths.length === 0) {
           log("no project paths, nothing to scan");
+          emitStatus(0);
           return { processed: 0, errors: 0, pendingRemaining: 0 };
         }
         const { toProcess, provenanceOnly } = scanForNewContent(projectPaths);
@@ -11813,6 +12001,7 @@ function createWikiAgent(config) {
       semanticHash,
       fulltextStatus: result.fulltextStatus,
       generatorVersion: GENERATOR_VERSION,
+      hashSchemaVersion: HASH_SCHEMA_VERSION,
       processedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     markPaperProcessed(entry);
@@ -11865,6 +12054,7 @@ function createWikiAgent(config) {
     start() {
       if (state !== "created") return;
       state = "idle";
+      emitStatus(0);
       log(`starting (delay ${config.pacing.startupDelayMs / 1e3}s)`);
       timer = setTimeout(() => tick(), config.pacing.startupDelayMs);
     },

package/app/out/preload/index.js

@@ -27,11 +27,13 @@ const api = {
   // OpenAI Codex (ChatGPT Subscription) OAuth
   getOpenAICodexStatus: () => electron.ipcRenderer.invoke("auth:get-openai-codex-status"),
   openaiCodexLogin: () => electron.ipcRenderer.invoke("auth:openai-codex-login"),
+  openaiCodexCancel: () => electron.ipcRenderer.invoke("auth:openai-codex-cancel"),
   openaiCodexLogout: () => electron.ipcRenderer.invoke("auth:openai-codex-logout"),
   // Anthropic Subscription (Claude Pro/Max) OAuth — enabled by default
   isClaudeSubEnabled: () => true,
   getAnthropicSubStatus: () => electron.ipcRenderer.invoke("auth:get-anthropic-sub-status"),
   anthropicSubLogin: () => electron.ipcRenderer.invoke("auth:anthropic-sub-login"),
+  anthropicSubCancel: () => electron.ipcRenderer.invoke("auth:anthropic-sub-cancel"),
   anthropicSubLogout: () => electron.ipcRenderer.invoke("auth:anthropic-sub-logout"),
   pickPreferredModel: () => electron.ipcRenderer.invoke("config:pick-preferred-model"),
   getApiKeyStatus: () => electron.ipcRenderer.invoke("config:get-api-key-status"),