farming-code 2.2.18 → 2.2.20

package/backend/agent-manager.js

@@ -1414,6 +1414,16 @@ class AgentManager extends EventEmitter {
         projectOrder: finiteOrder(record.projectOrder),
         pinnedOrder: finiteOrder(record.pinnedOrder),
         customTitle: record.customTitle || '',
+        pinned: record.pinned === true,
+        attentionSeq: finiteNonNegativeInteger(record.attentionSeq),
+        readAttentionSeq: finiteNonNegativeInteger(record.readAttentionSeq),
+        attentionUpdatedAt: finiteNumberOrNull(record.attentionUpdatedAt),
+        readAttentionAt: finiteNumberOrNull(record.readAttentionAt),
+        attentionReason: record.attentionReason || '',
+        attentionOutputEpoch: record.attentionOutputEpoch || '',
+        attentionOutputSeq: finiteNumberOrNull(record.attentionOutputSeq),
+        readOutputEpoch: record.readOutputEpoch || '',
+        readOutputSeq: finiteNumberOrNull(record.readOutputSeq),
         persistentSessionId: record.id || '',
         runtimeAgentId: record.runtimeAgentId || '',
         reviveTerminalState: record.serializedState || null,
@@ -1461,7 +1471,10 @@ class AgentManager extends EventEmitter {
       replacement.attentionUpdatedAt = finiteNumberOrNull(record.attentionUpdatedAt);
       replacement.readAttentionAt = finiteNumberOrNull(record.readAttentionAt);
       replacement.attentionReason = record.attentionReason || '';
+      replacement.attentionOutputEpoch = record.attentionOutputEpoch || '';
       replacement.attentionOutputSeq = finiteNumberOrNull(record.attentionOutputSeq);
+      replacement.readOutputEpoch = record.readOutputEpoch || '';
+      replacement.readOutputSeq = finiteNumberOrNull(record.readOutputSeq);
       replacement.unread = agentAttentionUnread(replacement);
       this.ensurePersistentAgentSession(replacement);
       if (sessionKey) liveProviderSessions.add(sessionKey);
@@ -1737,6 +1750,7 @@ class AgentManager extends EventEmitter {
     if (!agent || !this.configManager || typeof this.configManager.ensureAgentSessionRecord !== 'function') {
       return '';
     }
+    const previousPersistentSessionId = agent.persistentSessionId || '';
     const sessionOptions = agent.providerSessionKey
       ? this.acpSessionOptionsByKey.get(agent.providerSessionKey)
       : null;
@@ -1747,9 +1761,39 @@ class AgentManager extends EventEmitter {
       } : {}),
       ...patch,
     });
-    if (persistentSessionId && !agent.persistentSessionId) {
+    if (persistentSessionId) {
       agent.persistentSessionId = persistentSessionId;
     }
+    if (
+      persistentSessionId
+      && previousPersistentSessionId
+      && persistentSessionId !== previousPersistentSessionId
+      && agent.providerSessionKey
+      && typeof this.configManager.getAgentSessionRecordForProviderSessionKey === 'function'
+    ) {
+      const record = this.configManager.getAgentSessionRecordForProviderSessionKey(agent.providerSessionKey);
+      if (record) {
+        agent.projectWorkspace = record.projectWorkspace || agent.projectWorkspace || '';
+        agent.task = typeof record.task === 'string' ? record.task : (agent.task || '');
+        agent.workflowTemplate = typeof record.workflowTemplate === 'string'
+          ? record.workflowTemplate
+          : (agent.workflowTemplate || '');
+        agent.customTitle = typeof record.customTitle === 'string' ? record.customTitle : '';
+        agent.pinned = record.pinned === true;
+        agent.projectOrder = finiteOrder(record.projectOrder);
+        agent.pinnedOrder = finiteOrder(record.pinnedOrder);
+        agent.attentionSeq = finiteNonNegativeInteger(record.attentionSeq);
+        agent.readAttentionSeq = finiteNonNegativeInteger(record.readAttentionSeq);
+        agent.attentionUpdatedAt = finiteNumberOrNull(record.attentionUpdatedAt);
+        agent.readAttentionAt = finiteNumberOrNull(record.readAttentionAt);
+        agent.attentionReason = record.attentionReason || '';
+        agent.attentionOutputEpoch = record.attentionOutputEpoch || '';
+        agent.attentionOutputSeq = finiteNumberOrNull(record.attentionOutputSeq);
+        agent.readOutputEpoch = record.readOutputEpoch || '';
+        agent.readOutputSeq = finiteNumberOrNull(record.readOutputSeq);
+        agent.unread = agentAttentionUnread(agent);
+      }
+    }
     return persistentSessionId;
   }
 
@@ -2828,19 +2872,19 @@ class AgentManager extends EventEmitter {
       shellLastCommandStartedAt: null,
       shellLastCommandFinishedAt: null,
       shellLastCommandDurationMs: null,
-      pinned: false,
+      pinned: options.pinned === true,
       projectOrder: finiteOrder(options.projectOrder),
       pinnedOrder: finiteOrder(options.pinnedOrder),
-      attentionSeq: 0,
-      readAttentionSeq: 0,
-      attentionUpdatedAt: null,
-      readAttentionAt: null,
-      attentionReason: '',
-      attentionOutputEpoch: '',
-      attentionOutputSeq: null,
-      readOutputEpoch: '',
-      readOutputSeq: null,
-      unread: false,
+      attentionSeq: finiteNonNegativeInteger(options.attentionSeq),
+      readAttentionSeq: finiteNonNegativeInteger(options.readAttentionSeq),
+      attentionUpdatedAt: finiteNumberOrNull(options.attentionUpdatedAt),
+      readAttentionAt: finiteNumberOrNull(options.readAttentionAt),
+      attentionReason: typeof options.attentionReason === 'string' ? options.attentionReason : '',
+      attentionOutputEpoch: typeof options.attentionOutputEpoch === 'string' ? options.attentionOutputEpoch : '',
+      attentionOutputSeq: finiteNumberOrNull(options.attentionOutputSeq),
+      readOutputEpoch: typeof options.readOutputEpoch === 'string' ? options.readOutputEpoch : '',
+      readOutputSeq: finiteNumberOrNull(options.readOutputSeq),
+      unread: finiteNonNegativeInteger(options.attentionSeq) > finiteNonNegativeInteger(options.readAttentionSeq),
       archived: false,
       archivedAt: null,
       canForkNewWorktree: this.canCreateForkWorktree(projectWorkspace || workspace),
@@ -3102,6 +3146,9 @@ class AgentManager extends EventEmitter {
       agentRecord.persistentSessionId = this.ensurePersistentAgentSession(agentRecord, {
         visibleOnMainPage: true,
         archived: false,
+        ...(options.customTitleExplicit === true
+          ? { customTitle: agentRecord.customTitle }
+          : {}),
       });
 
       const agent = this.agents.get(agentId);
@@ -3717,7 +3764,7 @@ class AgentManager extends EventEmitter {
 
     const customTitle = String(title || '').trim().slice(0, 80);
     agent.customTitle = customTitle;
-    this.ensurePersistentAgentSession(agent);
+    this.ensurePersistentAgentSession(agent, { customTitle });
     this.updateEngineProviderSessionMetadata(agent);
     this.emit('update');
     return { agentId, customTitle };
@@ -4379,24 +4426,33 @@ class AgentManager extends EventEmitter {
   }
 
   async rollbackPermanentWorktree(created) {
-    if (!created?.workspace || !created?.sourceWorkspace) return;
+    if (!created?.workspace || !created?.sourceWorkspace) {
+      return { rolledBack: true };
+    }
+    const errors = [];
     try {
       await execFileAsync('git', ['-C', created.sourceWorkspace, 'worktree', 'remove', '--force', created.workspace], {
         timeout: 60000,
         maxBuffer: 1024 * 1024 * 4,
       });
-    } catch {
-      // Rollback is best-effort so the original create/persist failure remains visible.
+    } catch (error) {
+      const message = error && error.stderr ? String(error.stderr).trim() : '';
+      errors.push(message || 'Failed to remove the created worktree');
     }
-    if (!created.branch) return;
-    try {
-      await execFileAsync('git', ['-C', created.sourceWorkspace, 'branch', '-D', created.branch], {
-        timeout: 30000,
-        maxBuffer: 1024 * 1024 * 4,
-      });
-    } catch {
-      // The worktree removal may already have pruned the newly created branch.
+    if (created.branch) {
+      try {
+        await execFileAsync('git', ['-C', created.sourceWorkspace, 'branch', '-D', created.branch], {
+          timeout: 30000,
+          maxBuffer: 1024 * 1024 * 4,
+        });
+      } catch (error) {
+        const message = error && error.stderr ? String(error.stderr).trim() : '';
+        errors.push(message || 'Failed to delete the created worktree branch');
+      }
     }
+    return errors.length > 0
+      ? { rolledBack: false, error: errors.join('; ') }
+      : { rolledBack: true };
   }
 
   async inspectForkWorktreeProject(workspace) {
@@ -4498,13 +4554,6 @@ class AgentManager extends EventEmitter {
     }
 
     const projectAgents = this.agentsForProjectWorkspace(inspected.workspace);
-    const removedMainPageSessionKeys = this.removeMainPageProviderSessionsForAgents(projectAgents);
-    const archivedAgentIds = [];
-    for (const agent of projectAgents) {
-      const result = await this.archiveAgent(agent.id);
-      if (result && !result.error) archivedAgentIds.push(agent.id);
-    }
-
     const args = ['-C', inspected.workspace, 'worktree', 'remove'];
     if (options.force === true) args.push('--force');
     args.push(inspected.workspace);
@@ -4518,18 +4567,31 @@ class AgentManager extends EventEmitter {
       const message = error && error.stderr ? String(error.stderr).trim() : '';
       return {
         ...inspected,
-        archivedAgentIds,
-        removedMainPageSessionKeys,
         error: message || 'Failed to delete git worktree',
       };
     }
 
+    const archivedAgentIds = [];
+    const removedMainPageSessionKeys = [];
+    const cleanupErrors = [];
+    for (const agent of projectAgents) {
+      const result = await this.archiveAgent(agent.id, { requireEngineExit: true });
+      if (result && !result.error) {
+        archivedAgentIds.push(agent.id);
+        removedMainPageSessionKeys.push(...(result.removedMainPageSessionKeys || []));
+      } else {
+        cleanupErrors.push(`${agent.id}: ${result?.error || 'Failed to archive Agent'}`);
+      }
+    }
     return {
       workspace: inspected.workspace,
       deleted: true,
       forced: options.force === true,
       archivedAgentIds,
-      removedMainPageSessionKeys,
+      removedMainPageSessionKeys: Array.from(new Set(removedMainPageSessionKeys)),
+      ...(cleanupErrors.length > 0 ? {
+        cleanupError: cleanupErrors.join('; '),
+      } : {}),
     };
   }
 
@@ -4686,7 +4748,7 @@ class AgentManager extends EventEmitter {
     }
   }
 
-  async archiveAgent(agentId) {
+  async archiveAgent(agentId, options = {}) {
     const agent = this.agents.get(agentId);
     if (!agent) {
       return { error: 'Agent not found' };
@@ -4695,13 +4757,26 @@ class AgentManager extends EventEmitter {
       return { error: 'Main Agent cannot be archived' };
     }
 
+    if (options.requireEngineExit !== true) {
+      const removedMainPageSessionKeys = this.removeMainPageProviderSessionsForAgents([agent]);
+      this.ensurePersistentAgentSession(agent, { visibleOnMainPage: false });
+      await this.killAgent(agentId, {
+        reason: options.reason || 'manual-archive',
+        recordHistory: options.recordHistory !== false && !isEphemeralShellAgent(agent),
+      });
+      if (options.scheduleProviderArchive !== false) this.scheduleCodexSessionArchive(agent);
+      return { agentId, archived: true, removed: true, removedMainPageSessionKeys };
+    }
+
+    const killResult = await this.killAgent(agentId, {
+      reason: options.reason || 'manual-archive',
+      recordHistory: options.recordHistory !== false && !isEphemeralShellAgent(agent),
+      requireEngineExit: true,
+    });
+    if (killResult?.error) return killResult;
     const removedMainPageSessionKeys = this.removeMainPageProviderSessionsForAgents([agent]);
     this.ensurePersistentAgentSession(agent, { visibleOnMainPage: false });
-    await this.killAgent(agentId, {
-      reason: 'manual-archive',
-      recordHistory: !isEphemeralShellAgent(agent),
-    });
-    this.scheduleCodexSessionArchive(agent);
+    if (options.scheduleProviderArchive !== false) this.scheduleCodexSessionArchive(agent);
     return { agentId, archived: true, removed: true, removedMainPageSessionKeys };
   }
 
@@ -4736,15 +4811,42 @@ class AgentManager extends EventEmitter {
   
   async killAgent(agentId, options = {}) {
     const agent = this.agents.get(agentId);
-    if (!agent) return;
+    if (!agent) return { agentId, killed: true, missing: true };
 
+    const engine = this.engineBridge.getEngine(agent.engineName);
+    if (options.requireEngineExit === true && !engine) {
+      return { agentId, error: 'Agent runtime is unavailable; process exit cannot be verified' };
+    }
     try {
-      const engine = this.engineBridge.getEngine(agent.engineName);
       if (engine) {
         await engine.killSession(agentId);
       }
     } catch (error) {
       console.error('Failed to kill agent:', error);
+      if (options.requireEngineExit === true) {
+        return { agentId, error: error.message || 'Failed to stop Agent runtime' };
+      }
+    }
+
+    if (options.requireEngineExit === true && engine) {
+      const deadline = Date.now() + 3000;
+      let lastState = null;
+      while (Date.now() < deadline) {
+        try {
+          lastState = await engine.getSessionState(agentId);
+        } catch (error) {
+          if (isSessionNotAvailableError(error)) {
+            lastState = null;
+            break;
+          }
+          return { agentId, error: error.message || 'Failed to verify Agent process exit' };
+        }
+        if (!isLiveEngineSessionState(lastState)) break;
+        await new Promise(resolve => setTimeout(resolve, 50));
+      }
+      if (isLiveEngineSessionState(lastState)) {
+        return { agentId, error: 'Agent process did not exit within 3 seconds' };
+      }
     }
 
     if (options.recordHistory !== false && !isEphemeralShellAgent(agent)) {
@@ -4771,6 +4873,7 @@ class AgentManager extends EventEmitter {
     if (options.emitUpdate !== false) {
       this.emit('update');
     }
+    return { agentId, killed: true };
   }
 
   async getAgentSessionText(agentId) {

package/backend/bundle-update-helper.js

@@ -0,0 +1,109 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+function writeJsonAtomic(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const temporaryPath = `${filePath}.${process.pid}.tmp`;
+  fs.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temporaryPath, filePath);
+}
+
+function appendLog(logPath, message) {
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  fs.appendFileSync(logPath, `[${new Date().toISOString()}] ${message}\n`);
+}
+
+function validatePayload(payload) {
+  if (!payload || typeof payload !== 'object') throw new Error('Missing bundle update payload');
+  for (const key of ['stateFile', 'logPath', 'releaseDir', 'installer']) {
+    if (!path.isAbsolute(String(payload[key] || ''))) throw new Error(`Invalid bundle update ${key}`);
+  }
+  if (!/^[0-9A-Za-z.+-]+$/.test(String(payload.version || ''))) {
+    throw new Error('Invalid bundle update version');
+  }
+  return payload;
+}
+
+function stateFor(payload, phase, extra = {}) {
+  return {
+    method: payload.method,
+    targetMethod: payload.targetMethod,
+    phase,
+    version: payload.version,
+    previousVersion: payload.previousVersion,
+    startedAt: payload.startedAt,
+    logPath: payload.logPath,
+    ...extra,
+  };
+}
+
+function commandEnvironment() {
+  const env = { ...process.env };
+  delete env.FARMING_BUNDLE_UPDATE_PAYLOAD;
+  delete env.FARMING_RUN_SERVER;
+  delete env.FARMING_RUN_NATIVE_PTY_HOST;
+  return env;
+}
+
+function runInstaller(payload) {
+  return new Promise((resolve, reject) => {
+    const logFd = fs.openSync(payload.logPath, 'a');
+    const child = spawn('bash', [payload.installer, 'install'], {
+      cwd: payload.releaseDir,
+      env: commandEnvironment(),
+      stdio: ['ignore', logFd, logFd],
+    });
+    child.once('error', error => {
+      fs.closeSync(logFd);
+      reject(error);
+    });
+    child.once('exit', (code, signal) => {
+      fs.closeSync(logFd);
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`bundle installer exited with ${signal || code}`));
+    });
+  });
+}
+
+async function runBundleUpdate(rawPayload) {
+  const payload = validatePayload(rawPayload);
+  writeJsonAtomic(payload.stateFile, stateFor(payload, 'installing'));
+  await new Promise(resolve => setTimeout(resolve, 1_000));
+  try {
+    await runInstaller(payload);
+    writeJsonAtomic(payload.stateFile, stateFor(payload, 'succeeded', {
+      completedAt: new Date().toISOString(),
+    }));
+    appendLog(payload.logPath, `Farming updated to ${payload.version}`);
+  } catch (error) {
+    const message = error && error.message ? error.message : String(error);
+    writeJsonAtomic(payload.stateFile, stateFor(payload, 'failed', {
+      error: message,
+      completedAt: new Date().toISOString(),
+    }));
+    appendLog(payload.logPath, `Update failed: ${message}`);
+  }
+}
+
+if (require.main === module) {
+  let payload;
+  try {
+    payload = JSON.parse(process.env.FARMING_BUNDLE_UPDATE_PAYLOAD || '');
+  } catch {
+    console.error('Invalid FARMING_BUNDLE_UPDATE_PAYLOAD');
+    process.exit(1);
+  }
+  runBundleUpdate(payload).catch(error => {
+    console.error(error.message || error);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  runBundleUpdate,
+  validatePayload,
+};

package/backend/config-manager.js

@@ -222,13 +222,14 @@ class ConfigManager {
       if (!expanded) continue;
       const resolved = path.resolve(expanded);
       if (resolved === path.parse(resolved).root || this.isInternalWorkspace(resolved)) continue;
-      let canonical;
+      let canonical = resolved;
       try {
         canonical = fs.realpathSync(resolved);
-        if (!fs.statSync(canonical).isDirectory()) continue;
       } catch {
-        continue;
+        // Project membership is durable. A temporarily unavailable path remains
+        // until the user explicitly removes it.
       }
+      if (this.isInternalWorkspace(canonical)) continue;
       if (seen.has(canonical)) continue;
       seen.add(canonical);
       result.push(canonical);
@@ -752,6 +753,97 @@ class ConfigManager {
     };
   }
 
+  mountProjectWorkspace(workspace) {
+    const expanded = this.expandWorkspacePath(workspace);
+    const resolved = expanded ? path.resolve(expanded) : '';
+    let canonicalWorkspace = '';
+    if (resolved) {
+      try {
+        canonicalWorkspace = fs.realpathSync(resolved);
+        if (!fs.statSync(canonicalWorkspace).isDirectory()) canonicalWorkspace = '';
+      } catch {
+        canonicalWorkspace = '';
+      }
+    }
+    if (
+      !canonicalWorkspace
+      || canonicalWorkspace === path.parse(canonicalWorkspace).root
+      || this.isInternalWorkspace(canonicalWorkspace)
+    ) {
+      throw new Error('Project workspace is invalid or unavailable');
+    }
+    const current = this.settings.projectWorkspaces || [];
+    if (!current.includes(canonicalWorkspace)) {
+      this.commitProjectMembership({
+        projectWorkspaces: [canonicalWorkspace, ...current],
+      });
+    }
+    return {
+      workspace: canonicalWorkspace,
+      projectWorkspaces: [...(this.settings.projectWorkspaces || [])],
+      pinnedProjectWorkspaces: [...(this.settings.pinnedProjectWorkspaces || [])],
+    };
+  }
+
+  removeProjectWorkspace(workspace) {
+    const expanded = this.expandWorkspacePath(workspace);
+    if (!expanded) throw new Error('Project workspace is required');
+    const resolved = path.resolve(expanded);
+    const candidates = new Set([expanded, resolved]);
+    try {
+      candidates.add(fs.realpathSync(resolved));
+    } catch {
+      // A deleted worktree can still be removed by its last canonical path.
+    }
+    const current = this.settings.projectWorkspaces || [];
+    const nextProjects = current.filter(entry => !candidates.has(entry));
+    const currentPinned = this.settings.pinnedProjectWorkspaces || [];
+    const nextPinned = currentPinned.filter(entry => !candidates.has(entry));
+    if (nextProjects.length !== current.length || nextPinned.length !== currentPinned.length) {
+      this.commitProjectMembership({
+        projectWorkspaces: nextProjects,
+        pinnedProjectWorkspaces: nextPinned,
+      });
+    }
+    return {
+      workspace: current.find(entry => candidates.has(entry)) || resolved,
+      projectWorkspaces: [...(this.settings.projectWorkspaces || [])],
+      pinnedProjectWorkspaces: [...(this.settings.pinnedProjectWorkspaces || [])],
+    };
+  }
+
+  setProjectWorkspacePinned(workspace, pinned) {
+    const [canonicalWorkspace] = this.normalizeProjectWorkspaces([workspace]);
+    if (!canonicalWorkspace || !(this.settings.projectWorkspaces || []).includes(canonicalWorkspace)) {
+      throw new Error('Project does not exist');
+    }
+    const current = this.settings.pinnedProjectWorkspaces || [];
+    const nextPinned = pinned
+      ? [...current.filter(entry => entry !== canonicalWorkspace), canonicalWorkspace]
+      : current.filter(entry => entry !== canonicalWorkspace);
+    if (
+      nextPinned.length !== current.length
+      || nextPinned.some((entry, index) => entry !== current[index])
+    ) {
+      this.commitProjectMembership({ pinnedProjectWorkspaces: nextPinned });
+    }
+    return {
+      workspace: canonicalWorkspace,
+      projectWorkspaces: [...(this.settings.projectWorkspaces || [])],
+      pinnedProjectWorkspaces: [...(this.settings.pinnedProjectWorkspaces || [])],
+    };
+  }
+
+  commitProjectMembership(settingsPatch) {
+    const previousSettings = this.settings;
+    try {
+      this.updateSettings(settingsPatch);
+    } catch (error) {
+      this.settings = previousSettings;
+      throw error;
+    }
+  }
+
   getMainPageSessionKeys() {
     return this.sessionStore ? this.sessionStore.getMainPageSessionKeys() : [];
   }
@@ -776,6 +868,10 @@ class ConfigManager {
     return this.sessionStore ? this.sessionStore.ensureRecordForAgent(agent, patch) : '';
   }
 
+  getAgentSessionRecordForProviderSessionKey(sessionKey) {
+    return this.sessionStore ? this.sessionStore.getRecordForProviderSessionKey(sessionKey) : null;
+  }
+
   setProviderSessionDisplayState(sessionKey, patch = {}) {
     return this.sessionStore ? this.sessionStore.setProviderSessionDisplayState(sessionKey, patch) : '';
   }
@@ -794,7 +890,17 @@ class ConfigManager {
 
   writeSettingsFile() {
     fs.mkdirSync(this.farmingDir, { recursive: true });
-    fs.writeFileSync(this.settingsFile, JSON.stringify(this.settings, null, 2));
+    const tempFile = `${this.settingsFile}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      fs.writeFileSync(tempFile, JSON.stringify(this.settings, null, 2));
+      fs.renameSync(tempFile, this.settingsFile);
+    } finally {
+      try {
+        fs.unlinkSync(tempFile);
+      } catch {
+        // A successful rename already removed the temporary path.
+      }
+    }
   }
 
   appendTaskHistory(entry) {

package/backend/farming-session-store.js

@@ -6,6 +6,24 @@ const storageLayout = require('./storage-layout');
 
 const SESSION_ID_PREFIX = 'fsess';
 const MAX_MAIN_PAGE_SESSION_KEYS = 50;
+const PRODUCT_STATE_FIELDS = [
+  'projectWorkspace',
+  'task',
+  'workflowTemplate',
+  'pinned',
+  'projectOrder',
+  'pinnedOrder',
+  'attentionSeq',
+  'readAttentionSeq',
+  'attentionUpdatedAt',
+  'readAttentionAt',
+  'attentionReason',
+  'attentionOutputEpoch',
+  'attentionOutputSeq',
+  'readOutputEpoch',
+  'readOutputSeq',
+  'customTitle',
+];
 
 function now() {
   return Date.now();
@@ -184,10 +202,15 @@ class FarmingSessionStore {
       attentionUpdatedAt: typeof agent.attentionUpdatedAt === 'number' ? agent.attentionUpdatedAt : null,
       readAttentionAt: typeof agent.readAttentionAt === 'number' ? agent.readAttentionAt : null,
       attentionReason: typeof agent.attentionReason === 'string' ? agent.attentionReason : '',
+      attentionOutputEpoch: typeof agent.attentionOutputEpoch === 'string' ? agent.attentionOutputEpoch : '',
       attentionOutputSeq: typeof agent.attentionOutputSeq === 'number' ? agent.attentionOutputSeq : null,
+      readOutputEpoch: typeof agent.readOutputEpoch === 'string' ? agent.readOutputEpoch : '',
+      readOutputSeq: typeof agent.readOutputSeq === 'number' ? agent.readOutputSeq : null,
       archived: agent.archived === true,
       archivedAt: typeof agent.archivedAt === 'number' ? agent.archivedAt : null,
-      customTitle: typeof agent.customTitle === 'string' ? agent.customTitle : '',
+      ...(typeof agent.customTitle === 'string' && agent.customTitle
+        ? { customTitle: agent.customTitle }
+        : {}),
       title: typeof agent.customTitle === 'string' && agent.customTitle
         ? agent.customTitle
         : (typeof agent.providerSessionTitle === 'string' && agent.providerSessionTitle
@@ -222,6 +245,9 @@ class FarmingSessionStore {
       providerSessionTemporary: false,
       updatedAt: now(),
     };
+    if (typeof record.customTitle === 'string' && record.customTitle) {
+      record.title = record.customTitle;
+    }
     index.providerSessionRecords[sessionKey] = id;
     this.writeRecord(record);
     this.writeIndex();
@@ -231,10 +257,38 @@ class FarmingSessionStore {
   ensureRecordForAgent(agent, patch = {}) {
     const providerSessionKey = this.providerSessionKeyForAgent(agent);
     if (providerSessionKey) {
+      const previousId = safeSessionFileName(agent?.persistentSessionId)
+        ? agent.persistentSessionId
+        : '';
+      const previous = previousId ? this.readRecord(previousId) : null;
+      const canonical = this.getRecordForProviderSessionKey(providerSessionKey);
+      const agentPatch = this.recordPatchFromAgent(agent);
+      if (canonical && previousId && canonical.id !== previousId) {
+        PRODUCT_STATE_FIELDS.forEach(field => {
+          if (Object.prototype.hasOwnProperty.call(canonical, field)) {
+            agentPatch[field] = canonical[field];
+          } else if (previous && Object.prototype.hasOwnProperty.call(previous, field)) {
+            agentPatch[field] = previous[field];
+          }
+        });
+      }
       const id = this.ensureRecordForProviderSessionKey(providerSessionKey, {
-        ...this.recordPatchFromAgent(agent),
+        ...agentPatch,
         ...patch,
       }, agent?.persistentSessionId || '');
+      if (previousId && previousId !== id) {
+        if (previous && (previous.providerSessionTemporary === true || !previous.providerSessionKey)) {
+          this.writeRecord({
+            ...previous,
+            runtimeAgentId: '',
+            visibleOnMainPage: false,
+            archived: true,
+            archivedAt: now(),
+            mergedInto: id,
+            updatedAt: now(),
+          });
+        }
+      }
       return id;
     }
 
@@ -345,6 +399,12 @@ class FarmingSessionStore {
     return this.ensureIndex().mainPageSessionKeys.slice();
   }
 
+  getRecordForProviderSessionKey(sessionKey) {
+    const index = this.ensureIndex();
+    const id = index.providerSessionRecords[sessionKey];
+    return safeSessionFileName(id) ? this.readRecord(id) : null;
+  }
+
   listAgentRecords() {
     this.ensureIndex();
     let names = [];