@minhpnq1807/contextos 0.5.42 → 0.5.45

package/plugins/ctx/lib/output-config.js

@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { writeJsonFile } from "./fs-utils.js";
+import { defaultDataRoot } from "./workspace-data.js";
+
+const CONFIG_FILE = "output-config.json";
+
+export const OUTPUT_SECTION_OPTIONS = [
+  { value: "rules", label: "Critical ContextOS rules", hint: "Include critical and additional relevant AGENTS.md rules." },
+  { value: "files", label: "Suggested files to check", hint: "Include semantic, import-graph, and code-review-graph file suggestions." },
+  { value: "skills", label: "Suggested skills for this task", hint: "Include matching local skill recommendations." },
+  { value: "workflows", label: "Suggested workflow for this task", hint: "Include matching workflow recommendations." }
+];
+
+export function defaultOutputConfig() {
+  return {
+    sections: Object.fromEntries(OUTPUT_SECTION_OPTIONS.map((option) => [option.value, true]))
+  };
+}
+
+export function outputConfigPath(dataRoot = defaultDataRoot()) {
+  return path.join(dataRoot, CONFIG_FILE);
+}
+
+export function loadOutputConfig({ dataRoot = defaultDataRoot() } = {}) {
+  try {
+    return normalizeOutputConfig(JSON.parse(fs.readFileSync(outputConfigPath(dataRoot), "utf8")));
+  } catch {
+    return defaultOutputConfig();
+  }
+}
+
+export function saveOutputConfig(config, { dataRoot = defaultDataRoot() } = {}) {
+  const normalized = normalizeOutputConfig(config);
+  writeJsonFile(outputConfigPath(dataRoot), normalized);
+  return normalized;
+}
+
+export function enabledOutputSections(config = loadOutputConfig()) {
+  const normalized = normalizeOutputConfig(config);
+  return OUTPUT_SECTION_OPTIONS
+    .filter((option) => normalized.sections[option.value])
+    .map((option) => option.value);
+}
+
+export function enabledOutputSectionsLabel(config = loadOutputConfig()) {
+  const enabled = enabledOutputSections(config);
+  return enabled.length ? enabled.join(", ") : "(none)";
+}
+
+export async function configureOutputSections({
+  dataRoot = defaultDataRoot(),
+  select,
+  logger = console.log
+} = {}) {
+  if (typeof select !== "function") throw new Error("configureOutputSections requires a multi-select function");
+  const current = loadOutputConfig({ dataRoot });
+  const selected = await select({
+    message: "Select ContextOS prompt sections to show:",
+    options: OUTPUT_SECTION_OPTIONS.map((option) => ({
+      ...option,
+      selected: current.sections[option.value]
+    }))
+  });
+  const selectedSet = new Set(selected);
+  const saved = saveOutputConfig({
+    sections: Object.fromEntries(OUTPUT_SECTION_OPTIONS.map((option) => [option.value, selectedSet.has(option.value)]))
+  }, { dataRoot });
+  logger(`│  Saved ContextOS prompt section config: ${outputConfigPath(dataRoot)}`);
+  logger(`│  Enabled sections: ${enabledOutputSectionsLabel(saved)}`);
+  return saved;
+}
+
+function normalizeOutputConfig(config = {}) {
+  const defaults = defaultOutputConfig();
+  return {
+    sections: Object.fromEntries(OUTPUT_SECTION_OPTIONS.map((option) => [
+      option.value,
+      typeof config.sections?.[option.value] === "boolean"
+        ? config.sections[option.value]
+        : defaults.sections[option.value]
+    ]))
+  };
+}

package/plugins/ctx/lib/package-install.js

@@ -34,3 +34,11 @@ export function copyPackageRoot({ rootDir, targetRoot }) {
   }
   return targetRoot;
 }
+
+export function syncPackageRoot({ rootDir, targetRoot }) {
+  if (path.resolve(rootDir) === path.resolve(targetRoot)) {
+    return { targetRoot, synced: false };
+  }
+  copyPackageRoot({ rootDir, targetRoot });
+  return { targetRoot, synced: true };
+}

package/plugins/ctx/lib/prompt-hook.js

@@ -1,10 +1,17 @@
 import { scheduleContext } from "./scheduler.js";
 import { appendJsonLine, writeJsonFile } from "./fs-utils.js";
+import { maybeAutoWarmWorkspace } from "./auto-warm.js";
 import { callCtxScoreContext } from "./ctx-mcp-client.js";
 import { resolveHookCwd } from "./hook-io.js";
+import { loadOutputConfig } from "./output-config.js";
 import { scoreContext as scoreContextDirect } from "./score-context.js";
+import fs from "node:fs";
 import path from "node:path";
 
+const PROMPT_FILE_LIMIT = 7;
+const PROMPT_SKILL_LIMIT = 7;
+const PROMPT_WORKFLOW_LIMIT = 2;
+
 export async function handlePromptPayload(
   payload,
   {
@@ -14,11 +21,16 @@ export async function handlePromptPayload(
     started = Date.now(),
     injectContext = process.env.CONTEXTOS_INJECT !== "0",
     scoreContextClient = callCtxScoreContext,
-    mcpDataDir
+    scoreContextDirectClient = scoreContextDirect,
+    autoWarmWorkspace = maybeAutoWarmWorkspace,
+    mcpDataDir,
+    outputConfig,
+    directFallbackTimeoutMs = Number(process.env.CONTEXTOS_DIRECT_FALLBACK_TIMEOUT_MS || 6000)
   } = {}
 ) {
   const prompt = payload.prompt || payload.message || payload.user_prompt || "";
-  const cwd = resolveHookCwd(payload);
+  const hookCwd = resolveHookCwd(payload);
+  const cwd = resolvePromptTargetCwd({ cwd: hookCwd, prompt });
   const openFiles = payload.openFiles || payload.open_files || payload.files || [];
   const dataDir = dataPath ? path.dirname(dataPath) : undefined;
 
@@ -28,32 +40,55 @@ export async function handlePromptPayload(
       cwd,
       prompt,
       openFiles,
-      maxFiles: 3
+      maxFiles: PROMPT_FILE_LIMIT,
+      maxSkills: PROMPT_SKILL_LIMIT,
+      maxWorkflows: PROMPT_WORKFLOW_LIMIT
     }, {
       dataDir: mcpDataDir || dataDir,
-      timeoutMs: Number(process.env.CONTEXTOS_MCP_BRIDGE_TIMEOUT_MS || 1000)
+      timeoutMs: Number(process.env.CONTEXTOS_MCP_BRIDGE_TIMEOUT_MS || 2000)
     });
   } catch (error) {
-    scored = await scoreContextDirect({
-      cwd,
-      prompt,
-      openFiles,
-      maxFiles: 3,
-      dataDir: mcpDataDir || dataDir
-    });
-    scored.telemetry = {
-      ...(scored.telemetry || {}),
-      bridgeStatus: "fallback",
-      bridgeError: error?.message || String(error)
-    };
+    try {
+      scored = await withTimeout(scoreContextDirectClient({
+        cwd,
+        prompt,
+        openFiles,
+        maxFiles: PROMPT_FILE_LIMIT,
+        maxSkills: PROMPT_SKILL_LIMIT,
+        maxWorkflows: PROMPT_WORKFLOW_LIMIT,
+        dataDir: mcpDataDir || dataDir,
+        embeddingTimeoutMs: Number(process.env.CONTEXTOS_HOOK_EMBEDDING_TIMEOUT_MS || 500),
+        fileEmbeddingTimeoutMs: Number(process.env.CONTEXTOS_HOOK_FILE_EMBEDDING_TIMEOUT_MS || 1000)
+      }), directFallbackTimeoutMs, "direct fallback scoring");
+      scored.telemetry = {
+        ...(scored.telemetry || {}),
+        bridgeStatus: "fallback",
+        bridgeError: error?.message || String(error)
+      };
+    } catch (directError) {
+      scored = emptyScore({
+        bridgeStatus: "fallback-failed",
+        bridgeError: error?.message || String(error),
+        directFallbackError: directError?.message || String(directError)
+      });
+    }
   }
 
   if (scored.error) throw new Error(scored.error);
   const scoredRules = scored.scoredRules || [];
-  const relevantFiles = (scored.suggestedFiles || []).slice(0, 3);
-  const suggestedSkills = (scored.suggestedSkills || []).slice(0, 3);
-  const suggestedWorkflows = (scored.suggestedWorkflows || []).slice(0, 2);
-  const scheduled = scheduleContext({ rules: scoredRules, relevantFiles, suggestedSkills, suggestedWorkflows });
+  const relevantFiles = (scored.suggestedFiles || []).slice(0, PROMPT_FILE_LIMIT);
+  const suggestedSkills = (scored.suggestedSkills || []).slice(0, PROMPT_SKILL_LIMIT);
+  const suggestedWorkflows = (scored.suggestedWorkflows || []).slice(0, PROMPT_WORKFLOW_LIMIT);
+  const effectiveOutputConfig = outputConfig || loadOutputConfig();
+  const scheduled = scheduleContext({ rules: scoredRules, relevantFiles, suggestedSkills, suggestedWorkflows, outputConfig: effectiveOutputConfig });
+  const contextEmptyReason = emptyContextReason({ scheduled, outputConfig: effectiveOutputConfig, injectContext });
+  const autoWarm = autoWarmWorkspace({
+    cwd,
+    prompt,
+    dataDir,
+    reason: contextEmptyReason,
+    now: now.getTime()
+  });
 
   const runtime = {
     at: now.toISOString(),
@@ -72,7 +107,9 @@ export async function handlePromptPayload(
       rulesInjected: (scheduled.highRules?.length || 0) + (scheduled.midRules?.length || 0),
       filesSuggested: relevantFiles.length,
       skillsSuggested: suggestedSkills.length,
-      workflowsSuggested: suggestedWorkflows.length
+      workflowsSuggested: suggestedWorkflows.length,
+      emptyContextReason: contextEmptyReason,
+      autoWarm
     },
     scheduled,
     injected: injectContext,
@@ -86,12 +123,112 @@ export async function handlePromptPayload(
     // Context injection is the critical path; diagnostics are best-effort.
   }
 
-  return {
+  const additionalContext = injectContext ? scheduled.additionalContext : "";
+  const output = {
     continue: true,
-    suppressOutput: true,
-    hookSpecificOutput: {
+    suppressOutput: true
+  };
+  if (additionalContext) {
+    output.hookSpecificOutput = {
       hookEventName: "UserPromptSubmit",
-      additionalContext: injectContext ? scheduled.additionalContext : ""
+      additionalContext
+    };
+  }
+  return output;
+}
+
+export function resolvePromptTargetCwd({ cwd = process.cwd(), prompt = "" } = {}) {
+  const current = path.resolve(cwd);
+  const candidates = targetPathCandidates(prompt);
+  for (const candidate of candidates) {
+    const resolved = path.resolve(current, candidate);
+    if (!isAllowedTargetCwd({ current, resolved })) continue;
+    if (isWorkspaceRoot(resolved)) return resolved;
+  }
+  return current;
+}
+
+function targetPathCandidates(prompt) {
+  const text = String(prompt || "");
+  const patterns = [
+    /\b(?:tr[eê]n|in|inside|under|repo|workspace|cwd)\s+([.~A-Za-z0-9_/@.-]+(?:\/[A-Za-z0-9_@().-]+)*)/gi,
+    /\b(?:debug|test|check|run)\s+(?:on|tr[eê]n)\s+([.~A-Za-z0-9_/@.-]+(?:\/[A-Za-z0-9_@().-]+)*)/gi
+  ];
+  const results = [];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(text))) {
+      const value = cleanPromptPath(match[1]);
+      if (value) results.push(value);
+    }
+  }
+  return results;
+}
+
+function cleanPromptPath(value) {
+  const cleaned = String(value || "").trim().replace(/[),.;:]+$/g, "");
+  if (!cleaned || cleaned.includes("://")) return null;
+  return cleaned;
+}
+
+function isAllowedTargetCwd({ current, resolved }) {
+  const parent = path.dirname(current);
+  const relative = path.relative(parent, resolved);
+  return relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+
+function isWorkspaceRoot(directory) {
+  try {
+    const stat = fs.statSync(directory);
+    if (!stat.isDirectory()) return false;
+  } catch {
+    return false;
+  }
+  return fs.existsSync(path.join(directory, "package.json"))
+    || fs.existsSync(path.join(directory, "AGENTS.md"))
+    || fs.existsSync(path.join(directory, ".git"));
+}
+
+function emptyContextReason({ scheduled, outputConfig, injectContext }) {
+  if (!injectContext) return "injection-disabled";
+  if (scheduled.additionalContext) return null;
+  const sections = outputConfig?.sections || {};
+  const available = [];
+  if ((scheduled.highRules?.length || 0) || (scheduled.midRules?.length || 0)) available.push("rules");
+  if (scheduled.relevantFiles?.length) available.push("files");
+  if (scheduled.suggestedSkills?.length) available.push("skills");
+  if (scheduled.suggestedWorkflows?.length) available.push("workflows");
+  if (!available.length) return "no-context-candidates";
+  const enabled = available.filter((section) => sections[section] !== false);
+  return enabled.length ? "enabled-sections-empty-after-formatting" : `available-sections-disabled:${available.join(",")}`;
+}
+
+function emptyScore(telemetry = {}) {
+  return {
+    scoredRules: [],
+    suggestedFiles: [],
+    suggestedSkills: [],
+    suggestedWorkflows: [],
+    telemetry: {
+      elapsedMs: 0,
+      modelStatus: "skipped",
+      rulesParsed: 0,
+      rulesInjected: 0,
+      filesSuggested: 0,
+      skillsSuggested: 0,
+      workflowsSuggested: 0,
+      ...telemetry
     }
   };
 }
+
+function withTimeout(promise, timeoutMs, label) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return promise;
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+    })
+  ]).finally(() => clearTimeout(timer));
+}

package/plugins/ctx/lib/ruler-sync.js

@@ -6,6 +6,7 @@ import { stdin as input, stdout as output } from "node:process";
 import { execFileSync, spawn } from "node:child_process";
 
 import { defaultDataRoot } from "./workspace-data.js";
+import { formatTomlValue, readMcpServersFromToml } from "./toml-config.js";
 
 const DEFAULT_AGENTS = ["codex", "claude", "antigravity", "copilot"];
 const CTX_MCP_NAME = "ctx-mcp";
@@ -171,60 +172,12 @@ function hasTomlSection(content, sectionName) {
   return new RegExp(`^\\[${sectionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\]\\s*$`, "m").test(content);
 }
 
-function findMcpServerSections(content) {
-  const lines = String(content || "").split(/\r?\n/);
-  const sections = [];
-  for (let index = 0; index < lines.length; index += 1) {
-    const match = lines[index].match(/^\[mcp_servers\.([^\].]+)\]\s*$/);
-    if (!match) continue;
-    let end = lines.length;
-    for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
-      if (/^\[/.test(lines[cursor])) {
-        end = cursor;
-        break;
-      }
-    }
-    sections.push({
-      name: unquoteTomlKey(match[1]),
-      body: lines.slice(index + 1, end)
-    });
-  }
-  return sections;
-}
-
-function findStringValue(lines, key) {
-  const line = lines.find((item) => new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`).test(item));
-  if (!line) return null;
-  const match = line.match(/=\s*"((?:\\.|[^"\\])*)"/);
-  return match ? unescapeTomlString(match[1]) : null;
-}
-
-function findArrayValue(lines, key) {
-  const line = lines.find((item) => new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`).test(item));
-  if (!line) return [];
-  const arrayMatch = line.match(/=\s*\[(.*)\]\s*$/);
-  if (!arrayMatch) return [];
-  const values = [];
-  const pattern = /"((?:\\.|[^"\\])*)"/g;
-  let match;
-  while ((match = pattern.exec(arrayMatch[1]))) values.push(unescapeTomlString(match[1]));
-  return values;
-}
-
 function tomlString(value) {
-  return `"${String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  return formatTomlValue(value);
 }
 
 function tomlArray(values = []) {
-  return `[${values.map(tomlString).join(", ")}]`;
-}
-
-function unescapeTomlString(value) {
-  return String(value).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
-}
-
-function unquoteTomlKey(value) {
-  return value.replace(/^"|"$/g, "");
+  return formatTomlValue(values);
 }
 
 function escapeRegExp(value) {
@@ -246,19 +199,14 @@ function unwrapContextOSProxy(command, args = []) {
 export function readCodexMcpServers({ configPath = codexConfigPath() } = {}) {
   if (!fs.existsSync(configPath)) return [];
   const content = fs.readFileSync(configPath, "utf8");
-  const servers = [];
-  for (const section of findMcpServerSections(content)) {
-    const command = findStringValue(section.body, "command");
-    if (!command) continue;
-    const args = findArrayValue(section.body, "args");
+  return readMcpServersFromToml(content).map(({ name, command, args }) => {
     const unwrapped = unwrapContextOSProxy(command, args);
-    servers.push({
-      name: section.name,
+    return {
+      name,
       command: unwrapped.command,
       args: unwrapped.args
-    });
-  }
-  return servers;
+    };
+  });
 }
 
 export function readProjectMcpJsonServers({ cwd = process.cwd(), configPath = path.join(cwd, ".mcp.json") } = {}) {
@@ -302,17 +250,7 @@ function mergeMcpServers(...groups) {
 function readRulerMcpServers({ tomlPath } = {}) {
   if (!tomlPath || !fs.existsSync(tomlPath)) return [];
   const content = fs.readFileSync(tomlPath, "utf8");
-  const servers = [];
-  for (const section of findMcpServerSections(content)) {
-    const command = findStringValue(section.body, "command");
-    if (!command) continue;
-    servers.push({
-      name: section.name,
-      command,
-      args: findArrayValue(section.body, "args")
-    });
-  }
-  return servers;
+  return readMcpServersFromToml(content);
 }
 
 function readRulerMcpServer({ tomlPath, name } = {}) {

package/plugins/ctx/lib/scheduler.js

@@ -1,26 +1,36 @@
+import path from "node:path";
+
+import { loadOutputConfig } from "./output-config.js";
 
 const MAX_CONTEXT_CHARS = 4000;
 
-export function scheduleContext({ rules = [], relevantFiles = [], suggestedSkills = [], suggestedWorkflows = [], maxChars = MAX_CONTEXT_CHARS } = {}) {
+export function scheduleContext({
+  rules = [],
+  relevantFiles = [],
+  suggestedSkills = [],
+  suggestedWorkflows = [],
+  maxChars = MAX_CONTEXT_CHARS,
+  outputConfig = loadOutputConfig()
+} = {}) {
   const orderedRules = [...rules].sort(compareRulesForContext);
   const high = orderedRules.filter((rule) => rule.score >= 0.5);
   const mid = orderedRules.filter((rule) => rule.score >= 0.1 && rule.score < 0.5);
   const dropped = orderedRules.filter((rule) => rule.score < 0.1);
 
   const sections = [];
-  if (high.length) {
+  if (outputConfig.sections.rules && high.length) {
     sections.push(section("Critical ContextOS rules", high.slice(0, 5).map(formatRule)));
   }
-  if (relevantFiles.length) {
-    sections.push(section("Suggested files to check", relevantFiles.map((file) => `- ${file.path}`)));
+  if (outputConfig.sections.files && relevantFiles.length) {
+    sections.push(commaSection("Suggested files to check", formatFiles(relevantFiles)));
   }
-  if (suggestedSkills.length) {
-    sections.push(section("Skills to activate for this task", suggestedSkills.map(formatSkill)));
+  if (outputConfig.sections.skills && suggestedSkills.length) {
+    sections.push(inlineSection("Skills to activate for this task", suggestedSkills.map(formatSkill)));
   }
-  if (suggestedWorkflows.length) {
+  if (outputConfig.sections.workflows && suggestedWorkflows.length) {
     sections.push(section("Suggested workflow for this task", suggestedWorkflows.map(formatWorkflow)));
   }
-  if (mid.length) {
+  if (outputConfig.sections.rules && mid.length) {
     sections.push(section("Additional relevant rules", mid.slice(0, 5).map(formatRule)));
   }
 
@@ -51,32 +61,49 @@ function rulePriority(rule) {
 }
 
 function section(title, lines) {
-  if (!lines.length) return "";
-  return `## ${title}\n${lines.join("\n")}`;
+  const uniqueLines = [...new Set(lines)];
+  if (!uniqueLines.length) return "";
+  return `## ${title}\n${uniqueLines.join("\n")}`;
+}
+
+function inlineSection(title, values) {
+  const uniqueValues = [...new Set(values)];
+  if (!uniqueValues.length) return "";
+  return `## ${title}: ${uniqueValues.join(", ")}`;
 }
 
+function commaSection(title, values) {
+  const uniqueValues = [...new Set(values)];
+  if (!uniqueValues.length) return "";
+  return `## ${title}, ${uniqueValues.join(", ")}`;
+}
 
 function formatRule(rule) {
   return `- ${rule.content}`;
 }
 
+function formatFiles(files) {
+  const counts = new Map();
+  for (const file of files) {
+    const name = path.basename(file.path);
+    counts.set(name, (counts.get(name) || 0) + 1);
+  }
+  return files.map((file) => formatFile(file, counts));
+}
+
+function formatFile(file, basenameCounts) {
+  const name = path.basename(file.path);
+  return basenameCounts.get(name) > 1 ? file.path : name;
+}
+
 function formatSkill(skill) {
-  const desc = skill.description
-    ? `: ${truncate(skill.description, 80)}`
-    : "";
-  return `- ${skill.name}${desc}`;
+  return skill.name;
 }
 
 function formatWorkflow(workflow) {
   const name = workflow.title || workflow.name;
-  const hint = workflow.hint ? `: ${workflow.hint}` : "";
   const chain = workflow.chain?.length ? `\n  chain: ${workflow.chain.join(" -> ")}` : "";
-  return `- ${name}${hint}${chain}`;
-}
-
-function truncate(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  return `${text.slice(0, maxLen - 1)}…`;
+  return `- ${name}${chain}`;
 }
 
 function trimToLimit(value, maxChars) {

package/plugins/ctx/lib/score-context.js

@@ -17,46 +17,74 @@ export async function scoreContext({
   skills = null,
   workflows = null,
   embeddingTimeoutMs = 5000,
-  fileEmbeddingTimeoutMs = Number(process.env.CONTEXTOS_FILE_EMBEDDING_TIMEOUT_MS || 80)
+  fileEmbeddingTimeoutMs = Number(process.env.CONTEXTOS_FILE_EMBEDDING_TIMEOUT_MS || 1000)
 } = {}) {
   const started = Date.now();
-  const merged = readAgentsChain({ cwd });
-  const rawRules = parseRules(merged.content);
-  const parsedRules = filterActionableRules(rawRules);
-  const baseScoredRules = scoreRules(parsedRules, prompt, openFiles);
-  const embedding = await enhanceRuleScoresWithEmbeddings(baseScoredRules, prompt, {
-    dataDir,
-    sources: merged.sources,
-    timeoutMs: embeddingTimeoutMs,
-    allowRemote: false
+  const ruleInputsPromise = Promise.resolve().then(() => {
+    const merged = readAgentsChain({ cwd });
+    const rawRules = parseRules(merged.content);
+    const parsedRules = filterActionableRules(rawRules);
+    return {
+      merged,
+      rawRules,
+      parsedRules,
+      baseScoredRules: scoreRules(parsedRules, prompt, openFiles)
+    };
   });
-  const scoredRules = embedding.rules;
-  const suggestedFiles = await findRelevantFiles({
-    cwd,
-    task: prompt,
-    rules: scoredRules,
-    dataDir,
-    limit: maxFiles,
-    fileEmbeddingTimeoutMs,
-    fileEmbeddingOptions: {
+
+  const rulesPromise = ruleInputsPromise.then(({ merged, baseScoredRules }) => {
+    return enhanceRuleScoresWithEmbeddings(baseScoredRules, prompt, {
+      dataDir,
+      sources: merged.sources,
+      timeoutMs: embeddingTimeoutMs,
       allowRemote: false
-    }
+    });
   });
-  const skillCatalog = Array.isArray(skills) ? skills : scanSkills({ cwd });
-  const suggestedSkills = await suggestSkills({
-    prompt,
-    skills: skillCatalog,
-    dataDir,
-    limit: maxSkills
+
+  const filesPromise = ruleInputsPromise.then(({ baseScoredRules }) => {
+    return findRelevantFiles({
+      cwd,
+      task: prompt,
+      rules: baseScoredRules,
+      dataDir,
+      limit: maxFiles,
+      fileEmbeddingTimeoutMs,
+      fileEmbeddingOptions: {
+        allowRemote: false
+      }
+    });
   });
-  const workflowCatalog = Array.isArray(workflows) ? workflows : scanWorkflows({ cwd });
-  const suggestedWorkflows = await suggestWorkflows({
-    prompt,
-    workflows: workflowCatalog,
-    dataDir,
-    limit: maxWorkflows
+
+  const skillsPromise = Promise.resolve().then(async () => {
+    const catalog = Array.isArray(skills) ? skills : scanSkills({ cwd });
+    return {
+      catalog,
+      suggestions: await suggestSkills({ cwd, prompt, skills: catalog, dataDir, limit: maxSkills })
+    };
+  });
+
+  const workflowsPromise = Promise.resolve().then(async () => {
+    const catalog = Array.isArray(workflows) ? workflows : scanWorkflows({ cwd });
+    return {
+      catalog,
+      suggestions: await suggestWorkflows({ prompt, workflows: catalog, dataDir, limit: maxWorkflows })
+    };
   });
 
+  const [ruleInputs, embedding, suggestedFiles, skillResult, workflowResult] = await Promise.all([
+    ruleInputsPromise,
+    rulesPromise,
+    filesPromise,
+    skillsPromise,
+    workflowsPromise
+  ]);
+  const { merged, rawRules, parsedRules } = ruleInputs;
+  const scoredRules = embedding.rules;
+  const skillCatalog = skillResult.catalog;
+  const suggestedSkills = skillResult.suggestions;
+  const workflowCatalog = workflowResult.catalog;
+  const suggestedWorkflows = workflowResult.suggestions;
+
   return {
     cwd,
     prompt,

package/plugins/ctx/lib/setup-wizard.js

@@ -36,13 +36,16 @@ export function setupSummaryLines({
   cwd = process.cwd(),
   agents = DEFAULT_AGENTS,
   syncRules = true,
-  syncSkills = true
+  syncSkills = true,
+  promptSections = null
 } = {}) {
-  return [
+  const lines = [
     `Installation directory: ${cwd}`,
     `Agents: ${agents.join(", ") || "(none)"}`,
     `Prompt context injection: always enabled`,
     `Ruler rule/MCP sync: ${syncRules ? "enabled" : "skipped"}`,
     `skillshare skill sync: ${syncSkills ? "enabled" : "skipped"}`
   ];
+  if (promptSections !== null) lines.push(`Prompt sections shown: ${promptSections}`);
+  return lines;
 }