@rahularya01/pi-essentials 0.1.0

package/src/mcp/types.ts

@@ -0,0 +1,63 @@
+export type McpLifecycle = "lazy" | "eager" | "keep-alive";
+export type McpAuth = "bearer" | "oauth";
+
+export interface McpOAuthConfig {
+  clientId?: string;
+  clientSecret?: string;
+  scope?: string;
+  redirectUri?: string;
+}
+
+export interface McpServerDefinition {
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+  url?: string;
+  headers?: Record<string, string>;
+  auth?: McpAuth;
+  bearerToken?: string;
+  bearerTokenEnv?: string;
+  oauth?: McpOAuthConfig;
+  lifecycle?: McpLifecycle;
+  idleTimeout?: number;
+  requestTimeoutMs?: number;
+  disabled?: boolean;
+  includeTools?: string[];
+  excludeTools?: string[];
+  toolPrefix?: "server" | "none";
+}
+
+export interface McpFileShape {
+  mcpServers?: Record<string, McpServerDefinition>;
+  settings?: {
+    requestTimeoutMs?: number;
+    idleTimeout?: number;
+  };
+}
+
+export interface ResolvedServer {
+  name: string;
+  definition: McpServerDefinition;
+  source: string;
+}
+
+export interface CachedTool {
+  server: string;
+  name: string;
+  prefixedName: string;
+  description: string;
+  inputSchema?: unknown;
+}
+
+export type ServerStatus = "idle" | "connecting" | "connected" | "failed" | "needs-auth" | "disabled";
+
+export interface ServerSnapshot {
+  name: string;
+  status: ServerStatus;
+  toolCount: number;
+  disabled: boolean;
+  transport: "stdio" | "http" | "unknown";
+  error?: string;
+  source: string;
+}

package/src/paths.ts

@@ -0,0 +1,48 @@
+import os from "node:os";
+import path from "node:path";
+
+export const PROJECT_PI_DIR = ".pi";
+export const PACKAGE_DIR_NAME = "pi-essentials";
+
+export function getAgentDir(): string {
+  if (process.env.PI_CODING_AGENT_DIR?.trim()) {
+    return process.env.PI_CODING_AGENT_DIR.trim();
+  }
+  return path.join(os.homedir(), ".pi", "agent");
+}
+
+export function getProjectPiDir(cwd: string): string {
+  return path.join(cwd, PROJECT_PI_DIR);
+}
+
+export function getPiEssentialsDir(): string {
+  return path.join(getAgentDir(), PACKAGE_DIR_NAME);
+}
+
+export function getUserConfigPath(): string {
+  return path.join(getAgentDir(), "pi-essentials.json");
+}
+
+export function getProjectConfigPath(cwd: string): string {
+  return path.join(getProjectPiDir(cwd), "pi-essentials.json");
+}
+
+export function getOAuthStorePath(): string {
+  return path.join(getPiEssentialsDir(), "mcp-oauth.json");
+}
+
+export function getWebCacheDir(): string {
+  return path.join(getPiEssentialsDir(), "web-cache");
+}
+
+export function mcpConfigCandidates(cwd: string): string[] {
+  const home = os.homedir();
+  return [
+    path.join(home, ".config", "mcp", "mcp.json"),
+    path.join(home, ".agents", "mcp.json"),
+    path.join(home, ".agents", "mcp", "mcp.json"),
+    path.join(getAgentDir(), "mcp.json"),
+    path.join(cwd, ".mcp.json"),
+    path.join(getProjectPiDir(cwd), "mcp.json"),
+  ];
+}

package/src/questions/ask.ts

@@ -0,0 +1,134 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { isMultiple, type QuestionAnswer, type QuestionOption, type QuestionSpec } from "./validate.ts";
+
+const OTHER_LABEL = "Other (type your own answer)";
+const DONE_LABEL = "Done (finish this question)";
+
+export interface AskResult {
+  answers: QuestionAnswer[];
+  cancelled: boolean;
+}
+
+/**
+ * Options are shown with a numeric prefix so every entry is unique, which lets the
+ * selection be mapped back by array index instead of by parsing the label text.
+ */
+export function displayOptions(options: QuestionOption[]): string[] {
+  return options.map((option, index) => {
+    const description = option.description?.trim();
+    return `${index + 1}. ${option.label}${description ? ` — ${description}` : ""}`;
+  });
+}
+
+export async function askQuestions(
+  ctx: ExtensionContext,
+  questions: QuestionSpec[],
+  signal?: AbortSignal,
+): Promise<AskResult> {
+  if (!ctx.hasUI) return { answers: [], cancelled: true };
+
+  const answers: QuestionAnswer[] = [];
+  for (const question of questions) {
+    if (signal?.aborted) return { answers, cancelled: true };
+    const answer = isMultiple(question)
+      ? await askMultiSelect(ctx, question, signal)
+      : await askSingle(ctx, question, signal);
+    if (!answer) return { answers, cancelled: true };
+    answers.push(answer);
+  }
+  return { answers, cancelled: false };
+}
+
+async function askSingle(
+  ctx: ExtensionContext,
+  question: QuestionSpec,
+  signal?: AbortSignal,
+): Promise<QuestionAnswer | undefined> {
+  const labels = [...displayOptions(question.options), ...(question.allowOther === false ? [] : [OTHER_LABEL])];
+  // Pi's select API currently has no initial-index option, so `recommended`
+  // remains metadata and option order/display stay backward compatible.
+  const picked = await ctx.ui.select(question.question, labels, { signal });
+  if (picked === undefined || picked === null) return undefined;
+
+  const index = labels.indexOf(String(picked));
+  if (index === -1) return undefined;
+  if (question.allowOther !== false && index === question.options.length) {
+    const custom = await askCustom(ctx, question, signal);
+    return custom === undefined
+      ? undefined
+      : answerBase(question, [], [], custom);
+  }
+  const option = question.options[index];
+  if (!option) return undefined;
+  return answerBase(question, [option.label], [index]);
+}
+
+async function askMultiSelect(
+  ctx: ExtensionContext,
+  question: QuestionSpec,
+  signal?: AbortSignal,
+): Promise<QuestionAnswer | undefined> {
+  const remaining = question.options.map((option, index) => ({ option, index }));
+  const selected: string[] = [];
+  const selectedIndices: number[] = [];
+  let custom: string | undefined;
+
+  while (remaining.length > 0) {
+    const rows = remaining.map(({ option, index }) => {
+      const description = option.description?.trim();
+      return `${index + 1}. ${option.label}${description ? ` — ${description}` : ""}`;
+    });
+    const labels = [
+      ...rows,
+      ...(question.allowOther === false ? [] : [OTHER_LABEL]),
+      ...(selected.length > 0 || custom ? [DONE_LABEL] : []),
+    ];
+    const title = selected.length > 0 ? `${question.question} (selected: ${selected.join(", ")})` : question.question;
+
+    const picked = await ctx.ui.select(title, labels, { signal });
+    if (picked === undefined || picked === null) return undefined;
+    const choice = String(picked);
+    if (choice === DONE_LABEL) break;
+    if (question.allowOther !== false && choice === OTHER_LABEL) {
+      const typed = await askCustom(ctx, question, signal);
+      if (typed === undefined) return undefined;
+      custom = custom ? `${custom}; ${typed}` : typed;
+      continue;
+    }
+    const position = rows.indexOf(choice);
+    if (position === -1) return undefined;
+    selected.push(remaining[position].option.label);
+    selectedIndices.push(remaining[position].index);
+    remaining.splice(position, 1);
+  }
+
+  if (selected.length === 0 && !custom) return undefined;
+  return answerBase(question, selected, selectedIndices, custom);
+}
+
+function answerBase(
+  question: QuestionSpec,
+  selected: string[],
+  selectedIndices: number[],
+  custom?: string,
+): QuestionAnswer {
+  return {
+    id: question.id,
+    question: question.question,
+    header: question.header,
+    selected,
+    selectedIndices,
+    selectedValues: selectedIndices.map((index) => question.options[index]?.value ?? question.options[index]?.label ?? ""),
+    custom,
+  };
+}
+
+async function askCustom(
+  ctx: ExtensionContext,
+  question: QuestionSpec,
+  signal?: AbortSignal,
+): Promise<string | undefined> {
+  const typed = await ctx.ui.input(question.header?.trim() || "Your answer", "", { signal });
+  const value = typed === undefined || typed === null ? "" : String(typed).trim();
+  return value.length > 0 ? value : undefined;
+}

package/src/questions/index.ts

@@ -0,0 +1,72 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { errorMessage, toolFailure, toolText } from "../errors.ts";
+import { MAX_OPTIONS, MAX_QUESTIONS, MIN_OPTIONS } from "../security/limits.ts";
+import { askQuestions } from "./ask.ts";
+import { renderAskCall, renderAskResult } from "./render.ts";
+import { formatAnswers, validateQuestions, type QuestionSpec } from "./validate.ts";
+
+const OptionSchema = Type.Object({
+  label: Type.String({ description: "Option label" }),
+  description: Type.Optional(Type.String({ description: "What this choice means" })),
+  value: Type.Optional(Type.String({ description: "Machine-readable value returned for this option" })),
+});
+
+const QuestionSchema = Type.Object({
+  id: Type.Optional(Type.String({ description: "Caller-defined question id, echoed in the answer" })),
+  question: Type.String({ description: "Question text" }),
+  header: Type.Optional(Type.String({ description: "Short header, shown as the input title" })),
+  options: Type.Array(OptionSchema, { description: `${MIN_OPTIONS}-${MAX_OPTIONS} options` }),
+  multiSelect: Type.Optional(Type.Boolean({ description: "Allow picking several options" })),
+  multiple: Type.Optional(Type.Boolean({ description: "Alias for multiSelect; must agree if both are present" })),
+  recommended: Type.Optional(Type.Integer({ minimum: 0, description: "Zero-based recommended option index" })),
+  allowOther: Type.Optional(Type.Boolean({ description: "Allow a free-form answer (default true)" })),
+});
+
+export function registerQuestions(pi: ExtensionAPI): void {
+  pi.on("session_start", async (_event, ctx) => {
+    // Nothing can answer in print/JSON mode, so keep the tool out of the model's list.
+    if (ctx.hasUI) return;
+    const active = pi.getActiveTools();
+    if (active.includes("ask_user_question")) {
+      pi.setActiveTools(active.filter((name) => name !== "ask_user_question"));
+    }
+  });
+
+  pi.registerTool({
+    name: "ask_user_question",
+    label: "Ask User",
+    description:
+      "Pause and ask the user 1-4 multiple-choice questions when a real decision is required. Free-form answers are allowed by default. Do not use this for information you can find yourself.",
+    promptSnippet: "Ask the user a structured question instead of guessing",
+    promptGuidelines: [
+      "Use ask_user_question when a genuine user decision is required and guessing would be expensive to undo.",
+      "Do not use ask_user_question for facts you can inspect in the repo or look up with web_search.",
+    ],
+    parameters: Type.Object({
+      questions: Type.Array(QuestionSchema, { description: `1-${MAX_QUESTIONS} questions` }),
+    }),
+    executionMode: "sequential",
+    async execute(_id, params, signal, _onUpdate, ctx) {
+      const questions = params.questions as QuestionSpec[];
+      const invalid = validateQuestions(questions);
+      if (invalid) toolFailure(invalid, "QUESTION_INVALID");
+      if (!ctx.hasUI) {
+        toolFailure("Cannot ask the user in non-interactive mode; decide yourself and state the assumption.", "QUESTION_NO_UI");
+      }
+      if (signal?.aborted) toolFailure("Cancelled before the question was shown.", "QUESTION_CANCELLED");
+
+      try {
+        const result = await askQuestions(ctx, questions, signal);
+        return toolText(formatAnswers(result.answers, result.cancelled), {
+          answers: result.answers,
+          cancelled: result.cancelled,
+        });
+      } catch (error) {
+        toolFailure(`Could not ask the user: ${errorMessage(error)}`, "QUESTION_FAILED");
+      }
+    },
+    renderCall: renderAskCall,
+    renderResult: renderAskResult,
+  });
+}

package/src/questions/render.ts

@@ -0,0 +1,69 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import {
+  failLine,
+  firstText,
+  GLYPH,
+  meta,
+  okLine,
+  oneLine,
+  safeRender,
+  titleLine,
+  type RenderableResult,
+  type RenderSlot,
+} from "../ui/render.ts";
+import type { QuestionAnswer, QuestionSpec } from "./validate.ts";
+
+interface AskDetails {
+  answers?: QuestionAnswer[];
+  cancelled?: boolean;
+}
+
+export function renderAskCall(args: { questions?: QuestionSpec[] }, theme: Theme, context: RenderSlot): Text {
+  return safeRender(
+    () => {
+      const questions = args?.questions ?? [];
+      const first = questions[0]?.question;
+      return (
+        titleLine(theme, "ask_user_question", first ? oneLine(first, 56) : undefined) +
+        meta(theme, [questions.length > 1 ? `${questions.length} questions` : undefined])
+      );
+    },
+    "ask_user_question",
+    context,
+  );
+}
+
+export function renderAskResult(
+  result: RenderableResult<AskDetails | undefined>,
+  _options: { expanded: boolean; isPartial: boolean },
+  theme: Theme,
+  context: RenderSlot,
+): Text {
+  return safeRender(
+    () => {
+      if (context.isError) return failLine(theme, oneLine(firstText(result) || "could not ask", 96));
+
+      const details = result?.details ?? {};
+      const answers = details.answers ?? [];
+      if (details.cancelled && answers.length === 0) {
+        return `${theme.fg("warning", GLYPH.pending)} ${theme.fg("muted", "cancelled")}`;
+      }
+
+      // The answer is the point, so it is always shown in full.
+      let out = okLine(theme, theme.fg("text", `${answers.length} answered`));
+      for (const answer of answers) {
+        const label = answer.header?.trim() ? theme.fg("muted", `[${answer.header.trim()}] `) : "";
+        const picked = [answer.selected.join(", "), answer.custom && `"${answer.custom}"`]
+          .filter((part): part is string => Boolean(part))
+          .join(" | ");
+        out += `\n  ${label}${theme.fg("dim", oneLine(answer.question, 52))}`;
+        out += `\n    ${theme.fg("accent", GLYPH.arrow)} ${theme.fg("text", oneLine(picked || "(no answer)", 60))}`;
+      }
+      if (details.cancelled) out += theme.fg("warning", `\n  ${GLYPH.sep} remaining questions cancelled`);
+      return out;
+    },
+    oneLine(firstText(result), 120),
+    context,
+  );
+}

package/src/questions/validate.ts

@@ -0,0 +1,85 @@
+import { MAX_OPTIONS, MAX_QUESTIONS, MIN_OPTIONS } from "../security/limits.ts";
+
+export interface QuestionOption {
+  label: string;
+  description?: string;
+  value?: string;
+}
+
+export interface QuestionSpec {
+  id?: string;
+  question: string;
+  header?: string;
+  options: QuestionOption[];
+  multiSelect?: boolean;
+  /** OMP-compatible alias for multiSelect. */
+  multiple?: boolean;
+  recommended?: number;
+  allowOther?: boolean;
+}
+
+export interface QuestionAnswer {
+  id?: string;
+  question: string;
+  header?: string;
+  selected: string[];
+  selectedValues?: string[];
+  selectedIndices?: number[];
+  custom?: string;
+}
+
+export function isMultiple(question: QuestionSpec): boolean {
+  return question.multiple ?? question.multiSelect ?? false;
+}
+
+export function validateQuestions(questions: QuestionSpec[]): string | undefined {
+  if (!Array.isArray(questions) || questions.length === 0) return "Provide at least one question.";
+  if (questions.length > MAX_QUESTIONS) return `Ask at most ${MAX_QUESTIONS} questions at a time.`;
+  for (const [index, question] of questions.entries()) {
+    const label = `Question ${index + 1}`;
+    if (!question?.question?.trim()) return `${label} is missing question text.`;
+    if (question.id !== undefined && (typeof question.id !== "string" || !question.id.trim())) {
+      return `${label} id must be a non-empty string.`;
+    }
+    if (question.multiple !== undefined && question.multiSelect !== undefined && question.multiple !== question.multiSelect) {
+      return `${label} has conflicting multiple and multiSelect values.`;
+    }
+    if (!Array.isArray(question.options) || question.options.length < MIN_OPTIONS) {
+      return `${label} needs at least ${MIN_OPTIONS} options.`;
+    }
+    if (question.options.length > MAX_OPTIONS) {
+      return `${label} has more than ${MAX_OPTIONS} options.`;
+    }
+    if (
+      question.recommended !== undefined &&
+      (!Number.isInteger(question.recommended) || question.recommended < 0 || question.recommended >= question.options.length)
+    ) {
+      return `${label} recommended must be a valid zero-based option index.`;
+    }
+    const seen = new Set<string>();
+    for (const option of question.options) {
+      const text = option?.label?.trim();
+      if (!text) return `${label} has an option with an empty label.`;
+      if (option.value !== undefined && typeof option.value !== "string") return `${label} has an option with an invalid value.`;
+      const key = text.toLowerCase();
+      if (seen.has(key)) return `${label} repeats the option "${text}"; options must be distinct.`;
+      seen.add(key);
+    }
+  }
+  return undefined;
+}
+
+/** Render answers for the transcript and for the model's next turn. */
+export function formatAnswers(answers: QuestionAnswer[], cancelled: boolean): string {
+  if (cancelled && answers.length === 0) return "User cancelled the questionnaire.";
+  const body = answers
+    .map((answer) => {
+      const parts: string[] = [];
+      if (answer.selected.length > 0) parts.push(answer.selected.join(", "));
+      if (answer.custom) parts.push(`wrote: ${answer.custom}`);
+      const prefix = answer.header?.trim() ? `[${answer.header.trim()}] ` : "";
+      return `Q: ${prefix}${answer.question}\nA: ${parts.length > 0 ? parts.join(" | ") : "(no answer)"}`;
+    })
+    .join("\n\n");
+  return cancelled ? `${body}\n\nUser cancelled the remaining questions.` : body;
+}

package/src/security/env.ts

@@ -0,0 +1,132 @@
+const KEEP = new Set(["PATH", "HOME", "LANG", "LC_ALL", "TERM", "TMPDIR", "TEMP", "TMP", "USER", "LOGNAME", "SHELL"]);
+
+const SECRET_NAME =
+  /^(?:.+_)?(?:API_KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIALS|ACCESS_KEY|PRIVATE_KEY)$|^MCP_.+$/i;
+
+/**
+ * Provider credentials a child `pi` process needs to authenticate. Without these a
+ * subagent starts and immediately fails with "no API key", because every one of them
+ * is also secret-shaped. Mirrors the provider table in pi's docs/providers.md.
+ */
+const PROVIDER_CREDENTIAL_ENV = new Set(
+  [
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_OAUTH_TOKEN",
+    "ANT_LING_API_KEY",
+    "AZURE_OPENAI_API_KEY",
+    "OPENAI_API_KEY",
+    "DEEPSEEK_API_KEY",
+    "NVIDIA_API_KEY",
+    "GEMINI_API_KEY",
+    "GOOGLE_API_KEY",
+    "GOOGLE_APPLICATION_CREDENTIALS",
+    "AWS_BEARER_TOKEN_BEDROCK",
+    "MISTRAL_API_KEY",
+    "GROQ_API_KEY",
+    "CEREBRAS_API_KEY",
+    "CLOUDFLARE_API_KEY",
+    "CLOUDFLARE_ACCOUNT_ID",
+    "CLOUDFLARE_GATEWAY_ID",
+    "XAI_API_KEY",
+    "OPENROUTER_API_KEY",
+    "AI_GATEWAY_API_KEY",
+    "ZAI_API_KEY",
+    "ZAI_CODING_CN_API_KEY",
+    "OPENCODE_API_KEY",
+    "RADIUS_API_KEY",
+    "HF_TOKEN",
+    "FIREWORKS_API_KEY",
+    "TOGETHER_API_KEY",
+    "BASETEN_API_KEY",
+    "KIMI_API_KEY",
+    "MINIMAX_API_KEY",
+    "MINIMAX_CN_API_KEY",
+    "QWEN_TOKEN_PLAN_API_KEY",
+    "QWEN_TOKEN_PLAN_CN_API_KEY",
+    "XIAOMI_API_KEY",
+    "XIAOMI_TOKEN_PLAN_CN_API_KEY",
+    "XIAOMI_TOKEN_PLAN_AMS_API_KEY",
+    "XIAOMI_TOKEN_PLAN_SGP_API_KEY",
+  ].map((name) => name.toUpperCase()),
+);
+
+export function isSecretEnvKey(key: string): boolean {
+  return SECRET_NAME.test(key);
+}
+
+/** True for credentials a nested `pi` needs to reach a model provider. */
+export function isProviderCredentialEnvKey(key: string): boolean {
+  return PROVIDER_CREDENTIAL_ENV.has(key.toUpperCase());
+}
+
+export interface SanitizeEnvOptions {
+  /** Keep model-provider credentials so a child `pi` can authenticate. Default true. */
+  keepProviderCredentials?: boolean;
+}
+
+/** Child-process env: keep the parent environment except secret-shaped keys. */
+export function sanitizeEnv(
+  source: NodeJS.ProcessEnv = process.env,
+  extra: Record<string, string> = {},
+  options: SanitizeEnvOptions = {},
+): Record<string, string> {
+  const keepProviderCredentials = options.keepProviderCredentials !== false;
+  const out: Record<string, string> = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value === undefined) continue;
+    if (KEEP.has(key)) {
+      out[key] = value;
+      continue;
+    }
+    if (isSecretEnvKey(key)) {
+      if (keepProviderCredentials && isProviderCredentialEnvKey(key)) out[key] = value;
+      continue;
+    }
+    out[key] = value;
+  }
+  for (const [key, value] of Object.entries(extra)) {
+    out[key] = value;
+  }
+  return out;
+}
+
+export function interpolateEnvValue(raw: string, env: NodeJS.ProcessEnv = process.env, missing: string[] = []): string {
+  let value = raw.replace(/^~(?=\/|$)/, env.HOME ?? "");
+  const pattern = /\$\{([A-Z0-9_]+)\}|\$env:([A-Z0-9_]+)/gi;
+  value = value.replace(pattern, (_whole, brace: string | undefined, envStyle: string | undefined) => {
+    const name = brace ?? envStyle ?? "";
+    const found = env[name];
+    if (found === undefined) {
+      if (!missing.includes(name)) missing.push(name);
+      return "";
+    }
+    return found;
+  });
+  return value;
+}
+
+export function interpolateRecord(
+  input: Record<string, string> | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+): { values: Record<string, string>; missing: string[] } {
+  const values: Record<string, string> = {};
+  const missing: string[] = [];
+  if (!input) return { values, missing };
+  for (const [key, raw] of Object.entries(input)) {
+    values[key] = interpolateEnvValue(raw, env, missing);
+  }
+  return { values, missing };
+}
+
+export function combineSignals(...signals: Array<AbortSignal | undefined>): AbortSignal {
+  const present = signals.filter((s): s is AbortSignal => Boolean(s));
+  if (present.length === 0) return new AbortController().signal;
+  if (present.length === 1) return present[0];
+  return AbortSignal.any(present);
+}
+
+export function timeoutSignal(ms: number, parent?: AbortSignal): AbortSignal {
+  if (!Number.isFinite(ms) || ms <= 0) return parent ?? new AbortController().signal;
+  return combineSignals(parent, AbortSignal.timeout(ms));
+}

package/src/security/limits.ts

@@ -0,0 +1,20 @@
+export const DEFAULT_MCP_REQUEST_TIMEOUT_MS = 30_000;
+export const DEFAULT_MCP_IDLE_TIMEOUT_MS = 10 * 60_000;
+export const DEFAULT_WEB_TIMEOUT_MS = 15_000;
+export const DEFAULT_WEB_MAX_BYTES = 2 * 1024 * 1024;
+export const DEFAULT_WEB_MAX_CHARS = 32_000;
+export const DEFAULT_SEARCH_RESULTS = 5;
+export const MAX_SEARCH_RESULTS = 20;
+export const DEFAULT_SUBAGENT_CONCURRENCY = 4;
+export const MAX_PARALLEL_SUBAGENTS = 8;
+export const DEFAULT_SUBAGENT_SPAWN_BUDGET = 16;
+export const DEFAULT_SUBAGENT_OUTPUT_BYTES = 50 * 1024;
+export const MAX_TOOL_RESULT_CHARS = 100_000;
+export const WEB_CACHE_TTL_MS = 60 * 60 * 1000;
+export const WEB_CACHE_MAX_ENTRIES = 128;
+export const WEB_CACHE_MAX_BYTES = 128 * 1024 * 1024;
+export const MAX_QUESTIONS = 4;
+export const MIN_OPTIONS = 2;
+export const MAX_OPTIONS = 4;
+export const MAX_TODOS = 40;
+export const CONNECT_TIMEOUT_MS = 20_000;