…andles

Phase 1 of the kernel/mod.rs split. Move every `impl kernel_handle::* for
LibreFangKernel` block out of the 20K-line god-file into per-trait files
under `kernel/handles/`. The submodules are descendants of `kernel`, so
they retain access to LibreFangKernel's private fields and inherent
methods without any visibility surgery.

Mechanical, behavior-preserving move — no method bodies were touched.
mod.rs drops from ~20.6k to ~18.8k lines (-2073). Three imports that
became unused after the move were removed (kernel_handle self-alias,
ToolApprovalSubmission, std::str::FromStr) and re-imported locally in
the consuming handle files.

Traits moved:
  AgentControl, MemoryAccess, TaskQueue, EventBus, KnowledgeGraph,
  CronControl, HandsControl, ApprovalGate, A2ARegistry, ChannelSender,
  PromptStore, WorkflowRunner, GoalControl, ToolPolicy, ApiAuth,
  SessionWriter

Verified: cargo check -p librefang-kernel --lib + cargo clippy
-p librefang-kernel --lib -- -D warnings both green.

…n_tick

Phase 3b's `cron_tick.rs` body was the pre-#4683 closure (the version
my Phase 1 subagent saw); the SummarizeTrim runtime path was lost when
the Phase 1 work happened to omit #4683's mod.rs hunk. The earlier
repair commit restored the helper fns into `kernel::cron_compaction`
but left their call site missing.

Replace the body of `run_cron_scheduler_loop` with the post-#4683
version copied from origin/main's mod.rs (the `spawn_logged("cron_scheduler",
async move { … })` block at lines 14386..15064). Now the cron tick
body actually calls:

  - `cron_compute_keep_count` to size the keep window without mutating
  - `cron_resolve_compaction_mode` to fall back from SummarizeTrim →
    Prune when keep_count < 2
  - `cron_clamp_keep_recent` to enforce `[summary] + tail` cap
  - `try_summarize_trim` (aux LLM compaction) on the SummarizeTrim path
  - `apply_cron_prune` for both the configured Prune path and the
    SummarizeTrim → Prune fallback

`apply_cron_prune` was bumped to `pub(super)` so cron_tick.rs (sibling
submodule of cron_compaction) can call it.

Verified: cargo check / clippy -- -D warnings / cargo check --tests /
rustfmt --check all green.

Slice the still-resident giant `impl LibreFangKernel { ... }` body into
five cohesive sub-modules under `kernel/`:

  messaging.rs         — 26 send_message* / send_message_streaming_*
                         variants + send_message_full /
                         send_message_full_with_upstream +
                         resolve_agent_home_channel +
                         run_forked_agent_streaming
                         (~2 670 lines)
  assistant_routing.rs — 12 helpers driving the @-mention / specialist
                         routing path: notify_owner_bg,
                         llm_classify_intent, resolve_or_spawn_specialist,
                         send_message_streaming_resolved,
                         resolve_assistant_target,
                         route_assistant_by_metadata, etc.
                         (~460 lines)
  hands_lifecycle.rs   — 14 hand-management methods: activate_hand,
                         deactivate_hand, reload_hands,
                         apply_hand_agent_runtime_override_to_registry,
                         resolve_hand_agent_model_defaults, etc.
                         (~990 lines)
  mcp_setup.rs         — 6 MCP wiring fns: connect_mcp_servers,
                         reload_mcp_servers, retry_mcp_connection,
                         reconnect_mcp_server, run_mcp_health_loop,
                         disconnect_mcp_server (~610 lines)
  prompt_context.rs    — 7 cached-summary builders for prompt
                         assembly: cached_workspace_metadata,
                         cached_skill_metadata, active_goals_for_prompt,
                         build_skill_summary_from_skills,
                         build_mcp_summary, collect_prompt_context, etc.
                         (~340 lines)

Mechanical, behavior-preserving move — method bodies untouched.
mod.rs drops from ~16.2k to ~11.3k lines (-4 950). Combined with
phases 1+2+3a+3b that's a 9 350-line reduction (-45%) on the
original 20 609-line god-file.

Visibility surgery (only what the compiler demanded; private inherent
methods are not visible across sibling submodules without it):

  - messaging::send_message_full / send_message_streaming_with_sender_and_session
    bumped to pub(crate) — called from cron_tick + assistant_routing.
  - assistant_routing::{notify_owner_bg, send_message_streaming_resolved,
    resolve_assistant_target, assistant_route_key,
    should_skip_intent_classification} bumped to pub(crate) — called
    from messaging + tests.
  - mcp_setup::run_mcp_health_loop bumped to pub(crate) — kept-resident
    spawn_logged callsite in mod.rs needs it.
  - prompt_context::{cached_workspace_metadata, cached_skill_metadata,
    active_goals_for_prompt, build_mcp_summary} bumped to pub(crate)
    for cross-module consumers.
  - mod.rs structs CachedWorkspaceMetadata + CachedSkillMetadata
    bumped to pub(crate) struct (private fields kept) so the
    pub(crate) accessor signatures don't trip the private-interfaces
    lint.

Verified across all 5 cluster checkpoints + final pass: cargo check
-p librefang-kernel --lib + clippy -- -D warnings + check --tests +
rustfmt --check all green.

Continue slicing the still-resident `impl LibreFangKernel { ... }` body
into thematic sub-modules:

  boot.rs            — session_stream_hub, boot, boot_with_config
                       (~2 005 lines — `boot_with_config` is the
                       single largest method extracted so far)
  spawn.rs           — spawn_agent + 4 spawn_agent_with_*  +
                       spawn_agent_inner + verify_signed_manifest +
                       trusted_manifest_signer_keys (~410 lines)
  agent_execution.rs — execute_wasm_agent, execute_python_agent,
                       should_reuse_cached_route, is_brief_acknowledgement,
                       execute_llm_agent (~1 195 lines)
  session_ops.rs     — inject_message + inject_message_for_session +
                       setup/teardown_injection_channel + resolve_module_path
                       + reset/reboot_session + clear_agent_history +
                       list/create/switch/export/import_session +
                       inject_reset_prompt + evaluate_condition +
                       save_session_summary (~820 lines)
  agent_state.rs     — persist_manifest_to_disk, set_agent_model,
                       reload_agent_from_disk, update_manifest,
                       set_agent_skills, set_agent_mcp_servers,
                       set_agent_tool_filters (~530 lines)

Mechanical move — method bodies untouched. mod.rs drops from
~11.3k to ~6.4k lines (-4 870). Cumulative across phases 1+2+3a+3b+3c+3d
the original 20 609-line god-file is now ~6 385 lines (-69%).

Visibility surgery (only what the compiler demanded for cross-submodule
call sites):

  - spawn::spawn_agent_inner          → pub(crate) (called by hands_lifecycle)
  - agent_execution::execute_wasm_agent / execute_python_agent /
    execute_llm_agent / should_reuse_cached_route → pub(crate)
    (called by messaging + assistant_routing)
  - session_ops::{setup_injection_channel, teardown_injection_channel,
    resolve_module_path, inject_reset_prompt, evaluate_condition}
    → pub(crate) (called by messaging / spawn / tests)

No struct or enum visibility bumps were needed — `boot.rs` builds
the kernel via struct literal because descendant submodules retain
private-field access.

Verified: cargo check / clippy -- -D warnings / cargo check --tests /
rustfmt --check all green at every cluster checkpoint and the final
pass.

Move runtime-control methods (cost/stop/list/suspend/resume/compact/
context_report/kill + watchers) from the giant `impl LibreFangKernel`
into `kernel/agent_runtime.rs`. mod.rs drops from 6 385 to 5 825
(-560).

Methods: session_usage_cost, stop_agent_run, stop_session_run,
list_running_sessions, agent_has_active_session, running_session_ids,
suspend_agent, resume_agent, persist_agent_enabled,
compact_agent_session, compact_agent_session_with_id, context_report,
register_agent_watcher, abort_agent_watchers, kill_agent,
kill_agent_with_purge.

Verified: cargo check / clippy -- -D warnings / cargo check --tests
all green.

…ant impl

Continue slicing the still-resident `impl LibreFangKernel { ... }` body
into thematic submodules. After this commit the giant first impl block
is fully drained.

  bindings_and_handle.rs  — set_log_reloader, set_self_handle,
                            kernel_handle, list_bindings, add_binding,
                            remove_binding (~95 lines)
  config_reload_ops.rs    — reload_config + apply_hot_actions_inner
                            (~480 lines)
  triggers_and_workflow.rs — spawn_session_label_generation,
                             one_shot_llm_call, publish_event +
                             publish_event_inner, register_trigger +
                             register_trigger_with_target +
                             remove_trigger / set_trigger_enabled /
                             list_triggers / get_trigger / update_trigger,
                             register_workflow, run_workflow,
                             dry_run_workflow (~640 lines)
  background_lifecycle.rs — start_background_agents, start_ofp_node,
                            self_arc, start_heartbeat_monitor,
                            start_background_for_agent, shutdown
                            (~1 270 lines — the longest single
                            extraction in this PR)
  llm_drivers.rs          — lookup_provider_url, resolve_driver
                            (~250 lines)
  tools_and_skills.rs     — available_tools, reload_skills,
                            try_claim_skill_review_slot,
                            summarize_traces_for_review,
                            background_skill_review,
                            is_transient_review_error,
                            extract_json_from_llm_response,
                            context_engine_for_agent (~1 080 lines)

Mechanical move — method bodies untouched. mod.rs drops from
~5.8k to ~2.0k lines (-3 800). Combined with phases 1+2+3a+3b+3c+3d
the original 20 609-line god-file is now at ~2 000 lines (-90%).

Visibility surgery (only what the compiler demanded):

  - tools_and_skills::{context_engine_for_agent, try_claim_skill_review_slot,
    summarize_traces_for_review, background_skill_review,
    extract_json_from_llm_response, is_transient_review_error,
    MAX_INFLIGHT_SKILL_REVIEWS} → pub(crate) (cross-submodule + tests)
  - mod.rs `enum ReviewError` → pub(crate) enum (private-interfaces lint
    once tools_and_skills::background_skill_review's signature went
    pub(crate))

Plus a cosmetic doc-paragraph rewrap in `llm_drivers.rs` to satisfy
`clippy::doc_lazy_continuation`.

Verified: cargo check / clippy -- -D warnings / cargo check --tests
all green.

…review)

The kernel/mod split landed type-clean but silently dropped four
behavioural hooks that `cargo check` / `clippy` could not see. All
four fail open / fail-permissive (rather than fail-closed), which is
why CI green doesn't catch them — they're only visible by exercising
the boot path or the wiki tools at runtime.

Restored to parity with `origin/main` (pre-split):

- `boot.rs`: re-add `config.tool_exec.validate()` after the
  workspace-wide `config.validate()` warning loop. Without it, a
  deployment with `[tool_exec] kind = "ssh"` or `"daytona"` but
  missing the matching subtable boots silently and fails on first
  tool call instead of aborting at boot.
- `boot.rs`: `MemorySubstrate::open_with_chunking(...)` →
  `open_with_pool_size(..., config.memory.pool_size)`. The 3-arg form
  forces the r2d2 default pool size of 8 regardless of operator
  config, so `[memory] pool_size` (just landed in #4685) was a no-op
  for the primary substrate; only the prompt store init below this
  line still honoured the setting, leaving the two SQLite pools
  inconsistently sized.
- `spawn.rs::spawn_agent_inner`: re-add the
  `manifest.tool_exec_backend` override validation block after
  `validate_manifest_module_path`. Without it, an agent whose
  manifest pins `tool_exec_backend = "ssh"` against a daemon lacking
  `[tool_exec.ssh]` enters the registry and fails every tool
  invocation thereafter, instead of being rejected pre-registry.
- `mod.rs` + `boot.rs` + `handles/wiki_access.rs`: re-add the
  `wiki_vault: Option<Arc<librefang_memory_wiki::WikiVault>>` field on
  `LibreFangKernel`, the boot-time `WikiVault::new` initializer with
  the same fail-open warning behaviour as main, the
  `wiki_vault: wiki_vault.clone()` in the struct construction, and
  the concrete `wiki_get` / `wiki_search` / `wiki_write` method
  bodies (ported verbatim from the pre-split mod.rs). Without these
  three pieces, every `tool_wiki_*` call on a deployment with
  `[memory_wiki] enabled = true` flowed to the trait default and
  returned `KernelOpError::unavailable("wiki_*")`, silently disabling
  the just-landed #3329 feature. Phase 1 had left an empty
  `impl WikiAccess for LibreFangKernel {}` with a header comment
  claiming \"will arrive with the #3329 main-side merge\" — but
  #3329 was already on `origin/main` (#4712) at the time of the
  branch.

Verified locally:
  cargo check  -p librefang-kernel --lib                       OK
  cargo clippy -p librefang-kernel --lib -- -D warnings        0 warnings
  rustfmt      --check --edition 2021 (4 modified files)       clean

Refs Codex review on commits 594aa42 / 0107d06 / 79eb683 of the
parent PR — findings #2-#5 (the four P2 items still open at HEAD)
addressed here. Codex P1 finding #1 (cron SummarizeTrim) was
addressed earlier in 0107d06 and is unaffected by this commit.

…llow-list (#4713)

Phase 3e/3 moved Kernel::reload_config into kernel/config_reload_ops.rs
but the body that landed there was the pre-#4664 tolerant version: it
called crate::config::load_config(...) (which silently returns
KernelConfig::default() on parse / migration / deserialize / include
failures) and wrapped validator errors as "Validation failed: ..."
without the "live config unchanged" reload-boundary pledge.

The strict-loader function crate::config::try_load_config and its 7
direct unit tests in config.rs are still present (orphaned), but the
4 api integration tests + 1 kernel integration test that drive
reload_config end-to-end all fail because the strict path was never
re-wired after the move. Restore parity with #4664:

- swap load_config for try_load_config and propagate the Err through
  the same "Config reload failed; live config unchanged: {e}" wrapper
- wrap the validator branch with the same prefix so every
  reload-rejection path satisfies the "live config unchanged"
  invariant the integration helper relies on

Also: phase 3 split Kernel::cron_tick into a sibling kernel/cron_tick.rs
file that carries one inline comment mentioning the NO_REPLY literal.
The silent_response_single_source_of_truth grep-guard in
librefang-runtime allow-lists the literal in selected files; add
cron_tick.rs next to the existing mod.rs allow entry so the guard
stops flagging it.

Verified locally: kernel + api + runtime tests pass; clippy clean.

Pull in 7 commits from main since merge-base dbd9042, including the
two Rust changes that landed mid-split:

- #4725 (a6f1f91) — workflow drain on shutdown (#3335). Adds an
  18-line drain block + 1-line trace log between `supervisor.shutdown()`
  and the agent-state-suspend block. Migrated to its post-split home in
  `kernel/background_lifecycle.rs::shutdown` (the original mod.rs site
  was extracted in phase 3a).
- #4726 (13e8bb9) — KernelApi trait + Arc<dyn KernelApi> AppState
  (#3566). Auto-merged cleanly because all touched files outside
  mod.rs (api crate routes / extensions / extractors / kernel_api.rs)
  hit no overlap with the split. The doc comment added on
  `Kernel::run_workflow` referencing `KernelApi::run_workflow_typed`
  was migrated to its post-split home in
  `kernel/triggers_and_workflow.rs`.

The mod.rs conflict was the entire 16,460-line region that the split
moved out into ~28 sibling files. Resolution: keep HEAD (split version,
~2k lines), drop the origin/main reproduction of the pre-split block —
all of that code now lives under sibling submodules with the same
visibility (descendants of `kernel`).

Verified locally:
- `cargo check -p librefang-kernel -p librefang-api --lib` — clean (35s).
- `cargo check --workspace --lib` — clean (2m 10s).