@selesai/code 0.13.18 → 0.13.20

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.13.20] - 2026-09-10
+
+### Added
+- **DeepSeek V4.1 Flash in default catalog.** Added `deepseek-v4.1-flash` (text+image, 512K context, 128K max tokens, deepseek thinking format).
+- **Vision for DeepSeek V4 Pro.** `deepseek-v4-pro` now accepts text+image input with 128K max tokens.
+- **Typo-tolerant capability routing.** The capability gateway now scores one-character-off name/alias matches as exact, so a misspelled tool name (e.g. `inercom` → `intercom`) auto-activates when uniquely identifiable.
+
+## [0.13.19] - 2026-09-09
+
+### Changed
+- **Conditional web-search default.** pi-web-agent now defaults search to TokenIn when an active TokenIn account exists, and to keyless DuckDuckGo otherwise — no more TokenIn requests without an account.
+
+### Added
+- **TokenIn search timeout.** TokenIn search requests abort after 10s and fall back to DuckDuckGo instead of hanging.
+
+### Removed
+- **Brave web-agent onboarding.** The `web-agent-onboarding` extension, its `/setup-web-search` flow, and its docs are removed; existing manually configured Brave keys in `settings.json` are still honored.
+
 ## [0.13.18] - 2026-09-07
 
 ### Removed

package/dist/defaults/models.json

@@ -105,16 +105,35 @@
             "requiresReasoningContentOnAssistantMessages": true
             }
         },
+        {
+          "id": "deepseek-v4.1-flash",
+          "name": "DeepSeek V4.1 Flash",
+          "reasoning": true,
+          "input": ["text", "image"],
+          "contextWindow": 512000,
+          "maxTokens": 128000,
+          "thinkingLevelMap": {
+            "minimal": null,
+            "low": null,
+            "medium": null,
+            "high": "high",
+            "xhigh": null,
+            "max": "max"
+          },
+          "compat": {
+            "requiresReasoningContentOnAssistantMessages": true
+            }
+        },
         {
           "id": "deepseek-v4-pro",
           "name": "DeepSeek V4 pro",
           "reasoning": true,
-          "input": ["text"],
+          "input": ["text", "image"],
           "contextWindow": 512000,
-          "maxTokens": 64000,
+          "maxTokens": 128000,
           "thinkingLevelMap": {
             "minimal": null,
-            "low": "low",
+            "low": null,
             "medium": null,
             "high": "high",
             "xhigh": null,

package/dist/extensions/agent-browser.ts

@@ -12,8 +12,7 @@
  * - With no UI (headless/CI), fall back to a console warning with the install
  *   command, mirroring the rtk extension's fail-open behavior.
  *
- * Mirrors src/extensions/rtk.ts (probe, opt-out env var, fail-open warning)
- * and src/extensions/web-agent-onboarding.ts (confirm -> act -> marker).
+ * Mirrors src/extensions/rtk.ts (probe, opt-out env var, fail-open warning).
  */
 
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";

package/dist/extensions/capability-gateway/catalog.ts

@@ -86,6 +86,29 @@ export function tokenize(text: string): string[] {
 	return normalizeQuery(text).split(/\s+/).filter(Boolean);
 }
 
+/** True when two words differ by at most one insertion, deletion, or substitution. */
+function differsByOne(left: string, right: string): boolean {
+	if (Math.abs(left.length - right.length) > 1) return false;
+	let leftIndex = 0;
+	let rightIndex = 0;
+	let differences = 0;
+	while (leftIndex < left.length && rightIndex < right.length) {
+		if (left[leftIndex] === right[rightIndex]) {
+			leftIndex++;
+			rightIndex++;
+			continue;
+		}
+		if (++differences > 1) return false;
+		if (left.length > right.length) leftIndex++;
+		else if (right.length > left.length) rightIndex++;
+		else {
+			leftIndex++;
+			rightIndex++;
+		}
+	}
+	return true;
+}
+
 /** Words that carry no routing signal. */
 const STOPWORDS = new Set([
 	"the", "a", "an", "to", "of", "for", "with", "and", "or", "use", "using", "me", "my", "i",
@@ -103,8 +126,8 @@ export interface RouteResult {
 /**
  * Deterministic routing over the compact catalog.
  *
- * - Exact name/alias match scores 3; prefix match scores 2; each content token
- *   shared with the name/alias or summary adds 1.
+ * - Exact or one-character-off name/alias matches score 3; prefix matches score 2;
+ *   each content token shared with the name/alias or summary adds 1.
  * - A unique tool with score >= 3 is auto-activated.
  * - A unique skill with score >= 3 is recommended (never auto-loaded).
  * - Score 2 or a tie at the top produces a catalog-discovery hint.
@@ -127,6 +150,7 @@ export function route(query: string, catalog: CatalogEntry[]): RouteResult {
 		}
 		for (const token of contentTokens) {
 			if (nameTokens.has(token)) score += 3;
+			else if (token.length >= 5 && [...nameTokens].some((nameToken) => nameToken.length >= 5 && differsByOne(token, nameToken))) score += 3;
 			else if (token.length >= 3 && [...nameTokens].some((nameToken) => nameToken.startsWith(token))) score += 2;
 			if (summaryTokens.has(token)) score += 1;
 		}

package/dist/extensions/capability-gateway/index.test.ts

@@ -102,6 +102,15 @@ describe("deterministic routing", () => {
 		expect(result.entry?.name).toBe("grep_app_search");
 	});
 
+	it("auto-activates a uniquely identifiable one-character tool typo", () => {
+		const result = route("activate inercom", [
+			...catalog,
+			{ name: "intercom", kind: "tool", summary: "Coordinate with other local sessions", aliases: [], category: "coordination" },
+		]);
+		expect(result.action).toBe("activate");
+		expect(result.entry?.name).toBe("intercom");
+	});
+
 	it("recommends a unique high-confidence skill without auto-loading", () => {
 		const result = route("do research on this topic", catalog);
 		expect(result.action).toBe("recommend");

package/dist/extensions/package.json

@@ -24,7 +24,6 @@
 			"./pi-tool-display",
 			"./pi-web-agent",
 			"./pi-hermes-memory",
-			"./web-agent-onboarding.ts",
 			"./tps.ts",
 			"./capability-gateway",
 			"./pi-zentui/extensions/zentui/index.ts"

package/dist/extensions/pi-web-agent/README.md

@@ -16,18 +16,18 @@ One public tool, `web_explore`, that does bounded web research for Pi: search, f
 
 - **One tool.** `web_explore` handles direct links, discovery, HTTP reads, targeted headless rendering, source ranking, source-quality checks, and caveats internally.
 - **Reads the real content behind links.** Paste a GitHub, PDF, or YouTube URL and it pulls the actual thing (GitHub files/issues/PRs from the API, PDF text, YouTube transcripts), keyless. So "summarize this PDF" or "what does this repo do" works off the source, not the page shell.
-- **Six search backends.** DuckDuckGo (keyless default), SearXNG, Brave, You.com, Exa, Tavily.
+- **Seven search backends.** TokenIn (default with an active account), DuckDuckGo (keyless otherwise), SearXNG, Brave, You.com, Exa, Tavily.
 - **Optional search fanout.** Query several backends at once, dedupe, and rank pages that more than one provider agreed on to the top. Off by default; flip it to `on` or `auto`.
 - **Honest by default.** Weak, narrow, blocked, or cautionary evidence gets flagged instead of dressed up as confidence.
 - **Bounded output.** `compact` / `preview` / `verbose` transcript modes.
-- **Zero-config to start.** Runs keyless out of the box (DuckDuckGo search, local browser, the built-in readers). Opt into hosted backends, fallback, search fanout, and per-tool output modes through config when you want more control.
+- **Zero-config to start.** Without an active TokenIn account, runs keyless out of the box (DuckDuckGo search, local browser, the built-in readers). Opt into hosted backends, fallback, search fanout, and per-tool output modes through config when you want more control.
 
 ## Why pi-web-agent
 
 Compared to other web tooling for agents:
 
 - **Hands-off.** No curator, no browser windows to approve, no step that pops you out of your session. Ask `web_explore` once and the answer comes back with caveats. Nothing to babysit.
-- **Keyless by default.** Search, page reads, and the GitHub/PDF/YouTube readers all work with no API keys. Add hosted providers only when you want them.
+- **Keyless without TokenIn.** Search, page reads, and the GitHub/PDF/YouTube readers all work with no API keys when TokenIn is not configured. Add hosted providers only when you want them.
 - **Bounded and honest.** Compact output by default, and it says when a read was not good enough instead of returning fake confidence.
 
 ## Install
@@ -63,11 +63,12 @@ If a pass comes back thin, call `web_explore` again with a narrower query.
 
 ## Backends
 
-Defaults are DuckDuckGo search, plain HTTP fetch, and local-browser headless. Switch providers from `/web-agent settings → Backends`. API keys stay in environment variables, never in config files.
+Defaults are TokenIn search when an active TokenIn account exists, otherwise DuckDuckGo search; fetch remains plain HTTP and headless remains local-browser. Switch providers from `/web-agent settings → Backends`. API keys stay in environment variables, never in config files.
 
 | Backend | Role | Enable with |
 | --- | --- | --- |
-| DuckDuckGo | search (default) | nothing, keyless |
+| TokenIn | search (default with an active account) | `/tokenin add` |
+| DuckDuckGo | search (default without TokenIn) | nothing, keyless |
 | SearXNG | search (self-hosted) | base URL |
 | Brave | search (hosted) | `PI_WEB_AGENT_BRAVE_API_KEY` |
 | You.com | search (hosted) | `YDC_API_KEY` |

package/dist/extensions/pi-web-agent/src/backends/config.ts

@@ -54,11 +54,17 @@ export type BackendConfigFile = {
   };
 };
 
-export const DEFAULT_BACKEND_CONFIG: BackendConfig = {
-  search: { provider: 'tokenin', fallback: 'duckduckgo' },
-  fetch: { provider: 'http' },
-  headless: { provider: 'local-browser' }
-};
+export function getDefaultBackendConfig(
+  hasActiveAccount: () => boolean = hasActiveTokenInAccount
+): BackendConfig {
+  return {
+    search: hasActiveAccount()
+      ? { provider: 'tokenin', fallback: 'duckduckgo' }
+      : { provider: 'duckduckgo' },
+    fetch: { provider: 'http' },
+    headless: { provider: 'local-browser' }
+  };
+}
 
 function extractStringArray(value: unknown): string[] | undefined {
   if (!Array.isArray(value)) return undefined;
@@ -260,6 +266,6 @@ export function mergeBackendConfigLayers(
       fetch: mergeFetchConfig(merged.fetch, layer?.fetch),
       headless: { ...merged.headless, ...layer?.headless }
     }),
-    DEFAULT_BACKEND_CONFIG
+    getDefaultBackendConfig()
   );
 }

package/dist/extensions/pi-web-agent/src/backends/factory.ts

@@ -13,7 +13,7 @@ import { createWebFetchTool } from '../tools/web-fetch.js';
 import { createWebSearchTool } from '../tools/web-search.js';
 import { readBraveKeyFromSettings } from './settings-reader.js';
 import type { SearchProviderName, WebFetchHeadlessResponse, WebFetchResponse, WebSearchResponse } from '../types.js';
-import { DEFAULT_BACKEND_CONFIG, type BackendConfig, usableSearchProviders } from './config.js';
+import { getDefaultBackendConfig, type BackendConfig, usableSearchProviders } from './config.js';
 import { createSpecialContentResolver } from '../readers/resolver.js';
 import { createGithubReader } from '../readers/github-reader.js';
 import { createPdfReader } from '../readers/pdf-reader.js';
@@ -117,7 +117,7 @@ function withFetchFallback(
 }
 
 export function createBackendSet(
-  config: BackendConfig = DEFAULT_BACKEND_CONFIG,
+  config: BackendConfig = getDefaultBackendConfig(),
   deps: BackendFactoryDeps = {}
 ): BackendSet {
   const createDuckDuckGoSearch = deps.createDuckDuckGoSearch ?? createWebSearchTool;

package/dist/extensions/pi-web-agent/src/backends/settings-reader.ts

@@ -1,8 +1,7 @@
-// ponytail: selesai stores the Brave API key in settings.json (webAgent.braveApiKey),
-// set by the bundled web-agent-onboarding extension. Upstream pi-web-agent reads the
-// key only from PI_WEB_AGENT_BRAVE_API_KEY env var. This helper bridges that gap with a
-// minimal settings.json read. Ceiling: if selesai moves web search config elsewhere, this
-// helper needs updating; upgrade path = upstream pi-web-agent adopting a settings hook.
+// ponytail: preserve existing manually configured Brave keys in settings.json
+// (webAgent.braveApiKey). Upstream pi-web-agent reads only PI_WEB_AGENT_BRAVE_API_KEY.
+// Ceiling: if selesai moves web search config elsewhere, update this helper; upgrade path =
+// upstream pi-web-agent adopting a settings hook.
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getAgentDir, getSettingsPath } from '@selesai/code';

package/dist/extensions/pi-web-agent/src/commands/web-agent-config.ts

@@ -1,5 +1,5 @@
 import {
-  DEFAULT_BACKEND_CONFIG,
+  getDefaultBackendConfig,
   mergeBackendConfigLayers,
   validateBackendConfig,
   usableSearchProviders,
@@ -150,7 +150,7 @@ function formatFetchOptions(config: BackendConfig['fetch']) {
   ].filter(Boolean).join(' ');
 }
 
-function formatBackendSummary(config: BackendConfig = DEFAULT_BACKEND_CONFIG) {
+function formatBackendSummary(config: BackendConfig = getDefaultBackendConfig()) {
   const searchSuffix = formatSearchOptions(config.search);
   const fetchSuffix = formatFetchOptions(config.fetch);
   const searchBase = config.search.baseUrl
@@ -394,10 +394,10 @@ export function getInheritedBackendsForScope(
   scope: PresentationScope
 ): BackendConfig {
   if (scope === 'global') {
-    return DEFAULT_BACKEND_CONFIG;
+    return getDefaultBackendConfig();
   }
 
-  return mergeBackendConfigLayers(DEFAULT_BACKEND_CONFIG, loaded.global.rawBackends);
+  return mergeBackendConfigLayers(getDefaultBackendConfig(), loaded.global.rawBackends);
 }
 
 export function getScopeDisplayBackends(
@@ -405,11 +405,11 @@ export function getScopeDisplayBackends(
   scope: PresentationScope
 ): BackendConfig {
   if (scope === 'global') {
-    return mergeBackendConfigLayers(DEFAULT_BACKEND_CONFIG, loaded.global.rawBackends);
+    return mergeBackendConfigLayers(getDefaultBackendConfig(), loaded.global.rawBackends);
   }
 
   return mergeBackendConfigLayers(
-    DEFAULT_BACKEND_CONFIG,
+    getDefaultBackendConfig(),
     loaded.global.rawBackends,
     loaded.project.rawBackends
   );
@@ -942,7 +942,7 @@ export function registerWebAgentConfigCommands(pi: ExtensionAPI, deps: CommandDe
 
       if (action === 'doctor') {
         const [typeboxOk, browser, loaded] = await Promise.all([checkTypebox(), resolveBrowser(), load()]);
-        const backendConfig = loaded.effectiveBackends ?? DEFAULT_BACKEND_CONFIG;
+        const backendConfig = loaded.effectiveBackends ?? getDefaultBackendConfig();
         const backendIssues = validateBackendConfig(backendConfig);
         const backendHealth = await checkBackends(backendConfig);
         const lines = [
@@ -971,7 +971,7 @@ export function registerWebAgentConfigCommands(pi: ExtensionAPI, deps: CommandDe
         ctx.ui.notify(
           [
             formatConfigSummary(loaded.effectiveConfig),
-            formatBackendSummary(loaded.effectiveBackends ?? DEFAULT_BACKEND_CONFIG),
+            formatBackendSummary(loaded.effectiveBackends ?? getDefaultBackendConfig()),
             `global: ${loaded.global.path}${loaded.global.exists ? '' : ' (missing)'}`,
             `project: ${loaded.project.path}${loaded.project.exists ? '' : ' (missing)'}`
           ].join('\n'),

package/dist/extensions/pi-web-agent/src/extension.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from '@selesai/code';
-import { DEFAULT_BACKEND_CONFIG, type BackendConfig } from './backends/config.js';
+import { getDefaultBackendConfig, type BackendConfig } from './backends/config.js';
 import { Type } from 'typebox';
 import { registerWebAgentConfigCommands } from './commands/web-agent-config.js';
 import { DEFAULT_PRESENTATION_CONFIG, resolvePresentationMode } from './presentation/config.js';
@@ -60,9 +60,9 @@ async function getEffectivePresentationConfig(pi: ExtensionAPI): Promise<Present
 async function getEffectiveBackendConfig(pi: ExtensionAPI): Promise<BackendConfig> {
   try {
     const loaded = await loadWebAgentConfig(pi);
-    return loaded.effectiveBackends ?? DEFAULT_BACKEND_CONFIG;
+    return loaded.effectiveBackends ?? getDefaultBackendConfig();
   } catch {
-    return DEFAULT_BACKEND_CONFIG;
+    return getDefaultBackendConfig();
   }
 }
 

package/dist/extensions/pi-web-agent/src/presentation/config-store.ts

@@ -2,7 +2,7 @@ import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { CONFIG_DIR_NAME, getAgentDir } from '@selesai/code';
 import {
-  DEFAULT_BACKEND_CONFIG,
+  getDefaultBackendConfig,
   extractBackendConfigOverride,
   mergeBackendConfigLayers,
   type BackendConfig,
@@ -162,7 +162,7 @@ export async function loadPresentationConfigLayers(
       project.rawConfig
     ),
     effectiveBackends: mergeBackendConfigLayers(
-      DEFAULT_BACKEND_CONFIG,
+      getDefaultBackendConfig(),
       global.rawBackends,
       project.rawBackends
     )

package/dist/extensions/pi-web-agent/src/search/tokenin.ts

@@ -6,6 +6,7 @@ import type { SearchResult, WebSearchResponse } from '../types.js';
 
 export const TOKENIN_SEARCH_TOOL_NAME = 'firecrawl';
 export const TOKENIN_DEFAULT_BASE_URL = 'https://lite.andlet.me/v1';
+const TOKENIN_SEARCH_TIMEOUT_MS = 10_000;
 
 type TokenInAccount = { id: string; label: string; apiKey: string; baseUrl?: string };
 type TokenInAuth = { accounts: TokenInAccount[]; activeId: string | null };
@@ -54,10 +55,12 @@ function normalizeResults(response: LiteLLMSearchResponse): SearchResult[] {
 
 export function createTokenInSearchTool({
   readAccount = readActiveTokenInAccount,
-  fetchImpl = fetch
+  fetchImpl = fetch,
+  timeoutMs = TOKENIN_SEARCH_TIMEOUT_MS
 }: {
   readAccount?: () => TokenInAccount | undefined;
   fetchImpl?: typeof fetch;
+  timeoutMs?: number;
 } = {}) {
   return async function tokenInSearch({ query }: { query: string }): Promise<WebSearchResponse> {
     const normalizedQuery = query.trim();
@@ -89,6 +92,9 @@ export function createTokenInSearchTool({
       .replace(/\/v1$/, '');
     const url = `${rootUrl}/v1/search/${TOKENIN_SEARCH_TOOL_NAME}`;
 
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
     try {
       const response = await fetchImpl(url, {
         method: 'POST',
@@ -97,7 +103,8 @@ export function createTokenInSearchTool({
           'Content-Type': 'application/json',
           Authorization: `Bearer ${account.apiKey}`
         },
-        body: JSON.stringify({ query: normalizedQuery, max_results: 10 })
+        body: JSON.stringify({ query: normalizedQuery, max_results: 10 }),
+        signal: controller.signal
       });
 
       if (!response.ok) {
@@ -122,13 +129,17 @@ export function createTokenInSearchTool({
         metadata: { backend: 'tokenin', cacheHit: false }
       });
     } catch (error) {
-      const rawMessage = error instanceof Error ? error.message : String(error);
+      const rawMessage = controller.signal.aborted
+        ? `Token-In search timed out after ${timeoutMs}ms.`
+        : error instanceof Error ? error.message : String(error);
       return resultWithPresentation({
         status: 'error',
         results: [],
         metadata: { backend: 'tokenin', cacheHit: false },
         error: { code: 'FETCH_FAILED', message: `Token-In search request failed: ${rawMessage}` }
       });
+    } finally {
+      clearTimeout(timeout);
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selesai/code",
-  "version": "0.13.18",
+  "version": "0.13.20",
   "description": "Maintained, extension-first Pi coding agent with built-in workflows, subagents, web research, questions, skills, and an enhanced terminal UI.",
   "type": "module",
   "repository": {
@@ -52,8 +52,8 @@
     "clean": "shx rm -rf dist",
     "dev": "tsx src/cli.ts",
     "dev:print": "tsx src/cli.ts --print",
-    "test": "vitest run src/extensions/undo.test.ts src/extensions/tps.test.ts src/extensions/agent-browser.test.ts src/extensions/auto-session-name.test.ts src/extensions/context-compaction-reminder.test.ts src/extensions/copy-turn.test.ts src/extensions/grep-app/index.test.ts src/extensions/inline-skills.test.ts src/extensions/rtk.test.ts src/extensions/web-agent-onboarding.test.ts src/extensions/handoff-new.test.ts src/extensions/question/tests src/extensions/ponytail/test src/__tests__/tokenin-onboarding.test.ts src/__tests__/model-registry-defaults.test.ts src/cli/args.test.ts",
-    "test:coverage": "vitest run --coverage src/extensions/undo.test.ts src/extensions/tps.test.ts src/extensions/agent-browser.test.ts src/extensions/auto-session-name.test.ts src/extensions/context-compaction-reminder.test.ts src/extensions/copy-turn.test.ts src/extensions/grep-app/index.test.ts src/extensions/inline-skills.test.ts src/extensions/rtk.test.ts src/extensions/web-agent-onboarding.test.ts src/extensions/handoff-new.test.ts src/extensions/question/tests src/extensions/ponytail/test src/__tests__/tokenin-onboarding.test.ts src/__tests__/model-registry-defaults.test.ts src/cli/args.test.ts",
+    "test": "vitest run src/extensions/undo.test.ts src/extensions/tps.test.ts src/extensions/agent-browser.test.ts src/extensions/auto-session-name.test.ts src/extensions/context-compaction-reminder.test.ts src/extensions/copy-turn.test.ts src/extensions/grep-app/index.test.ts src/extensions/inline-skills.test.ts src/extensions/rtk.test.ts src/extensions/handoff-new.test.ts src/extensions/question/tests src/extensions/ponytail/test src/__tests__/tokenin-onboarding.test.ts src/__tests__/model-registry-defaults.test.ts src/cli/args.test.ts",
+    "test:coverage": "vitest run --coverage src/extensions/undo.test.ts src/extensions/tps.test.ts src/extensions/agent-browser.test.ts src/extensions/auto-session-name.test.ts src/extensions/context-compaction-reminder.test.ts src/extensions/copy-turn.test.ts src/extensions/grep-app/index.test.ts src/extensions/inline-skills.test.ts src/extensions/rtk.test.ts src/extensions/handoff-new.test.ts src/extensions/question/tests src/extensions/ponytail/test src/__tests__/tokenin-onboarding.test.ts src/__tests__/model-registry-defaults.test.ts src/cli/args.test.ts",
     "prepare": "npm run build",
     "build": "npm run clean && tsgo -p tsconfig.build.json && shx chmod +x dist/cli.js dist/rpc-entry.js && npm run copy-assets",
     "copy-assets": "shx mkdir -p dist/modes/interactive/theme && shx cp src/modes/interactive/theme/*.json dist/modes/interactive/theme/ && shx mkdir -p dist/modes/interactive/assets && shx cp src/modes/interactive/assets/*.png dist/modes/interactive/assets/ && shx mkdir -p dist/core/export-html/vendor && shx cp src/core/export-html/template.html src/core/export-html/template.css src/core/export-html/template.js dist/core/export-html/ && shx cp src/core/export-html/vendor/*.js dist/core/export-html/vendor/ && shx mkdir -p dist/defaults && shx cp src/defaults/* dist/defaults/ && shx mkdir -p dist/extensions && node scripts/copy-extensions.mjs && shx mkdir -p dist/themes && shx cp -r src/themes/. dist/themes/ && shx mkdir -p dist/skills && shx cp -r src/skills/. dist/skills/"

package/dist/extensions/web-agent-onboarding.test.ts

@@ -1,415 +0,0 @@
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("@selesai/code", () => ({
-	getAgentDir: () => process.env.SELESAI_CODING_AGENT_DIR ?? join(require("node:os").homedir(), ".selesai", "agent"),
-	getSettingsPath: () => join(process.env.SELESAI_CODING_AGENT_DIR ?? join(require("node:os").homedir(), ".selesai", "agent"), "settings.json"),
-}));
-
-import {
-	BRAVE_KEYS_URL,
-	getBraveApiKey,
-	getWebAgentConfigPath,
-	isPlaceholderKey,
-	ONBOARDING_MARKER_NAME,
-	readSettingsJson,
-	setBraveApiKey,
-	validateBraveKey,
-	WEB_AGENT_CONFIG_SUBPATH,
-	writeSettingsJson,
-	writeWebAgentBraveBackendConfig,
-} from "./web-agent-onboarding.ts";
-import webAgentOnboardingExtension from "./web-agent-onboarding.ts";
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, SessionStartEvent } from "../core/extensions/types.ts";
-
-let agentDir: string;
-
-beforeEach(() => {
-	agentDir = mkdtempSync(join(tmpdir(), "web-agent-ob-"));
-	process.env.SELESAI_CODING_AGENT_DIR = agentDir;
-});
-
-afterEach(() => {
-	rmSync(agentDir, { recursive: true, force: true });
-	delete process.env.SELESAI_CODING_AGENT_DIR;
-});
-
-describe("web-agent-onboarding helpers", () => {
-	it("isPlaceholderKey returns true for missing/empty/non-string values", () => {
-		expect(isPlaceholderKey(undefined)).toBe(true);
-		expect(isPlaceholderKey(null)).toBe(true);
-		expect(isPlaceholderKey("")).toBe(true);
-		expect(isPlaceholderKey("   ")).toBe(true);
-		expect(isPlaceholderKey(42)).toBe(true);
-		expect(isPlaceholderKey("BSA123abc")).toBe(false);
-	});
-
-	it("getBraveApiKey reads the nested value safely", () => {
-		expect(getBraveApiKey({})).toBeUndefined();
-		expect(getBraveApiKey({ webAgent: "not-an-object" })).toBeUndefined();
-		expect(getBraveApiKey({ webAgent: [] })).toBeUndefined();
-		expect(getBraveApiKey({ webAgent: { braveApiKey: "key-1" } })).toBe("key-1");
-	});
-
-	it("setBraveApiKey clones and sets the nested value", () => {
-		const original = { other: 1, webAgent: { braveApiKey: "old" } };
-		const next = setBraveApiKey(original, "new-key");
-		expect(next.webAgent).toEqual({ braveApiKey: "new-key" });
-		expect(next.other).toBe(1);
-		// original is not mutated
-		expect(original.webAgent.braveApiKey).toBe("old");
-		// missing/non-object webAgent is replaced
-		expect(setBraveApiKey({}, "k").webAgent).toEqual({ braveApiKey: "k" });
-		expect(setBraveApiKey({ webAgent: "x" }, "k").webAgent).toEqual({ braveApiKey: "k" });
-		expect(setBraveApiKey({ webAgent: [] }, "k").webAgent).toEqual({ braveApiKey: "k" });
-	});
-
-	it("validateBraveKey trims and reports errors", () => {
-		expect(validateBraveKey("  BSA-key  ")).toEqual({ key: "BSA-key" });
-		expect(validateBraveKey("")).toEqual({ error: "Key cannot be empty." });
-		expect(validateBraveKey("   ")).toEqual({ error: "Key cannot be empty." });
-		expect(validateBraveKey(undefined)).toEqual({ error: "No key entered." });
-		expect(validateBraveKey(null as unknown as string)).toEqual({ error: "No key entered." });
-	});
-
-	it("readSettingsJson parses existing file, defaults to {} for missing/corrupt", () => {
-		const settingsPath = join(agentDir, "settings.json");
-		writeFileSync(settingsPath, '{"webAgent":{"braveApiKey":"k"}}', "utf-8");
-		expect(readSettingsJson(settingsPath)).toEqual({ webAgent: { braveApiKey: "k" } });
-		expect(readSettingsJson(join(agentDir, "missing.json"))).toEqual({});
-		writeFileSync(settingsPath, "{not json", "utf-8");
-		expect(readSettingsJson(settingsPath)).toEqual({});
-	});
-
-	it("writeSettingsJson creates dirs and writes pretty JSON with trailing newline", () => {
-		const deep = join(agentDir, "nested", "dir");
-		const settingsPath = join(deep, "settings.json");
-		writeSettingsJson({ a: 1 }, settingsPath);
-		expect(readFileSync(settingsPath, "utf-8")).toBe('{\n  "a": 1\n}\n');
-	});
-
-	it("getWebAgentConfigPath joins agentDir with the config subpath", () => {
-		expect(getWebAgentConfigPath(agentDir)).toBe(join(agentDir, "extensions", "pi-web-agent", "config.json"));
-		expect(WEB_AGENT_CONFIG_SUBPATH).toBe(join("extensions", "pi-web-agent", "config.json"));
-	});
-
-	it("writeWebAgentBraveBackendConfig writes brave with duckduckgo fallback, merging existing", () => {
-		const configPath = getWebAgentConfigPath(agentDir);
-		// Pre-seed an existing config to verify merge-not-clobber.
-		mkdirSync(join(agentDir, "extensions", "pi-web-agent"), { recursive: true });
-		writeFileSync(configPath, '{"presentation":{"theme":"dark"}}', "utf-8");
-		writeWebAgentBraveBackendConfig(agentDir);
-		const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
-		expect(parsed.presentation).toEqual({ theme: "dark" });
-		expect(parsed.backends.search).toEqual({ provider: "brave", fallback: "duckduckgo" });
-	});
-
-	it("writeWebAgentBraveBackendConfig tolerates missing/corrupt existing config", () => {
-		const configPath = getWebAgentConfigPath(agentDir);
-		mkdirSync(join(agentDir, "extensions", "pi-web-agent"), { recursive: true });
-		writeFileSync(configPath, "{corrupt", "utf-8");
-		writeWebAgentBraveBackendConfig(agentDir);
-		const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
-		expect(parsed.backends.search).toEqual({ provider: "brave", fallback: "duckduckgo" });
-
-		// Missing file entirely -> starts fresh.
-		const freshDir = mkdtempSync(join(tmpdir(), "web-agent-fresh-"));
-		writeWebAgentBraveBackendConfig(freshDir);
-		const freshParsed = JSON.parse(readFileSync(join(freshDir, WEB_AGENT_CONFIG_SUBPATH), "utf-8"));
-		expect(freshParsed.backends.search).toEqual({ provider: "brave", fallback: "duckduckgo" });
-		rmSync(freshDir, { recursive: true, force: true });
-	});
-});
-
-describe("web-agent-onboarding constants and markers", () => {
-	it("exports the Brave keys URL and marker name", () => {
-		expect(BRAVE_KEYS_URL).toContain("brave.com");
-		expect(ONBOARDING_MARKER_NAME).toBe(".webAgentOnboardingComplete");
-	});
-});
-
-describe("web-agent-onboarding extension lifecycle", () => {
-	function makePi(overrides: Partial<ExtensionAPI> = {}): { pi: ExtensionAPI; on: ReturnType<typeof vi.fn>; registerCommand: ReturnType<typeof vi.fn> } {
-		const on = vi.fn();
-		const registerCommand = vi.fn();
-		const pi = { on, registerCommand, ...overrides } as unknown as ExtensionAPI;
-		webAgentOnboardingExtension(pi);
-		return { pi, on, registerCommand };
-	}
-
-	function sessionStartHandler(pi: ExtensionAPI): (event: SessionStartEvent, ctx: ExtensionContext) => Promise<void> {
-		return (pi.on as ReturnType<typeof vi.fn>).mock.calls.find(([event]: [string]) => event === "session_start")![1];
-	}
-
-	it("registers session_start and setup-web-search command", () => {
-		const { on, registerCommand } = makePi();
-		expect(on).toHaveBeenCalledWith("session_start", expect.any(Function));
-		expect(registerCommand).toHaveBeenCalledWith("setup-web-search", expect.objectContaining({ description: expect.stringContaining("Brave") }));
-	});
-
-	it("session_start ignores non-startup reasons", async () => {
-		const { pi } = makePi();
-		const handler = sessionStartHandler(pi);
-		const ctx = { hasUI: true } as unknown as ExtensionContext;
-		await handler({ reason: "reload" } as SessionStartEvent, ctx);
-		// No marker written, no prompt: marker missing proves no completion occurred.
-		expect(existsSync(join(agentDir, ONBOARDING_MARKER_NAME))).toBe(false);
-	});
-
-	it("session_start skips when onboarding is already complete", async () => {
-		writeFileSync(join(agentDir, ONBOARDING_MARKER_NAME), "1", "utf-8");
-		const { pi } = makePi();
-		const handler = sessionStartHandler(pi);
-		const input = vi.fn();
-		const ctx = { hasUI: true, ui: { input } } as unknown as ExtensionContext;
-		await handler({ reason: "startup" } as SessionStartEvent, ctx);
-		expect(input).not.toHaveBeenCalled();
-	});
-
-	it("session_start defers when SELESAI_SKIP_WEB_AGENT_ONBOARDING=1", async () => {
-		process.env.SELESAI_SKIP_WEB_AGENT_ONBOARDING = "1";
-		try {
-			const { pi } = makePi();
-			const handler = sessionStartHandler(pi);
-			const input = vi.fn();
-			const ctx = { hasUI: true, ui: { input } } as unknown as ExtensionContext;
-			await handler({ reason: "startup" } as SessionStartEvent, ctx);
-			expect(input).not.toHaveBeenCalled();
-		} finally {
-			delete process.env.SELESAI_SKIP_WEB_AGENT_ONBOARDING;
-		}
-	});
-
-	it("session_start skips when no UI is available", async () => {
-		const { pi } = makePi();
-		const handler = sessionStartHandler(pi);
-		const input = vi.fn();
-		const ctx = { hasUI: false, ui: { input } } as unknown as ExtensionContext;
-		await handler({ reason: "startup" } as SessionStartEvent, ctx);
-		expect(input).not.toHaveBeenCalled();
-	});
-
-	it("already-configured key defers and marks complete", async () => {
-		const settingsPath = join(agentDir, "settings.json");
-		writeFileSync(settingsPath, '{"webAgent":{"braveApiKey":"existing-key"}}', "utf-8");
-		const { pi } = makePi();
-		const handler = sessionStartHandler(pi);
-		const confirm = vi.fn();
-		const ctx = { hasUI: true, ui: { confirm } } as unknown as ExtensionContext;
-		await handler({ reason: "startup" } as SessionStartEvent, ctx);
-		expect(confirm).not.toHaveBeenCalled();
-		expect(existsSync(join(agentDir, ONBOARDING_MARKER_NAME))).toBe(true);
-	});
-
-	it("declining Brave skips onboarding and notifies", async () => {
-		const { pi } = makePi();
-		const handler = sessionStartHandler(pi);
-		const notify = vi.fn();
-		const ctx = { hasUI: true, ui: { confirm: async () => false, notify } } as unknown as ExtensionContext;
-		await handler({ reason: "startup" } as SessionStartEvent, ctx);
-		expect(notify).toHaveBeenCalledWith(expect.stringContaining("skipped"), "info");
-		expect(existsSync(join(agentDir, ONBOARDING_MARKER_NAME))).toBe(true);
-	});
-
-	it("accepting Brave saves the key and config", async () => {
-		const { pi } = makePi();
-		const handler = sessionStartHandler(pi);
-		const notify = vi.fn();
-		const exec = vi.fn().mockResolvedValue({ code: 0, stdout: "", stderr: "" });
-		const ctx = {
-			hasUI: true,
-			ui: { confirm: async () => true, input: async () => "  BSA-my-key  ", notify },
-		} as unknown as ExtensionContext;
-		await handler({ reason: "startup" } as SessionStartEvent, ctx);
-		expect(notify).toHaveBeenCalledWith(expect.stringContaining("saved"), "info");
-		expect(exec).not.toHaveBeenCalled(); // openBraveKeysUrl uses pi.exec — not provided here
-		const settings = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf-8"));
-		expect(settings.webAgent.braveApiKey).toBe("BSA-my-key");
-		const config = JSON.parse(readFileSync(join(agentDir, WEB_AGENT_CONFIG_SUBPATH), "utf-8"));
-		expect(config.backends.search).toEqual({ provider: "brave", fallback: "duckduckgo" });
-		expect(existsSync(join(agentDir, ONBOARDING_MARKER_NAME))).toBe(true);
-	});
-
-	it("accepting Brave with browser open failure still saves", async () => {
-		const { pi } = makePi();
-		const handler = sessionStartHandler(pi);
-		const notify = vi.fn();
-		const exec = vi.fn().mockResolvedValue({ code: 1, stdout: "", stderr: "no browser" });
-		const ctx = {
-			hasUI: true,
-			ui: { confirm: async () => true, input: async () => "BSA-key", notify },
-		} as unknown as ExtensionContext;
-		await handler({ reason: "startup" } as SessionStartEvent, ctx);
-		expect(notify).toHaveBeenCalledWith(expect.stringContaining("Could not open browser"), "warning");
-		expect(notify).toHaveBeenCalledWith(expect.stringContaining("manually"), "info");
-		const settings = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf-8"));
-		expect(settings.webAgent.braveApiKey).toBe("BSA-key");
-	});
-
-	describe("openBraveKeysUrl platform branches", () => {
-		it("uses win32 command and still saves on zero exit", async () => {
-			const original = process.platform;
-			const exec = vi.fn().mockResolvedValue({ code: 0, stdout: "", stderr: "" });
-			try {
-				Object.defineProperty(process, "platform", { value: "win32", configurable: true });
-				const { pi } = makePi({ exec } as unknown as ExtensionAPI);
-				const handler = sessionStartHandler(pi);
-				const notify = vi.fn();
-				const ctx = {
-					hasUI: true,
-					ui: { confirm: async () => true, input: async () => "BSA-win", notify },
-				} as unknown as ExtensionContext;
-				await handler({ reason: "startup" } as SessionStartEvent, ctx);
-				expect(exec).toHaveBeenCalledWith("cmd", ["/c", "start", "", BRAVE_KEYS_URL], { timeout: 10_000 });
-				expect(notify).toHaveBeenCalledWith(expect.stringContaining("Opened the Brave API key dashboard"), "info");
-			} finally {
-				Object.defineProperty(process, "platform", { value: original, configurable: true });
-			}
-		});
-
-		it("uses xdg-open on other platforms", async () => {
-			const original = process.platform;
-			const exec = vi.fn().mockResolvedValue({ code: 0, stdout: "", stderr: "" });
-			try {
-				Object.defineProperty(process, "platform", { value: "linux", configurable: true });
-				const { pi } = makePi({ exec } as unknown as ExtensionAPI);
-				const handler = sessionStartHandler(pi);
-				const notify = vi.fn();
-				const ctx = {
-					hasUI: true,
-					ui: { confirm: async () => true, input: async () => "BSA-lin", notify },
-				} as unknown as ExtensionContext;
-				await handler({ reason: "startup" } as SessionStartEvent, ctx);
-				expect(exec).toHaveBeenCalledWith("xdg-open", [BRAVE_KEYS_URL], { timeout: 10_000 });
-			} finally {
-				Object.defineProperty(process, "platform", { value: original, configurable: true });
-			}
-		});
-
-		it("non-zero exit warns and opens the manual URL even after a string error", async () => {
-			const original = process.platform;
-			const exec = vi.fn().mockResolvedValue({ code: 1, stdout: "", stderr: "browser failed" });
-			try {
-				Object.defineProperty(process, "platform", { value: "darwin", configurable: true });
-				const { pi } = makePi({ exec } as unknown as ExtensionAPI);
-				const handler = sessionStartHandler(pi);
-				const notify = vi.fn();
-				const ctx = {
-					hasUI: true,
-					ui: { confirm: async () => true, input: async () => "BSA-err", notify },
-				} as unknown as ExtensionContext;
-				await handler({ reason: "startup" } as SessionStartEvent, ctx);
-				expect(notify).toHaveBeenCalledWith(expect.stringContaining("Could not open browser: Failed to open"), "warning");
-				expect(notify).toHaveBeenCalledWith(expect.stringContaining("manually"), "info");
-				// Even though the browser failed, the key is still saved.
-				const settings = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf-8"));
-				expect(settings.webAgent.braveApiKey).toBe("BSA-err");
-			} finally {
-				Object.defineProperty(process, "platform", { value: original, configurable: true });
-			}
-		});
-
-		it("a rejecting exec (non-Error) still warns without crashing the flow", async () => {
-			const original = process.platform;
-			const exec = vi.fn().mockRejectedValue("plain string failure");
-			try {
-				Object.defineProperty(process, "platform", { value: "darwin", configurable: true });
-				const { pi } = makePi({ exec } as unknown as ExtensionAPI);
-				const handler = sessionStartHandler(pi);
-				const notify = vi.fn();
-				const ctx = {
-					hasUI: true,
-					ui: { confirm: async () => true, input: async () => "BSA-rej", notify },
-				} as unknown as ExtensionContext;
-				await handler({ reason: "startup" } as SessionStartEvent, ctx);
-				expect(notify).toHaveBeenCalledWith(expect.stringContaining("Could not open browser: plain string failure"), "warning");
-				const settings = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf-8"));
-				expect(settings.webAgent.braveApiKey).toBe("BSA-rej");
-			} finally {
-				Object.defineProperty(process, "platform", { value: original, configurable: true });
-			}
-		});
-		it("non-zero exit with both stderr and stdout empty falls back to unknown error", async () => {
-			const original = process.platform;
-			const exec = vi.fn().mockResolvedValue({ code: 1, stdout: "", stderr: "" });
-			try {
-				Object.defineProperty(process, "platform", { value: "darwin", configurable: true });
-				const { pi } = makePi({ exec } as unknown as ExtensionAPI);
-				const handler = sessionStartHandler(pi);
-				const notify = vi.fn();
-				const ctx = {
-					hasUI: true,
-					ui: { confirm: async () => true, input: async () => "BSA-un", notify },
-				} as unknown as ExtensionContext;
-				await handler({ reason: "startup" } as SessionStartEvent, ctx);
-				expect(notify).toHaveBeenCalledWith(expect.stringContaining("unknown error"), "warning");
-				const settings = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf-8"));
-				expect(settings.webAgent.braveApiKey).toBe("BSA-un");
-			} finally {
-				Object.defineProperty(process, "platform", { value: original, configurable: true });
-			}
-		});
-	});
-
-	it("empty pasted key defers without saving", async () => {
-		const { pi } = makePi();
-		const handler = sessionStartHandler(pi);
-		const notify = vi.fn();
-		const ctx = {
-			hasUI: true,
-			ui: { confirm: async () => true, input: async () => "  ", notify },
-		} as unknown as ExtensionContext;
-		await handler({ reason: "startup" } as SessionStartEvent, ctx);
-		expect(notify).toHaveBeenCalledWith("Key cannot be empty.", "warning");
-		expect(existsSync(join(agentDir, ONBOARDING_MARKER_NAME))).toBe(false);
-		expect(existsSync(join(agentDir, "settings.json"))).toBe(false);
-	});
-
-	it("setup-web-search command saves and reloads extensions", async () => {
-		const exec = vi.fn().mockResolvedValue({ code: 0, stdout: "", stderr: "" });
-		const { registerCommand } = makePi({ exec } as unknown as ExtensionAPI);
-		const { handler } = registerCommand.mock.calls.find(([name]: [string]) => name === "setup-web-search")![1] as { handler: (args: string, ctx: ExtensionCommandContext) => Promise<void> };
-		const reload = vi.fn().mockResolvedValue(undefined);
-		const notify = vi.fn();
-		const ctx = {
-			hasUI: true,
-			reload,
-			ui: { confirm: async () => true, input: async () => "BSA-key", notify },
-		} as unknown as ExtensionCommandContext;
-		await handler("", ctx);
-		expect(reload).toHaveBeenCalled();
-		expect(notify).toHaveBeenCalledWith(expect.stringContaining("reloading extensions"), "info");
-		const settings = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf-8"));
-		expect(settings.webAgent.braveApiKey).toBe("BSA-key");
-	});
-
-	it("setup-web-search command does not reload when skipped", async () => {
-		const { registerCommand } = makePi();
-		const { handler } = registerCommand.mock.calls.find(([name]: [string]) => name === "setup-web-search")![1] as { handler: (args: string, ctx: ExtensionCommandContext) => Promise<void> };
-		const reload = vi.fn();
-		const notify = vi.fn();
-		const ctx = {
-			hasUI: true,
-			reload,
-			ui: { confirm: async () => false, notify },
-		} as unknown as ExtensionCommandContext;
-		await handler("", ctx);
-		expect(reload).not.toHaveBeenCalled();
-	});
-
-	it("setup-web-search command defers (no reload) when key is invalid", async () => {
-		const { registerCommand } = makePi();
-		const { handler } = registerCommand.mock.calls.find(([name]: [string]) => name === "setup-web-search")![1] as { handler: (args: string, ctx: ExtensionCommandContext) => Promise<void> };
-		const reload = vi.fn();
-		const notify = vi.fn();
-		const ctx = {
-			hasUI: true,
-			reload,
-			ui: { confirm: async () => true, input: async () => "", notify },
-		} as unknown as ExtensionCommandContext;
-		await handler("", ctx);
-		expect(reload).not.toHaveBeenCalled();
-	});
-});

package/dist/extensions/web-agent-onboarding.ts

@@ -1,222 +0,0 @@
-/**
- * Web-Agent first-run onboarding extension.
- *
- * On the first interactive session, ask the user whether they want to use Brave
- * Search. If yes, open the Brave API key dashboard, collect the pasted key, and
- * persist it in ~/.selesai/agent/settings.json under webAgent.braveApiKey, then
- * configure the bundled pi-web-agent backend to use Brave (with DuckDuckGo fallback).
- * If no, the extension falls back to pi-web-agent's default DuckDuckGo backend.
- *
- * Mirrors src/extensions/tokenin-onboarding.ts.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { getAgentDir, getSettingsPath } from "@selesai/code";
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, SessionStartEvent } from "@selesai/code";
-
-export type OnboardingResult =
-	| { kind: "saved" }
-	| { kind: "skipped" }
-	| { kind: "deferred" }
-	| { kind: "error"; message: string };
-
-export const BRAVE_KEYS_URL = "https://api-dashboard.search.brave.com/app/keys";
-export const ONBOARDING_MARKER_NAME = ".webAgentOnboardingComplete";
-export const WEB_AGENT_CONFIG_SUBPATH = join("extensions", "pi-web-agent", "config.json");
-
-// ponytail: duplicated ~15 lines of marker-file + browser-open logic from
-// tokenin-onboarding.ts rather than extracting a shared module nobody asked for.
-// Ceiling: if a third onboarding extension appears, extract a shared helper then.
-
-/** Read and parse the current settings.json, returning a deep-ish mutable object. */
-export function readSettingsJson(settingsPath: string = getSettingsPath()): Record<string, unknown> {
-	try {
-		const raw = readFileSync(settingsPath, "utf-8");
-		return JSON.parse(raw) as Record<string, unknown>;
-	} catch {
-		return {};
-	}
-}
-
-/** Write settings.json back to disk atomically-ish with a trailing newline. */
-export function writeSettingsJson(settings: Record<string, unknown>, settingsPath: string = getSettingsPath()): void {
-	mkdirSync(dirname(settingsPath), { recursive: true });
-	writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
-}
-
-/**
- * Return true if the Brave key value is missing, empty. We prompt again for any
- * non-key value.
- */
-export function isPlaceholderKey(apiKey: unknown): boolean {
-	if (apiKey === undefined || apiKey === null) return true;
-	if (typeof apiKey !== "string") return true;
-	return apiKey.trim() === "";
-}
-
-/** Return the current webAgent.braveApiKey value from settings.json. */
-export function getBraveApiKey(settings: Record<string, unknown>): unknown {
-	const webAgent = settings.webAgent;
-	if (!webAgent || typeof webAgent !== "object" || Array.isArray(webAgent)) return undefined;
-	return (webAgent as Record<string, unknown>).braveApiKey;
-}
-
-/** Return a new settings object with webAgent.braveApiKey set to key. */
-export function setBraveApiKey(settings: Record<string, unknown>, key: string): Record<string, unknown> {
-	const next = JSON.parse(JSON.stringify(settings)) as Record<string, unknown>;
-	if (!next.webAgent || typeof next.webAgent !== "object" || Array.isArray(next.webAgent)) {
-		next.webAgent = {};
-	}
-	const webAgent = next.webAgent as Record<string, unknown>;
-	webAgent.braveApiKey = key;
-	return next;
-}
-
-/** Validate a pasted Brave key. Returns normalized key or an error message. */
-export function validateBraveKey(raw: string | undefined): { key?: string; error?: string } {
-	if (raw === undefined || raw === null) return { error: "No key entered." };
-	const trimmed = raw.trim();
-	if (trimmed === "") return { error: "Key cannot be empty." };
-	return { key: trimmed };
-}
-
-/** Path to the pi-web-agent global backend config (matches vendored config-store). */
-export function getWebAgentConfigPath(agentDir: string = getAgentDir()): string {
-	return join(agentDir, WEB_AGENT_CONFIG_SUBPATH);
-}
-
-/** Write pi-web-agent backend config selecting brave (with duckduckgo fallback). */
-export function writeWebAgentBraveBackendConfig(agentDir: string = getAgentDir()): void {
-	const configPath = getWebAgentConfigPath(agentDir);
-	mkdirSync(dirname(configPath), { recursive: true });
-	// Merge into any existing config so we don't clobber presentation settings.
-	let existing: Record<string, unknown> = {};
-	try {
-		existing = JSON.parse(readFileSync(configPath, "utf-8")) as Record<string, unknown>;
-	} catch {
-		// ENOENT or invalid JSON — start fresh.
-	}
-	const next = existing;
-	const backends = (next.backends ?? {}) as Record<string, unknown>;
-	(backends as Record<string, unknown>).search = { provider: "brave", fallback: "duckduckgo" };
-	next.backends = backends;
-	writeFileSync(configPath, `${JSON.stringify(next, null, 2)}\n`, "utf-8");
-}
-
-function getOnboardingMarkerPath(agentDir: string = getAgentDir()): string {
-	return join(agentDir, ONBOARDING_MARKER_NAME);
-}
-
-function markOnboardingComplete(agentDir: string = getAgentDir()): void {
-	writeFileSync(getOnboardingMarkerPath(agentDir), "1", "utf-8");
-}
-
-function isOnboardingComplete(agentDir: string = getAgentDir()): boolean {
-	return existsSync(getOnboardingMarkerPath(agentDir));
-}
-
-async function openBraveKeysUrl(pi: ExtensionAPI): Promise<void> {
-	const url = BRAVE_KEYS_URL;
-	let command: string;
-	let args: string[];
-	if (process.platform === "darwin") {
-		command = "open";
-		args = [url];
-	} else if (process.platform === "win32") {
-		command = "cmd";
-		args = ["/c", "start", "", url];
-	} else {
-		command = "xdg-open";
-		args = [url];
-	}
-	const result = await pi.exec(command, args, { timeout: 10_000 });
-	if (result.code !== 0) {
-		throw new Error(`Failed to open ${url}: ${result.stderr || result.stdout || "unknown error"}`);
-	}
-}
-
-async function promptForKey(ctx: ExtensionContext): Promise<string | undefined> {
-	return ctx.ui.input("Paste your Brave API key", "");
-}
-
-async function runOnboarding(pi: ExtensionAPI, ctx: ExtensionContext): Promise<OnboardingResult> {
-	const settingsPath = getSettingsPath();
-	const settings = readSettingsJson(settingsPath);
-	const currentKey = getBraveApiKey(settings);
-
-	// Already configured? Mark complete and skip.
-	if (!isPlaceholderKey(currentKey)) {
-		markOnboardingComplete();
-		return { kind: "deferred" };
-	}
-
-	// No UI? Defer to a later session.
-	if (!ctx.hasUI) {
-		return { kind: "deferred" };
-	}
-
-	const wantsBrave = await ctx.ui.confirm(
-		"Use Brave Search?",
-		"Brave gives reliable web results for the web_explore tool. You can get an API key at https://api-dashboard.search.brave.com/app/keys. Use Brave now?",
-	);
-
-	if (!wantsBrave) {
-		markOnboardingComplete();
-		ctx.ui.notify("Brave skipped — web search will use the default DuckDuckGo backend.", "info");
-		return { kind: "skipped" };
-	}
-
-	try {
-		await openBraveKeysUrl(pi);
-		ctx.ui.notify("Opened the Brave API key dashboard in your browser.", "info");
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		ctx.ui.notify(`Could not open browser: ${message}`, "warning");
-		ctx.ui.notify(`Open this URL manually: ${BRAVE_KEYS_URL}`, "info");
-	}
-
-	const rawKey = await promptForKey(ctx);
-	const validated = validateBraveKey(rawKey);
-
-	if (validated.error) {
-		ctx.ui.notify(validated.error, "warning");
-		// Do not mark complete so the prompt retries on next launch.
-		return { kind: "deferred" };
-	}
-
-	const updated = setBraveApiKey(settings, validated.key!);
-	writeSettingsJson(updated, settingsPath);
-	// Select Brave as the pi-web-agent search backend (DuckDuckGo fallback).
-	writeWebAgentBraveBackendConfig();
-	markOnboardingComplete();
-
-	ctx.ui.notify("Brave API key saved — web search will use Brave.", "info");
-	return { kind: "saved" };
-}
-
-export default function webAgentOnboardingExtension(pi: ExtensionAPI): void {
-	pi.on("session_start", async (event: SessionStartEvent, ctx: ExtensionContext) => {
-		if (event.reason !== "startup") return;
-		if (isOnboardingComplete()) return;
-
-		// Avoid prompting during tests or non-interactive runs.
-		if (process.env.SELESAI_SKIP_WEB_AGENT_ONBOARDING === "1") return;
-
-		await runOnboarding(pi, ctx);
-	});
-
-	// ponytail: command reuses runOnboarding() instead of duplicating the flow.
-	// On "saved" -> ctx.reload() so pi-web-agent re-applies the Brave backend config.
-	// On skipped/deferred -> no reload (nothing changed). The post-reload session_start
-	// fires with reason "reload" but the auto handler only acts on "startup", so no double prompt.
-	pi.registerCommand("setup-web-search", {
-		description: "Re-run the Brave Search onboarding flow, then reload extensions",
-		handler: async (_args: string, ctx: ExtensionCommandContext) => {
-			const result = await runOnboarding(pi, ctx);
-			if (result.kind === "saved") {
-				ctx.ui.notify("Brave key saved — reloading extensions…", "info");
-				await ctx.reload();
-			}
-		},
-	});
-}