@hienlh/ppm 0.23.11 → 0.23.13

package/src/providers/codex-app-server/codex-provider.ts

@@ -23,6 +23,8 @@ import {
   getCodexAccountUsage,
   codexUsageLevel,
   type CodexAccount,
+  CodexDailyGuardError,
+  CodexSignedOutError,
 } from "../../services/codex-account.service.ts";
 import { dailyGuardMessage, dailyGuardState } from "../../shared/codex-daily-guard.ts";
 import { isCodexAccountUsageLimited, markCodexAccountUsageLimited } from "../../services/codex-account-cooldown.ts";
@@ -33,12 +35,14 @@ import {
 } from "../../services/codex-account-auth-state.ts";
 import { killProcessTree } from "../../services/windows-process-tree.ts";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { CodexJsonRpcClient, CONTROL_REQUEST_TIMEOUT_MS, codexCommand } from "./codex-jsonrpc-client.ts";
 import { permissionModeToCodex, type CodexPermission } from "./codex-permission-map.ts";
-import { buildThreadParams, designMcpEnv, requestWithInstructionsFallback, type CodexThreadParams } from "./codex-thread-params.ts";
+import { buildThreadParams, designMcpEnv, requestWithInstructionsFallback, tabToolsMcpEnv, type CodexThreadParams } from "./codex-thread-params.ts";
 import type { DesignMcpAccess } from "../../services/design/mcp/design-mcp-tool.ts";
+import type { TabToolsMcpAccess } from "../../services/tab-tools-mcp/tab-tools-mcp-tool.ts";
 import { mapCodexEvent, parseTokenUsage } from "./codex-event-mapper.ts";
+import { recordFileChangeBaselines } from "./codex-file-baselines.ts";
 import { subagentCardId } from "./codex-subagent-thread.ts";
 import { decisionFor, isApprovalMethod, type ApprovalMethod } from "./codex-approval-decision.ts";
 import { parseModelList } from "./codex-model-parser.ts";
@@ -63,6 +67,10 @@ import type {
   CodexSkill,
 } from "./codex-protocol.ts";
 import { parseSkillList } from "./codex-skill-parser.ts";
+import { createLogger } from "../../services/logger.ts";
+
+const log = createLogger("codex");
+const usageLog = createLogger("usage");
 
 const CODEX_SESSIONS_DIR = join(homedir(), ".codex", "sessions");
 
@@ -152,6 +160,8 @@ interface LiveSession {
   developerInstructions?: string;
   /** A design session's `design_check` endpoint, kept for the same reason. */
   designMcp?: DesignMcpAccess;
+  /** The tab tools' endpoint, when the user has them on; kept for the same reason. */
+  tabToolsMcp?: TabToolsMcpAccess;
   pendingApprovals: Map<string, PendingApproval>;
   answeredCodexIds: Set<number | string>;
   /** Rollout history snapshot at connect — lets live message ids continue the
@@ -300,6 +310,12 @@ function missingRolloutError(sessionId: string): Error {
   return new Error(`Cannot resume Codex session ${sessionId}: its transcript was not found in the available account homes for this project. Restore the original account/transcript and retry, or explicitly open a new chat.`);
 }
 
+/** An error as a log line may show it. The signed-out message names account labels, which are often emails. */
+function loggableError(err: unknown): string {
+  if (err instanceof CodexSignedOutError) return "every enabled Codex account is signed out";
+  return redactTruncate((err as Error)?.message ?? String(err), 200);
+}
+
 /** Human label for an approval prompt (dormant in MVP under default bypass). */
 function approvalToolLabel(method: string, params: unknown): string {
   const p = (params && typeof params === "object" ? params : {}) as Record<string, unknown>;
@@ -351,6 +367,8 @@ export class CodexAppServerProvider implements AIProvider {
    *  instead of starting its own app-server. Without it, `/chat/prepare`'s 400ms slash
    *  budget left a cold cache spawning one app-server per concurrent request. */
   private skillsPending = new Map<string, Promise<CodexSkill[]>>();
+  /** model/list and skills/list fail again on every picker open, so each is a WARN once a minute. */
+  private listFailureWarned = new Map<string, { at: number; suppressed: number }>();
 
   private get config() {
     try { return configService.get("ai").providers["codex"] ?? null; } catch { return null; }
@@ -439,6 +457,9 @@ export class CodexAppServerProvider implements AIProvider {
       try {
         live = await this.connect(sessionId, opts);
       } catch (err) {
+        // Only a chat socket sees the error event below; every other origin needs this line.
+        if (err instanceof CodexDailyGuardError) log.warn(`session=${sessionId} connect refused by daily guard`);
+        else log.error(`session=${sessionId} connect failed: ${loggableError(err)}`);
         this.abortQuery(sessionId, "connect_failed");
         yield { type: "error", message: redactTruncate((err as Error)?.message ?? String(err), 512) };
         yield { type: "done", sessionId, resultSubtype: "error_during_execution" };
@@ -503,6 +524,7 @@ export class CodexAppServerProvider implements AIProvider {
     const guardError = await this.dailyGuardError(live);
     live.checkingDailyGuard = false;
     if (guardError) {
+      log.warn(`session=${live.threadId} turn refused by daily guard account=${getSessionCodexAccount(live.threadId) ?? "ambient"}`);
       live.channel.push({ type: "error", message: guardError });
       live.channel.push({ type: "done", sessionId: live.threadId, resultSubtype: "error_during_execution" });
       this.endTurn(live);
@@ -640,7 +662,7 @@ export class CodexAppServerProvider implements AIProvider {
       live.transcript.push({ id: nextRolloutId(live), role: "user", content: item.message, timestamp: new Date().toISOString() });
     }).catch((err) => {
       if (live.client.isClosed) return;
-      console.warn(`[codex] session=${live.threadId} steer refused, sending as its own turn: ${redactTruncate((err as Error)?.message ?? String(err), 200)}`);
+      log.warn(`session=${live.threadId} steer refused, sending as its own turn: ${redactTruncate((err as Error)?.message ?? String(err), 200)}`);
       const retry: QueuedTurn = { ...item, priority: "later" };
       // `later` so it is not steered straight back into a turn that just refused it; the
       // head of the queue because it was sent before anything waiting there.
@@ -683,7 +705,10 @@ export class CodexAppServerProvider implements AIProvider {
       (a) => a.status !== "disabled" && a.id !== currentId
         && !isCodexAccountUsageLimited(a.id) && !isCodexAccountAuthFailed(a.id),
     );
-    if (candidates.length === 0) return false;
+    if (candidates.length === 0) {
+      log.error(`session=${threadId} turn failed: ${kind === "auth" ? "signed out" : "usage limit"} on account ${currentId ?? "ambient"}, nothing to rotate to`);
+      return false;
+    }
     live.rotating = true;
     void this.rotateAccount(live, threadId, currentId, reason, kind);
     return true;
@@ -747,9 +772,14 @@ export class CodexAppServerProvider implements AIProvider {
       next = selectCodexAccount(currentId ? { exclude: [currentId] } : undefined);
     }
 
-    if (!next) { giveUp(); return; }
+    if (!next) {
+      log.error(`session=${threadId} turn failed: ${kind === "auth" ? "signed out" : "usage limit"} on account ${currentId ?? "ambient"}, nothing to rotate to`);
+      giveUp();
+      return;
+    }
 
-    console.warn(`[codex] session=${threadId} ${kind === "auth" ? "account signed out" : "usage limit"} — switching to ${next.id} (${next.label})`);
+    // By id only: a label defaults to the account's ChatGPT email.
+    log.warn(`session=${threadId} ${kind === "auth" ? "account signed out" : "usage limit"} — switching to ${next.id}`);
     live.channel.push({
       type: "account_retry",
       reason: kind === "auth" ? "Account signed out — switching account" : "Usage limit reached — switching account",
@@ -760,7 +790,7 @@ export class CodexAppServerProvider implements AIProvider {
     try {
       await this.respawnOn(live, threadId, next);
     } catch (e) {
-      console.error(`[codex] session=${threadId} rotation to ${next.id} failed: ${redactTruncate((e as Error)?.message, 200)}`);
+      log.error(`session=${threadId} rotation to ${next.id} failed: ${redactTruncate((e as Error)?.message, 200)}`);
       giveUp();
       return;
     }
@@ -828,7 +858,7 @@ export class CodexAppServerProvider implements AIProvider {
     client.onNotification((n) => this.handleNotification(live, n));
     client.onServerRequest((r) => this.handleServerRequest(live, r));
     client.onClose(() => this.handleClose(live));
-    client.start({ cwd: live.cwd, codexHome: account.home, env: designMcpEnv(live.designMcp) });
+    client.start({ cwd: live.cwd, codexHome: account.home, env: { ...designMcpEnv(live.designMcp), ...tabToolsMcpEnv(live.tabToolsMcp) }, purpose: "chat" });
     live.client = client;
 
     await client.request("initialize", { clientInfo: CLIENT_INFO, capabilities: CAPABILITIES }, CONTROL_REQUEST_TIMEOUT_MS);
@@ -841,6 +871,7 @@ export class CodexAppServerProvider implements AIProvider {
       configOverrides: this.contextConfigOverrides(),
       developerInstructions: live.developerInstructions,
       designMcp: live.designMcp,
+      tabToolsMcp: live.tabToolsMcp,
     });
     await requestWithInstructionsFallback(resumeBase,
       (params) => this.resumeThread(client, threadId, found, account.home, params));
@@ -869,7 +900,7 @@ export class CodexAppServerProvider implements AIProvider {
     const target = sessionsDirForHome(codexHome);
     const path = localizeRollout(found.path, found.sessionsDir, target);
     if (path !== found.path) {
-      console.log(`[codex] thread=${threadId} rollout copied into the serving account's home to resume`);
+      log.info(`thread=${threadId} rollout copied into the serving account's home to resume`);
     }
     return client.request("thread/resume", { threadId, path, ...resumeBase });
   }
@@ -906,6 +937,7 @@ export class CodexAppServerProvider implements AIProvider {
       client, threadId: null, cwd, channel, permission, model,
       developerInstructions: opts?.designInstructions,
       designMcp: opts?.designSession ? opts.designMcp : undefined,
+      tabToolsMcp: opts?.designSession ? undefined : opts?.tabToolsMcp,
       pendingApprovals: new Map(), answeredCodexIds: new Set(),
       history: [], transcript: [], currentAssistant: "", currentEvents: [],
       pendingTurns: [], subagentThreadIds: new Set(),
@@ -914,12 +946,13 @@ export class CodexAppServerProvider implements AIProvider {
 
     // Multi-account: resolve which codex account backs this session (sticky → strategy →
     // null = default ~/.codex). Spawn the app-server with that account's CODEX_HOME.
+    const sticky = getSessionCodexAccount(sessionId); // only for the log line below
     const account = await resolveCodexAccountForSession(sessionId);
 
     client.onNotification((n) => this.handleNotification(live, n));
     client.onServerRequest((r) => this.handleServerRequest(live, r));
     client.onClose(() => this.handleClose(live));
-    client.start({ cwd, codexHome: account?.home, env: designMcpEnv(live.designMcp) });
+    client.start({ cwd, codexHome: account?.home, env: { ...designMcpEnv(live.designMcp), ...tabToolsMcpEnv(live.tabToolsMcp) }, purpose: "chat" });
 
     await client.request("initialize", { clientInfo: CLIENT_INFO, capabilities: CAPABILITIES }, CONTROL_REQUEST_TIMEOUT_MS);
     client.notify("initialized");
@@ -929,6 +962,7 @@ export class CodexAppServerProvider implements AIProvider {
       configOverrides: this.contextConfigOverrides(),
       developerInstructions: live.developerInstructions,
       designMcp: live.designMcp,
+      tabToolsMcp: live.tabToolsMcp,
     });
     // Only treat as a resume when a rollout for this id is attributable to THIS
     // project (fail-closed cwd guard) — never resume another project's thread.
@@ -965,6 +999,8 @@ export class CodexAppServerProvider implements AIProvider {
       const msgs = getRolloutMessages(d, threadId, cwd);
       return msgs.length > 0 ? msgs : null;
     }) ?? [] : [];
+    const how = !account ? "" : account.id === sticky ? " (sticky)" : sticky ? ` (moved from ${sticky})` : " (picked)";
+    log.info(`session=${sessionId} thread=${threadId} ${found ? "resumed" : "new"} account=${account?.id ?? "ambient"}${how} pid=${client.pid ?? "?"}`);
     return live;
   }
 
@@ -976,6 +1012,11 @@ export class CodexAppServerProvider implements AIProvider {
       ? notificationThreadId !== live.threadId
       : live.subagentThreadIds.has(notificationThreadId));
     const parentToolUseId = isChild ? subagentCardId(notificationThreadId!) : undefined;
+    // Ahead of the guards below: a patch codex finished is on disk whatever becomes of the
+    // turn, and a spawned agent's patches belong to this session's review too.
+    if (notif.method === "item/completed" && live.threadId) {
+      void recordFileChangeBaselines(live.threadId, (notif.params as { item?: unknown } | undefined)?.item, live.cwd);
+    }
     // A quota refusal is an ordinary `error` notification, so it has to be recognised
     // before the mapper turns it into a plain error card in front of the user.
     if (!isChild && notif.method === "error" && !live.rotating && !live.discardingTurn) {
@@ -1097,7 +1138,7 @@ export class CodexAppServerProvider implements AIProvider {
         ...(account?.label ? { accountLabel: account.label } : {}),
       });
     } catch (err) {
-      console.warn(`[usage] failed to persist codex usage: ${(err as Error).message}`);
+      usageLog.warn(`failed to persist codex usage: ${(err as Error).message}`);
     }
   }
 
@@ -1174,7 +1215,13 @@ export class CodexAppServerProvider implements AIProvider {
   }
 
   private handleClose(live: LiveSession): void {
-    for (const [k, v] of this.live) if (v === live) this.live.delete(k);
+    // abortQuery forgets the session before it closes the client, so one still listed here
+    // is an app-server that exited on its own.
+    let unexpected = false;
+    for (const [k, v] of this.live) if (v === live) { this.live.delete(k); unexpected = true; }
+    if (unexpected) {
+      log.error(`session=${live.threadId ?? "?"} app-server pid=${live.client.pid ?? "?"} exited unexpectedly turnInFlight=${!!live.turnInFlight}`);
+    }
     live.channel.done();
   }
 
@@ -1309,11 +1356,13 @@ export class CodexAppServerProvider implements AIProvider {
 
   private async loadModels(): Promise<ModelOption[]> {
     const client = new CodexJsonRpcClient();
+    let accountId: string | null = null;
     try {
       // Without a CODEX_HOME the app-server falls back to the machine's own
       // ~/.codex login, which may be stale or absent — the model list then comes
       // from an account PPM does not use, or fails outright on a refresh error.
       const account = await resolveCodexAccountForSession();
+      accountId = account?.id ?? null;
       client.start({ cwd: process.cwd(), ...(account ? { codexHome: account.home } : {}) });
       await client.request("initialize", { clientInfo: CLIENT_INFO, capabilities: CAPABILITIES }, CONTROL_REQUEST_TIMEOUT_MS);
       client.notify("initialized");
@@ -1327,7 +1376,9 @@ export class CodexAppServerProvider implements AIProvider {
       const models = parseModelList(all);
       if (models.length > 0) this.modelsCache = { models, expiry: Date.now() + MODELS_CACHE_TTL };
       return models;
-    } catch {
+    } catch (err) {
+      // The picker shows an empty list either way; this is the only record of why.
+      this.warnListFailure("model/list", accountId ?? "ambient", err);
       return [];
     } finally {
       client.close();
@@ -1388,13 +1439,24 @@ export class CodexAppServerProvider implements AIProvider {
       const skills = parseSkillList(await client.request("skills/list", {}, CONTROL_REQUEST_TIMEOUT_MS));
       if (skills.length > 0) this.skillsCache.set(key, { skills, expiry: Date.now() + SKILLS_CACHE_TTL });
       return skills;
-    } catch {
+    } catch (err) {
+      // CODEX_HOME is <ppm dir>/codex-accounts/<account id>.
+      this.warnListFailure("skills/list", home ? basename(home) : "ambient", err);
       return [];
     } finally {
       client.close();
     }
   }
 
+  private warnListFailure(method: string, account: string, err: unknown): void {
+    const now = Date.now();
+    const last = this.listFailureWarned.get(method);
+    if (last && now - last.at < 60_000) { last.suppressed++; return; }
+    this.listFailureWarned.set(method, { at: now, suppressed: 0 });
+    const more = last?.suppressed ? ` (+${last.suppressed} more since the last warning)` : "";
+    log.warn(`${method} failed account=${account}: ${loggableError(err)}${more}`);
+  }
+
   /** Read the session's account without advancing the account-selection strategy. */
   async getUsage(sessionId?: string, pickedAccountId?: string): Promise<UsageInfo> {
     // Idempotent, and needed because a caller can reach the provider before the

package/src/providers/codex-app-server/codex-rollout-header.ts

@@ -1,3 +1,4 @@
+import { decodeReply } from "../../shared/chat-reply.ts";
 import { mapRolloutItem } from "./codex-rollout-items.ts";
 import { stripSharedContext } from "../../shared/provider-context.ts";
 
@@ -50,7 +51,7 @@ const TITLE_MAX_CHARS = 80;
 
 /** First user prompt → a one-line label. */
 function toTitle(text: string): string | undefined {
-  const flat = stripSharedContext(text).replace(/\s+/g, " ").trim();
+  const flat = decodeReply(stripSharedContext(text)).content.replace(/\s+/g, " ").trim();
   if (!flat) return undefined;
   return flat.length > TITLE_MAX_CHARS ? `${flat.slice(0, TITLE_MAX_CHARS - 1)}…` : flat;
 }

package/src/providers/codex-app-server/codex-rollout-items.ts

@@ -1,6 +1,7 @@
 import type { ChatEvent } from "../provider.interface.ts";
 import { redactTruncate } from "./codex-redact.ts";
 import { parseSubagentActivity, type SubagentActivity } from "./codex-subagent-thread.ts";
+import { changeToToolUse, rolloutFileChanges } from "./codex-patch.ts";
 
 /**
  * Rollout `item_completed` records → PPM chat events.
@@ -119,6 +120,26 @@ function imageGenerationEvents(item: Item): ChatEvent[] {
   ];
 }
 
+/**
+ * A patch codex applied. Without this it fell through to the generic card, so a conversation
+ * read back from disk showed its edits as raw JSON and counted no file as changed.
+ */
+function fileChangeEvents(item: Item): ChatEvent[] {
+  const changes = rolloutFileChanges(item.changes);
+  if (changes.length === 0) return genericEvents(item);
+  const toolUseId = typeof item.id === "string" ? item.id : undefined;
+  const status = String(item.status ?? "");
+  return [
+    changeToToolUse(changes[0]!, toolUseId, changes),
+    {
+      type: "tool_result",
+      output: redactTruncate(item.stdout || changes.map((c) => `${c.op} ${c.path}`).join("\n")),
+      isError: status === "failed" || status === "declined",
+      toolUseId,
+    },
+  ];
+}
+
 /** Everything the mapping does not know, shown rather than silently dropped. */
 function genericEvents(item: Item): ChatEvent[] {
   const toolUseId = typeof item.id === "string" ? item.id : undefined;
@@ -144,6 +165,7 @@ export function mapRolloutItem(item: unknown): RolloutItemMapping {
     return text ? { kind: "assistant", text } : { kind: "ignore" };
   }
   if (type === "CommandExecution") return { kind: "events", events: commandExecutionEvents(it) };
+  if (type === "FileChange") return { kind: "events", events: fileChangeEvents(it) };
   if (type === "Extension") {
     // `kind` names the extension; image generation is the one PPM renders specially.
     if (String(it.kind ?? "").startsWith("image_gen")) {

package/src/providers/codex-app-server/codex-thread-params.ts

@@ -4,6 +4,10 @@ import {
   CODEX_DESIGN_MCP_SERVER, CODEX_DESIGN_MCP_TOKEN_ENV, DESIGN_CHECK_TOOL, DESIGN_CHECK_TOOL_TIMEOUT_MS,
   type DesignMcpAccess,
 } from "../../services/design/mcp/design-mcp-tool.ts";
+import {
+  CODEX_TAB_TOOLS_MCP_SERVER, CODEX_TAB_TOOLS_MCP_TOKEN_ENV, OPEN_FILE_TOOL, OPEN_PREVIEW_TOOL, TAB_TOOLS_TIMEOUT_MS,
+  type TabToolsMcpAccess,
+} from "../../services/tab-tools-mcp/tab-tools-mcp-tool.ts";
 
 /** Config overrides, keyed like `-c key=value` on codex's command line (dotted paths). */
 export type CodexConfigOverrides = Record<string, unknown>;
@@ -20,6 +24,8 @@ export interface ThreadParamsInput {
   developerInstructions?: string;
   /** A design session's `design_check` endpoint; added as one more MCP server. */
   designMcp?: DesignMcpAccess;
+  /** The tab tools (`open_file`, `open_preview`) while the user has them on; likewise. */
+  tabToolsMcp?: TabToolsMcpAccess;
 }
 
 /**
@@ -49,6 +55,29 @@ export function designMcpEnv(access: DesignMcpAccess | undefined): Record<string
   return access ? { [CODEX_DESIGN_MCP_TOKEN_ENV]: access.token } : {};
 }
 
+/**
+ * The tab-tools MCP server, shaped and approved exactly like {@link designMcpConfig}: the
+ * tools only open a tab for the user to look at.
+ */
+export function tabToolsMcpConfig(access: TabToolsMcpAccess | undefined): CodexConfigOverrides {
+  if (!access) return {};
+  return {
+    [`mcp_servers.${CODEX_TAB_TOOLS_MCP_SERVER}`]: {
+      url: access.url,
+      bearer_token_env_var: CODEX_TAB_TOOLS_MCP_TOKEN_ENV,
+      enabled_tools: [OPEN_FILE_TOOL, OPEN_PREVIEW_TOOL],
+      default_tools_approval_mode: "approve",
+      startup_timeout_sec: 10,
+      tool_timeout_sec: Math.ceil(TAB_TOOLS_TIMEOUT_MS / 1000),
+    },
+  };
+}
+
+/** The environment the app-server needs for {@link tabToolsMcpConfig}; `{}` without the tools. */
+export function tabToolsMcpEnv(access: TabToolsMcpAccess | undefined): Record<string, string> {
+  return access ? { [CODEX_TAB_TOOLS_MCP_TOKEN_ENV]: access.token } : {};
+}
+
 /**
  * One builder for the params of every thread/start and thread/resume — the first connect
  * and the account-switch respawn used to assemble them separately, which is how a field
@@ -57,7 +86,11 @@ export function designMcpEnv(access: DesignMcpAccess | undefined): Record<string
  */
 export function buildThreadParams(input: ThreadParamsInput): CodexThreadParams {
   const instructions = input.developerInstructions?.trim();
-  const config = { ...(input.configOverrides?.config ?? {}), ...designMcpConfig(input.designMcp) };
+  const config = {
+    ...(input.configOverrides?.config ?? {}),
+    ...designMcpConfig(input.designMcp),
+    ...tabToolsMcpConfig(input.tabToolsMcp),
+  };
   return {
     ...(Object.keys(config).length ? { config } : {}),
     cwd: input.cwd,

package/src/providers/cursor-cli/cursor-history.ts

@@ -1,3 +1,4 @@
+import { decodeReply } from "../../shared/chat-reply.ts";
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -39,7 +40,7 @@ export async function listCursorSessions(providerId: string, chatsDir?: string):
               const hex = typeof row.value === "string" ? row.value : Buffer.from(row.value).toString("utf-8");
               const json = Buffer.from(hex, "hex").toString("utf-8");
               const meta = JSON.parse(json);
-              if (meta.name) title = stripSharedContext(meta.name).split("\n")[0]?.slice(0, 80) || title;
+              if (meta.name) title = decodeReply(stripSharedContext(meta.name)).content.split("\n")[0]?.slice(0, 80) || title;
               if (meta.createdAt) createdAt = new Date(meta.createdAt).toISOString();
             }
           } catch { /* use defaults */ }

package/src/providers/provider.interface.ts

@@ -9,5 +9,6 @@ export type {
   UsageInfo,
   LimitBucket,
   SendMessageOpts,
+  PrewarmInput,
   ModelOption,
 } from "../types/chat.ts";

package/src/providers/registry.ts

@@ -4,6 +4,9 @@ import { ClaudeAgentSdkProvider } from "./claude-agent-sdk.ts";
 import { configService } from "../services/config.service.ts";
 import { nextProbeDelayMs, type ProviderProbeStatus } from "./provider-probe.ts";
 import { CODEX_DEFAULT_MODEL } from "../types/config.ts";
+import { createLogger } from "../services/logger.ts";
+
+const log = createLogger("registry");
 
 export interface ProviderInfo {
   id: string;
@@ -84,12 +87,12 @@ export async function bootstrapProviders(): Promise<void> {
           },
         });
       }
-      console.log("[registry] Cursor provider registered (cursor-agent found)");
+      log.info("Cursor provider registered (cursor-agent found)");
     } else {
-      console.log("[registry] Cursor provider skipped (cursor-agent not found)");
+      log.info("Cursor provider skipped (cursor-agent not found)");
     }
   } catch (e) {
-    console.warn("[registry] Failed to load Cursor provider:", (e as Error).message);
+    log.warn("Failed to load Cursor provider:", (e as Error).message);
   }
 
   await probeCodexProvider();
@@ -174,13 +177,15 @@ async function probeCodexProvider(): Promise<ProviderProbeStatus> {
       if (result.ok) {
         providerRegistry.register(codex);
         ensureCodexConfigEntry();
-        console.log("[registry] Codex provider registered (@openai/codex found)");
+        log.info("Codex provider registered (@openai/codex found)");
         status = { id: "codex", registered: true, attempts, lastProbeAt };
       } else {
         status = { id: "codex", registered: false, attempts, lastProbeAt, reason: result.reason };
         if (result.retryable) status.nextProbeAt = scheduleCodexRetry(attempts);
-        console.log(
-          `[registry] Codex provider unavailable: ${result.reason}` +
+        // Retryable = codex should be here and is hidden until a later probe answers (degraded).
+        // Not retryable = this host cannot run it at all, which is a plain fact about the host.
+        (result.retryable ? log.warn : log.info)(
+          `Codex provider unavailable: ${result.reason}` +
           (status.nextProbeAt ? ` — retrying at ${status.nextProbeAt}` : ""),
         );
       }
@@ -189,7 +194,7 @@ async function probeCodexProvider(): Promise<ProviderProbeStatus> {
       // retrying, since the alternative is silence until the next restart.
       status = { id: "codex", registered: false, attempts, lastProbeAt, reason: (e as Error).message };
       status.nextProbeAt = scheduleCodexRetry(attempts);
-      console.warn("[registry] Failed to load Codex provider:", (e as Error).message);
+      log.warn("Failed to load Codex provider:", (e as Error).message);
     }
     probeStatuses.set("codex", status);
     return status;