@adhdev/daemon-core 0.8.19 → 0.8.21

package/dist/config/config.d.ts

@@ -4,11 +4,10 @@
  * Manages launcher config, machine auth, and user preferences.
  */
 import type { WorkspaceEntry } from './workspaces.js';
-import type { RecentActivityEntry } from './recent-activity.js';
-import type { SavedProviderSessionEntry } from './saved-sessions.js';
 export type { WorkspaceEntry } from './workspaces.js';
 export type { RecentActivityEntry } from './recent-activity.js';
 export type { SavedProviderSessionEntry } from './saved-sessions.js';
+export type { DaemonState } from './state-store.js';
 export interface ADHDevConfig {
     serverUrl: string;
     selectedIde: string | null;
@@ -23,14 +22,6 @@ export interface ADHDevConfig {
     workspaces?: WorkspaceEntry[];
     /** Default workspace id (from workspaces[]) — never used implicitly for launch */
     defaultWorkspaceId?: string | null;
-    /** Unified recent activity across IDE / CLI / ACP launch flows */
-    recentActivity?: RecentActivityEntry[];
-    /** Persistent resume-capable provider sessions keyed by providerSessionId */
-    savedProviderSessions?: SavedProviderSessionEntry[];
-    /** Last seen timestamps for live sessions, keyed by sessionId */
-    sessionReads?: Record<string, number>;
-    /** Last seen completion marker for live sessions, keyed by sessionId */
-    sessionReadMarkers?: Record<string, string>;
     machineNickname: string | null;
     /**
      * Stable local machine ID (prefix: `mach_`) — generated locally on first run.

package/dist/config/recent-activity.d.ts

@@ -6,7 +6,7 @@
  * - deduped by provider session when available, else by kind + providerType + workspace
  * - used only for quick-launch shortcuts
  */
-import type { ADHDevConfig } from './config.js';
+import type { DaemonState } from './state-store.js';
 export interface RecentActivityEntry {
     id: string;
     kind: 'ide' | 'cli' | 'acp';
@@ -20,10 +20,10 @@ export interface RecentActivityEntry {
 }
 export declare function buildRecentActivityKey(entry: Pick<RecentActivityEntry, 'kind' | 'providerType' | 'workspace'>): string;
 export declare function buildRecentActivityKeyForEntry(entry: Pick<RecentActivityEntry, 'kind' | 'providerType' | 'workspace' | 'providerSessionId'>): string;
-export declare function appendRecentActivity(config: ADHDevConfig, entry: Omit<RecentActivityEntry, 'id' | 'lastUsedAt'> & {
+export declare function appendRecentActivity(state: DaemonState, entry: Omit<RecentActivityEntry, 'id' | 'lastUsedAt'> & {
     lastUsedAt?: number;
-}): ADHDevConfig;
-export declare function getRecentActivity(config: ADHDevConfig, limit?: number): RecentActivityEntry[];
-export declare function getSessionSeenAt(config: ADHDevConfig, sessionId: string): number;
-export declare function getSessionSeenMarker(config: ADHDevConfig, sessionId: string): string;
-export declare function markSessionSeen(config: ADHDevConfig, sessionId: string, seenAt?: number, completionMarker?: string | null): ADHDevConfig;
+}): DaemonState;
+export declare function getRecentActivity(state: DaemonState, limit?: number): RecentActivityEntry[];
+export declare function getSessionSeenAt(state: DaemonState, sessionId: string): number;
+export declare function getSessionSeenMarker(state: DaemonState, sessionId: string): string;
+export declare function markSessionSeen(state: DaemonState, sessionId: string, seenAt?: number, completionMarker?: string | null): DaemonState;

package/dist/config/saved-sessions.d.ts

@@ -1,4 +1,4 @@
-import type { ADHDevConfig } from './config.js';
+import type { DaemonState } from './state-store.js';
 export interface SavedProviderSessionEntry {
     id: string;
     kind: 'cli' | 'acp';
@@ -12,11 +12,11 @@ export interface SavedProviderSessionEntry {
     lastUsedAt: number;
 }
 export declare function buildSavedProviderSessionKey(providerSessionId: string): string;
-export declare function upsertSavedProviderSession(config: ADHDevConfig, entry: Omit<SavedProviderSessionEntry, 'id' | 'createdAt' | 'lastUsedAt'> & {
+export declare function upsertSavedProviderSession(state: DaemonState, entry: Omit<SavedProviderSessionEntry, 'id' | 'createdAt' | 'lastUsedAt'> & {
     createdAt?: number;
     lastUsedAt?: number;
-}): ADHDevConfig;
-export declare function getSavedProviderSessions(config: ADHDevConfig, filters?: {
+}): DaemonState;
+export declare function getSavedProviderSessions(state: DaemonState, filters?: {
     providerType?: string;
     kind?: SavedProviderSessionEntry['kind'];
 }): SavedProviderSessionEntry[];

package/dist/config/state-store.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ADHDev State Store — Runtime state persistence
+ *
+ * Separates volatile runtime state (sessions, activity, read markers)
+ * from static configuration (config.json).
+ *
+ * State is stored in ~/.adhdev/state.json
+ */
+import type { RecentActivityEntry } from './recent-activity.js';
+import type { SavedProviderSessionEntry } from './saved-sessions.js';
+export interface DaemonState {
+    /** Unified recent activity across IDE / CLI / ACP launch flows */
+    recentActivity: RecentActivityEntry[];
+    /** Persistent resume-capable provider sessions keyed by providerSessionId */
+    savedProviderSessions: SavedProviderSessionEntry[];
+    /** Last seen timestamps for live sessions, keyed by sessionId */
+    sessionReads: Record<string, number>;
+    /** Last seen completion marker for live sessions, keyed by sessionId */
+    sessionReadMarkers: Record<string, string>;
+}
+/**
+ * Load runtime state from disk
+ */
+export declare function loadState(): DaemonState;
+/**
+ * Save runtime state to disk
+ */
+export declare function saveState(state: DaemonState): void;
+/**
+ * Reset runtime state
+ */
+export declare function resetState(): void;

package/dist/index.d.ts

@@ -22,6 +22,8 @@ export { appendRecentActivity, getRecentActivity } from './config/recent-activit
 export type { RecentActivityEntry } from './config/recent-activity.js';
 export { getSavedProviderSessions, upsertSavedProviderSession } from './config/saved-sessions.js';
 export type { SavedProviderSessionEntry } from './config/saved-sessions.js';
+export { loadState, saveState, resetState } from './config/state-store.js';
+export type { DaemonState } from './config/state-store.js';
 export { detectIDEs } from './detection/ide-detector.js';
 export type { IDEInfo } from './detection/ide-detector.js';
 export { detectCLIs } from './detection/cli-detector.js';

package/dist/index.js

@@ -61,14 +61,6 @@ function asBoolean(value, fallback) {
 }
 function normalizeConfig(raw) {
   const parsed = isPlainObject(raw) ? raw : {};
-  const legacySessionReads = isPlainObject(parsed.recentSessionReads) ? parsed.recentSessionReads : {};
-  const sessionReads = isPlainObject(parsed.sessionReads) ? parsed.sessionReads : {};
-  const mergedSessionReads = Object.fromEntries(
-    Object.entries({ ...legacySessionReads, ...sessionReads }).filter(([, value]) => typeof value === "number" && Number.isFinite(value))
-  );
-  const sessionReadMarkers = Object.fromEntries(
-    Object.entries(isPlainObject(parsed.sessionReadMarkers) ? parsed.sessionReadMarkers : {}).filter(([, value]) => typeof value === "string")
-  );
   return {
     serverUrl: typeof parsed.serverUrl === "string" && parsed.serverUrl.trim() ? parsed.serverUrl : DEFAULT_CONFIG.serverUrl,
     selectedIde: asNullableString(parsed.selectedIde),
@@ -81,10 +73,6 @@ function normalizeConfig(raw) {
     enabledIdes: asStringArray(parsed.enabledIdes),
     workspaces: Array.isArray(parsed.workspaces) ? parsed.workspaces : [],
     defaultWorkspaceId: asNullableString(parsed.defaultWorkspaceId) ?? asNullableString(parsed.activeWorkspaceId),
-    recentActivity: Array.isArray(parsed.recentActivity) ? parsed.recentActivity : [],
-    savedProviderSessions: Array.isArray(parsed.savedProviderSessions) ? parsed.savedProviderSessions : [],
-    sessionReads: mergedSessionReads,
-    sessionReadMarkers,
     machineNickname: asNullableString(parsed.machineNickname),
     machineId: asOptionalString(parsed.machineId),
     machineSecret: parsed.machineSecret === null ? null : asOptionalString(parsed.machineSecret),
@@ -125,6 +113,30 @@ function getConfigDir() {
 function getConfigPath() {
   return (0, import_path.join)(getConfigDir(), "config.json");
 }
+function migrateStateToStateFile(raw) {
+  const statePath = (0, import_path.join)(getConfigDir(), "state.json");
+  if ((0, import_fs.existsSync)(statePath)) return;
+  const recentActivity = Array.isArray(raw.recentActivity) ? raw.recentActivity : [];
+  const savedProviderSessions = Array.isArray(raw.savedProviderSessions) ? raw.savedProviderSessions : [];
+  const legacySessionReads = isPlainObject(raw.recentSessionReads) ? raw.recentSessionReads : {};
+  const sessionReads = isPlainObject(raw.sessionReads) ? raw.sessionReads : {};
+  const sessionReadMarkers = isPlainObject(raw.sessionReadMarkers) ? raw.sessionReadMarkers : {};
+  const hasData = recentActivity.length > 0 || savedProviderSessions.length > 0 || Object.keys(sessionReads).length > 0 || Object.keys(legacySessionReads).length > 0 || Object.keys(sessionReadMarkers).length > 0;
+  if (!hasData) return;
+  const mergedReads = Object.fromEntries(
+    Object.entries({ ...legacySessionReads, ...sessionReads }).filter(([, v]) => typeof v === "number" && Number.isFinite(v))
+  );
+  const cleanedMarkers = Object.fromEntries(
+    Object.entries(sessionReadMarkers).filter(([, v]) => typeof v === "string")
+  );
+  const state = {
+    recentActivity,
+    savedProviderSessions,
+    sessionReads: mergedReads,
+    sessionReadMarkers: cleanedMarkers
+  };
+  (0, import_fs.writeFileSync)(statePath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
+}
 function loadConfig() {
   const configPath = getConfigPath();
   if (!(0, import_fs.existsSync)(configPath)) {
@@ -138,6 +150,7 @@ function loadConfig() {
   try {
     const raw = (0, import_fs.readFileSync)(configPath, "utf-8");
     const parsed = JSON.parse(raw);
+    migrateStateToStateFile(parsed);
     const normalizedInput = normalizeConfig(parsed);
     const ensured = ensureMachineId(normalizedInput);
     const normalized = ensured.config;
@@ -209,10 +222,6 @@ var init_config = __esm({
       enabledIdes: [],
       workspaces: [],
       defaultWorkspaceId: null,
-      recentActivity: [],
-      savedProviderSessions: [],
-      sessionReads: {},
-      sessionReadMarkers: {},
       machineNickname: null,
       machineId: void 0,
       machineSecret: null,
@@ -2604,6 +2613,7 @@ __export(index_exports, {
   launchWithCdp: () => launchWithCdp,
   listHostedCliRuntimes: () => listHostedCliRuntimes,
   loadConfig: () => loadConfig,
+  loadState: () => loadState,
   logCommand: () => logCommand,
   markSetupComplete: () => markSetupComplete,
   maybeRunDaemonUpgradeHelperFromEnv: () => maybeRunDaemonUpgradeHelperFromEnv,
@@ -2613,7 +2623,9 @@ __export(index_exports, {
   readChatHistory: () => readChatHistory,
   registerExtensionProviders: () => registerExtensionProviders,
   resetConfig: () => resetConfig,
+  resetState: () => resetState,
   saveConfig: () => saveConfig,
+  saveState: () => saveState,
   setLogLevel: () => setLogLevel,
   setupIdeInstance: () => setupIdeInstance,
   shutdownDaemonComponents: () => shutdownDaemonComponents,
@@ -2812,35 +2824,35 @@ function buildRecentActivityKeyForEntry(entry) {
   }
   return buildRecentActivityKey(entry);
 }
-function appendRecentActivity(config, entry) {
+function appendRecentActivity(state, entry) {
   const nextEntry = {
     ...entry,
     workspace: entry.workspace ? normalizeWorkspace(entry.workspace) : void 0,
     id: buildRecentActivityKeyForEntry(entry),
     lastUsedAt: entry.lastUsedAt || Date.now()
   };
-  const filtered = (config.recentActivity || []).filter((item) => item.id !== nextEntry.id);
+  const filtered = (state.recentActivity || []).filter((item) => item.id !== nextEntry.id);
   return {
-    ...config,
+    ...state,
     recentActivity: [nextEntry, ...filtered].slice(0, MAX_ACTIVITY)
   };
 }
-function getRecentActivity(config, limit = 20) {
-  return [...config.recentActivity || []].sort((a, b) => b.lastUsedAt - a.lastUsedAt).slice(0, limit);
+function getRecentActivity(state, limit = 20) {
+  return [...state.recentActivity || []].sort((a, b) => b.lastUsedAt - a.lastUsedAt).slice(0, limit);
 }
-function getSessionSeenAt(config, sessionId) {
-  return config.sessionReads?.[sessionId] || 0;
+function getSessionSeenAt(state, sessionId) {
+  return state.sessionReads?.[sessionId] || 0;
 }
-function getSessionSeenMarker(config, sessionId) {
-  return config.sessionReadMarkers?.[sessionId] || "";
+function getSessionSeenMarker(state, sessionId) {
+  return state.sessionReadMarkers?.[sessionId] || "";
 }
-function markSessionSeen(config, sessionId, seenAt = Date.now(), completionMarker) {
-  const prev = config.sessionReads || {};
+function markSessionSeen(state, sessionId, seenAt = Date.now(), completionMarker) {
+  const prev = state.sessionReads || {};
   const nextSeenAt = Math.max(prev[sessionId] || 0, seenAt);
-  const prevMarkers = config.sessionReadMarkers || {};
+  const prevMarkers = state.sessionReadMarkers || {};
   const nextMarker = typeof completionMarker === "string" ? completionMarker : "";
   return {
-    ...config,
+    ...state,
     sessionReads: {
       ...prev,
       [sessionId]: nextSeenAt
@@ -2866,11 +2878,11 @@ function normalizeWorkspace2(workspace) {
 function buildSavedProviderSessionKey(providerSessionId) {
   return `saved:${providerSessionId.trim()}`;
 }
-function upsertSavedProviderSession(config, entry) {
+function upsertSavedProviderSession(state, entry) {
   const providerSessionId = typeof entry.providerSessionId === "string" ? entry.providerSessionId.trim() : "";
-  if (!providerSessionId) return config;
+  if (!providerSessionId) return state;
   const id = buildSavedProviderSessionKey(providerSessionId);
-  const existing = (config.savedProviderSessions || []).find((item) => item.id === id);
+  const existing = (state.savedProviderSessions || []).find((item) => item.id === id);
   const nextEntry = {
     id,
     kind: entry.kind,
@@ -2883,23 +2895,75 @@ function upsertSavedProviderSession(config, entry) {
     createdAt: existing?.createdAt || entry.createdAt || Date.now(),
     lastUsedAt: entry.lastUsedAt || Date.now()
   };
-  const filtered = (config.savedProviderSessions || []).filter((item) => item.id !== id);
+  const filtered = (state.savedProviderSessions || []).filter((item) => item.id !== id);
   return {
-    ...config,
+    ...state,
     savedProviderSessions: [nextEntry, ...filtered].slice(0, MAX_SAVED_SESSIONS)
   };
 }
-function getSavedProviderSessions(config, filters) {
-  return [...config.savedProviderSessions || []].filter((entry) => {
+function getSavedProviderSessions(state, filters) {
+  return [...state.savedProviderSessions || []].filter((entry) => {
     if (filters?.providerType && entry.providerType !== filters.providerType) return false;
     if (filters?.kind && entry.kind !== filters.kind) return false;
     return true;
   }).sort((a, b) => b.lastUsedAt - a.lastUsedAt);
 }
 
+// src/config/state-store.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+init_config();
+var DEFAULT_STATE = {
+  recentActivity: [],
+  savedProviderSessions: [],
+  sessionReads: {},
+  sessionReadMarkers: {}
+};
+function isPlainObject2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getStatePath() {
+  return (0, import_path2.join)(getConfigDir(), "state.json");
+}
+function normalizeState(raw) {
+  const parsed = isPlainObject2(raw) ? raw : {};
+  const sessionReads = Object.fromEntries(
+    Object.entries(isPlainObject2(parsed.sessionReads) ? parsed.sessionReads : {}).filter(([, value]) => typeof value === "number" && Number.isFinite(value))
+  );
+  const sessionReadMarkers = Object.fromEntries(
+    Object.entries(isPlainObject2(parsed.sessionReadMarkers) ? parsed.sessionReadMarkers : {}).filter(([, value]) => typeof value === "string")
+  );
+  return {
+    recentActivity: Array.isArray(parsed.recentActivity) ? parsed.recentActivity : [],
+    savedProviderSessions: Array.isArray(parsed.savedProviderSessions) ? parsed.savedProviderSessions : [],
+    sessionReads,
+    sessionReadMarkers
+  };
+}
+function loadState() {
+  const statePath = getStatePath();
+  if (!(0, import_fs2.existsSync)(statePath)) {
+    return { ...DEFAULT_STATE };
+  }
+  try {
+    const raw = (0, import_fs2.readFileSync)(statePath, "utf-8");
+    return normalizeState(JSON.parse(raw));
+  } catch {
+    return { ...DEFAULT_STATE };
+  }
+}
+function saveState(state) {
+  const statePath = getStatePath();
+  const normalized = normalizeState(state);
+  (0, import_fs2.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+}
+function resetState() {
+  saveState({ ...DEFAULT_STATE });
+}
+
 // src/detection/ide-detector.ts
 var import_child_process = require("child_process");
-var import_fs2 = require("fs");
+var import_fs3 = require("fs");
 var import_os2 = require("os");
 var BUILTIN_IDE_DEFINITIONS = [];
 var registeredIDEs = /* @__PURE__ */ new Map();
@@ -2945,9 +3009,9 @@ function checkPathExists(paths) {
     if (p.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = p.replace("*", username);
-      if ((0, import_fs2.existsSync)(resolved)) return resolved;
+      if ((0, import_fs3.existsSync)(resolved)) return resolved;
     } else {
-      if ((0, import_fs2.existsSync)(p)) return p;
+      if ((0, import_fs3.existsSync)(p)) return p;
     }
   }
   return null;
@@ -2962,7 +3026,7 @@ async function detectIDEs() {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os18 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if ((0, import_fs2.existsSync)(bundledCli)) resolvedCli = bundledCli;
+      if ((0, import_fs3.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os18 === "win32") {
       const { dirname: dirname6 } = await import("path");
@@ -2975,7 +3039,7 @@ async function detectIDEs() {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if ((0, import_fs2.existsSync)(c)) {
+        if ((0, import_fs3.existsSync)(c)) {
           resolvedCli = c;
           break;
         }
@@ -9609,9 +9673,9 @@ var DaemonCliManager = class {
   }
   persistRecentActivity(entry) {
     try {
-      let nextConfig = appendRecentActivity(loadConfig(), entry);
+      let nextState = appendRecentActivity(loadState(), entry);
       if (entry.providerSessionId && (entry.kind === "cli" || entry.kind === "acp")) {
-        nextConfig = upsertSavedProviderSession(nextConfig, {
+        nextState = upsertSavedProviderSession(nextState, {
           kind: entry.kind,
           providerType: entry.providerType,
           providerName: entry.providerName,
@@ -9621,7 +9685,7 @@ var DaemonCliManager = class {
           title: entry.title
         });
       }
-      saveConfig(nextConfig);
+      saveState(nextState);
     } catch (e) {
       console.error(colorize("red", `  \u2717 Failed to save recent activity: ${e}`));
     }
@@ -10413,14 +10477,14 @@ var ProviderLoader = class _ProviderLoader {
   */
   setIdeExtensionEnabled(ideType, extensionType, enabled) {
     try {
-      const { loadConfig: loadConfig2, saveConfig: saveConfig2 } = (init_config(), __toCommonJS(config_exports));
+      const { loadConfig: loadConfig2, saveConfig: saveConfig3 } = (init_config(), __toCommonJS(config_exports));
       const config = loadConfig2();
       const baseIdeType = ideType.split("_")[0];
       if (!config.ideSettings) config.ideSettings = {};
       if (!config.ideSettings[baseIdeType]) config.ideSettings[baseIdeType] = {};
       if (!config.ideSettings[baseIdeType].extensions) config.ideSettings[baseIdeType].extensions = {};
       config.ideSettings[baseIdeType].extensions[extensionType] = { enabled };
-      saveConfig2(config);
+      saveConfig3(config);
       this.log(`IDE extension setting: ${ideType}.${extensionType}.enabled = ${enabled}`);
       return true;
     } catch (e) {
@@ -10985,12 +11049,12 @@ var ProviderLoader = class _ProviderLoader {
     }
     if (schemaDef.type === "select" && schemaDef.options && !schemaDef.options.includes(value)) return false;
     try {
-      const { loadConfig: loadConfig2, saveConfig: saveConfig2 } = (init_config(), __toCommonJS(config_exports));
+      const { loadConfig: loadConfig2, saveConfig: saveConfig3 } = (init_config(), __toCommonJS(config_exports));
       const config = loadConfig2();
       if (!config.providerSettings) config.providerSettings = {};
       if (!config.providerSettings[type]) config.providerSettings[type] = {};
       config.providerSettings[type][key] = value;
-      saveConfig2(config);
+      saveConfig3(config);
       this.log(`Setting updated: ${type}.${key} = ${JSON.stringify(value)}`);
       return true;
     } catch (e) {
@@ -11768,16 +11832,17 @@ function buildRecentLaunches(recentActivity) {
 }
 function buildStatusSnapshot(options) {
   const cfg = loadConfig();
+  const state = loadState();
   const wsState = getWorkspaceState(cfg);
   const memSnap = getHostMemorySnapshot();
-  const recentActivity = getRecentActivity(cfg, 20);
+  const recentActivity = getRecentActivity(state, 20);
   const sessions = buildSessionEntries(
     options.allStates,
     options.cdpManagers
   );
   for (const session of sessions) {
-    const lastSeenAt = getSessionSeenAt(cfg, session.id);
-    const seenCompletionMarker = getSessionSeenMarker(cfg, session.id);
+    const lastSeenAt = getSessionSeenAt(state, session.id);
+    const seenCompletionMarker = getSessionSeenMarker(state, session.id);
     const lastUsedAt = getSessionLastUsedAt(session);
     const completionMarker = getSessionCompletionMarker(session);
     const { unread, inboxBucket } = session.surfaceHidden ? { unread: false, inboxBucket: "idle" } : getUnreadState(
@@ -12115,9 +12180,9 @@ var DaemonCommandRouter = class {
         const offset = Math.max(0, Number(args?.offset) || 0);
         const limit = Math.max(1, Math.min(100, Number(args?.limit) || 30));
         const { sessions: historySessions, hasMore } = listSavedHistorySessions(providerType, { offset, limit });
-        const config = loadConfig();
-        const savedSessions = getSavedProviderSessions(config, { providerType, kind });
-        const recentSessions = getRecentActivity(config, 200).filter((entry) => entry.providerType === providerType && entry.kind === kind && entry.providerSessionId);
+        const state = loadState();
+        const savedSessions = getSavedProviderSessions(state, { providerType, kind });
+        const recentSessions = getRecentActivity(state, 200).filter((entry) => entry.providerType === providerType && entry.kind === kind && entry.providerSessionId);
         const savedSessionById = new Map(savedSessions.map((entry) => [entry.providerSessionId, entry]));
         const recentSessionById = new Map(recentSessions.map((entry) => [entry.providerSessionId, entry]));
         const providerMeta = this.deps.providerLoader.getMeta(providerType);
@@ -12208,19 +12273,19 @@ var DaemonCommandRouter = class {
         this.deps.onIdeConnected?.();
         if (result.success && resolvedWorkspace) {
           try {
-            const next = appendRecentActivity(loadConfig(), {
+            const next = appendRecentActivity(loadState(), {
               kind: "ide",
               providerType: result.ideId || ideKey,
               providerName: result.ideId || ideKey,
               workspace: resolvedWorkspace,
               title: result.ideId || ideKey
             });
-            saveConfig(next);
+            saveState(next);
           } catch {
           }
         } else if (result.success && (result.ideId || ideKey)) {
           try {
-            saveConfig(appendRecentActivity(loadConfig(), {
+            saveState(appendRecentActivity(loadState(), {
               kind: "ide",
               providerType: result.ideId || ideKey,
               providerName: result.ideId || ideKey,
@@ -12249,8 +12314,8 @@ var DaemonCommandRouter = class {
         if (!sessionId || typeof sessionId !== "string") {
           return { success: false, error: "sessionId is required" };
         }
-        const currentConfig = loadConfig();
-        const prevSeenAt = currentConfig.sessionReads?.[sessionId] || 0;
+        const currentState = loadState();
+        const prevSeenAt = currentState.sessionReads?.[sessionId] || 0;
         const sessionEntries = buildSessionEntries(
           this.deps.instanceManager.collectAllStates(),
           this.deps.cdpManagers
@@ -12258,7 +12323,7 @@ var DaemonCommandRouter = class {
         const targetSession = sessionEntries.find((entry) => entry.id === sessionId);
         const completionMarker = targetSession ? getSessionCompletionMarker(targetSession) : "";
         const next = markSessionSeen(
-          currentConfig,
+          currentState,
           sessionId,
           typeof args?.seenAt === "number" ? args.seenAt : Date.now(),
           completionMarker
@@ -12266,7 +12331,7 @@ var DaemonCommandRouter = class {
         if (READ_DEBUG_ENABLED2) {
           LOG.info("RecentRead", `mark_session_seen sessionId=${sessionId} seenAt=${String(args?.seenAt || "")} prevSeenAt=${String(prevSeenAt)} nextSeenAt=${String(next.sessionReads?.[sessionId] || 0)} marker=${completionMarker || "-"}`);
         }
-        saveConfig(next);
+        saveState(next);
         this.deps.onStatusChange?.();
         return {
           success: true,
@@ -19612,6 +19677,7 @@ async function shutdownDaemonComponents(components) {
   launchWithCdp,
   listHostedCliRuntimes,
   loadConfig,
+  loadState,
   logCommand,
   markSetupComplete,
   maybeRunDaemonUpgradeHelperFromEnv,
@@ -19621,7 +19687,9 @@ async function shutdownDaemonComponents(components) {
   readChatHistory,
   registerExtensionProviders,
   resetConfig,
+  resetState,
   saveConfig,
+  saveState,
   setLogLevel,
   setupIdeInstance,
   shutdownDaemonComponents,