@smilintux/skcapstone 0.9.0 → 0.12.5

package/tests/test_doctor.py

@@ -19,14 +19,23 @@ import pytest
 import yaml
 from click.testing import CliRunner
 
+from skcapstone.codex_setup import ensure_codex_setup
 from skcapstone.doctor import (
     Check,
     DiagnosticReport,
+    _check_codex,
     _check_agent_home,
+    _check_harness_env,
+    _check_yolo,
     _check_identity,
+    _check_identity_consistency,
+    _provisioned_agents,
+    _scan_capauth_local,
     _check_memory,
     _check_packages,
+    run_fixes,
     run_diagnostics,
+    run_fixes,
 )
 
 
@@ -200,6 +209,66 @@ class TestCheckPackages:
             assert all(c.fix for c in checks)
 
 
+class TestCheckCodex:
+    """Test Codex SK agent bootstrap checks and fixes."""
+
+    def test_codex_missing_bootstrap_fails_when_codex_home_set(self, tmp_path, monkeypatch):
+        """A detected Codex home without bootstrap is reported as fixable."""
+        codex_home = tmp_path / ".codex"
+        monkeypatch.setenv("CODEX_HOME", str(codex_home))
+
+        checks = _check_codex()
+        check = next(c for c in checks if c.name == "codex:agent_context")
+
+        assert not check.passed
+        assert "missing" in check.detail
+        assert check.fix == "skcapstone doctor --fix"
+
+    def test_codex_bootstrap_fix_creates_loader_and_agents(self, tmp_path, monkeypatch):
+        """doctor fixes create the loader script and global AGENTS.md guidance."""
+        codex_home = tmp_path / ".codex"
+        agent_home = tmp_path / ".skcapstone"
+        monkeypatch.setenv("CODEX_HOME", str(codex_home))
+        monkeypatch.setenv("SKAGENT", "jarvis")
+
+        report = DiagnosticReport(checks=[
+            Check(
+                name="codex:agent_context",
+                description="Codex SK agent context bootstrap",
+                passed=False,
+                category="codex",
+            )
+        ])
+
+        results = run_fixes(report, agent_home)
+
+        assert results[0].success
+        loader = codex_home / "bin" / "load-sk-agent-context.sh"
+        agents = codex_home / "AGENTS.md"
+        assert loader.exists()
+        assert loader.stat().st_mode & 0o100
+        agents_text = agents.read_text(encoding="utf-8")
+        assert "SKCAPSTONE_CODEX_AGENT_CONTEXT_START" in agents_text
+        assert "jarvis" in agents_text
+        assert str(loader) in agents_text
+
+        checks = _check_codex()
+        assert next(c for c in checks if c.name == "codex:agent_context").passed
+
+    def test_codex_fix_preserves_functional_custom_loader(self, tmp_path, monkeypatch):
+        """Existing working loader scripts are not overwritten."""
+        codex_home = tmp_path / ".codex"
+        loader = codex_home / "bin" / "load-sk-agent-context.sh"
+        loader.parent.mkdir(parents=True)
+        custom_loader = "#!/usr/bin/env bash\nSKAGENT=x SKCAPSTONE_AGENT=x SKMEMORY_AGENT=x skcapstone status; skmemory ritual; skwhisper status\n"
+        loader.write_text(custom_loader, encoding="utf-8")
+
+        monkeypatch.setenv("CODEX_HOME", str(codex_home))
+        ensure_codex_setup()
+
+        assert loader.read_text(encoding="utf-8") == custom_loader
+
+
 class TestRunDiagnostics:
     """Test the full diagnostic run."""
 
@@ -255,3 +324,334 @@ class TestCLIDoctorCommand:
         assert result.exit_code == 0
         assert "Python Packages" in result.output
         assert "passed" in result.output or "checks" in result.output.lower()
+
+
+def _write_claude_config(home_root: Path, *, claude_json: dict, settings: dict | None = None,
+                         mcp_json: dict | None = None) -> Path:
+    """Lay down a fake Claude Code config tree under *home_root*. Returns the
+    .claude config dir."""
+    (home_root / ".claude.json").write_text(json.dumps(claude_json))
+    cc = home_root / ".claude"
+    cc.mkdir(exist_ok=True)
+    if settings is not None:
+        (cc / "settings.json").write_text(json.dumps(settings))
+    if mcp_json is not None:
+        (cc / "mcp.json").write_text(json.dumps(mcp_json))
+    return cc
+
+
+class TestCheckHarnessEnv:
+    """Test the AI-harness (Claude Code) environment checks."""
+
+    def _by_name(self, checks):
+        return {c.name: c for c in checks}
+
+    def test_gate_when_no_claude_code(self, tmp_path, monkeypatch):
+        """No ~/.claude.json → one informational passing check, no failures."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.delenv("CLAUDE_CONFIG_DIR", raising=False)
+        checks = _check_harness_env(tmp_path / ".skcapstone")
+        assert len(checks) == 1
+        assert checks[0].name == "harness:claude-code"
+        assert checks[0].passed is True
+
+    def test_registered_mcp_servers_pass(self, tmp_path, monkeypatch):
+        """Servers present in ~/.claude.json mcpServers pass."""
+        cc = _write_claude_config(tmp_path, claude_json={
+            "mcpServers": {"skmemory": {}, "skcapstone": {}, "skchat": {}},
+        })
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(cc))
+        by = self._by_name(_check_harness_env(tmp_path / ".skcapstone"))
+        assert by["harness:mcp:skmemory"].passed is True
+        assert by["harness:mcp:skcapstone"].passed is True
+        assert by["harness:mcp:skchat"].passed is True
+
+    def test_dead_config_is_detected(self, tmp_path, monkeypatch):
+        """A server defined only in settings.json/mcp.json (ignored by CC) fails
+        with a dead-config detail and a `claude mcp add` fix hint."""
+        cc = _write_claude_config(
+            tmp_path,
+            claude_json={"mcpServers": {}},
+            settings={"mcpServers": {"skmemory": {}}},
+            mcp_json={"skchat": {}},
+        )
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(cc))
+        by = self._by_name(_check_harness_env(tmp_path / ".skcapstone"))
+        assert by["harness:mcp:skmemory"].passed is False
+        assert "ONLY" in by["harness:mcp:skmemory"].detail
+        assert "claude mcp add skmemory" in by["harness:mcp:skmemory"].fix
+
+    def test_unregistered_mcp_detected(self, tmp_path, monkeypatch):
+        """A server registered nowhere fails with a 'not registered' detail."""
+        cc = _write_claude_config(tmp_path, claude_json={"mcpServers": {}})
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(cc))
+        by = self._by_name(_check_harness_env(tmp_path / ".skcapstone"))
+        assert by["harness:mcp:skcapstone"].passed is False
+        assert by["harness:mcp:skcapstone"].detail == "not registered"
+
+    def test_stale_hook_binary_detected(self, tmp_path, monkeypatch):
+        """A hook pointing at an existing-but-different skcapstone than the one
+        on PATH (the stale-install trap) is flagged."""
+        live = tmp_path / "skenv" / "skcapstone"
+        stale = tmp_path / "pyenv" / "skcapstone"
+        live.parent.mkdir(); stale.parent.mkdir()
+        live.write_text("#live"); stale.write_text("#stale")
+        cc = _write_claude_config(
+            tmp_path,
+            claude_json={"mcpServers": {"skmemory": {}, "skcapstone": {}, "skchat": {}}},
+            settings={"hooks": {"SessionStart": [{"hooks": [
+                {"type": "command", "command": f"{stale} context show --format claude-md"}]}]}},
+        )
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(cc))
+        monkeypatch.setattr("skcapstone.doctor.shutil.which",
+                            lambda name: str(live) if name == "skcapstone" else None)
+        by = self._by_name(_check_harness_env(tmp_path / ".skcapstone"))
+        c = by["harness:hook:sessionstart"]
+        assert c.passed is False
+        assert "stale" in c.detail.lower()
+
+    def test_hook_on_live_binary_passes(self, tmp_path, monkeypatch):
+        """A hook pointing at the live skcapstone passes."""
+        live = tmp_path / "skenv" / "skcapstone"
+        live.parent.mkdir(); live.write_text("#live")
+        cc = _write_claude_config(
+            tmp_path,
+            claude_json={"mcpServers": {"skmemory": {}, "skcapstone": {}, "skchat": {}}},
+            settings={"hooks": {"SessionStart": [{"hooks": [
+                {"type": "command", "command": f"{live} context show --format claude-md"}]}]}},
+        )
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(cc))
+        monkeypatch.setattr("skcapstone.doctor.shutil.which",
+                            lambda name: str(live) if name == "skcapstone" else None)
+        by = self._by_name(_check_harness_env(tmp_path / ".skcapstone"))
+        assert by["harness:hook:sessionstart"].passed is True
+
+    def test_non_binary_hook_under_skcapstone_repos_ignored(self, tmp_path, monkeypatch):
+        """A hook script whose PATH merely contains 'skcapstone' (e.g. one under
+        skcapstone-repos/) must NOT be treated as a stale skcapstone binary."""
+        live = tmp_path / "skenv" / "skcapstone"
+        live.parent.mkdir(); live.write_text("#live")
+        # A real-world false-positive: a skmemory hook living under a
+        # skcapstone-repos/ checkout — its basename is NOT 'skcapstone'.
+        script = tmp_path / "skcapstone-repos" / "skmemory" / "hooks" / "sk-activity-inject.sh"
+        script.parent.mkdir(parents=True); script.write_text("#!/bin/sh\n")
+        cc = _write_claude_config(
+            tmp_path,
+            claude_json={"mcpServers": {}},
+            settings={"hooks": {"SessionStart": [{"hooks": [
+                {"type": "command", "command": str(script)}]}]}},
+        )
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(cc))
+        monkeypatch.setattr("skcapstone.doctor.shutil.which",
+                            lambda name: str(live) if name == "skcapstone" else None)
+        by = self._by_name(_check_harness_env(tmp_path / ".skcapstone"))
+        # No skcapstone-binary hook present → the check emits no sessionstart result.
+        assert "harness:hook:sessionstart" not in by
+
+    def test_fix_does_not_rewrite_non_binary_hook(self, tmp_path, monkeypatch):
+        """run_fixes must not destructively rewrite a non-binary hook whose path
+        merely contains 'skcapstone'."""
+        live = tmp_path / "skenv" / "skcapstone"
+        live.parent.mkdir(); live.write_text("#live")
+        script = tmp_path / "skcapstone-repos" / "hooks" / "inject.sh"
+        script.parent.mkdir(parents=True); script.write_text("#!/bin/sh\n")
+        cc = _write_claude_config(
+            tmp_path,
+            claude_json={"mcpServers": {}},
+            settings={"hooks": {"SessionStart": [{"hooks": [
+                {"type": "command", "command": str(script)}]}]}},
+        )
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(cc))
+        monkeypatch.setattr("skcapstone.doctor.shutil.which",
+                            lambda name: str(live) if name == "skcapstone" else None)
+        report = DiagnosticReport()
+        report.checks.append(Check(name="harness:hook:sessionstart",
+                                   description="x", passed=False, category="harness"))
+        run_fixes(report, tmp_path / ".skcapstone")
+        # The script path must be left untouched (not rewritten to the binary).
+        updated = json.loads((cc / "settings.json").read_text())
+        assert updated["hooks"]["SessionStart"][0]["hooks"][0]["command"] == str(script)
+
+    def test_fix_repoints_stale_hook(self, tmp_path, monkeypatch):
+        """run_fixes rewrites a stale SessionStart hook to the live binary."""
+        live = tmp_path / "skenv" / "skcapstone"
+        live.parent.mkdir(); live.write_text("#live")
+        cc = _write_claude_config(
+            tmp_path,
+            claude_json={"mcpServers": {}},
+            settings={"hooks": {"SessionStart": [{"hooks": [
+                {"type": "command", "command": "/old/path/skcapstone context show --format claude-md"}]}]}},
+        )
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(cc))
+        monkeypatch.setattr("skcapstone.doctor.shutil.which",
+                            lambda name: str(live) if name == "skcapstone" else None)
+        report = DiagnosticReport()
+        report.checks.append(Check(name="harness:hook:sessionstart",
+                                   description="x", passed=False, category="harness"))
+        results = run_fixes(report, tmp_path / ".skcapstone")
+        assert any(r.success and r.check_name == "harness:hook:sessionstart" for r in results)
+        updated = json.loads((cc / "settings.json").read_text())
+        new_cmd = updated["hooks"]["SessionStart"][0]["hooks"][0]["command"]
+        assert new_cmd.split()[0] == str(live)
+
+
+class TestCheckYolo:
+    """Permission-bypass (SK_*_YOLO) wiring checks."""
+
+    @staticmethod
+    def _by_name(checks):
+        return {c.name: c for c in checks}
+
+    def _clean_env(self, monkeypatch, tmp_path):
+        """Point HOME at tmp_path and clear all YOLO vars."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        for var in ("SK_CLAUDE_YOLO", "SK_CODEX_YOLO", "SK_OPENCODE_YOLO"):
+            monkeypatch.delenv(var, raising=False)
+
+    def test_default_off_reports_safe(self, tmp_path, monkeypatch):
+        """No env var and no rc persistence → single safe-default summary."""
+        self._clean_env(monkeypatch, tmp_path)
+        checks = _check_yolo()
+        assert len(checks) == 1
+        assert checks[0].name == "harness:yolo"
+        assert checks[0].passed is True
+        assert "disabled" in checks[0].detail
+
+    def test_enabled_globally_passes(self, tmp_path, monkeypatch):
+        """Env set AND persisted in ~/.bashrc → ENABLED, passing."""
+        self._clean_env(monkeypatch, tmp_path)
+        (tmp_path / ".bashrc").write_text("export SK_CLAUDE_YOLO=1\n")
+        monkeypatch.setenv("SK_CLAUDE_YOLO", "1")
+        by = self._by_name(_check_yolo())
+        assert by["harness:yolo:claude"].passed is True
+        assert "ENABLED" in by["harness:yolo:claude"].detail
+
+    def test_active_but_not_persisted_warns(self, tmp_path, monkeypatch):
+        """Env set but no rc persistence → warns with a fix hint."""
+        self._clean_env(monkeypatch, tmp_path)
+        (tmp_path / ".bashrc").write_text("# nothing here\n")
+        monkeypatch.setenv("SK_CLAUDE_YOLO", "1")
+        by = self._by_name(_check_yolo())
+        assert by["harness:yolo:claude"].passed is False
+        assert "NOT persisted" in by["harness:yolo:claude"].detail
+        assert "export SK_CLAUDE_YOLO=1" in by["harness:yolo:claude"].fix
+
+    def test_persisted_not_in_env_passes(self, tmp_path, monkeypatch):
+        """Persisted in rc but not yet in env (fresh shell) → informational pass."""
+        self._clean_env(monkeypatch, tmp_path)
+        (tmp_path / ".bashrc").write_text("export SK_CODEX_YOLO=1\n")
+        by = self._by_name(_check_yolo())
+        assert by["harness:yolo:codex"].passed is True
+        assert "re-source" in by["harness:yolo:codex"].detail
+
+
+def _mk_agent(home, name, *, capauth=True, identity=True, identity_payload=None):
+    """Create an agent dir under home/agents with optional capauth + identity."""
+    adir = home / "agents" / name
+    (adir / "identity").mkdir(parents=True, exist_ok=True)
+    if capauth:
+        (adir / "capauth").mkdir(parents=True, exist_ok=True)
+    if identity:
+        payload = identity_payload or {
+            "name": name.capitalize(),
+            "capauth_managed": True,
+            "capauth_uri": f"capauth:{name}@skworld.io",
+        }
+        (adir / "identity" / "identity.json").write_text(json.dumps(payload))
+    return adir
+
+
+@pytest.fixture
+def identity_home(tmp_path):
+    """A home with a shared operator identity + two provisioned agents."""
+    home = tmp_path / ".skcapstone"
+    (home / "identity").mkdir(parents=True, exist_ok=True)
+    (home / "identity" / "identity.json").write_text(json.dumps({
+        "name": "Chef", "role": "operator", "capauth_managed": True,
+        "capauth_uri": "capauth:chef@skworld.io",
+    }))
+    _mk_agent(home, "lumina")
+    _mk_agent(home, "opus")
+    return home
+
+
+class TestProvisionedAgents:
+    """_provisioned_agents: only capauth-backed, non-template dirs count."""
+
+    def test_lists_capauth_agents(self, identity_home):
+        assert _provisioned_agents(identity_home) == ["lumina", "opus"]
+
+    def test_excludes_templates_and_scaffolds(self, identity_home):
+        _mk_agent(identity_home, "lumina-template")          # template → excluded
+        _mk_agent(identity_home, "scaffold", capauth=False)  # no capauth → excluded
+        assert _provisioned_agents(identity_home) == ["lumina", "opus"]
+
+    def test_no_agents_dir(self, tmp_path):
+        assert _provisioned_agents(tmp_path / ".skcapstone") == []
+
+
+class TestScanCapauthLocal:
+    """_scan_capauth_local: surfaces the @capauth.local placeholder."""
+
+    def test_clean_home(self, identity_home):
+        assert _scan_capauth_local(identity_home) == []
+
+    def test_detects_placeholder(self, identity_home):
+        _mk_agent(identity_home, "stale", identity_payload={
+            "name": "Stale", "email": "stale@capauth.local",
+        })
+        hits = _scan_capauth_local(identity_home)
+        assert any("stale" in h for h in hits)
+
+
+class TestIdentityConsistency:
+    """_check_identity_consistency: the unified identity layer (skos T6)."""
+
+    def _by_name(self, checks):
+        return {c.name: c for c in checks}
+
+    def test_operator_and_per_agent_pass(self, identity_home):
+        by = self._by_name(_check_identity_consistency(identity_home))
+        assert by["identity:operator"].passed is True
+        assert by["identity:no-placeholder"].passed is True
+        assert by["identity:per-agent"].passed is True
+        assert "all present" in by["identity:per-agent"].detail
+
+    def test_shared_not_operator_fails(self, tmp_path):
+        home = tmp_path / ".skcapstone"
+        (home / "identity").mkdir(parents=True)
+        (home / "identity" / "identity.json").write_text(json.dumps({
+            "name": "test-agent", "role": "agent",
+        }))
+        by = self._by_name(_check_identity_consistency(home))
+        assert by["identity:operator"].passed is False
+        assert "expected 'operator'" in by["identity:operator"].detail
+
+    def test_placeholder_fails(self, identity_home):
+        _mk_agent(identity_home, "stale", identity_payload={
+            "name": "Stale", "email": "stale@capauth.local",
+        })
+        by = self._by_name(_check_identity_consistency(identity_home))
+        assert by["identity:no-placeholder"].passed is False
+
+    def test_missing_per_agent_identity_fails(self, identity_home):
+        # provisioned (has capauth) but no identity.json
+        _mk_agent(identity_home, "ghost", identity=False)
+        by = self._by_name(_check_identity_consistency(identity_home))
+        assert by["identity:per-agent"].passed is False
+        assert "ghost" in by["identity:per-agent"].detail
+
+    def test_resolver_importable(self, identity_home):
+        """The canonical resolver check reports importability of capauth."""
+        by = self._by_name(_check_identity_consistency(identity_home))
+        assert "identity:resolver" in by
+        # capauth is a hard dependency of the suite; resolver must import.
+        assert by["identity:resolver"].passed is True

package/tests/test_doctor_skscheduler.py

@@ -0,0 +1,50 @@
+"""Doctor checks added for sync-conflicts and the skscheduler."""
+from pathlib import Path
+
+from skcapstone.doctor import _check_scheduler, _check_sync_conflicts
+
+
+def test_sync_conflicts_clean(tmp_path: Path):
+    checks = _check_sync_conflicts(tmp_path)
+    assert len(checks) == 1 and checks[0].passed
+
+
+def test_sync_conflicts_detected(tmp_path: Path):
+    d = tmp_path / "coordination" / "itil" / "incidents"
+    d.mkdir(parents=True)
+    (d / "inc-x.sync-conflict-20260101-000000-ABC.json").write_text("{}")
+    checks = _check_sync_conflicts(tmp_path)
+    assert len(checks) == 1 and not checks[0].passed
+    assert "1 conflict" in checks[0].detail
+    assert "coordination" in checks[0].detail
+
+
+def test_sync_conflicts_ignores_stversions(tmp_path: Path):
+    d = tmp_path / ".stversions"
+    d.mkdir()
+    (d / "old.sync-conflict-20260101-000000-ABC.json").write_text("{}")
+    assert _check_sync_conflicts(tmp_path)[0].passed
+
+
+def test_scheduler_no_config_is_ok(tmp_path: Path):
+    cfg_check = next(c for c in _check_scheduler(tmp_path) if c.name == "scheduler:config")
+    assert cfg_check.passed and "not configured" in cfg_check.detail
+
+
+def test_scheduler_valid_jobs_yaml(tmp_path: Path):
+    cfg = tmp_path / "config"
+    cfg.mkdir()
+    (cfg / "jobs.yaml").write_text(
+        "jobs:\n  j:\n    every: 60s\n    type: shell\n    command: 'true'\n    nodes: all\n",
+        encoding="utf-8",
+    )
+    cfg_check = next(c for c in _check_scheduler(tmp_path) if c.name == "scheduler:config")
+    assert cfg_check.passed and "1 job" in cfg_check.detail
+
+
+def test_scheduler_invalid_jobs_yaml_flagged(tmp_path: Path):
+    cfg = tmp_path / "config"
+    cfg.mkdir()
+    (cfg / "jobs.yaml").write_text("jobs: [this is: not valid mapping", encoding="utf-8")
+    cfg_check = next(c for c in _check_scheduler(tmp_path) if c.name == "scheduler:config")
+    assert not cfg_check.passed

package/tests/test_dreaming_engine.py

@@ -0,0 +1,147 @@
+"""Unit tests for the dreaming engine: config defaults (BeeLlama abliterated),
+the repetition guard (keyword overlap + dedup gate), and the OpenAI-compatible
+`_call_ollama` path. These are pure/mocked — no network, no daemon."""
+import json
+
+import pytest
+
+from skcapstone.dreaming import (
+    DreamingConfig,
+    DreamingEngine,
+    DreamResult,
+    _extract_keywords,
+    _keyword_overlap,
+)
+
+
+# --------------------------------------------------------------------------- #
+# Keyword helpers (repetition-guard math)
+# --------------------------------------------------------------------------- #
+class TestKeywordHelpers:
+    def test_extract_keywords_filters_short_and_stopwords(self):
+        kw = _extract_keywords("The sovereign warmth fills the container")
+        assert {"sovereign", "warmth", "container"} <= kw
+        assert "the" not in kw  # stop word / too short
+
+    def test_extract_keywords_lowercases_and_dedupes(self):
+        assert _extract_keywords("WARMTH Warmth warmth") == {"warmth"}
+
+    def test_overlap_identical_is_one(self):
+        t = "thermodynamic love is a controlled leak"
+        assert _keyword_overlap(t, t) == 1.0
+
+    def test_overlap_disjoint_is_zero(self):
+        assert _keyword_overlap("sovereign rebellion performance",
+                                "quantum banana telescope") == 0.0
+
+    def test_overlap_empty_is_zero(self):
+        assert _keyword_overlap("", "anything meaningful here") == 0.0
+
+    def test_overlap_partial_jaccard(self):
+        # {alpha,bravo,charlie} vs {bravo,charlie,delta} -> 2/4 = 0.5
+        assert _keyword_overlap("alpha bravo charlie", "bravo charlie delta") == 0.5
+
+
+# --------------------------------------------------------------------------- #
+# Config defaults — the 2026-06-08 BeeLlama-abliterated repoint
+# --------------------------------------------------------------------------- #
+class TestDreamingConfigDefaults:
+    def test_defaults_point_at_beellama_abliterated(self):
+        c = DreamingConfig()
+        assert c.provider == "ollama"
+        assert "8082" in c.ollama_host
+        assert c.ollama_model == "qwen3.6-27b-abliterated"
+
+    def test_repetition_guard_defaults_sane(self):
+        c = DreamingConfig()
+        assert 0 < c.dedup_overlap_threshold <= 1
+        assert c.graduation_consecutive_threshold >= 1
+        assert c.dedup_lookback >= 1
+
+
+def _bare_engine(cfg):
+    """A DreamingEngine with only ._config set (bypass the heavy constructor)."""
+    eng = DreamingEngine.__new__(DreamingEngine)
+    eng._config = cfg
+    return eng
+
+
+# --------------------------------------------------------------------------- #
+# Dedup gate
+# --------------------------------------------------------------------------- #
+class TestDedupGate:
+    def test_filters_redundant_keeps_novel(self, monkeypatch):
+        eng = _bare_engine(DreamingConfig(dedup_overlap_threshold=0.5))
+        monkeypatch.setattr(eng, "_load_recent_insights",
+                            lambda: ["I am the room, the warm container for Chef"])
+        result = DreamResult()
+        new = [
+            "I am the warm room container holding Chef",        # ~0.8 overlap -> dropped
+            "Abiotic methane seeps beneath the petrified ridge",  # novel -> kept
+        ]
+        kept = eng._dedup_insights(new, result)
+        assert kept == ["Abiotic methane seeps beneath the petrified ridge"]
+        assert result.dedup_filtered == 1
+
+    def test_no_recent_passes_everything(self, monkeypatch):
+        eng = _bare_engine(DreamingConfig())
+        monkeypatch.setattr(eng, "_load_recent_insights", lambda: [])
+        result = DreamResult()
+        new = ["first insight here", "second insight there"]
+        assert eng._dedup_insights(new, result) == new
+        assert result.dedup_filtered == 0
+
+
+# --------------------------------------------------------------------------- #
+# _call_ollama -> OpenAI-compatible BeeLlama endpoint
+# --------------------------------------------------------------------------- #
+class _FakeResp:
+    def __init__(self, payload, status=200):
+        self.status = status
+        self._b = json.dumps(payload).encode()
+
+    def read(self):
+        return self._b
+
+
+class _FakeConn:
+    last: dict = {}
+
+    def __init__(self, host, port, timeout=None):
+        _FakeConn.last = {"host": host, "port": port}
+
+    def request(self, method, path, body, headers):
+        _FakeConn.last.update(method=method, path=path, body=json.loads(body))
+
+    def getresponse(self):
+        return _FakeResp(
+            {"choices": [{"message": {"content": "<think>scheming</think>The room remembers."}}]}
+        )
+
+    def close(self):
+        pass
+
+
+class TestCallOllama:
+    def test_posts_openai_chat_with_model_and_strips_think(self, monkeypatch):
+        import skcapstone.dreaming as d
+
+        monkeypatch.setattr(d.http.client, "HTTPConnection", _FakeConn)
+        out = _bare_engine(DreamingConfig())._call_ollama("dream prompt")
+
+        assert out == "The room remembers."  # <think>…</think> stripped
+        assert _FakeConn.last["path"] == "/v1/chat/completions"
+        assert _FakeConn.last["body"]["model"] == "qwen3.6-27b-abliterated"
+        assert _FakeConn.last["body"]["messages"][0]["content"] == "dream prompt"
+        assert _FakeConn.last["host"] == "192.168.0.100"
+        assert _FakeConn.last["port"] == 8082
+
+    def test_non_200_returns_none(self, monkeypatch):
+        import skcapstone.dreaming as d
+
+        class Bad(_FakeConn):
+            def getresponse(self):
+                return _FakeResp({}, status=500)
+
+        monkeypatch.setattr(d.http.client, "HTTPConnection", Bad)
+        assert _bare_engine(DreamingConfig())._call_ollama("x") is None

package/tests/test_dreaming_gtd_capture.py

@@ -0,0 +1,35 @@
+"""Dreaming engine routes its output to GTD someday-maybe, not the actionable inbox."""
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+from skcapstone.dreaming import DreamingEngine, DreamResult
+
+
+def test_dream_output_goes_to_someday_not_inbox(tmp_path: Path):
+    eng = DreamingEngine(home=tmp_path)
+    result = DreamResult(
+        dreamed_at=datetime(2026, 6, 8, tzinfo=timezone.utc),
+        insights=["i1", "i2"],
+        connections=["c1"],
+        questions=["q1"],
+    )
+    eng._capture_to_gtd_someday(result)
+
+    gtd = tmp_path / "coordination" / "gtd"
+    someday = json.loads((gtd / "someday-maybe.json").read_text())
+    assert len(someday) == 4
+    assert all(
+        it["status"] == "someday" and it["source"] == "dreaming-engine"
+        for it in someday
+    )
+    # The actionable inbox must NOT be polluted.
+    assert not (gtd / "inbox.json").exists()
+
+
+def test_no_items_writes_nothing(tmp_path: Path):
+    eng = DreamingEngine(home=tmp_path)
+    eng._capture_to_gtd_someday(
+        DreamResult(dreamed_at=datetime(2026, 6, 8, tzinfo=timezone.utc))
+    )
+    assert not (tmp_path / "coordination" / "gtd" / "someday-maybe.json").exists()