pi-ultracode 0.4.0 → 0.6.0

package/src/mode.ts

@@ -1,45 +1,37 @@
 /**
  * Ultracode mode controller.
  *
- * Ultracode is a session-scoped effort mode. While on, it:
- *   - raises the thinking level to the model's maximum (remembering the previous level),
+ * Ultracode is a session-scoped semantic analysis-depth mode. While active, it:
+ *   - leaves the parent session's thinking level under user control,
  *   - keeps the `workflow` tool active,
- *   - injects a standing "author and run a workflow by default" system block on
- *     every turn,
- *   - persists its on/off state in session custom entries so it survives
- *     reload, resume, fork, and compaction.
+ *   - injects the configured auto/focused/standard/deep policy on every turn,
+ *   - persists branch-local mode state across reload, resume, fork, and compaction.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { ULTRACODE_ACTIVE_REMINDER, ULTRACODE_TAGLINE, ultracodeSystemBlock } from "./prompts.ts";
 import {
-  LEGACY_ULTRACODE_THINKING_LEVEL,
-  ULTRACODE_THINKING_LEVEL,
-  isThinkingLevel,
-  type ThinkingLevel,
-} from "./thinking.ts";
+  isActiveUltracodeMode,
+  type ActiveUltracodeMode,
+  type UltracodeModeName,
+} from "./depth.ts";
+import { ULTRACODE_ACTIVE_REMINDER, ULTRACODE_TAGLINE, ultracodeSystemBlock } from "./prompts.ts";
+import type { ThinkingLevel } from "./thinking.ts";
 
 export type { ThinkingLevel } from "./thinking.ts";
 
 export const MODE_ENTRY_TYPE = "ultracode-mode";
 
 interface PersistedModeState {
-  enabled: boolean;
-  previousThinking?: ThinkingLevel;
-  /** `null` records that the setting was originally absent (Pi defaults to medium). */
-  previousDefaultThinking?: ThinkingLevel | null;
-  /** Deferred when the selected model cannot represent the pre-mode level. */
-  pendingPreviousThinking?: ThinkingLevel;
+  mode: UltracodeModeName;
 }
 
+/** @deprecated Ultracode no longer reads or writes the parent's effort preference. */
 export interface ThinkingPreferenceSnapshot {
-  /** Raw global value; undefined means Pi's implicit medium default. */
   global: ThinkingLevel | undefined;
-  /** Global + project merged value used by Pi for model switches. */
   effective: ThinkingLevel | undefined;
 }
 
-/** Adapter for preserving Pi's raw global effort preference while this mode is active. */
+/** @deprecated Ultracode no longer reads or writes the parent's effort preference. */
 export interface ThinkingPreferenceStore {
   getThinkingPreference(): ThinkingPreferenceSnapshot;
   setDefaultThinkingLevel(level: ThinkingLevel | undefined): void | Promise<void>;
@@ -47,149 +39,95 @@ export interface ThinkingPreferenceStore {
 }
 
 export class UltracodeMode {
-  private enabled = false;
+  private mode: UltracodeModeName = "off";
   private suspended = false;
-  private previousThinking: ThinkingLevel | undefined;
-  private previousDefaultThinking: ThinkingLevel | null | undefined;
-  /** Restore a level later if the current non-reasoning model clamps it to off. */
-  private pendingPreviousThinking: ThinkingLevel | undefined;
-  /** The level Pi actually applied after clamping the maximum request. */
-  private appliedThinking: ThinkingLevel | undefined;
-  /** Prevent mode-owned thinking changes from being mistaken for manual overrides. */
-  private applyingThinking = false;
-  private thinkingPreferenceStore: ThinkingPreferenceStore | undefined;
-  private preferenceWriteQueue: Promise<void> = Promise.resolve();
-  private preferenceWriteGeneration = 0;
-  private legacyDefaultMigrationPending = false;
-  private pendingClearGeneration = 0;
-  private currentModelSupportsThinking: boolean | undefined;
-  private runtimeSupportsMaxThinking = true;
   private readonly workflowToolName: string;
 
   constructor(workflowToolName: string) {
     this.workflowToolName = workflowToolName;
   }
 
-  /** Bind the settings adapter once the session cwd is known. */
-  bindThinkingPreferenceStore(store: ThinkingPreferenceStore | undefined): void {
-    this.preferenceWriteGeneration++;
-    this.thinkingPreferenceStore = store;
-  }
+  /** @deprecated Parent effort is user-owned; retained as a compatibility no-op. */
+  bindThinkingPreferenceStore(_store: ThinkingPreferenceStore | undefined): void {}
 
-  /** Track capability explicitly; `off` alone cannot distinguish clamp from intent. */
-  setCurrentModelSupportsThinking(supportsThinking: boolean | undefined): void {
-    this.currentModelSupportsThinking = supportsThinking;
-  }
+  /** @deprecated Parent effort is user-owned; retained as a compatibility no-op. */
+  setCurrentModelSupportsThinking(_supportsThinking: boolean | undefined): void {}
 
-  /** Configure migration behavior for Pi versions released before `max`. */
-  setRuntimeSupportsMaxThinking(supportsMaxThinking: boolean): void {
-    this.runtimeSupportsMaxThinking = supportsMaxThinking;
-  }
+  /** @deprecated Parent effort is user-owned; retained as a compatibility no-op. */
+  setRuntimeSupportsMaxThinking(_supportsMaxThinking: boolean): void {}
 
-  /** Wait for queued preference restoration before teardown or command completion. */
-  async flushThinkingPreference(): Promise<void> {
-    try {
-      await this.preferenceWriteQueue;
-    } catch {
-      // Pi owns settings error reporting; effort enforcement must remain usable.
-    }
-  }
+  /** @deprecated Parent effort is user-owned; retained as a compatibility no-op. */
+  async flushThinkingPreference(): Promise<void> {}
 
-  /** Enable if off, disable if on. Returns the new enabled state. */
+  /** Enable auto if off, otherwise disable. Returns the new enabled state. */
   toggle(pi: ExtensionAPI): boolean {
-    if (this.enabled) {
+    if (this.isEnabled()) {
       this.disable(pi);
       return false;
     }
-    this.enable(pi);
+    this.enable(pi, "auto");
     return true;
   }
 
-  /** The thinking level Pi actually applied (`max`, or the model/runtime fallback). */
+  getMode(): UltracodeModeName {
+    return this.mode;
+  }
+
+  /** @deprecated Ultracode no longer applies a parent thinking level. */
   getAppliedThinking(): ThinkingLevel | undefined {
-    return this.appliedThinking;
+    return undefined;
   }
 
   /**
-   * Return the raw maximum request, not the parent's applied value, so every
-   * workflow subagent is clamped independently against its own model.
+   * @deprecated Workflow agents now select effort per call. An omitted suffix
+   * falls back to the child Pi session's normal user/model configuration rather
+   * than a mode-owned default.
    */
   getSubagentThinkingLevel(): ThinkingLevel | undefined {
-    return this.isEnforcing() ? ULTRACODE_THINKING_LEVEL : undefined;
+    return undefined;
   }
 
-  /** Reassert the maximum before a turn or after a model change. */
-  reapplyMaximumThinking(pi: ExtensionAPI): boolean {
-    if (!this.isEnforcing()) return false;
-    this.applyUltracodeThinking(pi);
-    return true;
+  /** @deprecated Parent effort is user-owned; retained as a compatibility no-op. */
+  reapplyConfiguredThinking(_pi: ExtensionAPI): boolean {
+    return false;
   }
 
-  /**
-   * Handle model switches both while active and after a clamped restoration.
-   * Returns true when Ultracode remains active and the UI should be refreshed.
-   */
-  handleModelSelect(pi: ExtensionAPI): boolean {
-    if (this.suspended) return false;
-    this.pendingClearGeneration++;
-    if (this.enabled) {
-      this.applyUltracodeThinking(pi);
-      return true;
-    }
-    if (this.pendingPreviousThinking) {
-      const pending = this.pendingPreviousThinking;
-      this.applyCompatibleThinking(pi, pending);
-      if (this.pendingRestoreSucceeded(pending)) this.pendingPreviousThinking = undefined;
-      this.persist(pi);
-    }
+  /** @deprecated Parent effort is user-owned; retained as a compatibility no-op. */
+  reapplyMaximumThinking(_pi: ExtensionAPI): boolean {
     return false;
   }
 
-  /** Restore the pre-mode effective effort without changing persisted mode state. */
-  restorePreviousThinking(pi: ExtensionAPI): void {
-    if (this.enabled && this.previousThinking) this.applyCompatibleThinking(pi, this.previousThinking);
+  /** @deprecated Model changes do not alter Ultracode mode or parent effort. */
+  handleModelSelect(_pi: ExtensionAPI): boolean {
+    return false;
   }
 
-  /** Stop enforcing synchronously, then restore effort before session teardown. */
+  /** @deprecated Parent effort is never restored because Ultracode never changes it. */
+  restorePreviousThinking(_pi: ExtensionAPI): void {}
+
+  /** Quiesce tool and prompt enforcement before session teardown. */
   suspend(pi: ExtensionAPI): void {
     if (this.suspended) {
       this.syncWorkflowTool(pi);
       return;
     }
     this.suspended = true;
-    this.restorePreviousThinking(pi);
     this.syncWorkflowTool(pi);
   }
 
-  /**
-   * Enforce the mode after an external thinking-level selection. Stale events
-   * and events emitted by this mode are ignored to avoid recursive updates.
-   * Returns true when a manual selection was overridden.
-   */
-  handleThinkingLevelSelect(pi: ExtensionAPI, level: ThinkingLevel): boolean {
-    if (this.suspended || this.applyingThinking) return false;
-    const current = safeGetThinking(pi);
-    if (!current || current !== level) return false;
-    if (!this.enabled) {
-      // Pi emits the same event for a user selection and an automatic model
-      // re-clamp. Defer clearing until model_select has had a chance to consume it.
-      if (this.pendingPreviousThinking) this.deferPendingClear(pi, level);
-      return false;
-    }
-    if (current === this.appliedThinking) return false;
-    this.applyUltracodeThinking(pi);
-    return true;
+  /** @deprecated User-selected parent effort is accepted without interception. */
+  handleThinkingLevelSelect(_pi: ExtensionAPI, _level: ThinkingLevel): boolean {
+    return false;
   }
 
   isEnabled(): boolean {
-    return this.enabled;
+    return this.mode !== "off";
   }
 
   isSuspended(): boolean {
     return this.suspended;
   }
 
-
   /** Keep tool availability aligned with the current mode state. */
   syncWorkflowTool(pi: ExtensionAPI): void {
     if (this.isEnforcing()) this.activateWorkflowTool(pi);
@@ -200,55 +138,31 @@ export class UltracodeMode {
     return ULTRACODE_TAGLINE;
   }
 
-  /** Turn ultracode on. Idempotent. */
-  enable(pi: ExtensionAPI): void {
+  /**
+   * Enable or switch modes. The no-argument form retains the pre-0.5
+   * programmatic deep behavior; user commands pass an explicit mode and bare
+   * `/ultracode` uses toggle() to enter auto.
+   */
+  enable(pi: ExtensionAPI, mode: ActiveUltracodeMode = "deep"): void {
     this.suspended = false;
-    this.pendingPreviousThinking = undefined;
-    this.pendingClearGeneration++;
-    if (!this.enabled) {
-      const current = safeGetThinking(pi);
-      const preference = this.captureThinkingPreference();
-      const effectivePreference = this.runtimeCompatibleThinking(preference.effective) as
-        | ThinkingLevel
-        | undefined;
-      const maxIsUnknownToRuntime = !this.runtimeSupportsMaxThinking
-        && preference.effective === ULTRACODE_THINKING_LEVEL;
-      // A non-reasoning model exposes only `off`; preserve the merged default
-      // that Pi would use when the user later selects a reasoning model. A
-      // pre-max Pi also reports a persisted max preference as off.
-      this.previousThinking = current === "off"
-        && (this.currentModelSupportsThinking !== true || maxIsUnknownToRuntime)
-        ? effectivePreference ?? current
-        : current;
-      this.previousDefaultThinking = this.runtimeCompatibleThinking(preference.global);
-      this.legacyDefaultMigrationPending = false;
-      this.enabled = true;
-    }
-    this.applyUltracodeThinking(pi);
+    this.mode = mode;
     this.syncWorkflowTool(pi);
     this.persist(pi);
   }
 
-  /** Turn ultracode off, restoring the previous thinking level. */
+  /** Turn Ultracode off without changing the parent thinking level. */
   disable(pi: ExtensionAPI): void {
-    if (!this.enabled) {
+    if (!this.isEnabled()) {
       this.syncWorkflowTool(pi);
       return;
     }
-    const previous = this.previousThinking;
-    this.restorePreviousThinking(pi);
-    this.pendingPreviousThinking = previous && !this.pendingRestoreSucceeded(previous)
-      ? previous
-      : undefined;
-    this.pendingClearGeneration++;
-    this.enabled = false;
+    this.mode = "off";
     this.suspended = false;
     this.syncWorkflowTool(pi);
     this.persist(pi);
   }
 
-
-  /** Restore mode state from the active session branch. */
+  /** Restore mode state from the active session branch without touching effort. */
   restore(
     pi: ExtensionAPI,
     entries: Array<{
@@ -258,250 +172,31 @@ export class UltracodeMode {
       thinkingLevel?: unknown;
     }>,
   ): void {
-    const wasEnforcing = this.isEnforcing();
-    this.pendingClearGeneration++;
     let latestData: unknown;
-    let branchThinking: ThinkingLevel | undefined;
-    let thinkingAfterLatestMode: ThinkingLevel | undefined;
     for (const entry of entries) {
       if (entry.type === "custom" && entry.customType === MODE_ENTRY_TYPE && entry.data) {
         latestData = entry.data;
-        thinkingAfterLatestMode = undefined;
-      } else if (entry.type === "thinking_level_change" && isThinkingLevel(entry.thinkingLevel)) {
-        branchThinking = entry.thinkingLevel;
-        if (latestData !== undefined) thinkingAfterLatestMode = entry.thinkingLevel;
       }
     }
 
-    const current = safeGetThinking(pi);
-    const preference = this.captureThinkingPreference();
-    const effectivePreference = this.runtimeCompatibleThinking(preference.effective) as
-      | ThinkingLevel
-      | undefined;
-    const globalPreference = this.runtimeCompatibleThinking(preference.global);
-    const latest = parsePersistedModeState(latestData);
-    if (!latest) {
-      const target = this.runtimeCompatibleThinking(
-        branchThinking
-          ?? (wasEnforcing ? this.previousThinking : undefined)
-          ?? effectivePreference,
-      ) as ThinkingLevel | undefined;
-      this.enabled = false;
-      this.suspended = false;
-      this.pendingPreviousThinking = undefined;
-      this.previousThinking = target;
-      this.previousDefaultThinking = globalPreference;
-      this.legacyDefaultMigrationPending = false;
-      this.appliedThinking = current;
-      this.syncWorkflowTool(pi);
-      if (target && current !== target) this.applyCompatibleThinking(pi, target);
-      if (target && !this.pendingRestoreSucceeded(target)) {
-        this.pendingPreviousThinking = target;
-        this.persist(pi);
-      } else {
-        this.previousThinking = undefined;
-        this.previousDefaultThinking = undefined;
-      }
-      return;
-    }
-
+    this.mode = parsePersistedModeState(latestData)?.mode ?? "off";
     this.suspended = false;
-    this.enabled = latest.enabled;
     this.syncWorkflowTool(pi);
-    const maxIsUnknownToRuntime = !this.runtimeSupportsMaxThinking
-      && preference.effective === ULTRACODE_THINKING_LEVEL;
-    this.previousThinking = latest.previousThinking
-      ?? (current === "off"
-        && (this.currentModelSupportsThinking !== true || maxIsUnknownToRuntime)
-        ? effectivePreference ?? current
-        : current);
-
-    // Pre-preference-store releases persisted only previousThinking while their
-    // active xhigh request polluted Pi's global default. Recover that baseline
-    // once instead of treating the known Ultracode value as a user preference.
-    const migratesLegacyDefault = latest.enabled
-      && latest.previousDefaultThinking === undefined
-      && latest.previousThinking !== undefined
-      && (preference.global === LEGACY_ULTRACODE_THINKING_LEVEL
-        || preference.global === ULTRACODE_THINKING_LEVEL);
-    this.previousDefaultThinking = migratesLegacyDefault
-      ? this.runtimeCompatibleThinking(latest.previousThinking)
-      : preference.global !== undefined
-        ? globalPreference
-        : this.runtimeCompatibleThinking(latest.previousDefaultThinking);
-    this.legacyDefaultMigrationPending = migratesLegacyDefault;
-
-    this.pendingPreviousThinking = this.enabled ? undefined : latest.pendingPreviousThinking;
-    if (this.enabled) {
-      this.applyUltracodeThinking(pi);
-      if (migratesLegacyDefault) {
-        this.queueDefaultThinkingRestore(() => {
-          this.legacyDefaultMigrationPending = false;
-          this.persist(pi);
-        });
-      }
-      return;
-    }
-
-    if (this.pendingPreviousThinking) {
-      if (thinkingAfterLatestMode !== undefined) {
-        // A thinking entry after the disabled mode snapshot is an explicit user
-        // choice and supersedes the older deferred restoration.
-        const target = this.runtimeCompatibleThinking(thinkingAfterLatestMode) as ThinkingLevel;
-        this.pendingPreviousThinking = undefined;
-        this.previousThinking = target;
-        this.appliedThinking = current;
-        if (current !== target) this.applyCompatibleThinking(pi, target);
-        if (!this.pendingRestoreSucceeded(target)) this.pendingPreviousThinking = target;
-        this.persist(pi);
-      } else if (this.currentModelSupportsThinking === true) {
-        const pending = this.pendingPreviousThinking;
-        this.applyCompatibleThinking(pi, pending);
-        if (this.pendingRestoreSucceeded(pending)) this.pendingPreviousThinking = undefined;
-        this.persist(pi);
-      }
-      return;
-    }
-
-    const target = this.runtimeCompatibleThinking(branchThinking ?? latest.previousThinking) as
-      | ThinkingLevel
-      | undefined;
-    this.appliedThinking = current;
-    if (target && current !== target) this.applyCompatibleThinking(pi, target);
-    if (target && !this.pendingRestoreSucceeded(target)) {
-      this.pendingPreviousThinking = target;
-      this.persist(pi);
-    }
   }
 
-  /**
-   * Build the before_agent_start result: appends the ultracode system block to the
-   * turn's system prompt when enabled.
-   */
+  /** Append the configured semantic-depth policy to the turn's system prompt. */
   beforeAgentStart(event: { systemPrompt: string }): { systemPrompt: string } | undefined {
-    if (!this.isEnforcing()) return undefined;
-    const block = ultracodeSystemBlock();
+    if (!this.isEnforcing() || !isActiveUltracodeMode(this.mode)) return undefined;
+    const block = ultracodeSystemBlock(this.mode);
     return { systemPrompt: `${event.systemPrompt}\n\n${block}\n\n${ULTRACODE_ACTIVE_REMINDER}` };
   }
 
-  statusLine(): string {
-    if (!this.enabled) return `ultracode: off`;
-    const parts = ["ultracode: on"];
-    // Show the level that actually applied, including compatibility/model fallback.
-    if (this.appliedThinking) parts.push(this.appliedThinking);
-    return parts.join(" · ");
-  }
-
-  private applyUltracodeThinking(pi: ExtensionAPI): void {
-    const writeGeneration = this.preferenceWriteGeneration;
-    this.applyCompatibleThinking(pi, ULTRACODE_THINKING_LEVEL);
-    // Pi normally skips persistence when the effective level is unchanged, but
-    // the extension API does not promise that. Defensively restore the raw
-    // baseline even after a stable max -> max request.
-    if (writeGeneration === this.preferenceWriteGeneration) {
-      this.queueDefaultThinkingRestore();
-    }
-  }
-
-  /** Apply max compatibly and return the concrete level accepted as success. */
-  private applyCompatibleThinking(pi: ExtensionAPI, level: ThinkingLevel): ThinkingLevel {
-    this.applyThinking(pi, level);
-    if (level === ULTRACODE_THINKING_LEVEL && this.appliedThinking !== level) {
-      // Modern Pi clamps max per model. Pre-max Pi may treat it as unknown, so
-      // retry xhigh for both activation and restoration of persisted max state.
-      this.applyThinking(pi, LEGACY_ULTRACODE_THINKING_LEVEL);
-      return LEGACY_ULTRACODE_THINKING_LEVEL;
-    }
-    return level;
-  }
-
-  private applyThinking(pi: ExtensionAPI, level: ThinkingLevel): void {
-    const wasApplying = this.applyingThinking;
-    const before = safeGetThinking(pi);
-    this.applyingThinking = true;
-    try {
-      // Pi clamps the request and persists the effective level. Preference
-      // restoration is queued after Pi's own SettingsManager chain drains.
-      pi.setThinkingLevel(level as any);
-      this.appliedThinking = safeGetThinking(pi) ?? level;
-    } catch {
-      this.appliedThinking = safeGetThinking(pi);
-    } finally {
-      if (this.appliedThinking !== before) this.queueDefaultThinkingRestore();
-      this.applyingThinking = wasApplying;
-    }
+  statusLine(styleLabel: (label: string) => string = (label) => label): string {
+    return [styleLabel("ultracode"), this.mode].join(" · ");
   }
 
   isEnforcing(): boolean {
-    return this.enabled && !this.suspended;
-  }
-
-  private pendingRestoreSucceeded(pending: ThinkingLevel): boolean {
-    if (this.appliedThinking === pending) return true;
-    return pending === ULTRACODE_THINKING_LEVEL
-      && !this.runtimeSupportsMaxThinking
-      && this.appliedThinking !== undefined
-      && this.appliedThinking !== "off";
-  }
-
-  private runtimeCompatibleThinking(
-    level: ThinkingLevel | null | undefined,
-  ): ThinkingLevel | null | undefined {
-    return level === ULTRACODE_THINKING_LEVEL && !this.runtimeSupportsMaxThinking
-      ? LEGACY_ULTRACODE_THINKING_LEVEL
-      : level;
-  }
-
-  private captureThinkingPreference(): {
-    global: ThinkingLevel | null | undefined;
-    effective: ThinkingLevel | undefined;
-  } {
-    if (!this.thinkingPreferenceStore) return { global: undefined, effective: undefined };
-    try {
-      const preference = this.thinkingPreferenceStore.getThinkingPreference();
-      return {
-        global: isThinkingLevel(preference.global) ? preference.global : null,
-        effective: isThinkingLevel(preference.effective) ? preference.effective : undefined,
-      };
-    } catch {
-      return { global: undefined, effective: undefined };
-    }
-  }
-
-  private queueDefaultThinkingRestore(onSuccess?: () => void): void {
-    const store = this.thinkingPreferenceStore;
-    const baseline = this.runtimeCompatibleThinking(this.previousDefaultThinking);
-    if (!store || baseline === undefined) return;
-    const generation = ++this.preferenceWriteGeneration;
-    this.preferenceWriteQueue = this.preferenceWriteQueue
-      .catch(() => {})
-      .then(waitForSettingsWrites)
-      .then(async () => {
-        if (generation !== this.preferenceWriteGeneration) return;
-        const currentGlobal = this.captureThinkingPreference().global;
-        if (currentGlobal !== baseline) {
-          await store.setDefaultThinkingLevel(baseline ?? undefined);
-          await store.flush?.();
-        }
-        if (generation === this.preferenceWriteGeneration) onSuccess?.();
-      })
-      .catch(() => {
-        // Keep the session usable even when settings cannot be restored.
-      });
-  }
-
-  private deferPendingClear(pi: ExtensionAPI, level: ThinkingLevel): void {
-    const generation = ++this.pendingClearGeneration;
-    setImmediate(() => {
-      if (
-        generation !== this.pendingClearGeneration
-        || this.enabled
-        || this.suspended
-        || safeGetThinking(pi) !== level
-      ) return;
-      this.pendingPreviousThinking = undefined;
-      this.persist(pi);
-    });
+    return this.isEnabled() && !this.suspended;
   }
 
   private activateWorkflowTool(pi: ExtensionAPI): void {
@@ -511,7 +206,7 @@ export class UltracodeMode {
         pi.setActiveTools([...active, this.workflowToolName]);
       }
     } catch {
-      // Mode enforcement remains usable when tool selection is unavailable.
+      // Prompt policy remains usable when tool selection is unavailable.
     }
   }
 
@@ -527,14 +222,7 @@ export class UltracodeMode {
   }
 
   private persist(pi: ExtensionAPI): void {
-    const state: PersistedModeState = {
-      enabled: this.enabled,
-      previousThinking: this.previousThinking,
-      previousDefaultThinking: this.legacyDefaultMigrationPending
-        ? undefined
-        : this.previousDefaultThinking,
-      pendingPreviousThinking: this.pendingPreviousThinking,
-    };
+    const state: PersistedModeState = { mode: this.mode };
     try {
       pi.appendEntry(MODE_ENTRY_TYPE, state);
     } catch {
@@ -546,28 +234,14 @@ export class UltracodeMode {
 function parsePersistedModeState(data: unknown): PersistedModeState | undefined {
   if (!data || typeof data !== "object") return undefined;
   const value = data as Record<string, unknown>;
-  const previousDefault = value.previousDefaultThinking;
-  return {
-    enabled: value.enabled === true,
-    previousThinking: isThinkingLevel(value.previousThinking) ? value.previousThinking : undefined,
-    previousDefaultThinking: previousDefault === null || isThinkingLevel(previousDefault)
-      ? previousDefault
-      : undefined,
-    pendingPreviousThinking: isThinkingLevel(value.pendingPreviousThinking)
-      ? value.pendingPreviousThinking
-      : undefined,
-  };
-}
-
-function waitForSettingsWrites(): Promise<void> {
-  return new Promise((resolve) => setImmediate(resolve));
-}
-
-function safeGetThinking(pi: ExtensionAPI): ThinkingLevel | undefined {
-  try {
-    const level = pi.getThinkingLevel();
-    return isThinkingLevel(level) ? level : undefined;
-  } catch {
-    return undefined;
-  }
+  // Sessions written before semantic-depth modes stored only enabled:boolean.
+  // Preserve their behavior by migrating enabled:true to the old deep mode.
+  const mode: UltracodeModeName = isActiveUltracodeMode(value.mode)
+    ? value.mode
+    : value.mode === "off"
+      ? "off"
+      : value.enabled === true
+        ? "deep"
+        : "off";
+  return { mode };
 }