Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions changelog.d/added-cli-memory-drain.md
Original file line number Diff line number Diff line change
@@ -0,0 +1 @@
- `agents.cli_memory.drain_to_knowledge` (default off) converts each agent's CLI memory (Claude `MEMORY.md` + topic files, Codex `memories*`, Gemini `GEMINI.md`) into `state: draft` knowledge entries in the bead-synth vault before every kick and before `clear_on_kick` wipes the store — tagged `cli-memory`, `agent:<name>`, `cli:<name>`, `repo:` when derivable, deduplicated by content hash, never auto-approved; one `cli-memory: drained N facts …` log line per drain. Proposed by @gregoryhunt (#17033).
87 changes: 87 additions & 0 deletions src/cmd/hive/boot_cli_memory_drain.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,87 @@
package main

import (
"errors"
"fmt"
"os"

"github.com/hivecommons/hive/crux"
"github.com/hivecommons/hive/pkg/knowledge"
"github.com/hivecommons/hive/pkg/knowledge/climemory"
)

// beadSynthVaultName is the store name the bead-synth vault is connected
// and registered under; CLI-memory drafts land in the same store.
const beadSynthVaultName = "bead-synth-wiki"

// cliMemoryDrainEnabled reports whether any enabled agent drains its CLI
// memory into the knowledge store (agents.cli_memory.drain_to_knowledge,
// fleet-wide or per agent).
func (b *boot) cliMemoryDrainEnabled() bool {
if b.cfg == nil {
return false
}
if b.cfg.AgentsCLIMemory.DrainToKnowledge {
return true
}
for _, ac := range b.cfg.EnabledAgents() {
if ac.CLIMemory.DrainMemoryToKnowledge() {
return true
}
}
return false
}

// installCLIMemoryDrainer connects the bead-synth vault when no bead store
// did and installs the drain hook on the in-process runtime
// (hivecommons/hive#17033). Drained facts are written as `state: draft`
// entries into that vault, so the Primer (approved-only by default) never
// primes them until an operator approves each one. It runs before
// registerKnowledgeStores so the vault is primed like any other store.
func (b *boot) installCLIMemoryDrainer() {
if !b.cliMemoryDrainEnabled() {
return
}
host, ok := b.agentMgr.(crux.CLIMemoryDrainHost)
if !ok {
b.logger.Warn("agents.cli_memory.drain_to_knowledge needs the in-process crux runtime; the sidecar runtime cannot drain CLI memory yet",
"runtime", fmt.Sprintf("%T", b.agentMgr))
return
}
if b.knowledgeAPI == nil {
b.logger.Warn("agents.cli_memory.drain_to_knowledge is set but the knowledge API is unavailable; CLI memory will not be drained")
return
}
vaultPath := b.beadSynthVaultPath()
if err := os.MkdirAll(vaultPath, 0o755); err != nil {
b.logger.Warn("failed to create vault for CLI memory drain", "path", vaultPath, "error", err)
return
}
if b.knowledgeAPI.GetVaultStore(vaultPath) == nil {
if err := b.knowledgeAPI.ConnectVault(vaultPath, beadSynthVaultName); err != nil {
b.logger.Warn("failed to connect vault for CLI memory drain", "path", vaultPath, "error", err)
return
}
}
layer := knowledge.LayerType(b.cfg.Knowledge.BeadSynthesizer.TargetLayer)
if layer == "" {
layer = knowledge.LayerPersonal
}
drainer := &climemory.Drainer{Dir: vaultPath, Store: b.knowledgeAPI.GetVaultStore(vaultPath), Layer: layer}
cfg := b.cfg
host.SetCLIMemoryDrainer(func(req crux.CLIMemoryDrainRequest) crux.CLIMemoryDrainResult {
sources := make([]climemory.Source, 0, len(req.Sources))
for _, s := range req.Sources {
sources = append(sources, climemory.Source{CLI: s.CLI, Path: s.Path})
}
res := drainer.Drain(climemory.Request{Agent: req.Agent, Repos: cfg.ReposForAgent(req.Agent), Sources: sources})
return crux.CLIMemoryDrainResult{
Store: beadSynthVaultName,
Drained: res.Drained,
Dupes: res.Dupes,
Skipped: res.Skipped,
Err: errors.Join(res.Errors...),
}
})
b.logger.Info("CLI memory drain installed", "store", beadSynthVaultName, "path", vaultPath, "layer", layer)
}
171 changes: 171 additions & 0 deletions src/cmd/hive/boot_cli_memory_drain_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,171 @@
package main

import (
"log/slog"
"os"
"path/filepath"
"strings"
"testing"

"github.com/hivecommons/hive/crux"
"github.com/hivecommons/hive/pkg/config"
"github.com/hivecommons/hive/pkg/knowledge/climemory"
)

// drainCapturingRuntime is a hosted runtime that records the drainer the
// boot installs so the test can invoke it the way the manager does on a kick.
type drainCapturingRuntime struct {
hostedRuntime
fn crux.CLIMemoryDrainer
}

func (r *drainCapturingRuntime) SetCLIMemoryDrainer(fn crux.CLIMemoryDrainer) { r.fn = fn }

// sidecarLikeRuntime deliberately lacks SetCLIMemoryDrainer.
type sidecarLikeRuntime struct{ hostedRuntime }

func TestCLIMemoryDrainEnabled(t *testing.T) {
b := &boot{}
if b.cliMemoryDrainEnabled() {
t.Fatal("nil config must not enable the drain")
}
cfg := bootKnowledgeConfig(t)
b.cfg = cfg
if b.cliMemoryDrainEnabled() {
t.Fatal("default config must not enable the drain")
}
ac := cfg.Agents["scanner"]
ac.CLIMemory = &config.CLIMemoryConfig{DrainToKnowledge: true}
cfg.Agents["scanner"] = ac
if !b.cliMemoryDrainEnabled() {
t.Fatal("a per-agent drain_to_knowledge must enable the drain")
}
cfg.Agents["scanner"] = config.AgentConfig{Enabled: false, Backend: "copilot", CLIMemory: &config.CLIMemoryConfig{DrainToKnowledge: true}}
if b.cliMemoryDrainEnabled() {
t.Fatal("a disabled agent must not enable the drain")
}
cfg.AgentsCLIMemory.DrainToKnowledge = true
if !b.cliMemoryDrainEnabled() {
t.Fatal("the fleet-wide flag must enable the drain")
}
}

func TestInstallCLIMemoryDrainerWritesDraftsIntoBeadSynthVault(t *testing.T) {
cfg := bootKnowledgeConfig(t)
cfg.AgentsCLIMemory.DrainToKnowledge = true
cfg.Knowledge.BeadSynthesizer.TargetLayer = "team"
b := newBootKnowledgeBoot(t, cfg)
var log strings.Builder
b.logger = slog.New(slog.NewTextHandler(&log, nil))
rt := &drainCapturingRuntime{hostedRuntime: b.agentMgr}
b.agentMgr = rt
b.bootKnowledgeWith(newBootKnowledgeFake(t).deps)
if b.knowledgeAPI == nil {
t.Fatal("knowledge API must be auto-enabled")
}

b.installCLIMemoryDrainer()

vaultPath := b.beadSynthVaultPath()
if b.knowledgeAPI.GetVaultStore(vaultPath) == nil {
t.Fatal("the bead-synth vault must be connected even with no bead stores")
}
if rt.fn == nil {
t.Fatalf("drainer must be installed on the in-process runtime; log:\n%s", log.String())
}
if !strings.Contains(log.String(), "CLI memory drain installed") || !strings.Contains(log.String(), "layer=team") {
t.Fatalf("log:\n%s", log.String())
}

memDir := filepath.Join(t.TempDir(), ".claude", "projects", "-data-agents-scanner-acme-widgets", "memory")
if err := os.MkdirAll(memDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(memDir, "MEMORY.md"), []byte("- The widgets build needs CGO_ENABLED=1 on CI runners\n"), 0o644); err != nil {
t.Fatal(err)
}
res := rt.fn(crux.CLIMemoryDrainRequest{Agent: "scanner", Backend: "claude", Sources: []crux.CLIMemorySource{{CLI: climemory.CLIClaude, Path: memDir}}})
if res.Err != nil || res.Store != beadSynthVaultName || res.Drained != 1 {
t.Fatalf("drain result = %+v", res)
}
entries, err := filepath.Glob(filepath.Join(vaultPath, "cli-memory-*.md"))
if err != nil || len(entries) != 1 {
t.Fatalf("vault entries = %v, err=%v", entries, err)
}
data, err := os.ReadFile(entries[0])
if err != nil {
t.Fatal(err)
}
for _, want := range []string{"state: draft", "repo: acme/widgets", "agent: scanner"} {
if !strings.Contains(string(data), want) {
t.Fatalf("entry missing %q:\n%s", want, data)
}
}
if again := rt.fn(crux.CLIMemoryDrainRequest{Agent: "scanner", Backend: "claude", Sources: []crux.CLIMemorySource{{CLI: climemory.CLIClaude, Path: memDir}}}); again.Drained != 0 || again.Dupes != 1 {
t.Fatalf("second drain = %+v, want dedupe", again)
}

// Calling again keeps the already-connected vault and reinstalls.
rt.fn = nil
b.installCLIMemoryDrainer()
if rt.fn == nil {
t.Fatal("reinstall must set the drainer again")
}
}

func TestInstallCLIMemoryDrainerStandsDown(t *testing.T) {
t.Run("disabled", func(t *testing.T) {
cfg := bootKnowledgeConfig(t)
b := newBootKnowledgeBoot(t, cfg)
rt := &drainCapturingRuntime{hostedRuntime: b.agentMgr}
b.agentMgr = rt
b.installCLIMemoryDrainer()
if rt.fn != nil {
t.Fatal("drain off must not install a drainer")
}
})
t.Run("sidecar runtime warns", func(t *testing.T) {
cfg := bootKnowledgeConfig(t)
cfg.AgentsCLIMemory.DrainToKnowledge = true
b := newBootKnowledgeBoot(t, cfg)
var log strings.Builder
b.logger = slog.New(slog.NewTextHandler(&log, nil))
b.agentMgr = &sidecarLikeRuntime{hostedRuntime: b.agentMgr}
b.installCLIMemoryDrainer()
if !strings.Contains(log.String(), "sidecar runtime cannot drain") {
t.Fatalf("log:\n%s", log.String())
}
})
t.Run("no knowledge API warns", func(t *testing.T) {
cfg := bootKnowledgeConfig(t)
cfg.AgentsCLIMemory.DrainToKnowledge = true
b := newBootKnowledgeBoot(t, cfg)
var log strings.Builder
b.logger = slog.New(slog.NewTextHandler(&log, nil))
rt := &drainCapturingRuntime{hostedRuntime: b.agentMgr}
b.agentMgr = rt
b.installCLIMemoryDrainer()
if rt.fn != nil || !strings.Contains(log.String(), "knowledge API is unavailable") {
t.Fatalf("installed=%v log:\n%s", rt.fn != nil, log.String())
}
})
t.Run("vault path blocked by a file warns", func(t *testing.T) {
cfg := bootKnowledgeConfig(t)
cfg.AgentsCLIMemory.DrainToKnowledge = true
blocker := filepath.Join(t.TempDir(), "file")
if err := os.WriteFile(blocker, []byte("x"), 0o644); err != nil {
t.Fatal(err)
}
cfg.Knowledge.BeadSynthesizer.VaultPath = filepath.Join(blocker, "vault")
b := newBootKnowledgeBoot(t, cfg)
var log strings.Builder
b.logger = slog.New(slog.NewTextHandler(&log, nil))
rt := &drainCapturingRuntime{hostedRuntime: b.agentMgr}
b.agentMgr = rt
b.bootKnowledgeWith(newBootKnowledgeFake(t).deps)
b.installCLIMemoryDrainer()
if rt.fn != nil || !strings.Contains(log.String(), "failed to create vault for CLI memory drain") {
t.Fatalf("installed=%v log:\n%s", rt.fn != nil, log.String())
}
})
}
7 changes: 5 additions & 2 deletions src/cmd/hive/boot_knowledge_primer.go
Original file line number Diff line number Diff line change
Expand Up @@ -39,13 +39,16 @@ func (b *boot) registerKnowledgeStores(p *knowledge.Primer) {
p.AddFileStore(gsc.Name, store, knowledge.LayerType(gsc.Layer))
}
}
if len(b.beadStores) > 0 {
// The bead-synth vault also receives CLI-memory drafts (#17033), so it is
// primed whenever either writer is on; the Primer's approved-only default
// keeps the drafts out of kicks.
if len(b.beadStores) > 0 || b.cliMemoryDrainEnabled() {
if store := api.GetVaultStore(b.beadSynthVaultPath()); store != nil {
layer := knowledge.LayerType(b.cfg.Knowledge.BeadSynthesizer.TargetLayer)
if layer == "" {
layer = knowledge.LayerPersonal
}
p.AddFileStore("bead-synth-wiki", store, layer)
p.AddFileStore(beadSynthVaultName, store, layer)
b.logger.Info("bead-synth vault registered with primer", "layer", layer)
}
}
Expand Down
7 changes: 6 additions & 1 deletion src/cmd/hive/main.go
Original file line number Diff line number Diff line change
Expand Up @@ -3081,7 +3081,7 @@ func (b *boot) bootKnowledgeWith(deps bootKnowledgeDeps) {
b.logger.Warn("failed to create bead-synth vault dir", "path", synthVaultPath, "error", err)
}
if b.knowledgeAPI != nil {
if connErr := b.knowledgeAPI.ConnectVault(synthVaultPath, "bead-synth-wiki"); connErr != nil {
if connErr := b.knowledgeAPI.ConnectVault(synthVaultPath, beadSynthVaultName); connErr != nil {
b.logger.Warn("failed to auto-connect bead-synth vault", "path", synthVaultPath, "error", connErr)
} else {
b.logger.Info("auto-connected bead-synth vault", "path", synthVaultPath)
Expand Down Expand Up @@ -3138,6 +3138,11 @@ func (b *boot) bootKnowledgeWith(deps bootKnowledgeDeps) {
}
}

// CLI memory drain (hivecommons/hive#17033); opt-in, makes sure the
// bead-synth vault it writes drafts into is connected before the primer
// registers stores below.
b.installCLIMemoryDrainer()

// Generated repository code maps (#11106); opt-in, connects its vault
// before stores are registered with the primer below.
b.startCodeMaps()
Expand Down
Loading
Loading