@golba98/codexa 1.0.1

package/src/config/persistence.test.ts

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mergeRuntimeIntoTomlConfig } from "./layeredConfig.js";
+import { DEFAULT_RUNTIME_CONFIG } from "./runtimeConfig.js";
+import {
+  extractLegacyRuntime,
+  getDefaultSettings,
+  parseSettingsData,
+  serializeSettings,
+} from "./persistence.js";
+
+test("extracts legacy flat runtime settings for migration", () => {
+  const runtime = extractLegacyRuntime({
+    backend: "codex-subprocess",
+    model: "gpt-5.4-mini",
+    mode: "suggest",
+    reasoning_level: "medium",
+  });
+
+  assert.equal(runtime?.model, "gpt-5.4-mini");
+  assert.equal(runtime?.mode, "suggest");
+  assert.equal(runtime?.reasoningLevel, "medium");
+});
+
+test("keeps UI and auth settings separate from runtime persistence", () => {
+  const initial = {
+    ui: {
+      layoutStyle: "gemini-shell",
+      theme: "purple",
+      workspaceDisplayMode: "simple" as const,
+      terminalTitleMode: "name" as const,
+      showBusyLoader: false,
+      terminalMouseMode: "selection" as const,
+      customTheme: { TEXT: "#fff" },
+    },
+    auth: {
+      preference: "runner-managed" as const,
+    },
+    header: {
+      showBrand: true,
+      showWorkspace: true,
+      showProvider: false,
+      showModel: false,
+      showReasoning: false,
+      showContext: false,
+      showAuthStatus: false,
+    },
+  };
+
+  const serialized = serializeSettings(initial);
+  const parsed = parseSettingsData(serialized);
+
+  assert.equal("runtime" in serialized, false);
+  assert.equal(parsed.ui.theme, "purple");
+  assert.equal(parsed.ui.workspaceDisplayMode, "simple");
+  assert.equal(parsed.ui.terminalTitleMode, "name");
+  assert.equal(parsed.ui.showBusyLoader, false);
+  assert.equal(parsed.ui.terminalMouseMode, "selection");
+  assert.equal(parsed.auth.preference, "runner-managed");
+});
+
+test("falls back to defaults for missing UI or auth preferences", () => {
+  const parsed = parseSettingsData({});
+  const defaults = getDefaultSettings();
+
+  assert.equal(parsed.ui.layoutStyle, defaults.ui.layoutStyle);
+  assert.equal(parsed.ui.theme, defaults.ui.theme);
+  assert.equal(parsed.ui.workspaceDisplayMode, defaults.ui.workspaceDisplayMode);
+  assert.equal(parsed.ui.terminalTitleMode, defaults.ui.terminalTitleMode);
+  assert.equal(parsed.ui.showBusyLoader, defaults.ui.showBusyLoader);
+  assert.equal(parsed.auth.preference, defaults.auth.preference);
+});
+
+test("maps legacy directory display settings into workspace display mode", () => {
+  assert.equal(parseSettingsData({ directory_display_mode: "normal" }).ui.workspaceDisplayMode, "dir");
+  assert.equal(parseSettingsData({ directoryDisplayMode: "simple" }).ui.workspaceDisplayMode, "simple");
+});
+
+test("parses workspace display and busy loader from camel and snake case", () => {
+  assert.equal(parseSettingsData({ workspace_display_mode: "name", terminal_title_mode: "simple", show_busy_loader: false }).ui.workspaceDisplayMode, "name");
+  assert.equal(parseSettingsData({ workspaceDisplayMode: "dir", terminalTitleMode: "name", showBusyLoader: true }).ui.showBusyLoader, true);
+  assert.equal(parseSettingsData({ terminalTitleMode: "name" }).ui.terminalTitleMode, "name");
+});
+
+test("merges legacy runtime fields into TOML without overwriting existing values", () => {
+  const merged = mergeRuntimeIntoTomlConfig({
+    model: "gpt-5.4",
+    codexa: {
+      mode: "suggest",
+    },
+  }, {
+    ...DEFAULT_RUNTIME_CONFIG,
+    model: "gpt-5.4-mini",
+    mode: "full-auto",
+    policy: {
+      ...DEFAULT_RUNTIME_CONFIG.policy,
+      networkAccess: "enabled",
+      writableRoots: ["C:\\safe"],
+      personality: "pragmatic",
+    },
+  });
+
+  assert.equal(merged.model, "gpt-5.4");
+  assert.deepEqual(merged.codexa, { mode: "suggest" });
+  assert.deepEqual(merged.sandbox_workspace_write, {
+    network_access: true,
+    writable_roots: ["C:\\safe"],
+  });
+  assert.equal(merged.personality, "pragmatic");
+});

package/src/config/persistence.ts

@@ -0,0 +1,311 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { Theme } from "../ui/theme.js";
+import {
+  AUTH_PREFERENCES,
+  DEFAULT_AUTH_PREFERENCE,
+  DEFAULT_LAYOUT_STYLE,
+  DEFAULT_SHOW_BUSY_LOADER,
+  DEFAULT_TERMINAL_MOUSE_MODE,
+  DEFAULT_TERMINAL_TITLE_MODE,
+  DEFAULT_THEME,
+  DEFAULT_WORKSPACE_DISPLAY_MODE,
+  HEADER_CONFIG_DEFAULTS,
+  LEGACY_DIRECTORY_DISPLAY_MODES,
+  TERMINAL_MOUSE_MODES,
+  WORKSPACE_DISPLAY_MODES,
+  getCodexConfigFile,
+  normalizeLegacyDirectoryDisplayMode,
+  SETTINGS_FILE,
+  type AuthPreference,
+  type HeaderConfig,
+  type TerminalMouseMode,
+  type TerminalTitleMode,
+  type WorkspaceDisplayMode,
+} from "./settings.js";
+import {
+  mergeRuntimeIntoTomlConfig,
+  parseTomlDocument,
+} from "./layeredConfig.js";
+import { serializeTomlDocument } from "./toml-serialize.js";
+import {
+  normalizeRuntimeConfig,
+  type RuntimeConfig,
+} from "./runtimeConfig.js";
+
+export interface UiSettings {
+  layoutStyle: string;
+  theme: string;
+  workspaceDisplayMode: WorkspaceDisplayMode;
+  terminalTitleMode: TerminalTitleMode;
+  showBusyLoader: boolean;
+  terminalMouseMode: TerminalMouseMode;
+  customTheme?: Partial<Theme>;
+}
+
+export interface AuthSettings {
+  preference: AuthPreference;
+}
+
+export interface AppSettings {
+  ui: UiSettings;
+  auth: AuthSettings;
+  header: HeaderConfig;
+}
+
+// Pick the first string value found under the camelCase or snake_case key.
+// Falls through to the snake_case key only when the camelCase value is absent or not a string.
+function pickStr(src: Record<string, unknown>, camel: string, snake: string): string | undefined {
+  const camelVal = src[camel];
+  if (typeof camelVal === "string") return camelVal;
+  const snakeVal = src[snake];
+  if (typeof snakeVal === "string") return snakeVal;
+  return undefined;
+}
+
+// Same as pickStr but for boolean values.
+function pickBool(src: Record<string, unknown>, camel: string, snake: string): boolean | undefined {
+  const camelVal = src[camel];
+  if (typeof camelVal === "boolean") return camelVal;
+  const snakeVal = src[snake];
+  if (typeof snakeVal === "boolean") return snakeVal;
+  return undefined;
+}
+
+function normalizeAuthPreference(value: unknown): AuthPreference {
+  return typeof value === "string" && AUTH_PREFERENCES.some((item) => item.id === value)
+    ? (value as AuthPreference)
+    : DEFAULT_AUTH_PREFERENCE;
+}
+
+function normalizeUiSettings(input: Partial<UiSettings> | null | undefined): UiSettings {
+  return {
+    layoutStyle: input?.layoutStyle ?? DEFAULT_LAYOUT_STYLE,
+    theme: input?.theme ?? DEFAULT_THEME,
+    workspaceDisplayMode: input?.workspaceDisplayMode ?? DEFAULT_WORKSPACE_DISPLAY_MODE,
+    terminalTitleMode: input?.terminalTitleMode ?? DEFAULT_TERMINAL_TITLE_MODE,
+    showBusyLoader: typeof input?.showBusyLoader === "boolean"
+      ? input.showBusyLoader
+      : DEFAULT_SHOW_BUSY_LOADER,
+    terminalMouseMode: TERMINAL_MOUSE_MODES.includes(input?.terminalMouseMode as TerminalMouseMode)
+      ? (input!.terminalMouseMode as TerminalMouseMode)
+      : DEFAULT_TERMINAL_MOUSE_MODE,
+    customTheme: input?.customTheme,
+  };
+}
+
+function normalizeHeaderConfig(input: Partial<HeaderConfig> | null | undefined): HeaderConfig {
+  return {
+    showBrand: typeof input?.showBrand === "boolean" ? input.showBrand : HEADER_CONFIG_DEFAULTS.showBrand,
+    showWorkspace: typeof input?.showWorkspace === "boolean" ? input.showWorkspace : HEADER_CONFIG_DEFAULTS.showWorkspace,
+    showProvider: typeof input?.showProvider === "boolean" ? input.showProvider : HEADER_CONFIG_DEFAULTS.showProvider,
+    showModel: typeof input?.showModel === "boolean" ? input.showModel : HEADER_CONFIG_DEFAULTS.showModel,
+    showReasoning: typeof input?.showReasoning === "boolean" ? input.showReasoning : HEADER_CONFIG_DEFAULTS.showReasoning,
+    showContext: typeof input?.showContext === "boolean" ? input.showContext : HEADER_CONFIG_DEFAULTS.showContext,
+    showAuthStatus: typeof input?.showAuthStatus === "boolean" ? input.showAuthStatus : HEADER_CONFIG_DEFAULTS.showAuthStatus,
+  };
+}
+
+export function getDefaultSettings(): AppSettings {
+  return {
+    ui: normalizeUiSettings(null),
+    auth: {
+      preference: DEFAULT_AUTH_PREFERENCE,
+    },
+    header: normalizeHeaderConfig(null),
+  };
+}
+
+function parseLegacyRuntime(data: Record<string, unknown>): RuntimeConfig {
+  return normalizeRuntimeConfig({
+    provider: typeof data.backend === "string" ? data.backend as RuntimeConfig["provider"] : undefined,
+    model: typeof data.model === "string" ? data.model as RuntimeConfig["model"] : undefined,
+    mode: typeof data.mode === "string" ? data.mode as RuntimeConfig["mode"] : undefined,
+    reasoningLevel: typeof data.reasoning_level === "string" ? data.reasoning_level as RuntimeConfig["reasoningLevel"] : undefined,
+  });
+}
+
+export function extractLegacyRuntime(data: unknown): RuntimeConfig | null {
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+
+  const record = data as Record<string, unknown>;
+  if (typeof record.runtime === "object" && record.runtime !== null) {
+    return normalizeRuntimeConfig(record.runtime as Partial<RuntimeConfig>);
+  }
+
+  const hasFlatRuntimeKeys = ["backend", "model", "mode", "reasoning_level"].some((key) => key in record);
+  return hasFlatRuntimeKeys ? parseLegacyRuntime(record) : null;
+}
+
+function stripLegacyRuntime(data: unknown): Record<string, unknown> {
+  if (!data || typeof data !== "object") {
+    return {};
+  }
+
+  const record = { ...(data as Record<string, unknown>) };
+  delete record.runtime;
+  delete record.backend;
+  delete record.model;
+  delete record.mode;
+  delete record.reasoning_level;
+  return record;
+}
+
+function parseTerminalTitleMode(uiSource: Record<string, unknown>, fallback: TerminalTitleMode): TerminalTitleMode {
+  const direct = uiSource.terminalTitleMode ?? uiSource.terminal_title_mode;
+  if (typeof direct === "string" && WORKSPACE_DISPLAY_MODES.includes(direct as WorkspaceDisplayMode)) {
+    return direct as TerminalTitleMode;
+  }
+
+  return fallback;
+}
+
+function parseTerminalMouseMode(uiSource: Record<string, unknown>, fallback: TerminalMouseMode): TerminalMouseMode {
+  const camel = uiSource.terminalMouseMode;
+  if (typeof camel === "string" && TERMINAL_MOUSE_MODES.includes(camel as TerminalMouseMode)) {
+    return camel as TerminalMouseMode;
+  }
+  const snake = uiSource.terminal_mouse_mode;
+  if (typeof snake === "string" && TERMINAL_MOUSE_MODES.includes(snake as TerminalMouseMode)) {
+    return snake as TerminalMouseMode;
+  }
+  return fallback;
+}
+
+function parseWorkspaceDisplayMode(uiSource: Record<string, unknown>, fallback: WorkspaceDisplayMode): WorkspaceDisplayMode {
+  const direct = uiSource.workspaceDisplayMode ?? uiSource.workspace_display_mode;
+  if (typeof direct === "string" && WORKSPACE_DISPLAY_MODES.includes(direct as WorkspaceDisplayMode)) {
+    return direct as WorkspaceDisplayMode;
+  }
+
+  const legacy = uiSource.directoryDisplayMode ?? uiSource.directory_display_mode;
+  if (typeof legacy === "string") {
+    if (WORKSPACE_DISPLAY_MODES.includes(legacy as WorkspaceDisplayMode)) {
+      return legacy as WorkspaceDisplayMode;
+    }
+    if (LEGACY_DIRECTORY_DISPLAY_MODES.includes(legacy as typeof LEGACY_DIRECTORY_DISPLAY_MODES[number])) {
+      return normalizeLegacyDirectoryDisplayMode(legacy as typeof LEGACY_DIRECTORY_DISPLAY_MODES[number]);
+    }
+  }
+
+  return fallback;
+}
+
+export function parseSettingsData(data: unknown): AppSettings {
+  const defaults = getDefaultSettings();
+  if (!data || typeof data !== "object") {
+    return defaults;
+  }
+
+  const record = data as Record<string, unknown>;
+  const uiSource = typeof record.ui === "object" && record.ui !== null
+    ? record.ui as Record<string, unknown>
+    : record;
+  const authSource = typeof record.auth === "object" && record.auth !== null
+    ? record.auth as Record<string, unknown>
+    : record;
+
+  const headerSource = typeof record.header === "object" && record.header !== null
+    ? record.header as Record<string, unknown>
+    : {};
+
+  return {
+    ui: normalizeUiSettings({
+      layoutStyle: pickStr(uiSource, "layoutStyle", "layout_style") ?? defaults.ui.layoutStyle,
+      theme: pickStr(uiSource, "theme", "theme") ?? defaults.ui.theme,
+      workspaceDisplayMode: parseWorkspaceDisplayMode(uiSource, defaults.ui.workspaceDisplayMode),
+      terminalTitleMode: parseTerminalTitleMode(uiSource, defaults.ui.terminalTitleMode),
+      showBusyLoader: pickBool(uiSource, "showBusyLoader", "show_busy_loader") ?? defaults.ui.showBusyLoader,
+      terminalMouseMode: parseTerminalMouseMode(uiSource, defaults.ui.terminalMouseMode),
+      customTheme: (uiSource.customTheme ?? uiSource.custom_theme) as Partial<Theme> | undefined,
+    }),
+    auth: {
+      preference: normalizeAuthPreference(authSource.preference ?? authSource.auth_preference),
+    },
+    header: normalizeHeaderConfig({
+      showBrand: pickBool(headerSource, "showBrand", "show_brand"),
+      showWorkspace: pickBool(headerSource, "showWorkspace", "show_workspace"),
+      showProvider: pickBool(headerSource, "showProvider", "show_provider"),
+      showModel: pickBool(headerSource, "showModel", "show_model"),
+      showReasoning: pickBool(headerSource, "showReasoning", "show_reasoning"),
+      showContext: pickBool(headerSource, "showContext", "show_context"),
+      showAuthStatus: pickBool(headerSource, "showAuthStatus", "show_auth_status"),
+    }),
+  };
+}
+
+export function serializeSettings(settings: AppSettings): Record<string, unknown> {
+  return {
+    ui: {
+      layout_style: settings.ui.layoutStyle,
+      theme: settings.ui.theme,
+      workspace_display_mode: settings.ui.workspaceDisplayMode,
+      terminal_title_mode: settings.ui.terminalTitleMode,
+      show_busy_loader: settings.ui.showBusyLoader,
+      terminal_mouse_mode: settings.ui.terminalMouseMode,
+      custom_theme: settings.ui.customTheme,
+    },
+    auth: {
+      preference: settings.auth.preference,
+    },
+    header: {
+      show_brand: settings.header.showBrand,
+      show_workspace: settings.header.showWorkspace,
+      show_provider: settings.header.showProvider,
+      show_model: settings.header.showModel,
+      show_reasoning: settings.header.showReasoning,
+      show_context: settings.header.showContext,
+      show_auth_status: settings.header.showAuthStatus,
+    },
+  };
+}
+
+function writeJsonFile(filePath: string, data: Record<string, unknown>): void {
+  mkdirSync(dirname(filePath), { recursive: true });
+  const tmpFile = `${filePath}.tmp`;
+  writeFileSync(tmpFile, JSON.stringify(data, null, 2), "utf-8");
+  renameSync(tmpFile, filePath);
+}
+
+function maybeMigrateLegacyRuntime(rawData: unknown): void {
+  const legacyRuntime = extractLegacyRuntime(rawData);
+  if (!legacyRuntime) {
+    return;
+  }
+
+  try {
+    const codexConfigFile = getCodexConfigFile();
+    const existingConfig = existsSync(codexConfigFile)
+      ? parseTomlDocument(readFileSync(codexConfigFile, "utf-8"))
+      : {};
+    const mergedConfig = mergeRuntimeIntoTomlConfig(existingConfig, legacyRuntime);
+    mkdirSync(dirname(codexConfigFile), { recursive: true });
+    const tmpTomlFile = `${codexConfigFile}.tmp`;
+    writeFileSync(tmpTomlFile, serializeTomlDocument(mergedConfig), "utf-8");
+    renameSync(tmpTomlFile, codexConfigFile);
+    writeJsonFile(SETTINGS_FILE, stripLegacyRuntime(rawData));
+  } catch {
+    // Best-effort migration only; keep legacy JSON intact if anything fails.
+  }
+}
+
+export function loadSettings(): AppSettings {
+  try {
+    const text = readFileSync(SETTINGS_FILE, "utf-8");
+    const rawData = JSON.parse(text);
+    maybeMigrateLegacyRuntime(rawData);
+    return parseSettingsData(rawData);
+  } catch {
+    return getDefaultSettings();
+  }
+}
+
+export function saveSettings(settings: AppSettings): void {
+  try {
+    writeJsonFile(SETTINGS_FILE, serializeSettings(settings));
+  } catch {
+    // Silently ignore — settings are best-effort
+  }
+}

package/src/config/runtimeConfig.test.ts

@@ -0,0 +1,218 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  DEFAULT_RUNTIME_CONFIG,
+  addWritableRoot,
+  buildRuntimeSummary,
+  buildCodexConfigOverrides,
+  diffRuntimeConfig,
+  formatPermissionsStatus,
+  formatRuntimeStatus,
+  mergeRuntimeConfig,
+  normalizeRuntimeConfig,
+  removeWritableRoot,
+  resolveRuntimeConfig,
+} from "./runtimeConfig.js";
+
+test("defaults resolve into a concrete runtime config", () => {
+  const resolved = resolveRuntimeConfig(DEFAULT_RUNTIME_CONFIG);
+
+  assert.equal(resolved.model, DEFAULT_RUNTIME_CONFIG.model);
+  assert.equal(resolved.mode, DEFAULT_RUNTIME_CONFIG.mode);
+  assert.equal(resolved.planMode, false);
+  assert.equal(resolved.policy.approvalPolicy, "on-request");
+  assert.equal(resolved.policy.sandboxMode, "workspace-write");
+  assert.equal(resolved.policy.networkAccess, false);
+  assert.equal(resolved.policy.serviceTier, "flex");
+  assert.equal(resolved.policy.personality, "none");
+});
+
+test("mode inheritance resolves to expected approval and sandbox policies", () => {
+  const suggest = resolveRuntimeConfig(normalizeRuntimeConfig({ mode: "suggest" }));
+  const autoEdit = resolveRuntimeConfig(normalizeRuntimeConfig({ mode: "auto-edit" }));
+  const fullAuto = resolveRuntimeConfig(normalizeRuntimeConfig({ mode: "full-auto" }));
+
+  assert.equal(suggest.policy.sandboxMode, "read-only");
+  assert.equal(suggest.policy.approvalPolicy, "on-request");
+  assert.equal(autoEdit.policy.sandboxMode, "workspace-write");
+  assert.equal(fullAuto.policy.sandboxMode, "workspace-write");
+});
+
+test("explicit policy overrides beat inherited mode defaults", () => {
+  const resolved = resolveRuntimeConfig(normalizeRuntimeConfig({
+    mode: "suggest",
+    policy: {
+      approvalPolicy: "never",
+      sandboxMode: "danger-full-access",
+      networkAccess: "enabled",
+    },
+  }));
+
+  assert.equal(resolved.policy.approvalPolicy, "never");
+  assert.equal(resolved.policy.sandboxMode, "danger-full-access");
+  assert.equal(resolved.policy.networkAccess, true);
+});
+
+test("writable roots normalize and dedupe", () => {
+  const withRoots = addWritableRoot(addWritableRoot(DEFAULT_RUNTIME_CONFIG, "C:/Repo"), "C:\\Repo\\");
+  assert.equal(withRoots.policy.writableRoots.length, 1);
+
+  const removed = removeWritableRoot(withRoots, "c:/repo");
+  assert.equal(removed.policy.writableRoots.length, 0);
+});
+
+test("writable root normalization strips redundant trailing separators", () => {
+  const normalized = normalizeRuntimeConfig({
+    policy: {
+      writableRoots: ["C:\\Repo\\", "C:\\Repo", "C:\\Repo\\\\nested\\..\\"],
+    },
+  });
+
+  assert.deepEqual(normalized.policy.writableRoots, ["C:\\Repo"]);
+});
+
+test("merges runtime overrides onto a canonical base", () => {
+  const merged = mergeRuntimeConfig(DEFAULT_RUNTIME_CONFIG, {
+    model: "gpt-5.4-mini",
+    planMode: true,
+    policy: {
+      writableRoots: ["C:/Repo/extra"],
+      serviceTier: "fast",
+    },
+  });
+
+  assert.equal(merged.model, "gpt-5.4-mini");
+  assert.equal(merged.planMode, true);
+  assert.deepEqual(merged.policy.writableRoots, ["C:\\Repo\\extra"]);
+  assert.equal(merged.policy.serviceTier, "fast");
+});
+
+test("diffRuntimeConfig emits only fields that differ from the base", () => {
+  const target = normalizeRuntimeConfig({
+    model: "gpt-5.4-mini",
+    planMode: true,
+    policy: {
+      networkAccess: "enabled",
+      personality: "pragmatic",
+    },
+  });
+
+  assert.deepEqual(diffRuntimeConfig(DEFAULT_RUNTIME_CONFIG, target), {
+    model: "gpt-5.4-mini",
+    planMode: true,
+    policy: {
+      networkAccess: "enabled",
+      personality: "pragmatic",
+    },
+  });
+});
+
+test("builds deterministic codex config overrides", () => {
+  const resolved = resolveRuntimeConfig(normalizeRuntimeConfig({
+    model: "gpt-5.4-mini",
+    mode: "suggest",
+    reasoningLevel: "medium",
+    policy: {
+      approvalPolicy: "never",
+      sandboxMode: "workspace-write",
+      networkAccess: "enabled",
+      writableRoots: ["C:/Repo/extra"],
+      serviceTier: "fast",
+      personality: "pragmatic",
+    },
+  }));
+  const writableRoot = resolved.policy.writableRoots[0];
+
+  assert.deepEqual(buildCodexConfigOverrides(resolved), [
+    "model_reasoning_effort=medium",
+    "approval_policy=never",
+    "sandbox_workspace_write.network_access=true",
+    `sandbox_workspace_write.writable_roots=${JSON.stringify([writableRoot])}`,
+    "service_tier=fast",
+    "personality=pragmatic",
+  ]);
+});
+
+test("builds runtime summary with network and writable-root indicators", () => {
+  const summary = buildRuntimeSummary(resolveRuntimeConfig(normalizeRuntimeConfig({
+    policy: {
+      networkAccess: "enabled",
+      writableRoots: ["C:/Repo/extra"],
+    },
+  })));
+
+  assert.equal(summary.networkLabel, "Net: on");
+  assert.equal(summary.writableRootsLabel, "Roots: 1");
+});
+
+test("formats permissions status with configured and effective policy", () => {
+  const runtime = normalizeRuntimeConfig({
+    mode: "suggest",
+    policy: {
+      approvalPolicy: "inherit",
+      sandboxMode: "inherit",
+      networkAccess: "enabled",
+      writableRoots: ["C:/Repo/extra"],
+    },
+  });
+  const status = formatPermissionsStatus(runtime, resolveRuntimeConfig(runtime), "C:\\Workspace");
+
+  assert.match(status, /Permissions status:/);
+  assert.match(status, /Approval policy: configured Inherit; effective On request/);
+  assert.match(status, /Network access: configured Enabled; effective Enabled/);
+  assert.match(status, /Configured:/);
+  assert.match(status, /Effective:/);
+});
+
+test("formats runtime status with effective policy details", () => {
+  const resolved = resolveRuntimeConfig(DEFAULT_RUNTIME_CONFIG);
+  const status = formatRuntimeStatus(resolved, {
+    workspaceRoot: "C:\\Workspace",
+    tokensUsed: 512,
+  });
+
+  assert.match(status, /Provider:/);
+  assert.match(status, /Plan mode: Disabled/);
+  assert.match(status, /Approval policy:/);
+  assert.match(status, /Sandbox mode:/);
+  assert.match(status, /Tokens used: ~512/);
+});
+
+test("formats runtime status with loaded project instructions", () => {
+  const resolved = resolveRuntimeConfig(DEFAULT_RUNTIME_CONFIG);
+  const status = formatRuntimeStatus(resolved, {
+    workspaceRoot: "C:\\Workspace",
+    projectInstructions: {
+      status: "loaded",
+      instructions: { path: "C:\\Workspace\\AGENTS.md", content: "# Instructions" },
+    },
+  });
+
+  assert.match(status, /Project instructions: loaded/);
+  assert.match(status, /Source: C:\\Workspace\\AGENTS\.md/);
+});
+
+test("formats runtime status with project instructions error", () => {
+  const resolved = resolveRuntimeConfig(DEFAULT_RUNTIME_CONFIG);
+  const status = formatRuntimeStatus(resolved, {
+    workspaceRoot: "C:\\Workspace",
+    projectInstructions: {
+      status: "error",
+      path: "C:\\Workspace\\AGENTS.md",
+      message: "ENOENT: file not found",
+    },
+  });
+
+  assert.match(status, /Project instructions: error/);
+  assert.match(status, /ENOENT/);
+});
+
+test("formats runtime status with missing project instructions", () => {
+  const resolved = resolveRuntimeConfig(DEFAULT_RUNTIME_CONFIG);
+  const status = formatRuntimeStatus(resolved, {
+    workspaceRoot: "C:\\Workspace",
+    projectInstructions: { status: "missing" },
+  });
+
+  assert.match(status, /Project instructions: none/);
+});