jeopi-cli 16.2.14 → 16.2.17

package/dist/types/web/search/types.d.ts

@@ -0,0 +1,431 @@
+/**
+ * Web Search Types
+ *
+ * Unified types for web search responses across supported providers.
+ */
+export declare const SEARCH_PROVIDER_OPTIONS: readonly [{
+    readonly value: "auto";
+    readonly label: "Auto";
+    readonly description: "Automatically uses the first configured web-search provider";
+}, {
+    readonly value: "perplexity";
+    readonly label: "Perplexity";
+    readonly description: "Uses auth when configured; explicit selection falls back to anonymous search";
+}, {
+    readonly value: "gemini";
+    readonly label: "Gemini";
+    readonly description: "Google Search grounding via Gemini (uses google-gemini-cli or google-antigravity OAuth)";
+}, {
+    readonly value: "anthropic";
+    readonly label: "Anthropic";
+    readonly description: "Claude's native web_search tool (uses Anthropic OAuth or ANTHROPIC_API_KEY)";
+}, {
+    readonly value: "codex";
+    readonly label: "OpenAI";
+    readonly description: "OpenAI's native web_search (uses ChatGPT OAuth via /login openai-codex)";
+}, {
+    readonly value: "xai";
+    readonly label: "xAI";
+    readonly description: "Grok web search via xAI Responses API (requires XAI_API_KEY)";
+}, {
+    readonly value: "zai";
+    readonly label: "Z.AI";
+    readonly description: "Calls Z.AI webSearchPrime MCP";
+}, {
+    readonly value: "exa";
+    readonly label: "Exa";
+    readonly description: "Uses Exa API when EXA_API_KEY is set; falls back to Exa MCP";
+}, {
+    readonly value: "tinyfish";
+    readonly label: "TinyFish";
+    readonly description: "Requires TINYFISH_API_KEY";
+}, {
+    readonly value: "jina";
+    readonly label: "Jina";
+    readonly description: "Requires JINA_API_KEY";
+}, {
+    readonly value: "kagi";
+    readonly label: "Kagi";
+    readonly description: "Requires KAGI_API_KEY and Kagi Search API beta access";
+}, {
+    readonly value: "tavily";
+    readonly label: "Tavily";
+    readonly description: "Requires TAVILY_API_KEY";
+}, {
+    readonly value: "firecrawl";
+    readonly label: "Firecrawl";
+    readonly description: "Requires FIRECRAWL_API_KEY";
+}, {
+    readonly value: "brave";
+    readonly label: "Brave";
+    readonly description: "Requires BRAVE_API_KEY";
+}, {
+    readonly value: "kimi";
+    readonly label: "Kimi";
+    readonly description: "Requires MOONSHOT_SEARCH_API_KEY or MOONSHOT_API_KEY";
+}, {
+    readonly value: "parallel";
+    readonly label: "Parallel";
+    readonly description: "Requires PARALLEL_API_KEY";
+}, {
+    readonly value: "synthetic";
+    readonly label: "Synthetic";
+    readonly description: "Requires SYNTHETIC_API_KEY";
+}, {
+    readonly value: "searxng";
+    readonly label: "SearXNG";
+    readonly description: "Requires SEARXNG_ENDPOINT or searxng.endpoint";
+}, {
+    readonly value: "duckduckgo";
+    readonly label: "DuckDuckGo";
+    readonly description: "Credential-free best-effort fallback; may be bot-challenged on datacenter/shared-egress IPs";
+}];
+/** Supported web search providers (every option except `auto`). */
+export type SearchProviderId = Exclude<(typeof SEARCH_PROVIDER_OPTIONS)[number]["value"], "auto">;
+/**
+ * Auto-resolution priority order. Derived from {@link SEARCH_PROVIDER_OPTIONS}
+ * (minus `auto`) so the settings/setup dropdown and `resolveProviderChain()`
+ * share one source of truth and never drift apart.
+ */
+export declare const SEARCH_PROVIDER_ORDER: readonly SearchProviderId[];
+export declare const SEARCH_PROVIDER_PREFERENCES: readonly ["auto", ...SearchProviderId[]];
+/** Display labels, derived from {@link SEARCH_PROVIDER_OPTIONS}. */
+export declare const SEARCH_PROVIDER_LABELS: Record<SearchProviderId, string>;
+export declare function isSearchProviderId(value: string): value is SearchProviderId;
+export declare function isSearchProviderPreference(value: string): value is SearchProviderId | "auto";
+/** Source returned by search (all providers) */
+export interface SearchSource {
+    title: string;
+    url: string;
+    snippet?: string;
+    /** ISO date string or relative ("2d ago") */
+    publishedDate?: string;
+    /** Age in seconds for consistent formatting */
+    ageSeconds?: number;
+    author?: string;
+}
+/** Citation with text reference (LLM-mediated providers) */
+export interface SearchCitation {
+    url: string;
+    title: string;
+    citedText?: string;
+}
+/** Usage metrics */
+export interface SearchUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    /** Anthropic: number of web search requests made */
+    searchRequests?: number;
+    /** Perplexity: combined token count */
+    totalTokens?: number;
+}
+/** Unified response across providers */
+export interface SearchResponse {
+    provider: SearchProviderId | "none";
+    /** Synthesized answer text (LLM-mediated providers) */
+    answer?: string;
+    /** Search result sources */
+    sources: SearchSource[];
+    /** Text citations with context */
+    citations?: SearchCitation[];
+    /** Intermediate search queries (anthropic) */
+    searchQueries?: string[];
+    /** Follow-up question suggestions (provider-dependent) */
+    relatedQuestions?: string[];
+    /** Token usage metrics */
+    usage?: SearchUsage;
+    /** Model used */
+    model?: string;
+    /** Request ID for debugging */
+    requestId?: string;
+    /** Authentication mode used by the provider (e.g. oauth, api-key) */
+    authMode?: string;
+}
+/** Provider-specific error with optional HTTP status */
+export declare class SearchProviderError extends Error {
+    readonly provider: SearchProviderId;
+    readonly status?: number | undefined;
+    constructor(provider: SearchProviderId, message: string, status?: number | undefined);
+}
+/** Anthropic API response types */
+export interface AnthropicSearchResult {
+    type: "web_search_result";
+    title: string;
+    url: string;
+    encrypted_content: string;
+    page_age: string | null;
+}
+export interface AnthropicCitation {
+    type: "web_search_result_location";
+    url: string;
+    title: string;
+    cited_text: string;
+    encrypted_index: string;
+}
+export interface AnthropicContentBlock {
+    type: string;
+    /** Text content (for type="text") */
+    text?: string;
+    /** Citations in text block */
+    citations?: AnthropicCitation[];
+    /** Tool name (for type="server_tool_use") */
+    name?: string;
+    /** Tool input (for type="server_tool_use") */
+    input?: {
+        query: string;
+    };
+    /** Search results (for type="web_search_tool_result") */
+    content?: AnthropicSearchResult[];
+}
+export interface AnthropicApiResponse {
+    id: string;
+    model: string;
+    content: AnthropicContentBlock[];
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_read_input_tokens?: number;
+        cache_creation_input_tokens?: number;
+        server_tool_use?: {
+            web_search_requests: number;
+        };
+    };
+}
+/** Perplexity API types */
+export type PerplexityChatMessageRole = "system" | "user" | "assistant" | "tool";
+export interface PerplexityUrl {
+    url: string;
+}
+export interface PerplexityVideoUrl {
+    url: string;
+    frame_interval?: string | number;
+}
+export interface PerplexityContentTextChunk {
+    type: "text";
+    text: string;
+}
+export interface PerplexityContentImageChunk {
+    type: "image_url";
+    image_url: PerplexityUrl | string;
+}
+export interface PerplexityContentFileChunk {
+    type: "file_url";
+    file_url: PerplexityUrl | string;
+    file_name?: string | null;
+}
+export interface PerplexityContentPdfChunk {
+    type: "pdf_url";
+    pdf_url: PerplexityUrl | string;
+}
+export interface PerplexityContentVideoChunk {
+    type: "video_url";
+    video_url: PerplexityVideoUrl | string;
+}
+export type PerplexityContentChunk = PerplexityContentTextChunk | PerplexityContentImageChunk | PerplexityContentFileChunk | PerplexityContentPdfChunk | PerplexityContentVideoChunk;
+export interface PerplexitySearchStepDetails {
+    search_results: PerplexitySearchResult[];
+    search_keywords: string[];
+}
+export interface PerplexityFetchUrlContentStepDetails {
+    contents: PerplexitySearchResult[];
+}
+export interface PerplexityExecutePythonStepDetails {
+    code: string;
+    result: string;
+}
+export interface PerplexityReasoningStepInput {
+    thought: string;
+    type?: string | null;
+    web_search?: PerplexitySearchStepDetails | null;
+    fetch_url_content?: PerplexityFetchUrlContentStepDetails | null;
+    execute_python?: PerplexityExecutePythonStepDetails | null;
+}
+export interface PerplexityReasoningStepOutput {
+    thought: string;
+    type?: string | null;
+    web_search?: PerplexitySearchStepDetails | null;
+    fetch_url_content?: PerplexityFetchUrlContentStepDetails | null;
+    execute_python?: PerplexityExecutePythonStepDetails | null;
+}
+export interface PerplexityToolCallFunction {
+    name?: string | null;
+    arguments?: string | null;
+}
+export interface PerplexityToolCall {
+    id?: string | null;
+    type?: "function" | null;
+    function?: PerplexityToolCallFunction | null;
+}
+export interface PerplexityMessageInput {
+    role: PerplexityChatMessageRole;
+    content: string | PerplexityContentChunk[] | null;
+    reasoning_steps?: PerplexityReasoningStepInput[] | null;
+    tool_calls?: PerplexityToolCall[] | null;
+    tool_call_id?: string | null;
+}
+export interface PerplexityMessageOutput {
+    role: PerplexityChatMessageRole;
+    content: string | PerplexityContentChunk[] | null;
+    reasoning_steps?: PerplexityReasoningStepOutput[] | null;
+    tool_calls?: PerplexityToolCall[] | null;
+    tool_call_id?: string | null;
+}
+export type PerplexityMessage = PerplexityMessageInput;
+export interface PerplexityResponseFormatText {
+    type: "text";
+}
+export interface PerplexityJSONSchema {
+    schema: Record<string, unknown>;
+    name?: string | null;
+    description?: string | null;
+    strict?: boolean | null;
+}
+export interface PerplexityResponseFormatJSONSchema {
+    type: "json_schema";
+    json_schema: PerplexityJSONSchema;
+}
+export interface PerplexityRegexSchema {
+    regex: string;
+    name?: string | null;
+    description?: string | null;
+    strict?: boolean | null;
+}
+export interface PerplexityResponseFormatRegex {
+    type: "regex";
+    regex: PerplexityRegexSchema;
+}
+export type PerplexityResponseFormat = PerplexityResponseFormatText | PerplexityResponseFormatJSONSchema | PerplexityResponseFormatRegex;
+export interface PerplexityParameterSpec {
+    type: string;
+    properties: Record<string, unknown>;
+    required?: string[] | null;
+    additional_properties?: boolean | null;
+}
+export interface PerplexityFunctionSpec {
+    name: string;
+    description: string;
+    parameters: PerplexityParameterSpec;
+    strict?: boolean | null;
+}
+export interface PerplexityToolSpec {
+    type: "function";
+    function: PerplexityFunctionSpec;
+}
+export interface PerplexityUserLocation {
+    latitude?: number | null;
+    longitude?: number | null;
+    country?: string | null;
+    city?: string | null;
+    region?: string | null;
+}
+export interface PerplexitySearchOptions {
+    search_context_size?: "low" | "medium" | "high";
+    search_type?: "fast" | "pro" | "auto" | null;
+    user_location?: PerplexityUserLocation | null;
+    image_results_enhanced_relevance?: boolean;
+}
+export interface PerplexityRequest {
+    max_tokens?: number | null;
+    temperature?: number | null;
+    n?: number | null;
+    model: string;
+    stream?: boolean | null;
+    stop?: string | string[] | null;
+    cum_logprobs?: boolean | null;
+    logprobs?: boolean | null;
+    top_logprobs?: number | null;
+    best_of?: number | null;
+    response_metadata?: Record<string, unknown> | null;
+    response_format?: PerplexityResponseFormat | null;
+    diverse_first_token?: boolean | null;
+    _inputs?: number[] | null;
+    _prompt_token_length?: number | null;
+    messages: PerplexityMessageInput[];
+    tools?: PerplexityToolSpec[] | null;
+    tool_choice?: "none" | "auto" | "required" | null;
+    parallel_tool_calls?: boolean | null;
+    web_search_options?: PerplexitySearchOptions;
+    search_mode?: "web" | "academic" | "sec" | null;
+    return_images?: boolean | null;
+    return_related_questions?: boolean | null;
+    num_search_results?: number;
+    num_images?: number;
+    enable_search_classifier?: boolean | null;
+    disable_search?: boolean | null;
+    search_domain_filter?: string[] | null;
+    search_language_filter?: string[] | null;
+    search_tenant?: string | null;
+    ranking_model?: string | null;
+    latitude?: number | null;
+    longitude?: number | null;
+    country?: string | null;
+    search_recency_filter?: "hour" | "day" | "week" | "month" | "year" | null;
+    search_after_date_filter?: string | null;
+    search_before_date_filter?: string | null;
+    last_updated_before_filter?: string | null;
+    last_updated_after_filter?: string | null;
+    image_format_filter?: string[] | null;
+    image_domain_filter?: string[] | null;
+    safe_search?: boolean | null;
+    file_workspace_id?: string | null;
+    updated_before_timestamp?: number | null;
+    updated_after_timestamp?: number | null;
+    search_internal_properties?: Record<string, unknown> | null;
+    use_threads?: boolean | null;
+    thread_id?: string | null;
+    stream_mode?: "full" | "concise";
+    _debug_pro_search?: boolean;
+    has_image_url?: boolean;
+    reasoning_effort?: "minimal" | "low" | "medium" | "high" | null;
+    language_preference?: string | null;
+    user_original_query?: string | null;
+    _force_new_agent?: boolean | null;
+}
+export interface PerplexitySearchResult {
+    title: string;
+    url: string;
+    date?: string | null;
+    last_updated?: string | null;
+    snippet?: string;
+    source?: "web" | "attachment";
+}
+export interface PerplexityCost {
+    input_tokens_cost: number;
+    output_tokens_cost: number;
+    reasoning_tokens_cost?: number | null;
+    request_cost?: number | null;
+    citation_tokens_cost?: number | null;
+    search_queries_cost?: number | null;
+    total_cost: number;
+}
+export interface PerplexityUsageInfo {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    search_context_size?: string | null;
+    citation_tokens?: number | null;
+    num_search_queries?: number | null;
+    reasoning_tokens?: number | null;
+    cost: PerplexityCost;
+}
+export type PerplexityCompletionResponseType = "message" | "info" | "end_of_stream";
+export type PerplexityCompletionResponseStatus = "PENDING" | "COMPLETED";
+export interface PerplexityChoice {
+    index: number;
+    finish_reason?: "stop" | "length" | null;
+    message: PerplexityMessageOutput;
+    delta: PerplexityMessageOutput;
+}
+export interface PerplexityResponse {
+    id: string;
+    model: string;
+    created: number;
+    usage?: PerplexityUsageInfo | null;
+    object?: string;
+    choices: PerplexityChoice[];
+    citations?: string[] | null;
+    search_results?: PerplexitySearchResult[] | null;
+    related_questions?: string[] | null;
+    type?: PerplexityCompletionResponseType | null;
+    status?: PerplexityCompletionResponseStatus | null;
+}

package/dist/types/web/search/utils.d.ts

@@ -0,0 +1,4 @@
+/** Calculate age in seconds from an ISO date string. Returns undefined on invalid input. */
+export declare function dateToAgeSeconds(dateStr: string | null | undefined): number | undefined;
+/** Clamp a result count to [1, maxVal], returning defaultVal when value is absent or NaN. */
+export declare function clampNumResults(value: number | undefined, defaultVal: number, maxVal: number): number;

package/dist/types/workspace-tree.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Hard cap on AGENTS.md files surfaced by `buildWorkspaceTree`. Mirrors the
+ * native cap so the system-prompt builder does not need a second pass.
+ */
+export declare const AGENTS_MD_LIMIT = 200;
+export interface DirectoryTree {
+    rootPath: string;
+    rendered: string;
+    truncated: boolean;
+    totalLines: number;
+}
+export interface WorkspaceTree extends DirectoryTree {
+    /** AGENTS.md files beneath the root whose rules may apply to subdirectories. */
+    agentsMdFiles: string[];
+}
+export interface BuildDirectoryTreeOptions {
+    /** Directory depth below the root to include. Root itself is depth 0. Default: 1. */
+    maxDepth?: number;
+    /** Per-directory child cap. `null` disables the cap. Default: `null`. */
+    perDirLimit?: number | null;
+    /** Optional override for the root level. Defaults to `perDirLimit`. */
+    rootLimit?: number | null;
+    /** Hard rendered line cap. `null` disables. Default: `null`. */
+    lineCap?: number | null;
+}
+export interface BuildWorkspaceTreeOptions {
+    /** Abort the native workspace scan after this many milliseconds. */
+    timeoutMs?: number;
+}
+/**
+ * Build a generic directory tree using a single native scan. Hidden files are
+ * shown, .gitignore is not consulted, and the standard non-source directories
+ * (`node_modules`, `.git`, build outputs, caches…) are pruned by the native
+ * walker. Used by the read tool's directory-listing path.
+ */
+export declare function buildDirectoryTree(cwd: string, options?: BuildDirectoryTreeOptions): Promise<DirectoryTree>;
+/**
+ * Build the workspace tree shown in the system prompt. Returns the rendered
+ * tree plus the AGENTS.md files surfaced by the same native walk so callers
+ * never need to do a second filesystem scan.
+ */
+export declare function buildWorkspaceTree(cwd: string, options?: BuildWorkspaceTreeOptions): Promise<WorkspaceTree>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-cli",
-	"version": "16.2.14",
+	"version": "16.2.17",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -53,49 +53,49 @@
 		"bench:guard": "bun scripts/bench-guard.ts"
 	},
 	"dependencies": {
-		"@agentclientprotocol/sdk": "catalog:",
-		"@babel/parser": "catalog:",
-		"@mozilla/readability": "catalog:",
-		"jeopi-hashline": "catalog:",
-		"jeopi-stats": "catalog:",
-		"jeopi-agent-core": "catalog:",
-		"jeopi-ai": "catalog:",
-		"jeopi-catalog": "catalog:",
-		"jeopi-mnemopi": "catalog:",
-		"jeopi-natives": "catalog:",
-		"jeopi-tui": "catalog:",
-		"jeopi-utils": "catalog:",
-		"jeopi-wire": "catalog:",
-		"jeopi-snapcompact": "catalog:",
-		"@opentelemetry/api": "catalog:",
-		"@opentelemetry/context-async-hooks": "catalog:",
-		"@opentelemetry/exporter-trace-otlp-proto": "catalog:",
-		"@opentelemetry/resources": "catalog:",
-		"@opentelemetry/sdk-trace-base": "catalog:",
-		"@opentelemetry/sdk-trace-node": "catalog:",
-		"@puppeteer/browsers": "catalog:",
-		"@types/turndown": "catalog:",
-		"@xterm/headless": "catalog:",
-		"arktype": "catalog:",
-		"chalk": "catalog:",
-		"diff": "catalog:",
-		"fast-xml-parser": "catalog:",
-		"handlebars": "catalog:",
-		"linkedom": "catalog:",
-		"lru-cache": "catalog:",
-		"mammoth": "catalog:",
-		"mupdf": "catalog:",
-		"puppeteer-core": "catalog:",
-		"turndown": "catalog:",
-		"turndown-plugin-gfm": "catalog:",
-		"zod": "catalog:"
+		"@agentclientprotocol/sdk": "0.25.0",
+		"@babel/parser": "^7.29.7",
+		"@mozilla/readability": "^0.6.0",
+		"jeopi-hashline": "16.2.17",
+		"jeopi-stats": "16.2.17",
+		"jeopi-agent-core": "16.2.17",
+		"jeopi-ai": "16.2.17",
+		"jeopi-catalog": "16.2.17",
+		"jeopi-mnemopi": "16.2.17",
+		"jeopi-natives": "16.2.17",
+		"jeopi-tui": "16.2.17",
+		"jeopi-utils": "16.2.17",
+		"jeopi-wire": "16.2.17",
+		"jeopi-snapcompact": "16.2.17",
+		"@opentelemetry/api": "^1.9.1",
+		"@opentelemetry/context-async-hooks": "^2.7.1",
+		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",
+		"@opentelemetry/resources": "^2.7.1",
+		"@opentelemetry/sdk-trace-base": "^2.7.1",
+		"@opentelemetry/sdk-trace-node": "^2.7.1",
+		"@puppeteer/browsers": "^3.0.4",
+		"@types/turndown": "5.0.6",
+		"@xterm/headless": "^6.0.0",
+		"arktype": "^2.2.0",
+		"chalk": "^5.6.2",
+		"diff": "^9.0.0",
+		"fast-xml-parser": "^5.9.0",
+		"handlebars": "^4.7.9",
+		"linkedom": "^0.18.12",
+		"lru-cache": "11.5.1",
+		"mammoth": "^1.12.0",
+		"mupdf": "^1.27.0",
+		"puppeteer-core": "^25.1.0",
+		"turndown": "7.2.4",
+		"turndown-plugin-gfm": "1.0.2",
+		"zod": "^4"
 	},
 	"optionalDependencies": {
-		"@huggingface/transformers": "catalog:",
+		"@huggingface/transformers": "^4.2.0",
 		"sherpa-onnx-node": "1.13.2"
 	},
 	"devDependencies": {
-		"@types/bun": "catalog:"
+		"@types/bun": "^1.3.14"
 	},
 	"engines": {
 		"bun": ">=1.3.14"

package/src/autolearn/managed-skills.ts

@@ -14,7 +14,7 @@ import { YAML } from "bun";
 import { getAgentDir, isEnoent } from "jeopi-utils";
 
 /** Provider id stamped on discovered managed skills (distinguishes them from authored). */
-export const MANAGED_SKILLS_PROVIDER_ID = "omp-managed";
+export const MANAGED_SKILLS_PROVIDER_ID = "jeopi-managed";
 
 /** Hard cap on a managed SKILL.md body to keep generated skills bounded. */
 export const MAX_MANAGED_SKILL_BYTES = 64_000;

package/src/autoresearch/storage.ts

@@ -572,7 +572,7 @@ export async function openAutoresearchStorageIfExists(cwd: string): Promise<Auto
 }
 
 async function resolveAutoresearchPaths(cwd: string): Promise<{ dbPath: string; projectDir: string }> {
-	const override = process.env.OMP_AUTORESEARCH_DB_DIR;
+	const override = process.env.JEOPI_AUTORESEARCH_DB_DIR;
 	const repoRoot = (await git.repo.root(cwd)) ?? cwd;
 	const encoded = encodeProjectKey(repoRoot);
 	if (override) {

package/src/capability/types.ts

@@ -31,7 +31,7 @@ export interface LoadResult<T> {
  * A provider that can load items for a capability.
  */
 export interface Provider<T> {
-	/** Unique provider ID (e.g., "claude", "omp", "mcp-json", "agents-md") */
+	/** Unique provider ID (e.g., "claude", "jeopi", "mcp-json", "agents-md") */
 	id: string;
 
 	/** Human-readable name for UI display (e.g., "Claude Code", "OpenAI Codex") */
@@ -43,7 +43,7 @@ export interface Provider<T> {
 	/**
 	 * Priority (higher = checked first, wins on conflicts).
 	 * Suggested ranges:
-	 *   100+ : Primary providers (omp, pi)
+	 *   100+ : Primary providers (jeopi, pi)
 	 *   50-99: Tool-specific providers (claude, codex, gemini)
 	 *   1-49 : Shared standards (mcp-json, agents-md)
 	 */

package/src/cli/args.ts

@@ -349,7 +349,7 @@ export function getExtraHelpText(): string {
   ANTHROPIC_SEARCH_BASE_URL  - Anthropic web search base URL (override; pairs with ANTHROPIC_SEARCH_API_KEY)
 
   ${chalk.dim("# Configuration")}
-  OMP_PROFILE                 - Named profile for isolated agent state (same as --profile)
+  JEOPI_PROFILE               - Named profile for isolated agent state (same as --profile)
   Use \`${APP_NAME} --profile <name> --alias <command>\` to create a shell shortcut for a profile
   PI_CODING_AGENT_DIR        - Session storage directory (default: ~/${CONFIG_DIR_NAME}/agent)
   PI_PACKAGE_DIR             - Override package directory (for Nix/Guix store paths)

package/src/cli/auth-broker-cli.ts

@@ -412,7 +412,7 @@ async function runList(flags: AuthBrokerCommandArgs["flags"]): Promise<void> {
 // ─── CLIProxyAPI import ─────────────────────────────────────────────────
 
 /**
- * Maps the `type` field of a CLIProxyAPI credential JSON to the omp provider id.
+ * Maps the `type` field of a CLIProxyAPI credential JSON to the jeopi provider id.
  * The filename also encodes the type (e.g. `claude-foo@bar.json`), but the
  * in-file `type` is authoritative — we only fall back to filename if absent.
  */
@@ -508,7 +508,7 @@ async function loadImportPlan(
 		if (!provider) {
 			skipped.push({
 				file,
-				reason: `cannot determine omp provider from type=${json.type ?? "?"} (pass --provider to override)`,
+				reason: `cannot determine jeopi provider from type=${json.type ?? "?"} (pass --provider to override)`,
 			});
 			continue;
 		}
@@ -693,7 +693,7 @@ async function runMigrate(flags: AuthBrokerCommandArgs["flags"]): Promise<void>
 	const brokerConfig = await resolveAuthBrokerConfig();
 	if (!brokerConfig) {
 		throw new Error(
-			"OMP_AUTH_BROKER_URL must be set (or `auth.broker.url` in config.yml). `migrate` uploads local credentials to a configured broker.",
+			"JEOPI_AUTH_BROKER_URL must be set (or `auth.broker.url` in config.yml). `migrate` uploads local credentials to a configured broker.",
 		);
 	}
 	if (flags.fromLocal !== true) {
@@ -846,7 +846,7 @@ async function runMigrate(flags: AuthBrokerCommandArgs["flags"]): Promise<void>
 async function runStatus(flags: AuthBrokerCommandArgs["flags"]): Promise<void> {
 	const cfg = await resolveAuthBrokerConfig();
 	if (!cfg) {
-		const message = "No auth-broker configured (set OMP_AUTH_BROKER_URL to enable).";
+		const message = "No auth-broker configured (set JEOPI_AUTH_BROKER_URL to enable).";
 		if (flags.json) process.stdout.write(`${JSON.stringify({ ok: false, reason: "not_configured" })}\n`);
 		else process.stdout.write(`${chalk.yellow(message)}\n`);
 		return;