npm - @shawnstack/quickforge - Versions diffs - 1.5.2 → 1.5.3 - Mend

@shawnstack/quickforge 1.5.2 → 1.5.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/dist/index.html CHANGED Viewed

@@ -11,7 +11,7 @@
     <meta name="apple-mobile-web-app-title" content="QuickForge" />
     <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
     <title>速构 QuickForge</title>
-    <script type="module" crossorigin src="/assets/index-BzOV50wA.js"></script>
+    <script type="module" crossorigin src="/assets/index-Bt_dRvdG.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-DWdDZTNf.js">
     <link rel="modulepreload" crossorigin href="/assets/pi-ai-Cx633yhb.js">
     <link rel="modulepreload" crossorigin href="/assets/lit-vendor-Dr3cpBGF.js">
@@ -20,7 +20,7 @@
     <link rel="modulepreload" crossorigin href="/assets/icons-DzxBk7tb.js">
     <link rel="modulepreload" crossorigin href="/assets/react-vendor-DsAeMFcm.js">
     <link rel="modulepreload" crossorigin href="/assets/logger-B65Akg8A.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-BI7xZuj-.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-BzaZg9Br.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@shawnstack/quickforge",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "AI chat application with Agent access modes for local workspace tools. React + Vite + Tailwind CSS frontend, local Node.js storage server.",
   "keywords": [
     "ai",

package/server/mcp/config.mjs CHANGED Viewed

@@ -163,43 +163,43 @@ export function normalizeMcpServers(value) {
 }
 export async function readMcpServers() {
-  const settings = await readStore('settings')
-  return normalizeMcpServers(settings?.[MCP_CONFIG_KEY])
+  const mcp = await readStore('mcp')
+  return normalizeMcpServers(mcp?.[MCP_CONFIG_KEY])
 }
 export async function writeMcpServers(servers) {
   const normalized = normalizeMcpServers(servers)
-  return atomicUpdate('settings', (settings) => {
-    settings[MCP_CONFIG_KEY] = normalized.map((server) => ({ ...server, updatedAt: new Date().toISOString() }))
-    return settings
-  }).then((settings) => normalizeMcpServers(settings?.[MCP_CONFIG_KEY]))
+  return atomicUpdate('mcp', (mcp) => {
+    mcp[MCP_CONFIG_KEY] = normalized.map((server) => ({ ...server, updatedAt: new Date().toISOString() }))
+    return mcp
+  }).then((mcp) => normalizeMcpServers(mcp?.[MCP_CONFIG_KEY]))
 }
 export async function upsertMcpServer(server) {
   const normalized = normalizeMcpServerConfig(server)
-  return atomicUpdate('settings', (settings) => {
-    const servers = normalizeMcpServers(settings?.[MCP_CONFIG_KEY])
+  return atomicUpdate('mcp', (mcp) => {
+    const servers = normalizeMcpServers(mcp?.[MCP_CONFIG_KEY])
     const index = servers.findIndex((item) => item.name === normalized.name)
     const next = { ...normalized, updatedAt: new Date().toISOString() }
     if (index >= 0) servers[index] = next
     else servers.push(next)
-    settings[MCP_CONFIG_KEY] = servers
-    return settings
-  }).then((settings) => normalizeMcpServers(settings?.[MCP_CONFIG_KEY]))
+    mcp[MCP_CONFIG_KEY] = servers
+    return mcp
+  }).then((mcp) => normalizeMcpServers(mcp?.[MCP_CONFIG_KEY]))
 }
 export async function deleteMcpServer(name) {
   const normalizedName = normalizeName(name)
-  return atomicUpdate('settings', (settings) => {
-    settings[MCP_CONFIG_KEY] = normalizeMcpServers(settings?.[MCP_CONFIG_KEY]).filter((server) => server.name !== normalizedName)
-    return settings
-  }).then((settings) => normalizeMcpServers(settings?.[MCP_CONFIG_KEY]))
+  return atomicUpdate('mcp', (mcp) => {
+    mcp[MCP_CONFIG_KEY] = normalizeMcpServers(mcp?.[MCP_CONFIG_KEY]).filter((server) => server.name !== normalizedName)
+    return mcp
+  }).then((mcp) => normalizeMcpServers(mcp?.[MCP_CONFIG_KEY]))
 }
 export async function setMcpServerEnabled(name, enabled) {
   const normalizedName = normalizeName(name)
-  return atomicUpdate('settings', (settings) => {
-    const servers = normalizeMcpServers(settings?.[MCP_CONFIG_KEY])
+  return atomicUpdate('mcp', (mcp) => {
+    const servers = normalizeMcpServers(mcp?.[MCP_CONFIG_KEY])
     const index = servers.findIndex((server) => server.name === normalizedName)
     if (index < 0) {
       const error = new Error(`MCP server not found: ${normalizedName}`)
@@ -211,7 +211,7 @@ export async function setMcpServerEnabled(name, enabled) {
       enabled: Boolean(enabled),
       updatedAt: new Date().toISOString(),
     }
-    settings[MCP_CONFIG_KEY] = servers
-    return settings
-  }).then((settings) => normalizeMcpServers(settings?.[MCP_CONFIG_KEY]))
+    mcp[MCP_CONFIG_KEY] = servers
+    return mcp
+  }).then((mcp) => normalizeMcpServers(mcp?.[MCP_CONFIG_KEY]))
 }

package/server/routes/backup.mjs CHANGED Viewed

@@ -16,7 +16,13 @@ import { getWorkspaceRoot } from '../utils/workspace.mjs'
 const BACKUP_VERSION = 1
 const BACKUP_APP = 'quickforge'
 const backupScopes = new Set(['all', 'config', 'sessions'])
-const restoreSectionIds = new Set(['settings', 'providerKeys', 'customProviders', 'projects', 'scheduledTasks', 'conversations'])
+const restoreSectionIds = new Set(['settings', 'mcp', 'providerKeys', 'customProviders', 'projects', 'scheduledTasks', 'conversations'])
+const restoreModes = new Set(['replace', 'merge'])
+function normalizeMode(value) {
+  const mode = String(value || 'replace')
+  return restoreModes.has(mode) ? mode : 'replace'
+}
 function normalizeScope(value) {
   const scope = String(value || 'all')
@@ -109,8 +115,9 @@ async function buildBackup(scope = 'all', options = {}) {
   const data = {}
   if (includeConfig) {
-    const [settings, providerKeys, customProviders, projects, scheduledTasks] = await Promise.all([
+    const [settings, mcp, providerKeys, customProviders, projects, scheduledTasks] = await Promise.all([
       readStore('settings'),
+      readStore('mcp'),
       includeSecrets ? readStore('provider-keys') : Promise.resolve(undefined),
       readStore('custom-providers'),
       readProjectConfigData(),
@@ -118,6 +125,7 @@ async function buildBackup(scope = 'all', options = {}) {
     ])
     Object.assign(data, {
       settings,
+      mcp,
       customProviders,
       projects,
       scheduledTasks,
@@ -160,6 +168,7 @@ function normalizeBackupPayload(payload) {
   const sections = {
     settings: section(data, 'settings'),
+    mcp: section(data, 'mcp'),
     providerKeys: section(data, 'providerKeys', 'provider-keys'),
     customProviders: section(data, 'customProviders', 'custom-providers'),
     projects: section(data, 'projects'),
@@ -168,6 +177,17 @@ function normalizeBackupPayload(payload) {
     sessionsMetadata: section(data, 'sessionsMetadata', 'sessions-metadata'),
   }
+  // Backward compat: older backups stored MCP servers inside settings.mcpServers.
+  if (
+    sections.mcp === undefined &&
+    sections.settings && typeof sections.settings === 'object' && !Array.isArray(sections.settings) &&
+    Object.prototype.hasOwnProperty.call(sections.settings, 'mcpServers')
+  ) {
+    const { mcpServers, ...restSettings } = sections.settings
+    sections.settings = restSettings
+    sections.mcp = { mcpServers: Array.isArray(mcpServers) ? mcpServers : [] }
+  }
   if (Object.values(sections).every((value) => value === undefined)) {
     const error = new Error('Backup does not contain any restorable sections')
     error.statusCode = 400
@@ -197,6 +217,7 @@ function validateBackupPayload(payload) {
     ...backup,
     sections: {
       settings: assertObjectSection(sections.settings, 'settings'),
+      mcp: assertObjectSection(sections.mcp, 'mcp'),
       providerKeys: assertObjectSection(sections.providerKeys, 'providerKeys'),
       customProviders: assertObjectSection(sections.customProviders, 'customProviders'),
       projects: assertProjectConfig(sections.projects),
@@ -249,6 +270,7 @@ function filterRestoreSections(sections, selected) {
   if (!selected) return sections
   return {
     settings: selected.has('settings') ? sections.settings : undefined,
+    mcp: selected.has('mcp') ? sections.mcp : undefined,
     providerKeys: selected.has('providerKeys') ? sections.providerKeys : undefined,
     customProviders: selected.has('customProviders') ? sections.customProviders : undefined,
     projects: selected.has('projects') ? sections.projects : undefined,
@@ -267,7 +289,8 @@ function parseImportPayload(body) {
   const backup = validateBackupPayload(payload)
   const requestedSections = body?.backup && typeof body === 'object' ? body.sections : undefined
   const selected = normalizeRestoreSections(requestedSections, backup.sections)
-  return backupWithSelectedSections(backup, selected)
+  const mode = normalizeMode(body?.mode)
+  return { backup: backupWithSelectedSections(backup, selected), mode }
 }
 function countKeys(value) {
@@ -277,6 +300,7 @@ function countKeys(value) {
 function buildSummary(sections) {
   const summary = {}
   if (sections.settings !== undefined) summary.settings = countKeys(sections.settings)
+  if (sections.mcp !== undefined) summary.mcp = Array.isArray(sections.mcp?.mcpServers) ? sections.mcp.mcpServers.length : countKeys(sections.mcp)
   if (sections.providerKeys !== undefined) summary.providerKeys = countKeys(sections.providerKeys)
   if (sections.customProviders !== undefined) summary.customProviders = countKeys(sections.customProviders)
   if (sections.projects !== undefined) summary.projects = sections.projects.projects.length
@@ -318,46 +342,86 @@ async function writeSafetyBackup() {
   return file
 }
-async function restoreValidatedBackup(backup) {
+// Merge two plain-object stores: backup entries override local on key collision,
+// local-only keys are preserved.
+function mergeRecordStore(localValue, backupValue) {
+  return { ...(localValue && typeof localValue === 'object' ? localValue : {}), ...backupValue }
+}
+// Merge projects config: dedupe the projects array by id (backup wins on
+// collision, local-only entries preserved), take activeProjectId / globalSkills
+// from backup.
+function mergeProjectConfig(localConfig, backupConfig) {
+  const localProjects = Array.isArray(localConfig?.projects) ? localConfig.projects : []
+  const backupProjects = Array.isArray(backupConfig.projects) ? backupConfig.projects : []
+  const merged = new Map()
+  for (const project of localProjects) {
+    if (project && typeof project.id === 'string') merged.set(project.id, project)
+  }
+  for (const project of backupProjects) {
+    if (project && typeof project.id === 'string') merged.set(project.id, project)
+  }
+  return {
+    activeProjectId: typeof backupConfig.activeProjectId === 'string' ? backupConfig.activeProjectId : (localConfig?.activeProjectId ?? null),
+    globalSkills: Array.isArray(backupConfig.globalSkills) ? backupConfig.globalSkills : (Array.isArray(localConfig?.globalSkills) ? localConfig.globalSkills : []),
+    projects: [...merged.values()],
+  }
+}
+async function restoreValidatedBackup(backup, mode = 'replace') {
+  const merge = mode === 'merge'
   const { sections } = backup
   const summary = {}
   if (sections.settings !== undefined) {
-    await writeStore('settings', sections.settings)
-    summary.settings = countKeys(sections.settings)
+    const value = merge ? mergeRecordStore(await readStore('settings'), sections.settings) : sections.settings
+    await writeStore('settings', value)
+    summary.settings = countKeys(value)
+  }
+  if (sections.mcp !== undefined) {
+    const value = merge ? mergeRecordStore(await readStore('mcp'), sections.mcp) : sections.mcp
+    await writeStore('mcp', value)
+    summary.mcp = Array.isArray(value?.mcpServers) ? value.mcpServers.length : countKeys(value)
   }
   if (sections.providerKeys !== undefined) {
-    await writeStore('provider-keys', sections.providerKeys)
-    summary.providerKeys = countKeys(sections.providerKeys)
+    const value = merge ? mergeRecordStore(await readStore('provider-keys'), sections.providerKeys) : sections.providerKeys
+    await writeStore('provider-keys', value)
+    summary.providerKeys = countKeys(value)
   }
   if (sections.customProviders !== undefined) {
-    await writeStore('custom-providers', sections.customProviders)
-    summary.customProviders = countKeys(sections.customProviders)
+    const value = merge ? mergeRecordStore(await readStore('custom-providers'), sections.customProviders) : sections.customProviders
+    await writeStore('custom-providers', value)
+    summary.customProviders = countKeys(value)
   }
   if (sections.projects !== undefined) {
-    await writeProjectConfigData(sections.projects)
+    const value = merge ? mergeProjectConfig(await readProjectConfigData(), sections.projects) : sections.projects
+    await writeProjectConfigData(value)
     await initializeActiveProject()
     setActiveWorkspaceRootForFilesystem(getWorkspaceRoot())
-    summary.projects = sections.projects.projects.length
+    summary.projects = value.projects.length
   }
   if (sections.scheduledTasks !== undefined) {
-    await writeStore('scheduled-tasks', sections.scheduledTasks)
-    summary.scheduledTasks = countKeys(sections.scheduledTasks)
+    const value = merge ? mergeRecordStore(await readStore('scheduled-tasks'), sections.scheduledTasks) : sections.scheduledTasks
+    await writeStore('scheduled-tasks', value)
+    summary.scheduledTasks = countKeys(value)
   }
   if (sections.sessions !== undefined) {
     const sessions = filterSessionsByMetadata(sections.sessions, sections.sessionsMetadata)
-    await writeStore('sessions', sessions)
-    summary.sessions = countKeys(sessions)
+    const value = merge ? mergeRecordStore(await readStore('sessions'), sessions) : sessions
+    await writeStore('sessions', value)
+    summary.sessions = countKeys(value)
   }
   if (sections.sessionsMetadata !== undefined) {
-    await writeStore('sessions-metadata', sections.sessionsMetadata)
-    summary.sessionsMetadata = countKeys(sections.sessionsMetadata)
+    const value = merge ? mergeRecordStore(await readStore('sessions-metadata'), sections.sessionsMetadata) : sections.sessionsMetadata
+    await writeStore('sessions-metadata', value)
+    summary.sessionsMetadata = countKeys(value)
   }
   return summary
@@ -382,9 +446,9 @@ export async function handleBackupApi(req, res, url) {
   if (req.method === 'POST' && url.pathname === '/api/backup/import') {
     await ensureStorage()
     const body = await readJsonBody(req)
-    const backup = parseImportPayload(body)
+    const { backup, mode } = parseImportPayload(body)
     const safetyBackupPath = await writeSafetyBackup()
-    const summary = await restoreValidatedBackup(backup)
+    const summary = await restoreValidatedBackup(backup, mode)
     sendJson(res, 200, { ok: true, safetyBackupPath, summary })
     return
   }

package/server/storage.mjs CHANGED Viewed

@@ -46,6 +46,7 @@ export async function cleanOldLogs() {
 export const stores = new Set([
   'settings',
+  'mcp',
   'provider-keys',
   'custom-providers',
   'plugins',
@@ -74,13 +75,102 @@ export function getStoreRevision(storeName) {
   return storeRevisions.get(storeName) || 0
 }
-const configStores = new Set(['settings', 'provider-keys', 'custom-providers', 'plugins'])
+// Each configuration store is persisted to its own file under config/.
+// "Solo" stores own a file whose root object *is* the store data.
+// "Shared" stores share one file (providers.json) keyed by section, so that
+// strongly-coupled provider definitions and their API keys stay in sync under
+// a single write queue.
+const soloConfigStores = {
+  settings: 'settings.json',
+  mcp: 'mcp-servers.json',
+  plugins: 'plugins.json',
+}
+const sharedConfigGroups = {
+  'providers.json': {
+    queue: 'providers',
+    sections: {
+      'provider-keys': 'providerKeys',
+      'custom-providers': 'customProviders',
+    },
+  },
+}
+// Reverse index: storeName -> { file, queue, sectionKey|null }
+const configStoreLocations = (() => {
+  const map = {}
+  for (const [store, file] of Object.entries(soloConfigStores)) {
+    map[store] = { file, queue: store, sectionKey: null }
+  }
+  for (const [file, group] of Object.entries(sharedConfigGroups)) {
+    for (const [store, sectionKey] of Object.entries(group.sections)) {
+      map[store] = { file, queue: group.queue, sectionKey }
+    }
+  }
+  return map
+})()
+function isConfigStore(storeName) {
+  return Boolean(configStoreLocations[storeName])
+}
+function configStoreFilePath(storeName) {
+  return path.join(configDir, configStoreLocations[storeName].file)
+}
+// Coerce a value into a plain object record (the shape every config store holds).
+function asRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {}
+}
-const configStoreSections = {
-  settings: ['app', 'settings'],
-  'provider-keys': ['credentials', 'providerKeys'],
-  'custom-providers': ['providers', 'customProviders'],
-  plugins: ['extensions', 'plugins'],
+// Where each config store lived in the legacy unified config.json, used only as
+// a read fallback (D6 read-side safety net).  Note: `mcp` was lifted out of
+// `settings.mcpServers` — its legacy source is nested, not a direct section.
+const legacyConfigSectionReaders = {
+  settings: (config) => asRecord(config.app?.settings),
+  mcp: (config) => ({ mcpServers: Array.isArray(config.app?.settings?.mcpServers) ? config.app.settings.mcpServers : [] }),
+  plugins: (config) => asRecord(config.extensions?.plugins),
+  'provider-keys': (config) => asRecord(config.credentials?.providerKeys),
+  'custom-providers': (config) => asRecord(config.providers?.customProviders),
+}
+// Read a single config store from its (possibly shared) file, with a fallback
+// to the legacy unified config.json section when the split file is absent and
+// the split migration has not completed yet (D6 read-side safety net, so an
+// interrupted or partially-completed migration can never surface empty data).
+async function readConfigStore(storeName) {
+  const loc = configStoreLocations[storeName]
+  const file = configStoreFilePath(storeName)
+  if (existsSync(file)) {
+    const content = await readJsonFile(file, {})
+    if (loc.sectionKey) return asRecord(content?.[loc.sectionKey])
+    return asRecord(content)
+  }
+  // Split file missing: only fall back to the legacy section while the split
+  // migration is still pending. Once `.split-migrated` exists the split files
+  // are authoritative, so a genuinely missing file means an empty store.
+  if (!existsSync(splitMigrationMarkerFile)) {
+    const reader = legacyConfigSectionReaders[storeName]
+    if (reader) return reader(await readConfigFile())
+  }
+  return {}
+}
+// Write a single config store back to its (possibly shared) file.  For shared
+// files the sibling sections are preserved.  Must run inside the store's queue.
+async function writeConfigStore(storeName, data) {
+  const loc = configStoreLocations[storeName]
+  const file = configStoreFilePath(storeName)
+  if (loc.sectionKey) {
+    const content = await readJsonFile(file, {})
+    content[loc.sectionKey] = data && typeof data === 'object' && !Array.isArray(data) ? data : {}
+    await writeJsonAtomic(file, content)
+    return
+  }
+  await writeJsonAtomic(file, data && typeof data === 'object' && !Array.isArray(data) ? data : {})
 }
 export function getDataDir() {
@@ -97,18 +187,16 @@ export const userCommandsDir = path.join(dataDir, 'commands')
 const quickForgeConfigFile = path.join(configDir, 'config.json')
 const configMigrationMarkerFile = path.join(configDir, '.layout-migrated')
+const splitMigrationMarkerFile = path.join(configDir, '.split-migrated')
+const projectsConfigFile = path.join(configDir, 'projects.json')
 const legacyStorageMigrationMarkerFile = path.join(storageDir, '.layout-migrated')
 export function storeFile(storeName) {
   assertStore(storeName)
-  if (configStores.has(storeName)) return quickForgeConfigFile
+  if (isConfigStore(storeName)) return configStoreFilePath(storeName)
   return sessionStoreFile(storeName, { scope: 'global' })
 }
-export function configFile() {
-  return quickForgeConfigFile
-}
 function legacyFlatStoreFile(storeName) {
   return path.join(storageDir, `${storeName}.json`)
 }
@@ -228,17 +316,6 @@ function normalizeConfig(value) {
   }
 }
-function configSection(config, storeName) {
-  const [section, key] = configStoreSections[storeName]
-  return config?.[section]?.[key] && typeof config[section][key] === 'object' ? config[section][key] : {}
-}
-function setConfigSection(config, storeName, data) {
-  const [section, key] = configStoreSections[storeName]
-  config[section] = config[section] && typeof config[section] === 'object' ? config[section] : {}
-  config[section][key] = data && typeof data === 'object' ? data : {}
-}
 function sessionBucket(value) {
   if (value?.scope === 'project' && value?.projectId) {
     return { scope: 'project', projectId: String(value.projectId) }
@@ -322,6 +399,10 @@ async function readConfigFile() {
   return normalizeConfig(await readJsonFile(quickForgeConfigFile, defaultConfig()))
 }
+// Used only within the migration chain (migrateUnifiedConfig). It persists the
+// unified (pre-split) layout at layoutVersion 1 as an intermediate step; the
+// subsequent migrateSplitConfig() then demotes config.json to metadata-only
+// (layoutVersion 2). Do not use for normal runtime config writes.
 async function writeConfigFile(config) {
   const next = normalizeConfig(config)
   next.layoutVersion = 1
@@ -651,6 +732,68 @@ async function migrateUnifiedConfig() {
   await fs.writeFile(configMigrationMarkerFile, `${new Date().toISOString()}\n`, 'utf8')
 }
+// Split the legacy unified config.json into per-store files under config/.
+// Each target file is only written when it does not already exist, so a
+// partially-completed migration can safely resume.  config.json is demoted to
+// metadata only after the split succeeds.
+async function migrateSplitConfig() {
+  if (existsSync(splitMigrationMarkerFile)) return
+  // Fresh installs have no unified config.json to split — just record marker.
+  if (!existsSync(quickForgeConfigFile)) {
+    await fs.writeFile(splitMigrationMarkerFile, `${new Date().toISOString()}\n`, 'utf8')
+    return
+  }
+  const config = await readConfigFile()
+  // settings.json — mcpServers is stripped out (moved to its own store below)
+  if (!existsSync(path.join(configDir, 'settings.json'))) {
+    const oldSettings = config.app?.settings && typeof config.app.settings === 'object'
+      ? { ...config.app.settings }
+      : {}
+    delete oldSettings.mcpServers
+    await writeJsonAtomic(path.join(configDir, 'settings.json'), oldSettings)
+  }
+  // mcp-servers.json — lifted out of settings.mcpServers
+  if (!existsSync(path.join(configDir, 'mcp-servers.json'))) {
+    const mcpServers = config.app?.settings?.mcpServers
+    await writeJsonAtomic(path.join(configDir, 'mcp-servers.json'), {
+      mcpServers: Array.isArray(mcpServers) ? mcpServers : [],
+    })
+  }
+  // providers.json — customProviders + providerKeys kept together (coupled)
+  if (!existsSync(path.join(configDir, 'providers.json'))) {
+    const customProviders = config.providers?.customProviders && typeof config.providers.customProviders === 'object'
+      ? config.providers.customProviders
+      : {}
+    const providerKeys = config.credentials?.providerKeys && typeof config.credentials.providerKeys === 'object'
+      ? config.credentials.providerKeys
+      : {}
+    await writeJsonAtomic(path.join(configDir, 'providers.json'), { customProviders, providerKeys })
+  }
+  // plugins.json
+  if (!existsSync(path.join(configDir, 'plugins.json'))) {
+    const plugins = config.extensions?.plugins && typeof config.extensions.plugins === 'object'
+      ? config.extensions.plugins
+      : {}
+    await writeJsonAtomic(path.join(configDir, 'plugins.json'), plugins)
+  }
+  // projects.json
+  if (!existsSync(projectsConfigFile)) {
+    await writeJsonAtomic(projectsConfigFile, normalizeProjectConfig(config.projects))
+  }
+  // Demote config.json to metadata only.
+  await writeJsonAtomic(quickForgeConfigFile, { layoutVersion: 2, migratedAt: new Date().toISOString() })
+  await fs.writeFile(splitMigrationMarkerFile, `${new Date().toISOString()}\n`, 'utf8')
+}
 const writeQueues = new Map()
 function enqueueWrite(queueName, operation) {
@@ -673,15 +816,13 @@ function enqueueWrite(queueName, operation) {
  */
 export async function atomicUpdate(storeName, updateFn) {
   assertStore(storeName)
-  const queueName = configStores.has(storeName) ? 'config' : storeName
+  const queueName = isConfigStore(storeName) ? configStoreLocations[storeName].queue : storeName
   return enqueueWrite(queueName, async () => {
     await ensureStorage()
-    if (configStores.has(storeName)) {
-      const config = await readConfigFile()
-      const data = configSection(config, storeName)
+    if (isConfigStore(storeName)) {
+      const data = await readConfigStore(storeName)
       const updated = updateFn(data)
-      setConfigSection(config, storeName, updated)
-      await writeConfigFile(config)
+      await writeConfigStore(storeName, updated)
       return updated
     }
     const data = await readSessionStore(storeName)
@@ -718,13 +859,11 @@ export async function atomicSessionMetadataUpdate(scope, projectId, updateFn) {
  * Atomically read-modify-write the project config within the config queue.
  */
 export async function atomicProjectConfigUpdate(updateFn) {
-  return enqueueWrite('config', async () => {
+  return enqueueWrite('projects', async () => {
     await ensureStorage()
-    const config = await readConfigFile()
-    const projectConfig = normalizeProjectConfig(config.projects)
+    const projectConfig = normalizeProjectConfig(await readJsonFile(projectsConfigFile, defaultProjectConfig()))
     const updated = updateFn(projectConfig)
-    config.projects = normalizeProjectConfig(updated)
-    await writeConfigFile(config)
+    await writeJsonAtomic(projectsConfigFile, normalizeProjectConfig(updated))
     return updated
   })
 }
@@ -755,9 +894,10 @@ export function ensureStorage() {
     ])
     await migrateUnifiedConfig()
+    await migrateSplitConfig()
     await Promise.all([
-      ensureJsonFile(quickForgeConfigFile, defaultConfig()),
+      ensureJsonFile(quickForgeConfigFile, { layoutVersion: 2 }),
       ensureJsonFile(sessionStoreFile('sessions-metadata', { scope: 'global' })),
     ])
   })()
@@ -770,9 +910,8 @@ export async function readStore(storeName) {
   assertStore(storeName)
   await ensureStorage()
-  if (configStores.has(storeName)) {
-    const config = await readConfigFile()
-    return configSection(config, storeName)
+  if (isConfigStore(storeName)) {
+    return readConfigStore(storeName)
   }
   return readSessionStore(storeName)
@@ -780,15 +919,13 @@ export async function readStore(storeName) {
 export async function writeStore(storeName, data) {
   assertStore(storeName)
-  const queueName = configStores.has(storeName) ? 'config' : storeName
+  const queueName = isConfigStore(storeName) ? configStoreLocations[storeName].queue : storeName
   return enqueueWrite(queueName, async () => {
     await ensureStorage()
-    if (configStores.has(storeName)) {
-      const config = await readConfigFile()
-      setConfigSection(config, storeName, data)
-      await writeConfigFile(config)
+    if (isConfigStore(storeName)) {
+      await writeConfigStore(storeName, data)
       return
     }
@@ -798,16 +935,13 @@ export async function writeStore(storeName, data) {
 export async function readProjectConfigData() {
   await ensureStorage()
-  const config = await readConfigFile()
-  return normalizeProjectConfig(config.projects)
+  return normalizeProjectConfig(await readJsonFile(projectsConfigFile, defaultProjectConfig()))
 }
 export async function writeProjectConfigData(projectConfig) {
-  return enqueueWrite('config', async () => {
+  return enqueueWrite('projects', async () => {
     await ensureStorage()
-    const config = await readConfigFile()
-    config.projects = normalizeProjectConfig(projectConfig)
-    await writeConfigFile(config)
+    await writeJsonAtomic(projectsConfigFile, normalizeProjectConfig(projectConfig))
   })
 }