pi-codex-search 0.1.2 → 0.1.4

package/src/command.ts

@@ -1,27 +1,198 @@
 import { relative } from "node:path";
-import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
+import {
+  type Component,
+  Input,
+  type SelectItem,
+  SelectList,
+  type SettingItem,
+  SettingsList,
+} from "@earendil-works/pi-tui";
+import { type CodexModel, extractAccountIdFromToken, fetchCodexModels } from "./codex.ts";
 import {
   type ConfigScope,
+  DEFAULT_BATCH_SIZE,
   DEFAULT_ENABLED,
   DEFAULT_FRESHNESS,
   DEFAULT_SEARCH_CONTEXT_SIZE,
-  DEFAULT_TOOL_NAME,
+  DEFAULT_STANDALONE_ENABLED,
+  STANDALONE_TOOL_NAME,
   deleteConfig,
-  type Freshness,
   getConfigPath,
+  isProjectTrustedContext,
   loadConfig,
+  MAX_BATCH_SIZE,
+  MIN_BATCH_SIZE,
   type PiCodexSearchConfig,
   type ResolvedConfig,
   saveConfig,
 } from "./config.ts";
-import type { SearchContextSize } from "./codex.ts";
 
 const COMMAND_NAME = "codex-search-settings";
 const SUBCOMMANDS = ["status", "reset"] as const;
+const OPENAI_CODEX_PROVIDER = "openai-codex";
+
+const DEFAULT_SUFFIX = " (default)";
+const defaultTag = (value: string): string => `${value}${DEFAULT_SUFFIX}`;
+const isDefaultTag = (value: string): boolean => value.endsWith(DEFAULT_SUFFIX);
+
+function normalizeStandaloneSearchContext(config: PiCodexSearchConfig): boolean {
+  const standaloneEnabled = config.standaloneEnabled ?? config.searchApi === "standalone";
+  if (!standaloneEnabled || config.searchContextSize !== "low") return false;
+  config.searchContextSize = DEFAULT_SEARCH_CONTEXT_SIZE;
+  return true;
+}
+
+interface CycleField {
+  id: string;
+  label: string;
+  description: string;
+  values(cfg: PiCodexSearchConfig): string[];
+  get(cfg: PiCodexSearchConfig): string;
+  apply(cfg: PiCodexSearchConfig, value: string): void;
+}
+
+interface TextField {
+  id: string;
+  label: string;
+  description: string;
+  /** Shown (tagged as default) when the field is not set in the active scope. */
+  defaultDisplay: string;
+  get(cfg: PiCodexSearchConfig): string | undefined;
+  apply(cfg: PiCodexSearchConfig, value: string): void;
+}
+
+// The default value is shown first as "<value> (default)"; selecting it clears the field.
+const CYCLE_FIELDS: CycleField[] = [
+  {
+    id: "enabled",
+    label: "Enabled",
+    description: "Register the search tool at session start",
+    values: () => [defaultTag(String(DEFAULT_ENABLED)), "false"],
+    get: (c) =>
+      c.enabled === undefined || c.enabled === DEFAULT_ENABLED
+        ? defaultTag(String(DEFAULT_ENABLED))
+        : String(c.enabled),
+    apply: (c, v) => {
+      if (isDefaultTag(v)) delete c.enabled;
+      else c.enabled = v === "true";
+    },
+  },
+  {
+    id: "standaloneEnabled",
+    label: "Standalone web tool",
+    description:
+      "Register codex_standalone_web for page open/find/click/screenshot and domain lookups",
+    values: () => [defaultTag(String(DEFAULT_STANDALONE_ENABLED)), "true", "false"],
+    get: (c) =>
+      c.standaloneEnabled === undefined && c.searchApi !== "standalone"
+        ? defaultTag(String(DEFAULT_STANDALONE_ENABLED))
+        : String(c.standaloneEnabled ?? c.searchApi === "standalone"),
+    apply: (c, v) => {
+      delete c.searchApi;
+      if (isDefaultTag(v)) delete c.standaloneEnabled;
+      else c.standaloneEnabled = v === "true";
+      normalizeStandaloneSearchContext(c);
+    },
+  },
+  {
+    id: "freshness",
+    label: "Freshness",
+    description: "live / indexed / cached web access",
+    values: () => [defaultTag(DEFAULT_FRESHNESS), "cached", "indexed"],
+    get: (c) =>
+      c.freshness === undefined || c.freshness === DEFAULT_FRESHNESS
+        ? defaultTag(DEFAULT_FRESHNESS)
+        : c.freshness,
+    apply: (c, v) => {
+      if (isDefaultTag(v)) delete c.freshness;
+      else c.freshness = v as PiCodexSearchConfig["freshness"];
+    },
+  },
+  {
+    id: "searchContextSize",
+    label: "Search context size",
+    description: "Amount of web context to retrieve",
+    values: (c) =>
+      c.standaloneEnabled || c.searchApi === "standalone"
+        ? [defaultTag(DEFAULT_SEARCH_CONTEXT_SIZE), "high"]
+        : [defaultTag(DEFAULT_SEARCH_CONTEXT_SIZE), "low", "high"],
+    get: (c) =>
+      c.searchContextSize === undefined || c.searchContextSize === DEFAULT_SEARCH_CONTEXT_SIZE
+        ? defaultTag(DEFAULT_SEARCH_CONTEXT_SIZE)
+        : c.searchContextSize,
+    apply: (c, v) => {
+      if (isDefaultTag(v)) delete c.searchContextSize;
+      else c.searchContextSize = v as PiCodexSearchConfig["searchContextSize"];
+      normalizeStandaloneSearchContext(c);
+    },
+  },
+];
+
+const TEXT_FIELDS: TextField[] = [
+  {
+    id: "model",
+    label: "Model",
+    description: "Pick from models loaded via /codex/models (default = auto-select)",
+    defaultDisplay: "auto",
+    get: (c) => c.model,
+    apply: (c, v) => {
+      if (v) c.model = v;
+      else delete c.model;
+    },
+  },
+  {
+    id: "baseUrl",
+    label: "Base URL",
+    description: "Codex backend base URL",
+    defaultDisplay: "built-in",
+    get: (c) => c.baseUrl,
+    apply: (c, v) => {
+      if (v) c.baseUrl = v;
+      else delete c.baseUrl;
+    },
+  },
+  {
+    id: "clientVersion",
+    label: "Client version",
+    description: "Client version sent to /codex/models",
+    defaultDisplay: "built-in",
+    get: (c) => c.clientVersion,
+    apply: (c, v) => {
+      if (v) c.clientVersion = v;
+      else delete c.clientVersion;
+    },
+  },
+  {
+    id: "batchSize",
+    label: "Max batch size",
+    description: `Max queries per tool call (${MIN_BATCH_SIZE}-${MAX_BATCH_SIZE})`,
+    defaultDisplay: String(DEFAULT_BATCH_SIZE),
+    get: (c) => (c.batchSize === undefined ? undefined : String(c.batchSize)),
+    apply: (c, v) => {
+      const trimmed = v.trim();
+      if (!trimmed) {
+        delete c.batchSize;
+        return;
+      }
+      const parsed = Number(trimmed);
+      if (!Number.isInteger(parsed) || parsed < MIN_BATCH_SIZE || parsed > MAX_BATCH_SIZE) {
+        throw new Error(
+          `Max batch size must be an integer between ${MIN_BATCH_SIZE} and ${MAX_BATCH_SIZE}.`,
+        );
+      }
+      c.batchSize = parsed;
+    },
+  },
+];
+
+function textDisplay(field: TextField, cfg: PiCodexSearchConfig): string {
+  return field.get(cfg) ?? defaultTag(field.defaultDisplay);
+}
 
 export function registerSettingsCommand(pi: ExtensionAPI): void {
   pi.registerCommand(COMMAND_NAME, {
-    description: "Configure pi-codex-search (tool name, model, defaults, freshness).",
+    description: "Configure pi-codex-search (tool name, model, API, defaults, freshness).",
     getArgumentCompletions(prefix) {
       const lower = prefix.toLowerCase();
       const matches = SUBCOMMANDS.filter((name) => name.startsWith(lower));
@@ -31,8 +202,8 @@ export function registerSettingsCommand(pi: ExtensionAPI): void {
       const trimmed = args.trim();
       try {
         if (!trimmed) {
-          if (ctx.hasUI) {
-            await openMainDialog(ctx);
+          if (ctx.mode === "tui") {
+            await openSettingsMenu(ctx);
             return;
           }
           await printStatus(ctx);
@@ -44,7 +215,7 @@ export function registerSettingsCommand(pi: ExtensionAPI): void {
         }
         if (trimmed === "reset") {
           if (ctx.hasUI) {
-            await openResetMenu(ctx);
+            await openResetMenu(ctx, isProjectTrustedContext(ctx));
           } else {
             notify(
               ctx,
@@ -66,130 +237,247 @@ export function registerSettingsCommand(pi: ExtensionAPI): void {
   });
 }
 
-async function openMainDialog(ctx: ExtensionCommandContext): Promise<void> {
+async function openSettingsMenu(ctx: ExtensionCommandContext): Promise<void> {
+  const isProjectTrusted = isProjectTrustedContext(ctx);
+  const resolved = await loadConfig(ctx.cwd, isProjectTrusted);
+  const drafts: Record<ConfigScope, PiCodexSearchConfig> = {
+    project: { ...resolved.sources.project },
+    home: { ...resolved.sources.home },
+  };
+  let scope: ConfigScope = isProjectTrusted ? "project" : "home";
   let dirty = false;
+  let saveQueue: Promise<void> = Promise.resolve();
 
-  while (true) {
-    const resolved = await loadConfig(ctx.cwd);
-    const choice = await ctx.ui.select(buildMainTitle(resolved, ctx.cwd), [
-      "Show current configuration",
-      `Edit project config (${relative(ctx.cwd, getConfigPath("project", ctx.cwd))})`,
-      `Edit home config (${homeRelative(getConfigPath("home", ctx.cwd))})`,
-      "Reset configuration…",
-      "Done",
-    ]);
-
-    if (!choice || choice === "Done") break;
-
-    if (choice === "Show current configuration") {
-      ctx.ui.notify(formatStatus(resolved, ctx.cwd));
-      continue;
-    }
-    if (choice.startsWith("Edit project")) {
-      if (await editScope(ctx, "project")) dirty = true;
-      continue;
-    }
-    if (choice.startsWith("Edit home")) {
-      if (await editScope(ctx, "home")) dirty = true;
-      continue;
-    }
-    if (choice.startsWith("Reset")) {
-      if (await openResetMenu(ctx)) dirty = true;
-      continue;
+  for (const currentScope of ["home", "project"] as const) {
+    if (currentScope === "project" && !isProjectTrusted) continue;
+    if (normalizeStandaloneSearchContext(drafts[currentScope])) {
+      const currentDraft = { ...drafts[currentScope] };
+      saveQueue = saveQueue
+        .catch(() => undefined)
+        .then(async () => {
+          try {
+            await saveConfig(currentScope, ctx.cwd, currentDraft);
+            dirty = true;
+          } catch (error: unknown) {
+            ctx.ui.notify((error as Error).message, "error");
+          }
+        });
     }
   }
 
-  if (dirty) {
-    // ctx is stale after reload — dialog is already closed at this point.
-    await ctx.reload();
-  }
+  let models: CodexModel[] = [];
+
+  await ctx.ui.custom<void>((_tui, theme, _keybindings, done) => {
+    const settingsTheme = buildSettingsTheme(theme);
+    const selectTheme = buildSelectTheme(theme);
+
+    let list: SettingsList;
+
+    const refreshDisplays = () => {
+      scopeItem.description = formatScopeDescription(scope, ctx.cwd);
+      for (const f of CYCLE_FIELDS) {
+        const item = items.find((candidate) => candidate.id === f.id);
+        if (item) item.values = f.values(drafts[scope]);
+        list.updateValue(f.id, f.get(drafts[scope]));
+      }
+      for (const f of TEXT_FIELDS) list.updateValue(f.id, textDisplay(f, drafts[scope]));
+      list.invalidate();
+    };
+
+    const save = () => {
+      if (scope === "project" && !isProjectTrusted) {
+        ctx.ui.notify("Project config cannot be saved until the project is trusted.", "warning");
+        return;
+      }
+      const currentScope = scope;
+      const currentDraft = { ...drafts[scope] };
+      saveQueue = saveQueue
+        .catch(() => undefined)
+        .then(async () => {
+          try {
+            await saveConfig(currentScope, ctx.cwd, currentDraft);
+            dirty = true;
+          } catch (error: unknown) {
+            ctx.ui.notify((error as Error).message, "error");
+          }
+        });
+    };
+
+    const onChange = (id: string, newValue: string) => {
+      if (id === "scope") {
+        scope = newValue as ConfigScope;
+        refreshDisplays();
+        return;
+      }
+      const cycle = CYCLE_FIELDS.find((f) => f.id === id);
+      if (cycle) {
+        cycle.apply(drafts[scope], newValue);
+        refreshDisplays();
+        save();
+        return;
+      }
+      const text = TEXT_FIELDS.find((f) => f.id === id);
+      if (text) {
+        try {
+          text.apply(drafts[scope], newValue.trim());
+        } catch (error: unknown) {
+          ctx.ui.notify((error as Error).message, "error");
+          list.updateValue(id, textDisplay(text, drafts[scope]));
+          return;
+        }
+        list.updateValue(id, textDisplay(text, drafts[scope]));
+        save();
+      }
+    };
+
+    const scopeItem: SettingItem = {
+      id: "scope",
+      label: "Config scope",
+      description: isProjectTrusted
+        ? formatScopeDescription(scope, ctx.cwd)
+        : "Project config disabled until the project is trusted; editing home config only",
+      currentValue: scope,
+      values: isProjectTrusted ? ["project", "home"] : ["home"],
+    };
+
+    const items: SettingItem[] = [
+      scopeItem,
+      ...CYCLE_FIELDS.map(
+        (f): SettingItem => ({
+          id: f.id,
+          label: f.label,
+          description: f.description,
+          currentValue: f.get(drafts[scope]),
+          values: f.values(drafts[scope]),
+        }),
+      ),
+      ...TEXT_FIELDS.map(
+        (f): SettingItem => ({
+          id: f.id,
+          label: f.label,
+          description: f.description,
+          currentValue: textDisplay(f, drafts[scope]),
+          submenu:
+            f.id === "model"
+              ? (_current, submenuDone) =>
+                  buildModelSelect(models, drafts[scope].model, selectTheme, submenuDone)
+              : (_current, submenuDone) => {
+                  const input = new Input();
+                  input.setValue(f.get(drafts[scope]) ?? "");
+                  input.onSubmit = (value) => submenuDone(value);
+                  input.onEscape = () => submenuDone();
+                  return input;
+                },
+        }),
+      ),
+    ];
+
+    const modelItem = items.find((i) => i.id === "model");
+    if (modelItem) modelItem.description = "Loading models via /codex/models…";
+
+    loadModels(ctx, resolved)
+      .then((loaded) => {
+        models = loaded;
+        if (modelItem) {
+          modelItem.description =
+            loaded.length === 0
+              ? "No models loaded from /codex/models (default = auto-select)"
+              : `Pick from ${loaded.length} model${loaded.length === 1 ? "" : "s"} loaded via /codex/models (default = auto-select)`;
+        }
+        list.invalidate();
+      })
+      .catch((error: unknown) => {
+        if (modelItem) {
+          modelItem.description =
+            "Could not load models from /codex/models (default = auto-select)";
+        }
+        list.invalidate();
+        ctx.ui.notify(`Could not load model list: ${(error as Error).message}`, "warning");
+      });
+
+    list = new SettingsList(items, items.length, settingsTheme, onChange, () => done(), {
+      enableSearch: true,
+    });
+    return list as Component;
+  });
+
+  await saveQueue;
+  if (dirty) await ctx.reload();
 }
 
-async function editScope(ctx: ExtensionCommandContext, scope: ConfigScope): Promise<boolean> {
-  const filePath = getConfigPath(scope, ctx.cwd);
-  const displayPath = scope === "home" ? homeRelative(filePath) : relative(ctx.cwd, filePath);
-  let saved = false;
+function buildSettingsTheme(theme: Theme) {
+  return {
+    label: (text: string, selected: boolean) => (selected ? theme.fg("accent", text) : text),
+    value: (text: string, selected: boolean) =>
+      selected ? theme.bold(theme.fg("accent", text)) : theme.fg("muted", text),
+    description: (text: string) => theme.fg("dim", text),
+    cursor: theme.fg("accent", "> "),
+    hint: (text: string) => theme.fg("dim", text),
+  };
+}
 
-  while (true) {
-    const resolved = await loadConfig(ctx.cwd);
-    const current: PiCodexSearchConfig = { ...resolved.sources[scope] };
-
-    const choice = await ctx.ui.select(`Edit ${scope} config (${displayPath})`, [
-      `Enabled → ${formatValue(current.enabled?.toString(), String(DEFAULT_ENABLED))}`,
-      `Tool name → ${formatValue(current.toolName, DEFAULT_TOOL_NAME)}`,
-      `Model → ${formatValue(current.model, "auto")}`,
-      `Base URL → ${formatValue(current.baseUrl, "default")}`,
-      `Client version → ${formatValue(current.clientVersion, "default")}`,
-      `Search context size → ${formatValue(current.searchContextSize, DEFAULT_SEARCH_CONTEXT_SIZE)}`,
-      `Freshness → ${formatValue(current.freshness, DEFAULT_FRESHNESS)}`,
-      "Back",
-    ]);
+function buildSelectTheme(theme: Theme) {
+  return {
+    selectedPrefix: (text: string) => theme.fg("accent", text),
+    selectedText: (text: string) => theme.bold(theme.fg("accent", text)),
+    description: (text: string) => theme.fg("dim", text),
+    scrollInfo: (text: string) => theme.fg("dim", text),
+    noMatch: (text: string) => theme.fg("warning", text),
+  };
+}
 
-    if (!choice || choice === "Back") return saved;
+function buildModelSelect(
+  models: CodexModel[],
+  current: string | undefined,
+  theme: ReturnType<typeof buildSelectTheme>,
+  done: (value?: string) => void,
+): Component {
+  const items: SelectItem[] = [
+    { value: "", label: defaultTag("auto"), description: "Auto-select from /codex/models" },
+    ...models.map((m): SelectItem => ({ value: m.id, label: m.id, description: m.name })),
+  ];
+  const select = new SelectList(items, Math.min(items.length, 10), theme);
+  const currentIndex = items.findIndex((i) => i.value === (current ?? ""));
+  if (currentIndex >= 0) select.setSelectedIndex(currentIndex);
+  select.onSelect = (item) => done(item.value);
+  select.onCancel = () => done();
+  return select;
+}
 
-    if (choice.startsWith("Enabled")) {
-      const value = await ctx.ui.select("Enabled", ["true", "false", "Clear"]);
-      if (!value) continue;
-      const next = value === "Clear" ? undefined : value === "true";
-      if (await applyBooleanField(ctx, scope, current, "enabled", next)) saved = true;
-      continue;
-    }
-    if (choice.startsWith("Tool name")) {
-      const value = await ctx.ui.input("Tool name (empty to clear)", current.toolName ?? "");
-      if (value === undefined) continue;
-      if (await applyTextField(ctx, scope, current, "toolName", value)) saved = true;
-      continue;
-    }
-    if (choice.startsWith("Model")) {
-      const value = await ctx.ui.input("Codex model id (empty to clear)", current.model ?? "");
-      if (value === undefined) continue;
-      if (await applyTextField(ctx, scope, current, "model", value)) saved = true;
-      continue;
-    }
-    if (choice.startsWith("Base URL")) {
-      const value = await ctx.ui.input(
-        "Codex backend base URL (empty to clear)",
-        current.baseUrl ?? "",
-      );
-      if (value === undefined) continue;
-      if (await applyTextField(ctx, scope, current, "baseUrl", value)) saved = true;
-      continue;
-    }
-    if (choice.startsWith("Client version")) {
-      const value = await ctx.ui.input(
-        "Client version sent to /codex/models (empty to clear)",
-        current.clientVersion ?? "",
-      );
-      if (value === undefined) continue;
-      if (await applyTextField(ctx, scope, current, "clientVersion", value)) saved = true;
-      continue;
-    }
-    if (choice.startsWith("Search context size")) {
-      const value = await ctx.ui.select("Search context size", ["low", "medium", "high", "Clear"]);
-      if (!value) continue;
-      const next = value === "Clear" ? undefined : (value as SearchContextSize);
-      if (await applyEnumField(ctx, scope, current, "searchContextSize", next)) saved = true;
-      continue;
-    }
-    if (choice.startsWith("Freshness")) {
-      const value = await ctx.ui.select("Freshness", ["live", "cached", "Clear"]);
-      if (!value) continue;
-      const next = value === "Clear" ? undefined : (value as Freshness);
-      if (await applyEnumField(ctx, scope, current, "freshness", next)) saved = true;
-      continue;
-    }
-  }
+async function loadModels(
+  ctx: ExtensionCommandContext,
+  resolved: ResolvedConfig,
+): Promise<CodexModel[]> {
+  const token = await ctx.modelRegistry.getApiKeyForProvider(OPENAI_CODEX_PROVIDER);
+  if (!token) return [];
+  const credential = ctx.modelRegistry.authStorage.get(OPENAI_CODEX_PROVIDER);
+  const accountId =
+    credential?.type === "oauth" && typeof credential.accountId === "string"
+      ? credential.accountId
+      : extractAccountIdFromToken(token);
+  if (!accountId) return [];
+
+  const opts: Parameters<typeof fetchCodexModels>[0] = { token, accountId };
+  if (resolved.baseUrl !== undefined) opts.baseUrl = resolved.baseUrl;
+  if (resolved.clientVersion !== undefined) opts.clientVersion = resolved.clientVersion;
+  return fetchCodexModels(opts);
 }
 
-async function openResetMenu(ctx: ExtensionCommandContext): Promise<boolean> {
+async function openResetMenu(
+  ctx: ExtensionCommandContext,
+  isProjectTrusted: boolean,
+): Promise<boolean> {
   let removed = false;
 
   while (true) {
-    const choice = await ctx.ui.select("Reset configuration", [
-      `Delete project config (${relative(ctx.cwd, getConfigPath("project", ctx.cwd))})`,
+    const options = [
+      ...(isProjectTrusted
+        ? [`Delete project config (${relative(ctx.cwd, getConfigPath("project", ctx.cwd))})`]
+        : []),
       `Delete home config (${homeRelative(getConfigPath("home", ctx.cwd))})`,
       "Back",
-    ]);
+    ];
+    const choice = await ctx.ui.select("Reset configuration", options);
 
     if (!choice || choice === "Back") return removed;
 
@@ -211,94 +499,25 @@ async function openResetMenu(ctx: ExtensionCommandContext): Promise<boolean> {
   }
 }
 
-async function applyTextField(
-  ctx: ExtensionCommandContext,
-  scope: ConfigScope,
-  current: PiCodexSearchConfig,
-  key: "toolName" | "model" | "baseUrl" | "clientVersion",
-  value: string,
-): Promise<boolean> {
-  const next: PiCodexSearchConfig = { ...current };
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    delete next[key];
-  } else {
-    next[key] = trimmed;
-  }
-  return await persist(ctx, scope, next, key);
-}
-
-async function applyEnumField<K extends "searchContextSize" | "freshness">(
-  ctx: ExtensionCommandContext,
-  scope: ConfigScope,
-  current: PiCodexSearchConfig,
-  key: K,
-  value: PiCodexSearchConfig[K] | undefined,
-): Promise<boolean> {
-  const next: PiCodexSearchConfig = { ...current };
-  if (value === undefined) {
-    delete next[key];
-  } else {
-    next[key] = value;
-  }
-  return await persist(ctx, scope, next, key);
-}
-
-async function applyBooleanField(
-  ctx: ExtensionCommandContext,
-  scope: ConfigScope,
-  current: PiCodexSearchConfig,
-  key: "enabled",
-  value: boolean | undefined,
-): Promise<boolean> {
-  const next: PiCodexSearchConfig = { ...current };
-  if (value === undefined) {
-    delete next[key];
-  } else {
-    next[key] = value;
-  }
-  return await persist(ctx, scope, next, key);
-}
-
-async function persist(
-  ctx: ExtensionCommandContext,
-  scope: ConfigScope,
-  next: PiCodexSearchConfig,
-  field: string,
-): Promise<boolean> {
-  try {
-    const filePath = await saveConfig(scope, ctx.cwd, next);
-    ctx.ui.notify(`Saved ${field} to ${filePath}.`);
-    return true;
-  } catch (error) {
-    ctx.ui.notify((error as Error).message, "error");
-    return false;
-  }
-}
-
 async function printStatus(ctx: ExtensionCommandContext): Promise<void> {
-  const resolved = await loadConfig(ctx.cwd);
+  const resolved = await loadConfig(ctx.cwd, isProjectTrustedContext(ctx));
   notify(ctx, formatStatus(resolved, ctx.cwd));
 }
 
-function buildMainTitle(resolved: ResolvedConfig, cwd: string): string {
-  return [
-    "Codex Search settings",
-    `Effective: enabled=${resolved.enabled}, tool=${resolved.toolName}, model=${resolved.model ?? "(auto)"}, freshness=${resolved.defaultFreshness}, contextSize=${resolved.defaultSearchContextSize}`,
-    `Project file: ${relative(cwd, getConfigPath("project", cwd))}${resolved.sources.project ? "" : " (absent)"}`,
-    `Home file: ${homeRelative(getConfigPath("home", cwd))}${resolved.sources.home ? "" : " (absent)"}`,
-  ].join("\n");
-}
-
-function formatStatus(resolved: ResolvedConfig, cwd: string): string {
+export function formatStatus(resolved: ResolvedConfig, cwd: string): string {
   const lines = ["Codex Search settings:"];
   lines.push(`  enabled             = ${resolved.enabled}`);
-  lines.push(`  toolName            = ${resolved.toolName}`);
+  lines.push(`  searchToolName      = codex_search`);
+  lines.push(`  standaloneToolName  = ${STANDALONE_TOOL_NAME}`);
   lines.push(`  model               = ${resolved.model ?? "(auto from /codex/models)"}`);
   lines.push(`  baseUrl             = ${resolved.baseUrl ?? "(default)"}`);
   lines.push(`  clientVersion       = ${resolved.clientVersion ?? "(default)"}`);
   lines.push(`  searchContextSize   = ${resolved.defaultSearchContextSize}`);
   lines.push(`  freshness           = ${resolved.defaultFreshness}`);
+  lines.push(`  searchApi           = responses`);
+  lines.push(`  standaloneEnabled   = ${resolved.standaloneEnabled}`);
+  lines.push(`  maxBatchSize        = ${resolved.batchSize}`);
+  lines.push(`  standaloneBatchSize = 1`);
   lines.push("");
   lines.push("Sources (env > project > home):");
   lines.push(`  env     = ${describeSource(resolved.sources.env)}`);
@@ -318,8 +537,10 @@ function describeSource(config: PiCodexSearchConfig | undefined): string {
   return keys.sort().join(", ");
 }
 
-function formatValue(value: string | undefined, fallback: string): string {
-  return value ?? `(default: ${fallback})`;
+function formatScopeDescription(scope: ConfigScope, cwd: string): string {
+  const filePath = getConfigPath(scope, cwd);
+  const displayPath = scope === "home" ? homeRelative(filePath) : relative(cwd, filePath);
+  return `Writes to the ${scope} config file: ${displayPath}`;
 }
 
 function homeRelative(filePath: string): string {