diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@
 middleware, JSON Schema validation, plugin manifest parsing, and runtime helpers.
 
 - Implementation type: Core.
-- Package version: `0.6.0`; supported `SPEC_VERSION`: `0.2.0`.
+- Package version: `0.7.0`; supported `SPEC_VERSION`: `0.2.0`.
 - Local gate: all eleven shared vector groups, native regression tests, and
   source API/parity checks.
 - Linux and Windows CI run the full suite. Hackage publication uses
@@ -20,7 +20,7 @@
 - Machine-readable entry: [llms.txt](https://github.com/axisvela/praxo-core/blob/main/language/haskell/llms.txt) and [llms.md](https://github.com/axisvela/praxo-core/blob/main/language/haskell/llms.md)
 - [Examples](https://github.com/axisvela/praxo-core/tree/main/language/haskell/examples): runnable language-specific examples.
 - Coding-agent contract: [docs/getting-started/coding-agents.md](https://github.com/axisvela/praxo-core/blob/main/docs/getting-started/coding-agents.md)
-- Registry: [Hackage](https://hackage.haskell.org/package/praxo-core-0.6.0)
+- Registry: [Hackage](https://hackage.haskell.org/package/praxo-core-0.6.1)
 - Community: [X](https://x.com/axisvela) · [Weibo](https://weibo.com/u/1936025761)
 
 ## Get started
@@ -57,6 +57,7 @@
 | Retry transient failures | [retry](https://github.com/axisvela/praxo-core/tree/main/language/haskell/examples/retry) |
 | Add provider fallback | [provider-fallback](https://github.com/axisvela/praxo-core/tree/main/language/haskell/examples/provider-fallback) |
 | Observe agent events | [event-sink](https://github.com/axisvela/praxo-core/tree/main/language/haskell/examples/event-sink) |
+| Require human approval | [hitl](https://github.com/axisvela/praxo-core/tree/main/language/haskell/examples/hitl) |
 
 ## Build and Test
 
@@ -169,6 +170,36 @@
 the status and a bounded body otherwise. The sink adds no authentication,
 retries, buffering, ordering, or exactly-once delivery. Event data may contain
 sensitive content, so filter caller-side; use HTTPS for remote endpoints.
+
+## Human-in-the-Loop Approval
+
+`AgentOptions` accepts `interruptOn`, `onInterruptDecision`, and `onInterrupt` to
+pause matching tool calls. The agent checks allowed tools, runs the initial
+policy, applies `beforeTool`, and then applies the interrupt before `tool.call`
+and `invoke`.
+
+```haskell
+import Praxo.Agent
+import Praxo.Json
+
+options :: AgentOptions -> AgentOptions
+options base = base
+    { interruptOn = ["write_note"]
+    , onInterruptDecision = Just $ \interrupt ->
+        pure (InterruptDecision interruptEdit
+            (Just (JObject [("text", JString "hello"),
+                            ("visibility", JString "private")]))
+            "" "")
+    }
+```
+
+Decisions are `interruptApprove` (continue), `interruptEdit` (replace arguments
+and reauthorize), `interruptReject` (return `AGENT_APPROVAL_DENIED` with the
+reason), and `interruptRespond` (skip the tool and use the response). A matching
+call with no handler returns `AGENT_INTERRUPT_UNHANDLED`; an unknown action or
+an edit without arguments returns `AGENT_INTERRUPT_DECISION_INVALID`. The policy
+hook receives an `Action` so edited arguments are reauthorized. See
+[`examples/hitl`](examples/hitl/).
 
 ## Declared Scope and Limits
 
diff --git a/REGISTRY.md b/REGISTRY.md
--- a/REGISTRY.md
+++ b/REGISTRY.md
@@ -1,7 +1,7 @@
 # PRAXO-CORE Haskell Registry Introduction
 
-**Status:** published. Source version `0.6.1`, source
-tag `haskell/v0.6.1`. Published registry version: `0.6.0`. Registry
+**Status:** published. Source version `0.7.0`, source
+tag `haskell/v0.7.0`. Published registry version: `0.6.1`. Registry
 pages are release snapshots; verify the published version before relying on a
 feature.
 
@@ -14,12 +14,12 @@
 | Field | Value |
 | --- | --- |
 | Package | `praxo-core` |
-| Registry | [Hackage](https://hackage.haskell.org/package/praxo-core-0.6.0) |
-| Source version | `0.6.1` |
-| Published registry version | `0.6.0` |
+| Registry | [Hackage](https://hackage.haskell.org/package/praxo-core-0.6.1) |
+| Source version | `0.7.0` |
+| Published registry version | `0.6.1` |
 | Install (published) | `cabal install praxo-core` |
 | Install (source/release prepared) | `cabal install praxo-core` |
-| Source tag | `haskell/v0.6.1` |
+| Source tag | `haskell/v0.7.0` |
 | Tier | Core |
 | Contract | `SPEC_VERSION` `0.2.0` |
 | Documentation | https://axisvela.github.io/praxo-core/languages/haskell/ |
diff --git a/conformance/Main.hs b/conformance/Main.hs
--- a/conformance/Main.hs
+++ b/conformance/Main.hs
@@ -61,7 +61,7 @@
                 then pure (Right (A.toolCallArguments call))
                 else pure (Left (A.AgentError "TOOL_NOT_FOUND" "tool not found"))
         sink event = modifyIORef' events (++ [JString event]) >> pure (Right ())
-        options = A.AgentOptions model tool sink (fromInteger (number (field "maxSteps" input))) (number (field "maxTokens" input)) Nothing [] False False
+        options = A.AgentOptions model tool sink (fromInteger (number (field "maxSteps" input))) (number (field "maxTokens" input)) Nothing [] False False "run-conformance" "session-conformance" [] Nothing Nothing Nothing
     result <- A.runAgent options [] (asString (field "prompt" input))
     actualEvents <- readIORef events
     count <- readIORef invocations
diff --git a/llms.md b/llms.md
--- a/llms.md
+++ b/llms.md
@@ -7,12 +7,12 @@
 ## Package
 
 - package: `praxo-core`
-- registry: [Hackage](https://hackage.haskell.org/package/praxo-core-0.6.0)
-- source_version: `0.6.1`
-- published_version: `0.6.0`
+- registry: [Hackage](https://hackage.haskell.org/package/praxo-core-0.6.1)
+- source_version: `0.7.0`
+- published_version: `0.6.1`
 - install_published: `cabal install praxo-core`
 - install_source: `cabal install praxo-core`
-- source_tag: `haskell/v0.6.1`
+- source_tag: `haskell/v0.7.0`
 - tier: Core
 - contract: `SPEC_VERSION` `0.2.0`
 - documentation: https://axisvela.github.io/praxo-core/languages/haskell/
diff --git a/llms.txt b/llms.txt
--- a/llms.txt
+++ b/llms.txt
@@ -7,12 +7,12 @@
 # Package
 
 - package: `praxo-core`
-- registry: [Hackage](https://hackage.haskell.org/package/praxo-core-0.6.0)
-- source_version: `0.6.1`
-- published_version: `0.6.0`
+- registry: [Hackage](https://hackage.haskell.org/package/praxo-core-0.6.1)
+- source_version: `0.7.0`
+- published_version: `0.6.1`
 - install_published: `cabal install praxo-core`
 - install_source: `cabal install praxo-core`
-- source_tag: `haskell/v0.6.1`
+- source_tag: `haskell/v0.7.0`
 - tier: Core
 - contract: `SPEC_VERSION` `0.2.0`
 - documentation: https://axisvela.github.io/praxo-core/languages/haskell/
diff --git a/praxo-core.cabal b/praxo-core.cabal
--- a/praxo-core.cabal
+++ b/praxo-core.cabal
@@ -1,6 +1,6 @@
 cabal-version: 2.4
 name: praxo-core
-version: 0.6.1
+version: 0.7.0
 synopsis: Embeddable MIT-licensed agent framework for Haskell
 description: Native agent loop with tools, policy hooks, typed events, memory,
              checkpoints, context budgets, middleware, JSON Schema validation,
diff --git a/src/Praxo/Agent.hs b/src/Praxo/Agent.hs
--- a/src/Praxo/Agent.hs
+++ b/src/Praxo/Agent.hs
@@ -1,16 +1,40 @@
-module Praxo.Agent (AgentError(..), ToolCall(..), Message(..), Response(..), AgentOptions(..), RunResult(..), runAgent) where
+module Praxo.Agent (AgentError(..), ToolCall(..), Action(..), Interrupt(..), InterruptDecision(..), InterruptHandler, InterruptApproval, interruptApprove, interruptEdit, interruptReject, interruptRespond, Message(..), Response(..), AgentOptions(..), RunResult(..), runAgent) where
 
 import Data.Maybe (isNothing)
 
-import Praxo.Json (Json, encodeJson)
+import Praxo.Json (Json(..), encodeJson)
 
+interruptApprove :: String
+interruptApprove = "approve"
+
+interruptEdit :: String
+interruptEdit = "edit"
+
+interruptReject :: String
+interruptReject = "reject"
+
+interruptRespond :: String
+interruptRespond = "respond"
+
 data AgentError = AgentError { errorCode :: String, errorMessage :: String } deriving (Eq, Show)
 data ToolCall = ToolCall { toolCallId :: String, toolCallName :: String, toolCallArguments :: Json } deriving (Eq, Show)
+data Action = Action { actionKind :: String, actionSessionId :: String, actionToolName :: String, actionArguments :: Json } deriving (Eq, Show)
+data Interrupt = Interrupt { interruptRunId :: String, interruptSessionId :: String, interruptCall :: ToolCall } deriving (Eq, Show)
+data InterruptDecision = InterruptDecision { interruptAction :: String, interruptArguments :: Maybe Json, interruptResponse :: String, interruptReason :: String } deriving (Eq, Show)
+type InterruptHandler = Interrupt -> IO InterruptDecision
+type InterruptApproval = Interrupt -> IO Bool
 data Message = Message { messageRole :: String, messageContent :: String, messageToolCalls :: [ToolCall], messageToolCallId :: String } deriving (Eq, Show)
 data Response = Response { responseContent :: String, responseToolCalls :: [ToolCall], inputTokens :: Integer, outputTokens :: Integer } deriving (Eq, Show)
-data AgentOptions = AgentOptions { generate :: [Message] -> IO (Either AgentError Response), invoke :: ToolCall -> IO (Either AgentError Json), emit :: String -> IO (Either AgentError ()), maxSteps :: Int, maxTokens :: Integer, policy :: Maybe (String -> Bool), allowedTools :: [String], requirePolicy :: Bool, requireToolScope :: Bool }
+data AgentOptions = AgentOptions { generate :: [Message] -> IO (Either AgentError Response), invoke :: ToolCall -> IO (Either AgentError Json), emit :: String -> IO (Either AgentError ()), maxSteps :: Int, maxTokens :: Integer, policy :: Maybe (Action -> Bool), allowedTools :: [String], requirePolicy :: Bool, requireToolScope :: Bool, runId :: String, sessionId :: String, interruptOn :: [String], onInterruptDecision :: Maybe InterruptHandler, onInterrupt :: Maybe InterruptApproval, beforeTool :: Maybe (ToolCall -> IO (Either AgentError ToolCall)) }
 data RunResult = RunResult { runOutput :: String, runSteps :: Int, runInputTokens :: Integer, runOutputTokens :: Integer, runMessages :: [Message] } deriving (Eq, Show)
 
+data InterruptOutcome = InterruptOutcome
+    { outcomeSkip :: Bool
+    , outcomeResponse :: String
+    , outcomeCall :: ToolCall
+    , outcomeEdited :: Bool
+    }
+
 ensureAllowed :: Either AgentError () -> IO (Either AgentError a) -> IO (Either AgentError a)
 ensureAllowed (Left err) _ = pure (Left err)
 ensureAllowed (Right ()) action = action
@@ -44,16 +68,19 @@
         | requireToolScope opts && null (allowedTools opts) =
             Just (AgentError "AGENT_INVALID_OPTIONS" "agent: require tool scope: allowedTools must not be empty")
         | otherwise = Nothing
-    authorize kind = case policy options of
+    authorize kind call = case policy options of
         Nothing -> Right ()
-        Just hook -> if hook kind then Right () else Left (AgentError "AGENT_POLICY_DENIED" ("agent: " ++ kind ++ " denied"))
+        Just hook ->
+            if hook (Action kind (sessionId options) (toolCallName call) (toolCallArguments call))
+                then Right ()
+                else Left (AgentError "AGENT_POLICY_DENIED" ("agent: " ++ kind ++ " denied"))
     checkTool call
         | not (null (allowedTools options)) && toolCallName call `notElem` allowedTools options =
             Left (AgentError "AGENT_TOOL_NOT_ALLOWED" ("agent: tool " ++ toolCallName call ++ " is not allowed"))
-        | otherwise = authorize "tool.invoke"
+        | otherwise = authorize "tool.invoke" call
     loop step usedIn usedOut messages
         | step > limit = pure (Left (AgentError "AGENT_MAX_STEPS" "agent: maximum steps exceeded"))
-        | otherwise = ensureAllowed (authorize "model.generate") $ do
+        | otherwise = ensureAllowed (authorize "model.generate" (ToolCall "" "" JNull)) $ do
             generated <- generate options messages
             case generated of
                 Left err -> pure (Left err)
@@ -73,14 +100,78 @@
                                     Left err -> pure (Left err)
                                     Right updated -> loop (step + 1) totalIn totalOut updated
     tools messages [] = pure (Right messages)
-    tools messages (call:rest) = ensureAllowed (checkTool call) $ do
-        event <- emit options "tool.call"
-        case event of
-            Left err -> pure (Left err)
-            Right () -> do
-                result <- invoke options call
-                case result of
-                    Left err -> pure (Left err)
-                    Right value -> case encodeJson value of
-                        Left detail -> pure (Left (AgentError "TOOL_RESULT" detail))
-                        Right content -> tools (messages ++ [Message "tool" content [] (toolCallId call)]) rest
+    tools messages (call:rest) = case checkTool call of
+        Left err -> pure (Left err)
+        Right () -> do
+            prepared <- applyBeforeTool call
+            case prepared of
+                Left err -> pure (Left err)
+                Right active -> do
+                    interrupted <- applyInterrupt active
+                    case interrupted of
+                        Left err -> pure (Left err)
+                        Right outcome
+                            | outcomeSkip outcome -> finishSkipped messages outcome rest
+                            | otherwise -> do
+                                let final = outcomeCall outcome
+                                    recheck = if outcomeEdited outcome || final /= call
+                                        then checkTool final
+                                        else Right ()
+                                ensureAllowed recheck $ do
+                                    event <- emit options "tool.call"
+                                    case event of
+                                        Left err -> pure (Left err)
+                                        Right () -> do
+                                            result <- invoke options final
+                                            case result of
+                                                Left err -> pure (Left err)
+                                                Right value -> case encodeJson value of
+                                                    Left detail -> pure (Left (AgentError "TOOL_RESULT" detail))
+                                                    Right content -> tools (messages ++ [Message "tool" content [] (toolCallId final)]) rest
+    finishSkipped messages outcome rest =
+        case encodeJson (JString (outcomeResponse outcome)) of
+            Left detail -> pure (Left (AgentError "TOOL_RESULT" detail))
+            Right content -> tools (messages ++ [Message "tool" content [] (toolCallId (outcomeCall outcome))]) rest
+    applyBeforeTool call = case beforeTool options of
+        Nothing -> pure (Right call)
+        Just handler -> handler call
+    applyInterrupt call
+        | toolCallName call `notElem` interruptOn options =
+            pure (Right (InterruptOutcome False "" call False))
+        | isNothing (onInterruptDecision options) && isNothing (onInterrupt options) =
+            pure (Left (AgentError "AGENT_INTERRUPT_UNHANDLED"
+                ("agent: approval handler not configured: " ++ toolCallName call)))
+        | otherwise = do
+            event <- emit options "tool.interrupt"
+            case event of
+                Left err -> pure (Left err)
+                Right () -> do
+                    let pending = Interrupt (runId options) (sessionId options) call
+                    case onInterruptDecision options of
+                        Just handler -> fmap (applyDecision call) (handler pending)
+                        Nothing -> case onInterrupt options of
+                            Just approval -> do
+                                approved <- approval pending
+                                pure $ if approved
+                                    then Right (InterruptOutcome False "" call False)
+                                    else Left (AgentError "AGENT_APPROVAL_DENIED"
+                                        ("agent: tool call denied by approval: " ++ toolCallName call))
+                            Nothing -> pure (Left (AgentError "AGENT_INTERRUPT_UNHANDLED"
+                                ("agent: approval handler not configured: " ++ toolCallName call)))
+    applyDecision call decision
+        | interruptAction decision == interruptApprove =
+            Right (InterruptOutcome False "" call False)
+        | interruptAction decision == interruptEdit =
+            case interruptArguments decision of
+                Nothing -> Left (AgentError "AGENT_INTERRUPT_DECISION_INVALID" "agent: edit requires arguments")
+                Just arguments -> Right (InterruptOutcome False ""
+                    (call { toolCallArguments = arguments }) True)
+        | interruptAction decision == interruptReject =
+            Left (AgentError "AGENT_APPROVAL_DENIED"
+                ("agent: tool call denied by approval: " ++ toolCallName call ++ ": "
+                    ++ interruptReason decision))
+        | interruptAction decision == interruptRespond =
+            Right (InterruptOutcome True (interruptResponse decision) call False)
+        | otherwise =
+            Left (AgentError "AGENT_INTERRUPT_DECISION_INVALID"
+                ("agent: invalid interrupt decision: " ++ show (interruptAction decision)))
diff --git a/src/Praxo/Wire.hs b/src/Praxo/Wire.hs
--- a/src/Praxo/Wire.hs
+++ b/src/Praxo/Wire.hs
@@ -4,4 +4,4 @@
 specVersion = "0.2.0"
 
 sdkVersion :: String
-sdkVersion = "0.6.1"
+sdkVersion = "0.7.0"
diff --git a/tests/Main.hs b/tests/Main.hs
--- a/tests/Main.hs
+++ b/tests/Main.hs
@@ -26,6 +26,7 @@
 main :: IO ()
 main = do
     agentTests
+    hitlTests
     runtimeTests
     middlewareTests
     adapterTests
@@ -33,7 +34,7 @@
     harmovelaTests
     mcpTests
     seamTests
-    assert "contract version" (specVersion == "0.2.0" && sdkVersion == "0.6.1")
+    assert "contract version" (specVersion == "0.2.0" && sdkVersion == "0.7.0")
     forM_ ["", "01", "1.", "+1", "NaN", "1e", "[1,]", "{\"a\":1,}", "{}{}", "\"\\q\"", "\"\\ud800\"", "\"\\udc00\"", "\"\\ud800\\u0041\"", "\"line\nbreak\"", "true garbage"] $ \raw ->
         assert ("invalid JSON " ++ show raw) (isLeft (parseJson raw))
     assert "unicode escape" (parseJson "\"\\u00e9\\ud83d\\ude00\"" == Right (JString "\x00e9\x1f600"))
@@ -103,7 +104,7 @@
             n <- readIORef calls
             pure (Right (if n == 0 then A.Response "" [call] 2 1 else A.Response "done" [] 1 1))
         tool _ = modifyIORef' calls (+1) >> pure (Right JNull)
-        options = A.AgentOptions model tool sink 2 5 Nothing [] False False
+        options = A.AgentOptions model tool sink 2 5 Nothing [] False False "run-test" "session-test" [] Nothing Nothing Nothing
     result <- A.runAgent options [] "hello"
     assert "agent success and usage" (case result of Right r -> A.runSteps r == 2 && A.runInputTokens r == 3 && A.runOutputTokens r == 2; _ -> False)
     history <- readIORef requests
@@ -173,6 +174,125 @@
     writeIORef calls 1
     defaults <- A.runAgent options [] "x"
     assert "safe defaults preserve behavior" (case defaults of Right r -> A.runOutput r == "done"; _ -> False)
+
+hitlTests :: IO ()
+hitlTests = do
+    let echoCall = A.ToolCall "call-1" "echo" (JObject [("value", JString "original")])
+        model messages = pure $ Right $ case reverse messages of
+            (lastMessage:_) | A.messageRole lastMessage == "tool" -> A.Response "final" [] 0 0
+            _ -> A.Response "" [echoCall] 0 0
+        echoModel messages = pure $ Right $ case reverse messages of
+            (lastMessage:_) | A.messageRole lastMessage == "tool" -> A.Response (A.messageContent lastMessage) [] 0 0
+            _ -> A.Response "" [echoCall] 0 0
+        base tool = A.AgentOptions
+            { A.generate = model
+            , A.invoke = tool
+            , A.emit = \_ -> pure (Right ())
+            , A.maxSteps = 4
+            , A.maxTokens = 0
+            , A.policy = Nothing
+            , A.allowedTools = ["echo"]
+            , A.requirePolicy = False
+            , A.requireToolScope = False
+            , A.runId = "run-hitl"
+            , A.sessionId = "session-hitl"
+            , A.interruptOn = ["echo"]
+            , A.onInterruptDecision = Nothing
+            , A.onInterrupt = Nothing
+            , A.beforeTool = Nothing
+            }
+
+    approveCalls <- newIORef []
+    approveEvents <- newIORef []
+    let approveTool call = modifyIORef' approveCalls (++ [A.toolCallArguments call]) >> pure (Right (A.toolCallArguments call))
+        approveOptions = (base approveTool)
+            { A.emit = \name -> modifyIORef' approveEvents (++ [name]) >> pure (Right ())
+            , A.onInterruptDecision = Just $ \interrupt -> do
+                assert "hitl interrupt run id" (A.interruptRunId interrupt == "run-hitl")
+                assert "hitl interrupt session id" (A.interruptSessionId interrupt == "session-hitl")
+                assert "hitl interrupt call" (A.toolCallName (A.interruptCall interrupt) == "echo")
+                assert "hitl interrupt arguments" (A.toolCallArguments (A.interruptCall interrupt) == JObject [("value", JString "original")])
+                pure (A.InterruptDecision A.interruptApprove Nothing "" "")
+            }
+    approved <- A.runAgent approveOptions [] "go"
+    approveCallValues <- readIORef approveCalls
+    approveEventValues <- readIORef approveEvents
+    assert "hitl approve" (case approved of Right r -> A.runOutput r == "final"; _ -> False)
+    assert "hitl approve effects" (approveCallValues == [JObject [("value", JString "original")]])
+    assert "hitl interrupt event order" (approveEventValues == ["run.started", "tool.interrupt", "tool.call", "run.completed"])
+
+    editCalls <- newIORef []
+    editOrder <- newIORef []
+    let editTool call = modifyIORef' editCalls (++ [call]) >> pure (Right JNull)
+        editPolicy action
+            | A.actionKind action == "model.generate" = True
+            | otherwise = asString (field "value" (A.actionArguments action)) == "original"
+        editOptions = (base editTool)
+            { A.policy = Just editPolicy
+            , A.beforeTool = Just $ \call -> do
+                modifyIORef' editOrder (++ ["before"])
+                pure (Right call)
+            , A.onInterruptDecision = Just $ \_ -> do
+                current <- readIORef editOrder
+                assert "hitl before middleware precedes interrupt" (current == ["before"])
+                modifyIORef' editOrder (++ ["interrupt"])
+                pure (A.InterruptDecision A.interruptEdit (Just (JObject [("value", JString "edited")])) "" "")
+            }
+    edited <- A.runAgent editOptions [] "go"
+    editCallValues <- readIORef editCalls
+    editOrderValues <- readIORef editOrder
+    assert "hitl edit reauthorization denied" (case edited of Left err -> A.errorCode err == "AGENT_POLICY_DENIED"; _ -> False)
+    assert "hitl edit no effects" (null editCallValues)
+    assert "hitl middleware before interrupt order" (editOrderValues == ["before", "interrupt"])
+
+    rejectCalls <- newIORef []
+    let rejectOptions = (base (\call -> modifyIORef' rejectCalls (++ [call]) >> pure (Right JNull)))
+            { A.onInterruptDecision = Just $ \_ -> pure (A.InterruptDecision A.interruptReject Nothing "" "not allowed") }
+    rejected <- A.runAgent rejectOptions [] "go"
+    rejectCallValues <- readIORef rejectCalls
+    assert "hitl reject code" (case rejected of Left err -> A.errorCode err == "AGENT_APPROVAL_DENIED" && "not allowed" `isInfixOf` A.errorMessage err; _ -> False)
+    assert "hitl reject no effects" (null rejectCallValues)
+
+    respondCalls <- newIORef []
+    let respondOptions = (base (\call -> modifyIORef' respondCalls (++ [call]) >> pure (Right JNull)))
+            { A.generate = echoModel
+            , A.onInterruptDecision = Just $ \_ -> pure (A.InterruptDecision A.interruptRespond Nothing "human answer" "")
+            }
+    responded <- A.runAgent respondOptions [] "go"
+    respondCallValues <- readIORef respondCalls
+    assert "hitl respond output" (case responded of Right r -> A.runOutput r == "\"human answer\""; _ -> False)
+    assert "hitl respond no effects" (null respondCallValues)
+
+    unhandledCalls <- newIORef []
+    unhandled <- A.runAgent (base (\call -> modifyIORef' unhandledCalls (++ [call]) >> pure (Right JNull))) [] "go"
+    unhandledCallValues <- readIORef unhandledCalls
+    assert "hitl unhandled code" (case unhandled of Left err -> A.errorCode err == "AGENT_INTERRUPT_UNHANDLED"; _ -> False)
+    assert "hitl unhandled no effects" (null unhandledCallValues)
+
+    invalidCalls <- newIORef []
+    let invalidOptions = (base (\call -> modifyIORef' invalidCalls (++ [call]) >> pure (Right JNull)))
+            { A.onInterruptDecision = Just $ \_ -> pure (A.InterruptDecision "invalid" Nothing "" "") }
+    invalid <- A.runAgent invalidOptions [] "go"
+    invalidCallValues <- readIORef invalidCalls
+    assert "hitl invalid decision code" (case invalid of Left err -> A.errorCode err == "AGENT_INTERRUPT_DECISION_INVALID"; _ -> False)
+    assert "hitl invalid decision no effects" (null invalidCallValues)
+
+    missingArgumentsCalls <- newIORef []
+    let missingArgumentsOptions = (base (\call -> modifyIORef' missingArgumentsCalls (++ [call]) >> pure (Right JNull)))
+            { A.onInterruptDecision = Just $ \_ -> pure (A.InterruptDecision A.interruptEdit Nothing "" "") }
+    missingArguments <- A.runAgent missingArgumentsOptions [] "go"
+    missingArgumentsCallValues <- readIORef missingArgumentsCalls
+    assert "hitl edit requires arguments" (case missingArguments of Left err -> A.errorCode err == "AGENT_INTERRUPT_DECISION_INVALID"; _ -> False)
+    assert "hitl edit missing arguments no effects" (null missingArgumentsCallValues)
+
+    approvalCalls <- newIORef []
+    let approvalOptions = (base (\call -> modifyIORef' approvalCalls (++ [call]) >> pure (Right JNull)))
+            { A.onInterrupt = Just $ \_ -> pure False }
+    approval <- A.runAgent approvalOptions [] "go"
+    approvalCallValues <- readIORef approvalCalls
+    assert "hitl approval denial code" (case approval of Left err -> A.errorCode err == "AGENT_APPROVAL_DENIED"; _ -> False)
+    assert "hitl approval denial no effects" (null approvalCallValues)
+
 
 runtimeTests :: IO ()
 runtimeTests = do
