Method Store

pkg/cache/cache.go:135–164

Store records the response for the given question, replacing any existing entry with the same normalized key. Storing the same (question, response) pair twice is a no-op and skips the file rewrite — useful when an agent's stop hook re-fires with the same content (e.g. a cache-replay turn). When the

(question, response string)

// processes simultaneously storing different keys both see their
// writes preserved on disk; in-process callers serialize via c.mu.
func (c *Cache) Store(question, response string) {
	key := c.normalize(question)

	c.mu.Lock()
	defer c.mu.Unlock()

	// Cheap in-memory dedup: skip the cross-process lock and disk
	// write when our local view already matches. After a recent
	// Lookup our view is fresh, so this catches the common
	// "store the answer we just replayed" path of cache_response.
	if existing, ok := c.entries[key]; ok && existing == response {
		return
	}

	if c.path != "" {
		if err := c.persistToDisk(key, response); err != nil {
			// Persistence failures are not fatal: keep the entry
			// in memory and let the next Store retry the file
			// write.
			slog.Warn("cache persist failed; keeping entry in memory only",
				"path", c.path, "error", err)
		}
	}

	// Update in-memory map after persist (not before) so that if persist
	// fails, we still have the entry in memory for this process. The next
	// Lookup will reload from disk if another process wrote successfully.

	c.entries[key] = response
}

// persistToDisk takes the cross-process lock on c.path's sibling .lock
// file, reloads the on-disk entries, merges (key, response), writes