@@ -134,6 +134,14 @@ PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=src python -m aethermesh_core.cli dispatch-
 
 The dispatch log contains deterministic `node_heartbeat` messages for available nodes and `job_assigned` messages for scheduled jobs. Heartbeat payloads include each available node's manifest capabilities. Use `process-local-inbox` to consume the dispatch log later for one node and record validation-gated contribution.
 
+Dispatch jobs to peers discovered from an existing local heartbeat message log instead of from manifest `nodes`:
+
+```bash
+PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=src python -m aethermesh_core.cli dispatch-local-peers --peer-message-log-path ./local-peers.json --manifest examples/local-batch.json --message-log-path ./local-peer-dispatch.json
+```
+
+This remains local message-log discovery only. The command reads jobs from the manifest, builds the scheduling roster from latest `node_heartbeat` messages, ignores offline peers for assignment, and writes the same assignment-only dispatch log shape used by local inbox processing.
+
 To test the file-backed local transport seam, materialize addressed dispatch messages into per-node inbox files and have a node consume only its own inbox:
 
 ```bash
 
@@ -14,7 +14,11 @@
 from aethermesh_core.dispatch import dispatch_local_batch
 from aethermesh_core.flow_audit import FlowAuditError, audit_local_flow
 from aethermesh_core.identity import IdentityPersistenceError, load_or_create_identity
-from aethermesh_core.job_manifest import ManifestError, load_job_manifest
+from aethermesh_core.job_manifest import (
+    ManifestError,
+    load_job_manifest,
+    load_job_manifest_jobs,
+)
 from aethermesh_core.ledger import (
     ContributionLedger,
     LedgerPersistenceError,
@@ -48,7 +52,11 @@
     load_node_processing_state,
     save_node_processing_state,
 )
-from aethermesh_core.peer_registry import PeerRegistryError, peer_summary_document
+from aethermesh_core.peer_registry import (
+    PeerRegistryError,
+    peer_summary_document,
+    scheduled_nodes_from_heartbeat_log,
+)
 from aethermesh_core.receipts import (
     ReceiptPersistenceError,
     build_receipt_document,
@@ -144,6 +152,26 @@ def build_parser() -> argparse.ArgumentParser:
         help="Path to write the version 1 assignment-only local message log.",
     )
 
+    peer_dispatch = subcommands.add_parser(
+        "dispatch-local-peers",
+        help="Write local dispatch messages using heartbeat-discovered peers.",
+    )
+    peer_dispatch.add_argument(
+        "--peer-message-log-path",
+        required=True,
+        help="Path to an existing version 1 message log with node heartbeats.",
+    )
+    peer_dispatch.add_argument(
+        "--manifest",
+        required=True,
+        help="Path to a version 1 local job manifest whose jobs should be dispatched.",
+    )
+    peer_dispatch.add_argument(
+        "--message-log-path",
+        required=True,
+        help="Path to write the version 1 assignment-only local message log.",
+    )
+
     local_flow = subcommands.add_parser(
         "run-local-flow",
         help="Run dispatch plus all available local worker inboxes for a manifest.",
@@ -431,6 +459,36 @@ def dispatch_local_batch_command(
     return dispatch.to_dict()
 
 
+def dispatch_local_peers_command(
+    peer_message_log_path: str,
+    manifest_path: str,
+    message_log_path: str,
+) -> dict[str, object]:
+    """Dispatch manifest jobs to nodes discovered from heartbeat messages."""
+
+    nodes = scheduled_nodes_from_heartbeat_log(peer_message_log_path)
+    jobs = load_job_manifest_jobs(manifest_path)
+    dispatch = dispatch_local_batch(
+        manifest_path=manifest_path,
+        message_log_path=message_log_path,
+        nodes=nodes,
+        jobs=jobs,
+    )
+    message_log_document = build_dispatch_message_log_document(
+        messages=dispatch.messages,
+        jobs=dispatch.jobs,
+        nodes=dispatch.nodes,
+        assignments=dispatch.assignments,
+        manifest_path=manifest_path,
+        source="dispatch-local-peers",
+    )
+    write_message_log(message_log_path, message_log_document)
+    payload = dispatch.to_dict()
+    payload["command"] = "dispatch-local-peers"
+    payload["peer_message_log_path"] = peer_message_log_path
+    return payload
+
+
 def summarize_ledger(ledger_path: str) -> dict[str, object]:
     """Load an existing ledger and return read-only aggregate totals."""
 
@@ -837,6 +895,20 @@ def main(argv: Sequence[str] | None = None) -> int:
         print(json.dumps(payload, sort_keys=True))
         return 0
 
+    if args.command == "dispatch-local-peers":
+        try:
+            payload = dispatch_local_peers_command(
+                args.peer_message_log_path, args.manifest, args.message_log_path
+            )
+        except (ManifestError, PeerRegistryError, MessageLogPersistenceError) as exc:
+            print(f"error: {exc}", file=sys.stderr)
+            return 1
+        except ValueError as exc:
+            print(f"error: local peer dispatch failed: {exc}", file=sys.stderr)
+            return 1
+        print(json.dumps(payload, sort_keys=True))
+        return 0
+
     if args.command == "run-local-flow":
         try:
             payload = run_local_flow(args.manifest, args.output_dir)
 
@@ -36,6 +36,21 @@ def node_ids(self) -> list[str]:
 def load_job_manifest(path: str | Path) -> LocalJobBatch:
     """Load and validate a version 1 local job-batch manifest."""
 
+    document = _load_manifest_document(path)
+    return LocalJobBatch(
+        nodes=_parse_nodes(document.get("nodes")),
+        jobs=_parse_jobs(document.get("jobs")),
+    )
+
+
+def load_job_manifest_jobs(path: str | Path) -> list[Job]:
+    """Load only jobs from a version 1 manifest, ignoring any node roster."""
+
+    document = _load_manifest_document(path)
+    return _parse_jobs(document.get("jobs"))
+
+
+def _load_manifest_document(path: str | Path) -> dict[str, Any]:
     manifest_path = Path(path)
     try:
         raw_manifest = manifest_path.read_text(encoding="utf-8")
@@ -55,11 +70,7 @@ def load_job_manifest(path: str | Path) -> LocalJobBatch:
         raise ManifestError("manifest version must be integer 1")
     if version != 1:
         raise ManifestError(f"unsupported manifest version: {version}")
-
-    return LocalJobBatch(
-        nodes=_parse_nodes(document.get("nodes")),
-        jobs=_parse_jobs(document.get("jobs")),
-    )
+    return document
 
 
 def _parse_nodes(value: Any) -> list[ScheduledNode]:
 
@@ -88,13 +88,14 @@ def build_dispatch_message_log_document(
     nodes: list[ScheduledNode],
     assignments: list[JobAssignment],
     manifest_path: str | Path,
+    source: str = "dispatch-local-batch",
 ) -> dict[str, Any]:
     """Build a deterministic version 1 assignment-only dispatch document."""
 
     return {
         "version": 1,
         "metadata": {
-            "source": "dispatch-local-batch",
+            "source": source,
             "manifest_path": str(manifest_path),
             "message_count": len(messages),
             "node_count": len(nodes),
 
@@ -11,6 +11,7 @@
     load_message_log_messages,
 )
 from aethermesh_core.messages import MeshMessage
+from aethermesh_core.scheduler import NodeStatus, ScheduledNode
 
 
 class PeerRegistryError(ValueError):
@@ -81,6 +82,50 @@ def peer_summary_document(message_log_path: str | Path) -> dict[str, object]:
     }
 
 
+def scheduled_nodes_from_heartbeat_log(
+    message_log_path: str | Path,
+) -> list[ScheduledNode]:
+    """Build deterministic scheduler nodes from latest local heartbeats.
+
+    The input message log is read-only. Returned nodes are sorted by node id so a
+    repeated dispatch from the same heartbeat log produces stable assignment
+    ordering independent of the original message ordering.
+    """
+
+    document = peer_summary_document(message_log_path)
+    raw_peers = document["peers"]
+    if not isinstance(raw_peers, list):
+        raise PeerRegistryError("peer summary peers must be a list")
+
+    nodes: list[ScheduledNode] = []
+    for peer in raw_peers:
+        if not isinstance(peer, dict):
+            raise PeerRegistryError("peer summary entries must be objects")
+        node_id = peer.get("node_id")
+        raw_status = peer.get("status")
+        raw_capabilities = peer.get("capabilities")
+        if not isinstance(node_id, str) or node_id == "":
+            raise PeerRegistryError("peer node_id must be a non-empty string")
+        if not isinstance(raw_status, str):
+            raise PeerRegistryError(f"peer {node_id} status must be a string")
+        try:
+            status = NodeStatus(raw_status)
+        except ValueError as exc:
+            supported = ", ".join(status.value for status in NodeStatus)
+            raise PeerRegistryError(
+                f"peer {node_id} status must be one of: {supported}"
+            ) from exc
+        capabilities = _parse_capabilities(raw_capabilities, f"peer {node_id}")
+        nodes.append(
+            ScheduledNode(
+                node_id=node_id,
+                status=status,
+                capabilities=tuple(capabilities),
+            )
+        )
+    return nodes
+
+
 def _parse_heartbeat(message: MeshMessage) -> PeerSummary:
     payload = message.payload
     node_id = payload.get("node_id")