agent-loop: root turn driven by the library kernel (phase 2)

ChatSessionHandler now runs the root turn on the agent-loop kernel
instead of run_agent_turn; sub-agents follow on the same kernel via
DelegateTool. The old loop stays for resume/recovery until phase 3.

agent-loop:
- DelegateTool + AgentCatalog/AgentProfile (full toolset override,
  per-child selector/assembler, frame-scoped get), StaticCatalog,
  FilteredToolSet; sync flow with sticky child_token; batch via the
  generic fan-out
- manager: start_loop skips the registry (children are not
  double-driving; they ride the parent's token tree); LoopParams gains
  selector/token overrides
- store: get_frame, get_call, set_call_extras; HistoryStore result text
  aligned to raw-stored semantics (projection formats)
- events: ApprovalRequired.request_id, AgentSpawned/Finished parent
  info; AskUserTool with_name + suggested_answers alias + Question.frame

skald-core (loop_adapters + handler):
- SkaldAssembler (byte-parity port of MessageBuilder's projection:
  scratchpad/summary/window, DTL Kimi/Anthropic injection, media, user
  coalescing, reasoning echo) + AgentSystemContext (prompt layers,
  substitutions, MCP list, shared folders, user profile)
- SkaldAgentCatalog (build_sub_agent_config port), SkaldHumanChannel,
  scratchpad/todos tools, execute_task sync/async alias,
  LegacyInterfaceTool, PendingLiveInput
- ApprovalGate: PendingWrite diffs via LoopEvent::Host (memory/disk
  routed like the fs-tools); SkaldWritePreviewHook for executed-write
  diffs; EventTranslator LoopEvent→ServerEvent (display meta, preview,
  FileChanged, AgentStart/Done, root-only Done/Truncated/Cancelled)
- handle_message: builds TurnParams and drives the kernel; resume of
  pending tools runs first (results belong to the previous turn);
  ChatEvent publication stays handler-side; /stop cancels the live loop
- ToolRegistry.get_tool/all_tools; def builders made pub(crate)

Full workspace suite green (179 skald-core, 34 agent-loop, adapters
incl.); two pre-existing doc-test failures fixed along the way.

crates/agent-loop/src/store.rs

@@ -75,13 +75,16 @@ impl CallOutcome {
         }
     }
 
-    /// Text persisted as the call's result (what the model will read back).
+    /// Text persisted as the call's result. Kept RAW (the assembler formats
+    /// for the model: `Failed` results get their "Error:" prefix at
+    /// projection time, not here) so hosts with an existing schema (Skald's
+    /// `chat_llm_tools.result`) round-trip byte-identically.
     pub fn result_text(&self) -> String {
         match self {
             Self::Completed(out) => out.to_wire(),
-            Self::Failed(e)      => format!("Error: {e}"),
-            Self::Cancelled      => "Tool call cancelled by user.".to_string(),
-            Self::Rejected { reason } => format!("Tool call rejected: {reason}"),
+            Self::Failed(e)      => e.clone(),
+            Self::Cancelled      => "Cancelled by user.".to_string(),
+            Self::Rejected { reason } => reason.clone(),
         }
     }
 
@@ -253,6 +256,8 @@ pub trait HistoryStore: Send + Sync {
         spec:   FrameSpec,
     ) -> crate::Result<FrameId>;
     async fn close_frame(&self, frame: FrameId) -> crate::Result<()>;
+    /// One frame by id (DelegateTool depth checks, recovery).
+    async fn get_frame(&self, frame: FrameId) -> crate::Result<Option<FrameRecord>>;
     /// All active frames of a conversation (recovery: batch detection, cascade).
     async fn active_frames(&self, conv: &ConversationId) -> crate::Result<Vec<FrameRecord>>;
     async fn deepest_active(&self, conv: &ConversationId) -> crate::Result<Option<FrameRecord>>;
@@ -273,6 +278,11 @@ pub trait HistoryStore: Send + Sync {
     async fn resolve_call(&self, id: ToolCallId, outcome: &CallOutcome) -> crate::Result<()>;
     /// Only `Running → AwaitingHuman`.
     async fn set_call_state(&self, id: ToolCallId, state: CallState) -> crate::Result<()>;
+    /// One call by id (translators enriching finish events, recovery).
+    async fn get_call(&self, id: ToolCallId) -> crate::Result<Option<StoredCall>>;
+    /// Merge host free-form extras into a call (Skald: diff preview, media).
+    /// Keys not understood by the store are ignored.
+    async fn set_call_extras(&self, id: ToolCallId, extras: Value) -> crate::Result<()>;
     async fn calls_in_state(&self, frame: FrameId, states: &[CallState]) -> crate::Result<Vec<StoredCall>>;
 
     // ── summaries ──