Add OTel tracing, runBatch streaming, on-demand handler init, and finecode-user.toml

- Add ITracingHooks protocol (finecode_jsonrpc) and JsonRpcTracingHooks
  implementations in WM and ER; wire into JsonRpcClient and
  JsonRpcServerSession for per-hop envelope spans. Add lsp_request_span,
  mcp_tool_span, attach_incoming_traceparent, add_span_event helpers.
  Scatter span events across the ER handler execution path.

- Rewrite _handle_run_batch_with_partial_results to use the ER streaming
  path (run_with_partial_results) per action/project so ER partials are
  forwarded to the CLI as they arrive rather than after the full action
  completes.

- Propagate result_formats through _TrackingPartialResultSender and
  partial_result_sender.schedule_sending to the ER.

- Add deferred extension activators to Registry so handlers can be
  initialized on demand; expose initialize_all_handlers flag on add_dir
  and use it in CLI own-server mode to skip eager handler init.

- Add read_project_user_config for finecode-user.toml: per-project
  user-local preset additions, forbidden from carrying [workspace] config.

- Fix ServerStoppedError (typed exception replacing RuntimeError),
  follow_redirects=True in HttpSession, BaseRunnerRequestException
  message forwarded to super(), QueueShutDown handled in client send.
  Merge get_action_metadata into resolve_action_meta. Upgrade failed
  action import log from trace to warning. Add CLI status log lines.

Author: Aksem

finecode_extension_api/src/finecode_extension_api/workspace_utils.py

@@ -1,5 +1,7 @@
 import pathlib
 
+from loguru import logger
+
 
 def group_files_by_project(
     files: list[pathlib.Path],
@@ -13,8 +15,20 @@ def group_files_by_project(
     sorted_projects = sorted(project_paths, key=lambda p: len(p.parts), reverse=True)
     result: dict[pathlib.Path, list[pathlib.Path]] = {}
     for file in files:
+        exists_on_disk = file.exists()
+        matched = False
         for project in sorted_projects:
             if file.is_relative_to(project):
+                logger.debug(
+                    f"group_files_by_project: assigned {file} to project {project}"
+                    f" (exists_on_disk={exists_on_disk})"
+                )
                 result.setdefault(project, []).append(file)
+                matched = True
                 break
+        if not matched:
+            logger.debug(
+                f"group_files_by_project: {file} not under any known project"
+                f" (exists_on_disk={exists_on_disk})"
+            )
     return result

finecode_extension_runner/src/finecode_extension_runner/_services/run_action.py

@@ -154,14 +154,19 @@ def bootstrap(
     )
 
     svc_registry = service_registry.ServiceRegistry(di_registry=registry)
-    _activate_extensions(handler_packages, svc_registry)
+    all_eps, activated = _activate_extensions(handler_packages, svc_registry)
     _apply_user_service_config(service_declarations, svc_registry)
 
+    remaining = sorted(set(all_eps.keys()) - set(activated))
+    if remaining:
+        deferred = [_make_deferred_activator(pkg, all_eps[pkg], svc_registry) for pkg in remaining]
+        registry.set_deferred_activators(deferred)
+
 
 def _activate_extensions(
     handler_packages: set[str],
     svc_registry: service_registry.ServiceRegistry,
-) -> None:
+) -> tuple[dict[str, importlib.metadata.EntryPoint], ordered_set.OrderedSet[str]]:
     all_eps = {
         ep.name: ep
         for ep in importlib.metadata.entry_points(group="finecode.activator")
@@ -183,6 +188,24 @@ def _activate_extensions(
         except Exception as e:
             logger.error(f"Failed to activate extension '{pkg_name}': {e}")
 
+    return all_eps, packages_to_activate
+
+
+def _make_deferred_activator(
+    pkg_name: str,
+    ep: importlib.metadata.EntryPoint,
+    svc_registry: service_registry.ServiceRegistry,
+) -> Callable[[], None]:
+    def activate() -> None:
+        try:
+            activator_cls = ep.load()
+            activator_cls(registry=svc_registry).activate()
+            logger.debug(f"On-demand activated extension '{pkg_name}'")
+        except Exception as e:
+            logger.error(f"Failed to on-demand activate extension '{pkg_name}': {e}")
+
+    return activate
+
 
 def _find_installed_packages_with_missing_eps(
     handler_packages: set[str],

finecode_extension_runner/src/finecode_extension_runner/di/bootstrap.py

@@ -12,6 +12,12 @@ class Registry:
     def __init__(self) -> None:
         self._container: dict[type, Any] = {}
         self._factories: dict[type, Callable] = {}
+        self._deferred_activators: list[Callable[[], None]] = []
+        self._next_deferred: int = 0
+
+    def set_deferred_activators(self, activators: list[Callable[[], None]]) -> None:
+        self._deferred_activators = activators
+        self._next_deferred = 0
 
     def register_instance(self, type_: type, instance: Any, *, override: bool = False) -> None:
         if type_ in self._container and not override:
@@ -27,6 +33,13 @@ async def get_instance(self, type_: Type[T]) -> T:
         if type_ in self._container:
             return self._container[type_]
 
+        if type_ not in self._factories:
+            while self._next_deferred < len(self._deferred_activators):
+                activate = self._deferred_activators[self._next_deferred]
+                self._next_deferred += 1
+                activate()
+                if type_ in self._factories:
+                    break
         if type_ not in self._factories:
             raise ServiceNotFoundError(f"No implementation found for {type_}")
 

finecode_extension_runner/src/finecode_extension_runner/di/registry.py

@@ -173,7 +173,7 @@ class ErServer:
     """
 
     def __init__(self) -> None:
-        self._session = finecode_jsonrpc_module.JsonRpcServerSession()
+        self._session = finecode_jsonrpc_module.JsonRpcServerSession(tracing=er_telemetry.JsonRpcTracingHooks())
         self._finecode_async_tasks: list[asyncio.Task] = []
         self._finecode_exit_stack = contextlib.AsyncExitStack()
         self._finecode_file_editor_session: ifileeditor.IFileEditorSession
@@ -874,36 +874,6 @@ async def resolve_source(_server: ErServer, params: dict | None) -> dict:
     return {"canonicalSource": canonical}
 
 
-async def get_action_metadata_cmd(_server: ErServer, params: dict | None) -> dict:
-    """Handler for ``actions/getActionMetadata``.
-
-    Imports the action class identified by *source* and returns its
-    ``PARENT_ACTION`` and ``LANGUAGE`` class attributes as a dict.
-
-    Raises ``ValueError`` when the source cannot be imported.
-    """
-    assert params is not None
-    source: str = params["source"]
-    logger.trace(f"Get action metadata for source: {source}")
-    last_dot = source.rfind(".")
-    if last_dot == -1:
-        raise ValueError(f"Invalid source (no dot separator): {source!r}")
-    import importlib
-    module_path = source[:last_dot]
-    attr_name = source[last_dot + 1:]
-    try:
-        mod = importlib.import_module(module_path)
-        cls = getattr(mod, attr_name)
-    except (ImportError, AttributeError) as exc:
-        raise ValueError(f"Cannot resolve source '{source}': {exc}") from exc
-    parent = getattr(cls, "PARENT_ACTION", None)
-    parent_source = (
-        f"{parent.__module__}.{parent.__qualname__}" if parent is not None else None
-    )
-    language = getattr(cls, "LANGUAGE", None)
-    return {"parentActionSource": parent_source, "language": language}
-
-
 async def resolve_action_meta(server: ErServer, _params: dict | None) -> dict:
     """Handler for ``finecodeRunner/resolveActionMeta``."""
     if server._runner_context is None:
@@ -971,7 +941,6 @@ async def _on_progress_from_wm(params: dict | None) -> None:
     session.on_request("actions/run", _wrap(run_action))
     session.on_request("actions/runHandlers", _wrap(run_handlers))
     session.on_request("actions/resolveSource", _wrap(resolve_source))
-    session.on_request("actions/getActionMetadata", _wrap(get_action_metadata_cmd))
     session.on_request("actions/reload", _wrap(reload_action))
     session.on_request("packages/resolvePath", _wrap(resolve_package_path))
     session.on_request("actions/mergeResults", _wrap(merge_results_cmd))

finecode_extension_runner/src/finecode_extension_runner/er_server.py

@@ -179,7 +179,19 @@ def get_current_traceparent() -> str | None:
 
 
 @contextlib.contextmanager
-def handler_span(handler_name: str, action_name: str, traceparent: str | None):
+def handler_span(
+    handler_name: str,
+    action_name: str,
+    traceparent: str | None,
+    trigger: str = "unknown",
+    dev_env: str = "unknown",
+):
+    # traceparent is passed explicitly from the action payload (options.traceparent),
+    # not taken from the ambient OTel context.  This is intentional: JsonRpcServerSession
+    # is a long-running, concurrent session whose event loop has no per-request span
+    # context, so the ambient context at call time is not the correct parent.
+    # options.traceparent carries the action_run_span identity explicitly across
+    # WM → ER → WM → ER hops, which ambient context propagation cannot do.
     if traceparent is None:
         yield None
         return
@@ -194,13 +206,111 @@ def handler_span(handler_name: str, action_name: str, traceparent: str | None):
         attributes={
             "handler.name": handler_name,
             "action.name": action_name,
+            "run.trigger": trigger,
+            "run.dev_env": dev_env,
         },
         record_exception=True,
         set_status_on_exception=True,
     ) as span:
         yield span
 
 
+@contextlib.contextmanager
+def handler_initialize_span(handler_name: str, action_name: str):
+    """Span for handler cold-start initialization — must be entered within a handler_span context.
+
+    Emits no span when telemetry is off or when there is no active parent span
+    (i.e. handler_span was a no-op because traceparent was absent).
+    """
+    if not _telemetry_initialized:
+        yield None
+        return
+    from opentelemetry import trace
+    if not trace.get_current_span().get_span_context().is_valid:
+        yield None
+        return
+    tracer = trace.get_tracer("finecode.er")
+    with tracer.start_as_current_span(
+        f"handler.initialize/{handler_name}",
+        attributes={
+            "handler.name": handler_name,
+            "action.name": action_name,
+        },
+        record_exception=True,
+        set_status_on_exception=True,
+    ) as span:
+        yield span
+
+
+@contextlib.contextmanager
+def _jsonrpc_client_span(method: str, peer_id: str):
+    from opentelemetry import trace
+
+    tracer = trace.get_tracer("finecode.jsonrpc")
+    with tracer.start_as_current_span(
+        f"jsonrpc.client/{method}",
+        attributes={"rpc.system": "jsonrpc", "rpc.method": method, "peer.id": peer_id},
+        record_exception=True,
+        set_status_on_exception=True,
+    ) as span:
+        yield span
+
+
+@contextlib.contextmanager
+def _jsonrpc_server_span(method: str, traceparent: str | None):
+    from opentelemetry import propagate, trace
+
+    tracer = trace.get_tracer("finecode.jsonrpc")
+    parent_ctx = propagate.extract({"traceparent": traceparent}) if traceparent else None
+    with tracer.start_as_current_span(
+        f"jsonrpc.server/{method}",
+        context=parent_ctx,
+        attributes={"rpc.system": "jsonrpc", "rpc.method": method},
+        record_exception=True,
+        set_status_on_exception=True,
+    ) as span:
+        yield span
+
+
+class JsonRpcTracingHooks:
+    """OTel implementation of ITracingHooks for ER processes.
+
+    Provides single-hop envelope tracing for JSON-RPC messages.  Does not
+    replace options.traceparent in action payloads — see ITracingHooks docstring
+    and the comment on handler_span for the rationale.
+    """
+
+    def get_traceparent(self) -> str | None:
+        return get_current_traceparent()
+
+    def client_span(self, method: str, peer_id: str):
+        return _jsonrpc_client_span(method, peer_id)
+
+    def server_span(self, method: str, traceparent: str | None):
+        return _jsonrpc_server_span(method, traceparent)
+
+    def notification_sent(self, method: str) -> None:
+        from opentelemetry import trace
+        span = trace.get_current_span()
+        if span.is_recording():
+            span.add_event("jsonrpc.notification.sent", {"rpc.method": method})
+
+    def notification_received(self, method: str, traceparent: str | None) -> None:
+        from opentelemetry import trace
+        span = trace.get_current_span()
+        if span.is_recording():
+            span.add_event("jsonrpc.notification.received", {"rpc.method": method})
+
+
+def add_span_event(name: str, attributes: dict | None = None) -> None:
+    if not _telemetry_initialized:
+        return
+    from opentelemetry import trace
+    span = trace.get_current_span()
+    if span.is_recording():
+        span.add_event(name, attributes or {})
+
+
 @contextlib.contextmanager
 def handler_metrics(handler_name: str, action_name: str):
     start = time.perf_counter()

finecode_extension_runner/src/finecode_extension_runner/er_telemetry.py

@@ -152,6 +152,10 @@ async def resolve_action_meta(runner_context: context.RunnerContext) -> dict[str
     - ``runs_concurrently``: True when the action declares CONCURRENT handler
       execution (``HANDLER_EXECUTION = HandlerExecution.CONCURRENT``).
     - ``scope``: ``"project"`` or ``"workspace"`` (from ``Action.SCOPE``).
+    - ``parentActionSource``: canonical source of the parent action class, or
+      ``None`` for top-level actions (from ``Action.PARENT_ACTION``).
+    - ``language``: language tag this action is specific to, or ``None`` for
+      language-agnostic actions (from ``Action.LANGUAGE``).
 
     Actions that fail to import are omitted.
     """
@@ -166,13 +170,20 @@ async def resolve_action_meta(runner_context: context.RunnerContext) -> dict[str
             cls = run_utils.import_module_member_by_source_str(action.source)
             if not (isinstance(cls, type) and issubclass(cls, Action)):
                 raise TypeError(f"{action.source} is not a subclass of Action")
+            parent = getattr(cls, "PARENT_ACTION", None)
             resolved[action.source] = {
                 "canonical_source": f"{cls.__module__}.{cls.__qualname__}",
                 "runs_concurrently": cls.HANDLER_EXECUTION == HandlerExecution.CONCURRENT,
                 "scope": cls.SCOPE.value,
+                "parentActionSource": (
+                    f"{parent.__module__}.{parent.__qualname__}"
+                    if parent is not None
+                    else None
+                ),
+                "language": getattr(cls, "LANGUAGE", None),
             }
         except Exception as exception:
-            logger.trace(f'Failed to import action {action.source}: {exception}')
+            logger.warning(f'Failed to import action {action.source}: {exception}')
     return resolved
 
 

finecode_extension_runner/src/finecode_extension_runner/services.py

@@ -45,7 +45,7 @@ def __init__(self, logger: ilogger.ILogger):
     async def __aenter__(self) -> Self:
         """Async context manager entry. Creates and initializes the httpx client."""
         self.logger.debug("HTTP session opened")
-        self._client = httpx.AsyncClient()
+        self._client = httpx.AsyncClient(follow_redirects=True)
         return self
 
     async def __aexit__(

finecode_httpclient/src/finecode_httpclient/client.py

@@ -6,23 +6,27 @@
     ResponseTimeout,
     ServerFailedToStart,
     RequestCancelledError,
+    ServerStoppedError,
 )
 from .jsonrpc_client import JsonRpcError
 from .transports import StdioTransport
 from .server_transport import ServerStdioTransport, TcpServerTransport
 from .jsonrpc_server import JsonRpcHandlerError, JsonRpcServerSession
+from .tracing import ITracingHooks
 
 
 __all__ = [
     "JsonRpcClient",
     "JsonRpcError",
     "JsonRpcHandlerError",
+    "ITracingHooks",
     "BaseRunnerRequestException",
     "ErrorOnRequest",
     "NoResponse",
     "ResponseTimeout",
     "ServerFailedToStart",
     "RequestCancelledError",
+    "ServerStoppedError",
     "StdioTransport",
     "ServerStdioTransport",
     "TcpServerTransport",