feat(orchestration): always-on resume across the agent graph

A scan that crashes or is stopped can now be resumed by re-invoking
``strix`` with the same ``--run-name``. Resume is implicit — presence
of ``{run_dir}/bus.json`` triggers it. To force a fresh start, delete
the run dir.

What survives a process restart with the same scan_id:

  * Root agent's LLM history — already worked (root SDK SQLiteSession).
  * Every non-terminal subagent's LLM history — new. ``create_agent``
    now opens SQLiteSession(session_id=child_id,
    db_path={run_dir}/sessions/{child_id}.db) per child and passes it
    to ``run_with_continuation``.
  * Bus topology — new. ``AgentMessageBus`` gains snapshot/restore/
    _maybe_snapshot async methods plus a ``metadata`` field that holds
    per-agent {task, skills, is_whitebox, scan_mode, diff_scope}.
    ``register``, ``finalize``, ``park``, and ``mark_llm_failed`` each
    call ``_maybe_snapshot`` to atomically persist the bus to
    {run_dir}/bus.json (tempfile + Path.replace).
  * Vulnerability reports — new. ``ScanArtifactWriter._write_
    vulnerabilities`` now also writes ``vulnerabilities.json``
    (atomic). ``Tracer.hydrate_from_run_dir`` reads it on resume so
    new vuln-NNNN ids don't collide with prior on-disk files.

What does not survive: the sandbox container itself (fresh per
process), so ``/workspace/scratch`` and Caido state are lost.
``/workspace/sources`` re-mounts from the host so source code is
unchanged.

``orchestration/scan.py:run_strix_scan`` does the actual resume:
  1. Resolve run_dir up front; if bus.json exists it's a resume.
  2. Acquire {run_dir}/.lock (fcntl.flock) so a second strix process
     can't run concurrently on the same scan_id.
  3. ``bus.set_snapshot_path(...)``, ``tracer.hydrate_from_run_dir()``.
  4. On resume: load + bus.restore, find root_id from snapshot (the
     agent with parent_of[id] is None), spawn the sandbox, skip the
     root's bus.register (already in snapshot).
  5. ``_respawn_subagents`` walks every agent with status in
     running/waiting/llm_failed: reopens its SQLiteSession, rebuilds
     the child agent via the captured factory, builds run config /
     context, asyncio.create_task the run with initial_input=[] so
     the SDK replays from session. Per-child failure (missing/corrupt
     DB, factory raises) finalizes that child as crashed and continues.
  6. Open root SQLiteSession at the same path, run the root with
     initial_input=[] on resume (or the formatted root task on a
     fresh run), and let SDK replay drive the next turn.
  7. ``finally``: close every per-agent session, take a final
     snapshot, tear down sandbox, release the lock.

HARNESS_WIKI.md updated with the new run-dir layout (sessions/,
bus.json, vulnerabilities.json, .lock) and the resume contract.

Net: +500 LoC across 7 files. No new deps.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

strix/tools/agents_graph/tools.py

@@ -20,10 +20,12 @@ import json
 import logging
 import uuid
 from datetime import UTC, datetime
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
 
 from agents import RunConfig, RunContextWrapper, function_tool
 from agents.items import TResponseInputItem
+from agents.memory import SQLiteSession
 from agents.model_settings import ModelSettings
 from agents.sandbox import SandboxRunConfig
 
@@ -454,7 +456,16 @@ async def create_agent(
             default=str,
         )
 
-    await bus.register(child_id, name, parent_id)
+    await bus.register(
+        child_id,
+        name,
+        parent_id,
+        task=task,
+        skills=list(skills or []),
+        is_whitebox=bool(inner.get("is_whitebox", False)),
+        scan_mode=str(inner.get("scan_mode", "deep")),
+        diff_scope=inner.get("diff_scope"),
+    )
 
     # ``ctx.turn_input`` carries the parent's full conversation up to and
     # including the call that's currently invoking ``create_agent``
@@ -503,13 +514,35 @@ async def create_agent(
         "agent_finish_called": False,
         "is_whitebox": bool(inner.get("is_whitebox", False)),
         "interactive": bool(inner.get("interactive", False)),
+        "scan_mode": str(inner.get("scan_mode", "deep")),
         "diff_scope": inner.get("diff_scope"),
         "run_id": inner.get("run_id"),
         "agent_factory": factory,
         # Stashed for ``agent_finish`` to echo back in its completion report.
         "task": task,
+        # Inherited so ``create_agent`` calls from this child can also
+        # add their per-child sessions to the same teardown list.
+        "_sessions_to_close": inner.get("_sessions_to_close", []),
     }
 
+    # Per-child SQLiteSession at ``{run_dir}/sessions/{child_id}.db`` so
+    # this subagent's full conversation survives a process restart and
+    # can be replayed by the SDK on resume. Path is derived from the
+    # tracer's run_dir (root-side construction in
+    # :func:`run_strix_scan`); fall back to ``./strix_runs/{run_id}/`` if
+    # the tracer is absent (unit-test path).
+    tracer = inner.get("tracer")
+    if tracer is not None and hasattr(tracer, "get_run_dir"):
+        child_session_path = tracer.get_run_dir() / "sessions" / f"{child_id}.db"
+    else:
+        run_id = inner.get("run_id") or "default"
+        child_session_path = Path.cwd() / "strix_runs" / str(run_id) / "sessions" / f"{child_id}.db"
+    child_session_path.parent.mkdir(parents=True, exist_ok=True)
+    child_session = SQLiteSession(session_id=child_id, db_path=child_session_path)
+    sessions_list = child_ctx.get("_sessions_to_close")
+    if isinstance(sessions_list, list):
+        sessions_list.append(child_session)
+
     child_model_settings = ModelSettings(
         parallel_tool_calls=False,
         tool_choice="required",
@@ -544,6 +577,7 @@ async def create_agent(
             bus=bus,
             agent_id=child_id,
             interactive=bool(inner.get("interactive", False)),
+            session=child_session,
         ),
         name=f"agent-{name}-{child_id}",
     )