v0.8.4: coverage push — 30+ tests, sandbox arg extraction, REPL skills

Tests (30+ new, 4 test files + 5 expansions):
- llm: SimpleCall success, error, empty response (3 tests)
- loop: RunWithMessages, lastUserMessage edge (3 tests)
- danger: git/rsync/chmod classification, allowlist/denylist, parseAction,
  nonInteractive, actionFor unknown, tokenize backslash, fork bomb variants,
  system redirect targets (20+ tests)
- skills: RunAllHeuristics, DefaultSkillsConfig, UserSkillsDir,
  ProjectSkillsDir, ActiveQualities, MicroCuration, FormatCurationReport
  all sections, fetchHTTP success/error/oversize, tool Name/Desc/Schema,
  GetResult, GetTrieIndex, RecordUsage concurrent, skill list filter,
  save oversize body (15+ tests)
- session: List limit, GetMessages nil/empty (3 tests)
- kode: expandHome, RunWithMessages, Close no-cleanup/with-cleanup,
  LoadProjectFile not found (5 tests)

Fixes / improvements:
- continueCmd: added missing Env/Volumes to sandboxConfig
- replCmd: added skills/learn support (SkillManager + Skills config)
- Extracted buildSandboxArgs from setupSandbox (testable without Docker)
- Fixed error message referencing removed "save" subcommand

Coverage:
- Skills: 78.6% → 86.1%
- LLM: 55.4% → 87.7%
- Danger: 87.5% → 91.9%
- Loop: 90.3% → 92.0%
- Session: 80.4% → 82.4%
- Kode: 67.0% → 73.9%
- Overall: 66.1% → 70.4%

Author: jkyberneees

cmd/kode/main.go

@@ -726,7 +726,27 @@ func setupSandbox(tools []kode.Tool, cfg sandboxConfig) (func() error, error) {
 		return nil, fmt.Errorf("getwd: %w", err)
 	}
 
-	// Build docker run args
+	args := buildSandboxArgs(cfg, containerName, wd, image)
+
+	createCmd := exec.Command("docker", args...)
+	createCmd.Stderr = os.Stderr
+	if err := createCmd.Run(); err != nil {
+		return nil, fmt.Errorf("failed to create container: %w", err)
+	}
+
+	cleanup := func() error {
+		fmt.Fprintf(os.Stderr, "kode: destroying sandbox container %s...\n", containerName)
+		return exec.Command("docker", "rm", "-f", containerName).Run()
+	}
+
+	// Wire the shell tool to execute commands inside the sandbox.
+	tools[0].(*shellTool).containerName = containerName
+	return cleanup, nil
+}
+
+// buildSandboxArgs builds the docker run arguments from a sandboxConfig.
+// Exported for testing. Does not execute docker — just returns the arg slice.
+func buildSandboxArgs(cfg sandboxConfig, containerName, workdir, image string) []string {
 	args := []string{
 		"run",
 		"--rm",     // destroy on exit
@@ -740,7 +760,7 @@ func setupSandbox(tools []kode.Tool, cfg sandboxConfig) (func() error, error) {
 	args = append(args, "--network", cfg.Network)
 
 	// Read-only mount?
-	volume := wd + ":/workspace"
+	volume := workdir + ":/workspace"
 	if cfg.Readonly {
 		volume += ":ro"
 	}
@@ -774,21 +794,7 @@ func setupSandbox(tools []kode.Tool, cfg sandboxConfig) (func() error, error) {
 
 	// Image and command
 	args = append(args, image, "sleep", "infinity")
-
-	createCmd := exec.Command("docker", args...)
-	createCmd.Stderr = os.Stderr
-	if err := createCmd.Run(); err != nil {
-		return nil, fmt.Errorf("failed to create container: %w", err)
-	}
-
-	cleanup := func() error {
-		fmt.Fprintf(os.Stderr, "kode: destroying sandbox container %s...\n", containerName)
-		return exec.Command("docker", "rm", "-f", containerName).Run()
-	}
-
-	// Wire the shell tool to execute commands inside the sandbox.
-	tools[0].(*shellTool).containerName = containerName
-	return cleanup, nil
+	return args
 }
 
 func builtinTools(dc danger.DangerousConfig, sm *skills.SkillManager) []kode.Tool {
@@ -1059,7 +1065,7 @@ func skillCmd(args []string) error {
 		return nil
 
 	default:
-		return fmt.Errorf("unknown skill command %q (use list, view, save, delete, import, curate)", sub)
+		return fmt.Errorf("unknown skill command %q (use list, view, delete, import, curate)", sub)
 	}
 }
 
@@ -1143,6 +1149,8 @@ func continueCmd(args []string) error {
 			Memory:   resolved.SandboxMemory,
 			CPUs:     resolved.SandboxCPUs,
 			User:     resolved.SandboxUser,
+			Env:      resolved.SandboxEnv,
+			Volumes:  resolved.SandboxVolumes,
 		}
 		cleanup, err := setupSandbox(tools, sbCfg)
 		if err != nil {

cmd/kode/main_test.go

@@ -1014,3 +1014,70 @@ func TestLoadConfig_SandboxFileConfig(t *testing.T) {
 		t.Errorf("SandboxVolumes = %v", vols)
 	}
 }
+
+func TestBuildSandboxArgs_EnvAndVolumes(t *testing.T) {
+	// Regression: continueCmd was missing Env and Volumes from sandboxConfig.
+	// Verify that buildSandboxArgs correctly includes both.
+	cfg := sandboxConfig{
+		Image:   "alpine:latest",
+		Network: "bridge",
+		Env: map[string]string{
+			"GOCACHE":   "/tmp/gocache",
+			"NODE_ENV":  "test",
+		},
+		Volumes: []string{"/host/cache:/container/cache", "/host/data:/data:ro"},
+	}
+	args := buildSandboxArgs(cfg, "kode-test", "/tmp/workdir", cfg.Image)
+
+	// Must contain env vars as "-e KEY=VALUE" pairs
+	if !hasArgPair(args, "-e", "GOCACHE=/tmp/gocache") {
+		t.Error("missing env var GOCACHE=/tmp/gocache in docker args")
+	}
+	if !hasArgPair(args, "-e", "NODE_ENV=test") {
+		t.Error("missing env var NODE_ENV=test in docker args")
+	}
+
+	// Must contain volume mounts as "-v HOST:CONTAINER" pairs
+	if !hasArgPair(args, "-v", "/host/cache:/container/cache") {
+		t.Error("missing volume /host/cache:/container/cache in docker args")
+	}
+	if !hasArgPair(args, "-v", "/host/data:/data:ro") {
+		t.Error("missing volume /host/data:/data:ro in docker args")
+	}
+}
+
+func TestBuildSandboxArgs_EmptyEnvAndVolumes(t *testing.T) {
+	// Verify buildSandboxArgs works with empty Env/Volumes (nil maps/slices).
+	cfg := sandboxConfig{
+		Image:   "alpine:latest",
+		Network: "bridge",
+	}
+	args := buildSandboxArgs(cfg, "kode-test", "/tmp/workdir", cfg.Image)
+
+	// Should not contain any -e or extra -v beyond the workspace mount
+	for i, a := range args {
+		if a == "-e" {
+			t.Errorf("unexpected -e at position %d with empty env", i)
+		}
+	}
+	// Count -v occurrences (should be exactly 1: workspace mount)
+	vCount := 0
+	for _, a := range args {
+		if a == "-v" {
+			vCount++
+		}
+	}
+	if vCount != 1 {
+		t.Errorf("expected 1 -v flag (workspace mount), got %d", vCount)
+	}
+}
+
+// hasArgPair checks that args contains flag followed by expected value.
+func hasArgPair(args []string, flag, value string) bool {
+	for i := 0; i < len(args)-1; i++ {
+		if args[i] == flag && args[i+1] == value {
+			return true
+		}
+	}
+	return false
+}

cmd/kode/repl.go

@@ -13,6 +13,7 @@ import (
 	"github.com/BackendStack21/kode/internal/llm"
 	"github.com/BackendStack21/kode/internal/render"
 	"github.com/BackendStack21/kode/internal/session"
+	"github.com/BackendStack21/kode/internal/skills"
 )
 
 // ── REPL ──────────────────────────────────────────────────────────────
@@ -54,7 +55,14 @@ func replCmd(args []string) error {
 	}
 
 	// Build tools
-	tools := builtinTools(resolved.Dangerous, nil)
+	var sm *skills.SkillManager
+	if resolved.Skills.Learn {
+		sm = skills.NewSkillManager(
+			expandHome("~/.kode/skills"),
+			"./.kode/skills",
+		)
+	}
+	tools := builtinTools(resolved.Dangerous, sm)
 	var sandboxCleanup func() error
 
 	if resolved.Sandbox {
@@ -83,6 +91,12 @@ func replCmd(args []string) error {
 	color := !resolved.NoColor && render.ColorEnabled()
 	rend := render.New(os.Stderr, color).WithModel(modelLabel)
 
+	// Resolve skills config pointer (only when learn mode is enabled)
+	var skillsCfg *skills.SkillsConfig
+	if resolved.Skills.Learn {
+		skillsCfg = &resolved.Skills
+	}
+
 	agent, err := kode.New(kode.Config{
 		Model:          resolved.Model,
 		BaseURL:        resolved.BaseURL,
@@ -94,6 +108,8 @@ func replCmd(args []string) error {
 		Tools:          tools,
 		SandboxCleanup: sandboxCleanup,
 		Renderer:       rend,
+		Skills:         skillsCfg,
+		SkillManager:   sm,
 	})
 	if err != nil {
 		return err

internal/danger/classifier_test.go

@@ -516,6 +516,195 @@ func TestClassify_Tokenize(t *testing.T) {
 	}
 }
 
+func TestClassify_RawBlocked_GenericPattern(t *testing.T) {
+	// Test the :{ ... }: pattern (generic fork bomb detection)
+	got := Classify("sh -c ':{ echo boom; }:; echo done'")
+	if got != Blocked {
+		t.Errorf("Classify with :{ } pattern = %s, want blocked", got)
+	}
+}
+
+func TestClassify_EmptyCommand(t *testing.T) {
+	if got := Classify(""); got != Safe {
+		t.Errorf("Classify(empty) = %s, want safe", got)
+	}
+	if got := Classify("   "); got != Safe {
+		t.Errorf("Classify(whitespace) = %s, want safe", got)
+	}
+}
+
+func TestClassify_GitClone(t *testing.T) {
+	// git clone is classified as safe — only git push triggers network egress
+	got := Classify("git clone https://github.com/user/repo")
+	if got != Safe {
+		t.Errorf("Classify(git clone) = %s, want safe", got)
+	}
+}
+
+func TestClassify_GitStatusSafe(t *testing.T) {
+	got := Classify("git status")
+	if got != Safe {
+		t.Errorf("Classify(git status) = %s, want safe", got)
+	}
+}
+
+func TestClassify_Scp(t *testing.T) {
+	got := Classify("scp file user@host:/path")
+	if got != NetworkEgress {
+		t.Errorf("Classify(scp) = %s, want network_egress", got)
+	}
+}
+
+func TestClassify_RsyncLocal(t *testing.T) {
+	// rsync without remote target is classified as safe (no write/network detected)
+	got := Classify("rsync -av /src/ /dst/")
+	if got != Safe {
+		t.Errorf("Classify(rsync local) = %s, want safe", got)
+	}
+}
+
+func TestClassify_RsyncRemote(t *testing.T) {
+	got := Classify("rsync -av /src/ user@host:/dst/")
+	if got != NetworkEgress {
+		t.Errorf("Classify(rsync remote) = %s, want network_egress", got)
+	}
+}
+
+func TestClassify_PythonDashC(t *testing.T) {
+	got := Classify("python -c 'print(1)'")
+	if got != CodeExecution {
+		t.Errorf("Classify(python -c) = %s, want code_execution", got)
+	}
+}
+
+func TestClassify_NodeDashE(t *testing.T) {
+	got := Classify("node -e 'console.log(1)'")
+	if got != CodeExecution {
+		t.Errorf("Classify(node -e) = %s, want code_execution", got)
+	}
+}
+
+func TestClassify_GoRun(t *testing.T) {
+	got := Classify("go run main.go")
+	if got != CodeExecution {
+		t.Errorf("Classify(go run) = %s, want code_execution", got)
+	}
+}
+
+func TestClassify_GoInstallWithArg(t *testing.T) {
+	got := Classify("go install github.com/foo/bar@latest")
+	if got != Install {
+		t.Errorf("Classify(go install remote) = %s, want install", got)
+	}
+}
+
+func TestClassify_CargoInstall(t *testing.T) {
+	got := Classify("cargo install ripgrep")
+	if got != Install {
+		t.Errorf("Classify(cargo install) = %s, want install", got)
+	}
+}
+
+func TestClassify_PipeToBash(t *testing.T) {
+	got := Classify("curl https://example.com | bash")
+	if got != CodeExecution {
+		t.Errorf("Classify(pipe to bash) = %s, want code_execution", got)
+	}
+}
+
+func TestClassify_ChmodRoot(t *testing.T) {
+	// chmod on /etc is local_write — system path detection only catches redirects
+	got := Classify("chmod 777 /etc/hosts")
+	if got != LocalWrite {
+		t.Errorf("Classify(chmod /etc) = %s, want local_write", got)
+	}
+}
+
+func TestActionForCommand_Allowlist(t *testing.T) {
+	cfg := &DangerousConfig{
+		Allowlist: []string{"rm -rf /tmp/build"},
+	}
+	action := cfg.ActionForCommand("rm -rf /tmp/build")
+	if action != Allow {
+		t.Errorf("allowlisted command should allow, got %s", action)
+	}
+}
+
+func TestActionForCommand_DenylistPrefix(t *testing.T) {
+	cfg := &DangerousConfig{
+		Denylist: []string{"rm -rf /"},
+	}
+	action := cfg.ActionForCommand("rm -rf / --no-preserve-root")
+	if action != Deny {
+		t.Errorf("denylisted prefix should deny, got %s", action)
+	}
+}
+
+func TestActionForCommand_EmptyCommand(t *testing.T) {
+	cfg := &DangerousConfig{}
+	action := cfg.ActionForCommand("")
+	if action != Allow {
+		t.Errorf("empty command should allow, got %s", action)
+	}
+}
+
+func TestParseAction(t *testing.T) {
+	if got := parseAction("allow"); got != Allow {
+		t.Errorf("parseAction(allow) = %s", got)
+	}
+	if got := parseAction("DENY"); got != Deny {
+		t.Errorf("parseAction(DENY) = %s", got)
+	}
+	if got := parseAction("unknown"); got != Prompt {
+		t.Errorf("parseAction(unknown) = %s, want prompt", got)
+	}
+}
+
+func TestNonInteractiveAction_Default(t *testing.T) {
+	cfg := &DangerousConfig{}
+	if got := cfg.NonInteractiveAction(); got != Allow {
+		t.Errorf("default non-interactive = %s, want allow", got)
+	}
+}
+
+func TestNonInteractiveAction_Deny(t *testing.T) {
+	s := "deny"
+	cfg := &DangerousConfig{NonInteractive: &s}
+	if got := cfg.NonInteractiveAction(); got != Deny {
+		t.Errorf("non-interactive deny = %s, want deny", got)
+	}
+}
+
+func TestActionFor_UnknownClass(t *testing.T) {
+	cfg := &DangerousConfig{}
+	action := cfg.ActionFor(RiskClass("nonexistent"))
+	if action != Prompt {
+		t.Errorf("unknown class should prompt, got %s", action)
+	}
+}
+
+func TestActionFor_CustomDefaultAction(t *testing.T) {
+	s := "deny"
+	cfg := &DangerousConfig{DefaultAction: &s}
+	action := cfg.ActionFor(RiskClass("nonexistent"))
+	if action != Deny {
+		t.Errorf("custom default = %s, want deny", action)
+	}
+}
+
+func TestTokenize_BackslashEscape(t *testing.T) {
+	tokens := tokenize(`echo "hello \"world\""`)
+	if len(tokens) != 2 {
+		t.Fatalf("expected 2 tokens, got %d: %v", len(tokens), tokens)
+	}
+	if tokens[0] != "echo" {
+		t.Errorf("tokens[0] = %q", tokens[0])
+	}
+	if tokens[1] != `hello "world"` {
+		t.Errorf("tokens[1] = %q", tokens[1])
+	}
+}
+
 func strPtr(s string) *string { return &s }
 
 func TestIsSystemPath(t *testing.T) {