feat(extended-memory): config, loop, tool, and CLI wiring

Author: jkyberneees

cmd/odek/main.go

@@ -272,6 +272,12 @@ type runFlags struct {
 	SandboxUser     string // Container user (e.g. "1000:1000")
 	SandboxReadonly *bool  // nil = not set; true = read-only mount
 
+	// Extended memory subsystem CLI overrides.
+	MemoryExtendedEnabled         *bool // nil = not set
+	MemoryExtendedMaxSizeMB       int   // 0 = not set
+	MemoryExtendedAtomMaxChars    int   // 0 = not set
+	MemoryExtendedMemoryBudgetChars int // 0 = not set
+
 	Deliver *bool // nil = not set; true = deliver result to default channel
 }
 
@@ -403,6 +409,27 @@ func parseRunFlags(args []string) (runFlags, error) {
 			}
 			f.Ctx = strings.Split(args[i+1], ",")
 			i += 2
+		case "--memory-extended-enabled":
+			f.MemoryExtendedEnabled = boolPtr(true)
+			i++
+		case "--memory-extended-max-size-mb":
+			if i+1 >= len(args) {
+				return f, fmt.Errorf("--memory-extended-max-size-mb requires a value")
+			}
+			fmt.Sscanf(args[i+1], "%d", &f.MemoryExtendedMaxSizeMB)
+			i += 2
+		case "--memory-extended-atom-max-chars":
+			if i+1 >= len(args) {
+				return f, fmt.Errorf("--memory-extended-atom-max-chars requires a value")
+			}
+			fmt.Sscanf(args[i+1], "%d", &f.MemoryExtendedAtomMaxChars)
+			i += 2
+		case "--memory-extended-memory-budget-chars":
+			if i+1 >= len(args) {
+				return f, fmt.Errorf("--memory-extended-memory-budget-chars requires a value")
+			}
+			fmt.Sscanf(args[i+1], "%d", &f.MemoryExtendedMemoryBudgetChars)
+			i += 2
 		case "--deliver":
 			f.Deliver = boolPtr(true)
 			i++
@@ -454,6 +481,10 @@ done:
 			f.SandboxReadonly = boolPtr(true)
 			taskArgs = append(taskArgs[:j], taskArgs[j+1:]...)
 			j--
+		case "--memory-extended-enabled":
+			f.MemoryExtendedEnabled = boolPtr(true)
+			taskArgs = append(taskArgs[:j], taskArgs[j+1:]...)
+			j--
 		}
 	}
 	f.Task = strings.Join(taskArgs, " ")
@@ -646,6 +677,12 @@ Sandbox flags:
   --sandbox-cpus <n>   CPU limit (e.g. 0.5, 2, 4)
   --sandbox-user <s>   Run as user (uid:gid or name)
 
+Extended memory flags:
+  --memory-extended-enabled                 Enable Extended Memory (opt-in)
+  --memory-extended-max-size-mb <n>         Max on-disk size in MiB (default: 100)
+  --memory-extended-atom-max-chars <n>      Max chars per atom (default: 300)
+  --memory-extended-memory-budget-chars <n> Max chars injected into prompt (default: 2000)
+
 Config sources (lowest to highest priority):
   ~/.odek/config.json   Global defaults (shared across projects)
   ./odek.json          Project-level overrides
@@ -669,7 +706,11 @@ Environment variables:
   ODEK_SANDBOX_READONLY true/false — mount read-only
   ODEK_SANDBOX_MEMORY  Memory limit (e.g. 512m, 2g)
   ODEK_SANDBOX_CPUS    CPU limit (e.g. 0.5, 2)
-  ODEK_SANDBOX_USER    Container user (uid:gid or name)`)
+  ODEK_SANDBOX_USER    Container user (uid:gid or name)
+  ODEK_MEMORY_EXTENDED_ENABLED                 true/false — enable Extended Memory
+  ODEK_MEMORY_EXTENDED_MAX_SIZE_MB             Max on-disk size in MiB
+  ODEK_MEMORY_EXTENDED_ATOM_MAX_CHARS          Max chars per atom
+  ODEK_MEMORY_EXTENDED_MEMORY_BUDGET_CHARS     Max chars injected into prompt`)
 }
 
 // ── Init ──────────────────────────────────────────────────────────────
@@ -867,6 +908,11 @@ func run(args []string) error {
 		SandboxMemory:   f.SandboxMemory,
 		SandboxCPUs:     f.SandboxCPUs,
 		SandboxUser:     f.SandboxUser,
+
+		MemoryExtendedEnabled:         f.MemoryExtendedEnabled,
+		MemoryExtendedMaxSizeMB:       f.MemoryExtendedMaxSizeMB,
+		MemoryExtendedAtomMaxChars:    f.MemoryExtendedAtomMaxChars,
+		MemoryExtendedMemoryBudgetChars: f.MemoryExtendedMemoryBudgetChars,
 	})
 
 	// Resolve @references and --ctx file attachments in the task
@@ -1048,6 +1094,11 @@ func run(args []string) error {
 			}
 			store.Save(sess)
 			fmt.Fprintf(os.Stderr, "odek: session %s saved — continue with: odek continue \"...\"\n", sess.ID)
+			// Tag any atoms extracted during this run with the session ID so
+			// future review can trace their origin.
+			if mm := agent.Memory(); mm != nil {
+				mm.SetSessionContext(sess.ID, "")
+			}
 		}
 	} else {
 		// Single-shot mode (default)
@@ -1932,6 +1983,12 @@ func continueCmd(args []string) error {
 		mm.RestoreBuffer(sess.Buffer)
 	}
 
+	// Propagate session context to Extended Memory so extracted atoms are
+	// tagged with the session they came from.
+	if mm := agent.Memory(); mm != nil {
+		mm.SetSessionContext(sess.ID, "")
+	}
+
 	// Build message history: session messages + new user message
 	// The system message is already in the session
 	messages := sess.GetMessages()

cmd/odek/memory_cmd.go

@@ -3,12 +3,14 @@ package main
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 	"strings"
 
 	"github.com/BackendStack21/odek/internal/memory"
+	"github.com/BackendStack21/odek/internal/memory/extended"
 )
 
-// memoryCmd handles `odek memory <list|promote> [args]`.
+// memoryCmd handles `odek memory <list|promote|extended> [args]`.
 //
 // This is the human-gated surface for the episode-memory trust control.
 // Episodes whose originating session touched external content (web/http/MCP/
@@ -18,7 +20,7 @@ import (
 // approve its own poisoned memory.
 func memoryCmd(args []string) error {
 	if len(args) == 0 {
-		fmt.Fprintf(os.Stderr, "Usage: odek memory <list|promote> [args]\n")
+		fmt.Fprintf(os.Stderr, "Usage: odek memory <list|promote|extended> [args]\n")
 		return nil
 	}
 
@@ -60,7 +62,61 @@ func memoryCmd(args []string) error {
 		fmt.Printf("odek: promoted episode %q — it can now be recalled into future sessions\n", id)
 		return nil
 
+	case "extended":
+		return extendedMemoryCmd(dir, subArgs)
+
+	default:
+		return fmt.Errorf("unknown memory subcommand %q (expected: list, promote, extended)", sub)
+	}
+}
+
+// extendedMemoryCmd handles `odek memory extended forget|quarantine|compact`.
+func extendedMemoryCmd(dir string, args []string) error {
+	if len(args) == 0 {
+		fmt.Fprintf(os.Stderr, "Usage: odek memory extended <forget|quarantine|compact> [args]\n")
+		return nil
+	}
+
+	sub := args[0]
+	subArgs := args[1:]
+
+	extDir := filepath.Join(dir, "extended")
+	cfg := extended.DefaultConfig()
+	em := extended.New(extDir, nil, cfg)
+
+	switch sub {
+	case "forget":
+		if len(subArgs) == 0 {
+			return fmt.Errorf("usage: odek memory extended forget <atom_id>")
+		}
+		id := subArgs[0]
+		if err := em.ForgetAtom(id); err != nil {
+			return err
+		}
+		fmt.Printf("odek: forgot atom %q\n", id)
+		return nil
+
+	case "quarantine":
+		atoms, err := em.ListQuarantine()
+		if err != nil {
+			return err
+		}
+		if len(atoms) == 0 {
+			fmt.Println("No atoms in quarantine.")
+			return nil
+		}
+		fmt.Printf("%d atom(s) in quarantine (excluded from recall):\n\n", len(atoms))
+		for _, a := range atoms {
+			fmt.Printf("• %s [%s] %s\n", a.ID, a.SourceClass, truncate(a.Text, 120))
+		}
+		return nil
+
+	case "compact":
+		em.Compact()
+		fmt.Println("odek: Extended Memory vector index compaction triggered in the background")
+		return nil
+
 	default:
-		return fmt.Errorf("unknown memory subcommand %q (expected: list, promote)", sub)
+		return fmt.Errorf("unknown extended memory subcommand %q (expected: forget, quarantine, compact)", sub)
 	}
 }

internal/config/loader.go

@@ -27,6 +27,7 @@ import (
 	"github.com/BackendStack21/odek/internal/embedding"
 	"github.com/BackendStack21/odek/internal/mcpclient"
 	"github.com/BackendStack21/odek/internal/memory"
+	"github.com/BackendStack21/odek/internal/memory/extended"
 	"github.com/BackendStack21/odek/internal/redact"
 	"github.com/BackendStack21/odek/internal/skills"
 	"github.com/BackendStack21/odek/internal/telegram"
@@ -83,6 +84,12 @@ type CLIFlags struct {
 	// "verbose" = raw tool names, args, and results.
 	// "off" = no intermediate progress output, clean answer only.
 	InteractionMode string
+
+	// Extended memory subsystem CLI overrides.
+	MemoryExtendedEnabled         *bool // nil = not set
+	MemoryExtendedMaxSizeMB       int   // 0 = not set
+	MemoryExtendedAtomMaxChars    int   // 0 = not set
+	MemoryExtendedMemoryBudgetChars int // 0 = not set
 }
 
 // SkillsConfig holds the skills configuration section from JSON files.
@@ -627,6 +634,14 @@ func envStringList(key string) []string {
 	return out
 }
 
+// ensureExtended returns a non-nil *extended.Config, allocating one if needed.
+func ensureExtended(cfg *extended.Config) *extended.Config {
+	if cfg == nil {
+		return &extended.Config{}
+	}
+	return cfg
+}
+
 // envScheduleDangerousConfig parses ODEK_SCHEDULES_DANGEROUS_* env vars into a
 // DangerousConfig. Returns nil if none are set.
 func envScheduleDangerousConfig(prefix string) *danger.DangerousConfig {
@@ -872,6 +887,36 @@ func LoadConfig(cli CLIFlags) ResolvedConfig {
 		cfg.InteractionMode = v
 	}
 
+	// Extended memory env overrides
+	if v := envBool("MEMORY_EXTENDED_ENABLED"); v != nil {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.Enabled = v
+	}
+	if v := envInt("MEMORY_EXTENDED_MAX_SIZE_MB"); v > 0 {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.MaxSizeMB = v
+	}
+	if v := envInt("MEMORY_EXTENDED_ATOM_MAX_CHARS"); v > 0 {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.AtomMaxChars = v
+	}
+	if v := envInt("MEMORY_EXTENDED_MEMORY_BUDGET_CHARS"); v > 0 {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.MemoryBudgetChars = v
+	}
+
 	// Schedules env overrides (ODEK_SCHEDULES_*): lets the scheduler be tuned
 	// from the environment, like everything else in a containerised deploy.
 	// Allocate once — an all-zero SchedulesConfig resolves identically to nil.
@@ -983,6 +1028,34 @@ func LoadConfig(cli CLIFlags) ResolvedConfig {
 	if cli.InteractionMode != "" {
 		cfg.InteractionMode = cli.InteractionMode
 	}
+	if cli.MemoryExtendedEnabled != nil {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.Enabled = cli.MemoryExtendedEnabled
+	}
+	if cli.MemoryExtendedMaxSizeMB > 0 {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.MaxSizeMB = cli.MemoryExtendedMaxSizeMB
+	}
+	if cli.MemoryExtendedAtomMaxChars > 0 {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.AtomMaxChars = cli.MemoryExtendedAtomMaxChars
+	}
+	if cli.MemoryExtendedMemoryBudgetChars > 0 {
+		if cfg.Memory == nil {
+			cfg.Memory = &memory.MemoryConfig{}
+		}
+		cfg.Memory.Extended = ensureExtended(cfg.Memory.Extended)
+		cfg.Memory.Extended.MemoryBudgetChars = cli.MemoryExtendedMemoryBudgetChars
+	}
 	if len(cli.ToolsEnabled) > 0 {
 		if cfg.Tools == nil {
 			cfg.Tools = &ToolsConfig{}
@@ -1292,6 +1365,10 @@ func resolveMemory(cfg *memory.MemoryConfig) memory.MemoryConfig {
 	if cfg.Embedding != nil {
 		def.Embedding = cfg.Embedding
 	}
+	if cfg.Extended != nil {
+		resolved := extended.Resolve(*cfg.Extended)
+		def.Extended = &resolved
+	}
 	return def
 }
 

internal/config/loader_test.go

@@ -1414,3 +1414,74 @@ func TestLoadConfig_SecretsEnvPermissionCheck(t *testing.T) {
 		t.Errorf("owner-only secrets.env not loaded, got %q", os.Getenv("ODEK_TEST_SECRET"))
 	}
 }
+
+func TestLoadConfig_ExtendedMemoryEnv(t *testing.T) {
+	t.Setenv("HOME", t.TempDir())
+	t.Setenv("ODEK_MEMORY_EXTENDED_ENABLED", "true")
+	t.Setenv("ODEK_MEMORY_EXTENDED_MAX_SIZE_MB", "200")
+	t.Setenv("ODEK_MEMORY_EXTENDED_ATOM_MAX_CHARS", "500")
+	t.Setenv("ODEK_MEMORY_EXTENDED_MEMORY_BUDGET_CHARS", "4000")
+	cfg := LoadConfig(CLIFlags{})
+	if cfg.Memory.Extended == nil {
+		t.Fatal("Extended memory config not loaded from env")
+	}
+	if cfg.Memory.Extended.Enabled == nil || !*cfg.Memory.Extended.Enabled {
+		t.Error("Extended memory should be enabled")
+	}
+	if cfg.Memory.Extended.MaxSizeMB != 200 {
+		t.Errorf("MaxSizeMB = %d, want 200", cfg.Memory.Extended.MaxSizeMB)
+	}
+	if cfg.Memory.Extended.AtomMaxChars != 500 {
+		t.Errorf("AtomMaxChars = %d, want 500", cfg.Memory.Extended.AtomMaxChars)
+	}
+	if cfg.Memory.Extended.MemoryBudgetChars != 4000 {
+		t.Errorf("MemoryBudgetChars = %d, want 4000", cfg.Memory.Extended.MemoryBudgetChars)
+	}
+}
+
+func TestLoadConfig_ExtendedMemoryCLIOverridesEnv(t *testing.T) {
+	t.Setenv("HOME", t.TempDir())
+	t.Setenv("ODEK_MEMORY_EXTENDED_MAX_SIZE_MB", "200")
+	cfg := LoadConfig(CLIFlags{
+		MemoryExtendedEnabled:         boolPtr(true),
+		MemoryExtendedMaxSizeMB:       300,
+		MemoryExtendedAtomMaxChars:    600,
+		MemoryExtendedMemoryBudgetChars: 5000,
+	})
+	if cfg.Memory.Extended == nil {
+		t.Fatal("Extended memory config not resolved")
+	}
+	if !*cfg.Memory.Extended.Enabled {
+		t.Error("Extended memory should be enabled")
+	}
+	if cfg.Memory.Extended.MaxSizeMB != 300 {
+		t.Errorf("MaxSizeMB = %d, want 300", cfg.Memory.Extended.MaxSizeMB)
+	}
+	if cfg.Memory.Extended.AtomMaxChars != 600 {
+		t.Errorf("AtomMaxChars = %d, want 600", cfg.Memory.Extended.AtomMaxChars)
+	}
+	if cfg.Memory.Extended.MemoryBudgetChars != 5000 {
+		t.Errorf("MemoryBudgetChars = %d, want 5000", cfg.Memory.Extended.MemoryBudgetChars)
+	}
+}
+
+func TestLoadConfig_ProjectMemoryRejected(t *testing.T) {
+	wd := t.TempDir()
+	t.Setenv("HOME", t.TempDir())
+	t.Setenv("ODEK_MEMORY_EXTENDED_ENABLED", "true")
+	if err := os.WriteFile(filepath.Join(wd, "odek.json"), []byte(`{"memory":{"extended":{"enabled":false,"max_size_mb":50}}}`), 0600); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("PWD", wd)
+	origGetwd, _ := os.Getwd()
+	os.Chdir(wd)
+	defer os.Chdir(origGetwd)
+	cfg := LoadConfig(CLIFlags{})
+	// Project memory should be rejected, so env-true wins.
+	if cfg.Memory.Extended == nil || cfg.Memory.Extended.Enabled == nil || !*cfg.Memory.Extended.Enabled {
+		t.Error("project memory should be rejected; env enabled should win")
+	}
+	if cfg.Memory.Extended.MaxSizeMB != 100 {
+		t.Errorf("MaxSizeMB = %d, want default 100 (project rejected)", cfg.Memory.Extended.MaxSizeMB)
+	}
+}