M4.4: an unreachable build VM blocks its projects until it's back (#137)

M4.3's block, with new triggers and a way out. A VM out of reach at the
check before a run, in a run (which ends there: the driver, a toolchain
step and a requested step), or while preparing the workspace blocks every
project on it; the item stays ready, waiting on no one. On the intake round
it is tried again every tuning.build_vm.retry_s (300), and once it answers
it must still answer settle_s (180) later; then the work a lost run left
there is parked (pushed), the VM unblocked, and that said once.

A changed host key, at the check or on a retry, blocks the VM too, until
the operator's `vm ready`, which trusts the new key: `trust new host key`
is retired, and the message says it's a key problem that may be an
impersonation. Questions are answered while a VM is blocked, without it.
Starting the agent with a VM down no longer fails.

The walk breaks the VM's SSH, now or partway through a run, and checks that
no model works on a VM that is down; loop.qnt models the VM going and
coming back (unblocked_only_when_up). Together they found: a lost run's
work set aside by the next item there; a question left behind a block; a
lost VM swallowed while the toolchain step checked or recorded it; and a
remark waiting to be answered that outlived its PR's merge. All fixed.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J5Utyfzw7gF7UhjRDEtjTk

nisse-dev/src/nisse_dev/loop/driver.py

@@ -29,13 +29,19 @@ _PROSE_NUDGE = (
 
 @dataclass(frozen=True)
 class RunOutcome:
-    # stuck: failed commands in a row hit the failure limit (L9's trigger)
-    kind: Literal["wait", "capped", "stuck", "stopped", "failed"]
+    # stuck: failed commands in a row hit the failure limit (L9's trigger);
+    # unreachable: the build VM went out of reach (#137), noted in ``note``
+    kind: Literal["wait", "capped", "stuck", "stopped", "failed", "unreachable"]
     tool: str = ""  # the waiting tool called
     arguments: dict[str, Any] | None = None
     note: str = ""
 
 
+class VMUnreachable(Exception):
+    """Raised by a handler whose work found the build VM out of reach: the
+    run ends there, as for an execution call (#137)."""
+
+
 # The waiting outcome a dangerous action ends a run with (P3): the harness
 # puts it to the operator, rendered from the action itself.
 ASK_ALLOW = "ask_allow"
@@ -157,7 +163,10 @@ class Driver:
                     )
                     return RunOutcome("wait", call.tool, dict(call.arguments))
                 if call.tool in handlers and call.tool in offered:
-                    result, ok = handlers[call.tool](dict(call.arguments))
+                    try:
+                        result, ok = handlers[call.tool](dict(call.arguments))
+                    except VMUnreachable as exc:
+                        return self._unreachable(transcript, calls, index, str(exc))
                 elif call.tool not in offered or workspace is None:
                     result, ok = (
                         f"no such tool: {call.tool}; the tools are "
@@ -200,6 +209,12 @@ class Driver:
                         )
                         break
                     outcome = workspace.dispatch(call.tool, call.arguments)
+                    if outcome.unreachable:
+                        # Not the work failing: no model call works on a VM
+                        # that isn't there (P6).
+                        return self._unreachable(
+                            transcript, calls, index, outcome.result
+                        )
                     result, ok = outcome.result, outcome.success
                     if screening.note:
                         result = f"{result}\n\n[harness] {screening.note}"
@@ -219,6 +234,20 @@ class Driver:
                         )
         return RunOutcome("capped", note=f"hit the {cap}-turn cap")
 
+    @staticmethod
+    def _unreachable(
+        transcript: Transcript, calls: list[ToolCall], index: int, said: str
+    ) -> RunOutcome:
+        transcript.append(
+            ToolResult(
+                call_id=calls[index].call_id,
+                result=f"not finished: {said}; your turn has ended",
+                success=False,
+            )
+        )
+        skip_calls(transcript, calls[index + 1 :], "not run: the turn had ended")
+        return RunOutcome("unreachable", note=said)
+
 
 def _brief(call: ToolCall, result: str) -> str:
     """A failed command and the end of what it said, for a helper's brief."""