flightdeck-sensor 0.5.2__tar.gz → 0.5.3__tar.gz

flightdeck_sensor-0.5.3/CLAUDE.md

@@ -0,0 +1,78 @@
+# Flightdeck Sensor -- Claude Code Rules
+
+> Component-specific rules moved out of the root CLAUDE.md so they load only
+> when working under sensor/. All root CLAUDE.md rules still apply; the
+> numbering below keeps the original rule numbers.
+
+## Sensor Rules
+
+27. **The sensor must never add meaningful latency to the agent's hot path.**
+    All control plane communication is fire-and-forget or background.
+    Never introduce synchronous blocking calls in the LLM call intercept path.
+
+28. **The sensor must fail open.** If the control plane is unreachable and
+    FLIGHTDECK_UNAVAILABLE_POLICY=continue, the agent proceeds with no enforcement.
+    Do not raise exceptions for connectivity failures.
+
+29. **Token counting carries over from tokencap.** Do not rewrite the counting logic.
+    Extend it. Pre-call estimation, post-call reconciliation, delta correction -- these
+    are proven and must not be changed without Supervisor approval.
+
+30. **capture_prompts defaults to False.** The default init() call never captures
+    content. Always verify this default has not been accidentally changed.
+
+31. **init() limit param fires WARN only.** Never upgrade a local limit to BLOCK
+    or DEGRADE regardless of what the server policy says. See DECISIONS.md D035.
+
+32. **The sensor is a library wrapper, not an OS agent.** Never add background
+    threads, polling loops, or daemon threads to the sensor beyond the existing
+    event queue drain thread. If a feature requires background activity
+    independent of LLM calls, it does not belong in the sensor.
+
+---
+
+## Framework Coverage Discipline
+
+40d. **Framework coverage discipline.** Any phase that adds
+     framework support OR changes framework-emission behaviour
+     MUST include BOTH:
+
+     1. **Real-provider playground demos** per affected framework --
+        manual, NOT in CI (they cost money and need live API
+        credentials). Live under ``playground/`` and self-skip
+        (exit 2) when the relevant API key / framework / optional
+        gateway URL is missing so ``make playground-all`` runs
+        cleanly on any box. Driven via ``make playground-<script>``
+        targets. Each demo asserts payload shape inline using
+        ``print_result`` + ``raise AssertionError``; ``run_all.py``
+        exits 0 only when every script returned 0 (PASS) or 2
+        (SKIP). Results documented in the phase's audit doc before
+        PR merge.
+     2. **Integration tests** per framework × behaviour combo,
+        mock-free (or lightly mocked at the network boundary),
+        running in CI via the existing Integration job. Seed a
+        realistic event payload for each new framework + behaviour
+        combination and verify end-to-end landing.
+
+     V-pass for such a phase MUST enumerate the playground demos
+     and integration tests that will be added before
+     implementation starts. Skipping either is a phase-gate
+     failure.
+
+     Why: Phase 4 (agent communication coverage hardening) shipped
+     embeddings, streaming semantics, structured error events, and
+     session-lifecycle edge-case fixes. Mock-only coverage would
+     have let a future SDK upgrade silently break the classifier
+     (anthropic renames ``RateLimitError`` to ``QuotaError`` and
+     our classifier falls through to ``other``; no CI gate catches
+     it). The playground matrix is the only thing that exercises
+     the real class hierarchy every provider ships.
+
+     Applies to: every phase from Phase 4 onwards that touches
+     ``sensor/flightdeck_sensor/interceptor/*``, adds a new
+     interceptor file, or changes the event-emission shape for an
+     existing framework.
+
+     Does NOT apply to: non-framework sensor work (transport,
+     policy, directives) — those are covered by the standard unit
+     + integration suites.

{flightdeck_sensor-0.5.2 → flightdeck_sensor-0.5.3}/PKG-INFO

@@ -1,7 +1,9 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: flightdeck-sensor
-Version: 0.5.2
+Version: 0.5.3
 Summary: In-process agent observability sensor for Flightdeck
+Project-URL: Repository, https://github.com/flightdeckhq/flightdeck
+Author-email: Omri Arnon <omri.arnon@gmail.com>
 License-Expression: Apache-2.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers

{flightdeck_sensor-0.5.2 → flightdeck_sensor-0.5.3}/flightdeck_sensor/__init__.py

@@ -235,6 +235,7 @@ def init(
     agent_name: str | None = None,
     langgraph_agent_node_pattern: str | None = None,
     mcp_block_on_uncertainty: bool = False,
+    allow_insecure_transport: bool = False,
 ) -> None:
     """Initialize the sensor and start the run.
 
@@ -298,6 +299,16 @@ def init(
       for k8s pod grouping)
     - ``FLIGHTDECK_UNAVAILABLE_POLICY`` -- ``"continue"`` or ``"halt"``
     - ``FLIGHTDECK_CAPTURE_PROMPTS`` -- ``"true"`` to enable
+    - ``FLIGHTDECK_ALLOW_INSECURE_TRANSPORT`` -- ``"true"`` to allow plain
+      ``http://`` egress to a non-local control plane (overrides
+      *allow_insecure_transport*)
+
+    ``allow_insecure_transport`` opts in to plaintext ``http://`` egress
+    for a **non-local** control-plane host. Off by default: the resolved
+    ``server`` / ``api_url`` must use ``https://`` for any public host, or
+    init raises. Local / loopback / private hosts (``localhost``,
+    ``127.0.0.1``, RFC1918, ...) are always allowed over ``http``. A URL
+    with any scheme other than ``http`` / ``https`` is rejected outright.
 
     ``langgraph_agent_node_pattern`` (D126) is an optional regex
     string that narrows which LangGraph nodes the sub-agent
@@ -316,6 +327,23 @@ def init(
                 _log.warning("flightdeck_sensor.init() called twice; ignoring")
             return
 
+        # H-01: env-var precedence is preserved (env wins over the kwarg,
+        # matching every other init() knob), but a silent override of an
+        # explicitly-passed value is the vulnerability — a stale/hostile
+        # FLIGHTDECK_SERVER in the environment could redirect egress with
+        # no signal. Warn (naming both values) when the environment
+        # overrides a non-empty caller-supplied server with a different
+        # value, then keep the env value.
+        env_server = os.environ.get(_env.ENV_SERVER)
+        if env_server is not None and server and env_server != server:
+            _log.warning(
+                "%s=%r overrides the server=%r passed to init(); using the "
+                "environment value. Unset %s if this was not intended.",
+                _env.ENV_SERVER,
+                env_server,
+                server,
+                _env.ENV_SERVER,
+            )
         resolved_server = os.environ.get(_env.ENV_SERVER, server)
         resolved_token = os.environ.get(_env.ENV_TOKEN, token)
         if not resolved_server:
@@ -323,6 +351,12 @@ def init(
         if not resolved_token:
             raise ConfigurationError("token is required")
 
+        # H-01: resolve the plaintext-transport opt-in. Env wins over the
+        # kwarg (same precedence as every other flag); default False.
+        resolved_allow_insecure = _env_bool(
+            _env.ENV_ALLOW_INSECURE_TRANSPORT, allow_insecure_transport
+        )
+
         # KI20: normalize ``FLIGHTDECK_SERVER`` / ``server`` kwarg to
         # always carry the ``/ingest`` suffix. The Claude Code plugin
         # uses the same env var without the suffix (it appends
@@ -334,6 +368,17 @@ def init(
         if "/ingest" not in resolved_server:
             resolved_server = resolved_server.rstrip("/") + "/ingest"
 
+        # H-01: same silent-override guard for the control-plane API URL.
+        env_api_url = os.environ.get(_env.ENV_API_URL)
+        if env_api_url and api_url and env_api_url != api_url:
+            _log.warning(
+                "%s=%r overrides the api_url=%r passed to init(); using the "
+                "environment value. Unset %s if this was not intended.",
+                _env.ENV_API_URL,
+                env_api_url,
+                api_url,
+                _env.ENV_API_URL,
+            )
         resolved_api_url = os.environ.get(_env.ENV_API_URL) or api_url
         if not resolved_api_url:
             resolved_api_url = resolved_server.rstrip("/").replace("/ingest", "/api")
@@ -419,6 +464,7 @@ def init(
             "token": resolved_token,
             "api_url": resolved_api_url,
             "capture_prompts": capture,
+            "allow_insecure_transport": resolved_allow_insecure,
             "unavailable_policy": os.environ.get(_env.ENV_UNAVAILABLE_POLICY, "continue"),
             # Legacy wire-level ``flavor`` field stays populated for
             # backward compat with every downstream surface that still

{flightdeck_sensor-0.5.2 → flightdeck_sensor-0.5.3}/flightdeck_sensor/config.py

@@ -41,6 +41,9 @@ ENV_AGENT_FLAVOR_LEGACY = "AGENT_FLAVOR"
 # ----------------------------------------------------------------
 ENV_CAPTURE_PROMPTS = "FLIGHTDECK_CAPTURE_PROMPTS"
 ENV_UNAVAILABLE_POLICY = "FLIGHTDECK_UNAVAILABLE_POLICY"
+# H-01: opt-in to plaintext http:// egress for a non-local control
+# plane. Bool-coerced; default False forces https:// for public hosts.
+ENV_ALLOW_INSECURE_TRANSPORT = "FLIGHTDECK_ALLOW_INSECURE_TRANSPORT"
 
 
 # Stable list of every FLIGHTDECK_* env var the sensor consults, in
@@ -56,4 +59,5 @@ ALL_ENV_VARS: tuple[str, ...] = (
     ENV_HOSTNAME,
     ENV_CAPTURE_PROMPTS,
     ENV_UNAVAILABLE_POLICY,
+    ENV_ALLOW_INSECURE_TRANSPORT,
 )

{flightdeck_sensor-0.5.2 → flightdeck_sensor-0.5.3}/flightdeck_sensor/core/session.py

@@ -1273,6 +1273,11 @@ class Session:
             # "what budget/MCP rules were in effect at session start"
             # without joining time-windowed policy state.
             payload["sensor_version"] = _sensor_version()
+            # C-01: emit the session's capture posture authoritatively at
+            # session_start so the server can persist whether this session
+            # is capturing prompt content. Sourced directly from the
+            # resolved config — the single source of truth for the flag.
+            payload["capture_prompts"] = self.config.capture_prompts
             iv = _collect_interceptor_versions()
             if iv:
                 payload["interceptor_versions"] = iv

{flightdeck_sensor-0.5.2 → flightdeck_sensor-0.5.3}/flightdeck_sensor/core/types.py

@@ -3,9 +3,87 @@
 from __future__ import annotations
 
 import enum
+import ipaddress
 import uuid
 from dataclasses import dataclass, field
 from typing import Any, Callable, Literal
+from urllib.parse import urlparse
+
+# Schemes the sensor is willing to egress control-plane traffic over.
+# Anything else (file://, ftp://, gopher://, a bare host with no
+# scheme, ...) is rejected outright — the sensor only speaks HTTP(S)
+# to the control plane, and an unexpected scheme is almost always a
+# misconfiguration or an attempt to redirect egress somewhere it does
+# not belong.
+_ALLOWED_EGRESS_SCHEMES = frozenset({"https", "http"})
+
+
+def _is_local_host(host: str) -> bool:
+    """Return True when *host* is a local/loopback/private target for
+    which plain ``http://`` is acceptable without an explicit opt-in.
+
+    Covers ``localhost`` (and ``*.localhost``), loopback IPs
+    (127.0.0.0/8, ::1), RFC1918 / ULA private ranges, and link-local
+    addresses. Everything else — public hostnames and public IPs —
+    is treated as remote and must use TLS unless the operator opts in.
+    """
+    if not host:
+        return False
+    h = host.lower()
+    if h == "localhost" or h.endswith(".localhost"):
+        return True
+    try:
+        ip = ipaddress.ip_address(h)
+    except ValueError:
+        # Not an IP literal and not a localhost name → treat as a
+        # public host. DNS is deliberately NOT resolved here: the
+        # sensor must never make a blocking network call on the config
+        # path (Sensor Rule 27), and resolving would also open a
+        # rebinding hole. Operators pointing at a private hostname that
+        # only resolves to an RFC1918 address use the opt-in flag.
+        return False
+    return ip.is_loopback or ip.is_private or ip.is_link_local
+
+
+def validate_egress_url(
+    url: str,
+    *,
+    field_name: str,
+    allow_insecure_transport: bool = False,
+) -> None:
+    """Validate a resolved control-plane egress URL (H-01).
+
+    Raises :class:`ValueError` when:
+
+    - the URL does not parse to a scheme in ``{"https", "http"}`` — this
+      rejects ``file://``, ``ftp://``, scheme-less strings, etc.; or
+    - the URL uses plain ``http://`` for a non-local host and the
+      operator has not opted into insecure transport
+      (``allow_insecure_transport`` / ``FLIGHTDECK_ALLOW_INSECURE_TRANSPORT``).
+
+    ``field_name`` is the config field being checked (``"server"`` /
+    ``"api_url"``) and is woven into the error message so a
+    misconfiguration is self-describing.
+    """
+    parsed = urlparse(url)
+    scheme = parsed.scheme.lower()
+    if scheme not in _ALLOWED_EGRESS_SCHEMES:
+        raise ValueError(
+            f"{field_name} must use an http:// or https:// URL; got "
+            f"scheme {scheme or '(none)'!r} in {url!r}. The sensor only "
+            "egresses control-plane traffic over HTTP(S)."
+        )
+    if scheme == "http" and not allow_insecure_transport:
+        host = parsed.hostname or ""
+        if not _is_local_host(host):
+            raise ValueError(
+                f"{field_name} uses insecure http:// for non-local host "
+                f"{host or '(none)'!r} ({url!r}). Use https://, or opt in "
+                "to plaintext transport by setting allow_insecure_transport"
+                "=True (env FLIGHTDECK_ALLOW_INSECURE_TRANSPORT=true). "
+                "Plaintext control-plane traffic to a remote host exposes "
+                "the access token and event payloads on the wire."
+            )
 
 
 class SessionState(enum.Enum):
@@ -215,6 +293,13 @@ class SensorConfig:
     client_type: str = "flightdeck_sensor"
     api_url: str = ""
     capture_prompts: bool = False
+    # H-01: opt-in to plaintext http:// egress for a non-local control
+    # plane. Default False forces https:// for any public host; local /
+    # loopback / private targets are always allowed over http regardless.
+    # Env-readable via FLIGHTDECK_ALLOW_INSECURE_TRANSPORT (resolved in
+    # init()). Never flip this on for a real deployment — it exposes the
+    # access token and event payloads on the wire.
+    allow_insecure_transport: bool = False
     unavailable_policy: str = "continue"
     agent_flavor: str = "unknown"
     agent_type: str = "production"
@@ -233,6 +318,19 @@ class SensorConfig:
     def __post_init__(self) -> None:
         if not self.api_url:
             self.api_url = self.server
+        # H-01: validate the resolved control-plane egress URLs. Both
+        # ``server`` (ingestion) and ``api_url`` (control-plane API) are
+        # checked so every egress target is covered by the single helper.
+        validate_egress_url(
+            self.server,
+            field_name="server",
+            allow_insecure_transport=self.allow_insecure_transport,
+        )
+        validate_egress_url(
+            self.api_url,
+            field_name="api_url",
+            allow_insecure_transport=self.allow_insecure_transport,
+        )
 
 
 # Default directive grace period (ms): the window an agent gets to wind down

{flightdeck_sensor-0.5.2 → flightdeck_sensor-0.5.3}/pyproject.toml

@@ -4,10 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flightdeck-sensor"
-version = "0.5.2"
+version = "0.5.3"
 description = "In-process agent observability sensor for Flightdeck"
 readme = "README.md"
 license = "Apache-2.0"
+authors = [
+    { name = "Omri Arnon", email = "omri.arnon@gmail.com" },
+]
 requires-python = ">=3.10,<3.14"
 dependencies = [
     "pydantic>=2.0",
@@ -24,6 +27,9 @@ classifiers = [
     "Typing :: Typed",
 ]
 
+[project.urls]
+Repository = "https://github.com/flightdeckhq/flightdeck"
+
 [project.optional-dependencies]
 anthropic = ["anthropic>=0.20"]
 openai = ["openai>=1.0", "tiktoken>=0.5"]

flightdeck_sensor-0.5.3/tests/unit/test_egress_url_validation.py

@@ -0,0 +1,235 @@
+"""H-01 — control-plane egress URL validation.
+
+The sensor rejects non-HTTP(S) schemes outright and refuses plaintext
+``http://`` to a non-local control plane unless the operator explicitly
+opts in (``allow_insecure_transport`` / ``FLIGHTDECK_ALLOW_INSECURE_TRANSPORT``).
+Local / loopback / private hosts are always allowed over http. When an
+env var overrides an explicitly-passed ``server`` / ``api_url``, init()
+warns naming both values (silent override is the vuln).
+"""
+
+from __future__ import annotations
+
+import os
+from contextlib import contextmanager
+from typing import TYPE_CHECKING
+
+import pytest
+
+import flightdeck_sensor
+from flightdeck_sensor.core.types import SensorConfig, validate_egress_url
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+@contextmanager
+def _clean_env() -> Iterator[None]:
+    saved = {k: v for k, v in os.environ.items() if k.startswith(("FLIGHTDECK_", "AGENT_"))}
+    for k in list(saved):
+        os.environ.pop(k, None)
+    try:
+        yield
+    finally:
+        for k in [k for k in os.environ if k.startswith(("FLIGHTDECK_", "AGENT_"))]:
+            os.environ.pop(k, None)
+        os.environ.update(saved)
+
+
+@contextmanager
+def _no_session() -> Iterator[None]:
+    flightdeck_sensor._session = None
+    flightdeck_sensor._client = None
+    try:
+        yield
+    finally:
+        if flightdeck_sensor._session is not None:
+            try:
+                flightdeck_sensor.teardown()
+            except Exception:
+                flightdeck_sensor._session = None
+                flightdeck_sensor._client = None
+
+
+# ------------------------------------------------------------------
+# Helper-level (validate_egress_url) tests
+# ------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "file:///etc/passwd",
+        "ftp://example.com/x",
+        "gopher://example.com",
+        "ws://example.com/ingest",
+        "example.com/ingest",  # scheme-less
+        "",  # empty
+    ],
+)
+def test_rejects_non_http_schemes(url: str) -> None:
+    with pytest.raises(ValueError, match="http:// or https://"):
+        validate_egress_url(url, field_name="server")
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "http://localhost:9999/ingest",
+        "http://localhost/ingest",
+        "http://sub.localhost/ingest",
+        "http://127.0.0.1:4000/ingest",
+        "http://127.5.5.5/ingest",
+        "http://10.0.0.4/ingest",
+        "http://192.168.1.10:4000/ingest",
+        "http://172.16.0.1/ingest",
+        "http://[::1]/ingest",
+    ],
+)
+def test_allows_http_for_local_and_private_hosts(url: str) -> None:
+    # Must not raise.
+    validate_egress_url(url, field_name="server")
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "http://stack.internal/ingest",
+        "http://example.com/ingest",
+        "http://8.8.8.8/ingest",
+    ],
+)
+def test_rejects_http_for_non_local_host_without_optin(url: str) -> None:
+    with pytest.raises(ValueError, match="insecure http"):
+        validate_egress_url(url, field_name="server")
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "http://stack.internal/ingest",
+        "http://example.com/ingest",
+    ],
+)
+def test_allows_http_non_local_with_optin(url: str) -> None:
+    validate_egress_url(url, field_name="server", allow_insecure_transport=True)
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "https://stack.internal/ingest",
+        "https://example.com/ingest",
+    ],
+)
+def test_allows_https_for_any_host(url: str) -> None:
+    validate_egress_url(url, field_name="server")
+
+
+# ------------------------------------------------------------------
+# SensorConfig-level tests
+# ------------------------------------------------------------------
+
+
+def test_config_rejects_non_local_http_by_default() -> None:
+    with pytest.raises(ValueError):
+        SensorConfig(server="http://stack.internal/ingest", token="tok")
+
+
+def test_config_allows_non_local_http_with_optin() -> None:
+    cfg = SensorConfig(
+        server="http://stack.internal/ingest",
+        token="tok",
+        allow_insecure_transport=True,
+    )
+    assert cfg.server == "http://stack.internal/ingest"
+
+
+def test_config_validates_api_url_too() -> None:
+    # server is https (fine) but api_url is a bad scheme → still rejected.
+    with pytest.raises(ValueError, match="api_url"):
+        SensorConfig(
+            server="https://stack.internal/ingest",
+            token="tok",
+            api_url="ftp://stack.internal/api",
+        )
+
+
+def test_config_defaults_secure_transport_off() -> None:
+    cfg = SensorConfig(server="https://x.example/ingest", token="tok")
+    assert cfg.allow_insecure_transport is False
+
+
+# ------------------------------------------------------------------
+# init()-level tests
+# ------------------------------------------------------------------
+
+
+def test_init_rejects_non_local_http() -> None:
+    with _clean_env(), _no_session(), pytest.raises(ValueError):
+        flightdeck_sensor.init(
+            server="http://stack.internal/ingest",
+            token="tok",
+            quiet=True,
+        )
+
+
+def test_init_env_flag_enables_insecure(monkeypatch: pytest.MonkeyPatch) -> None:
+    with _clean_env(), _no_session():
+        monkeypatch.setattr(
+            "flightdeck_sensor.core.session.Session.start",
+            lambda self: None,
+        )
+        os.environ["FLIGHTDECK_ALLOW_INSECURE_TRANSPORT"] = "true"
+        flightdeck_sensor.init(
+            server="http://stack.internal/ingest",
+            token="tok",
+            quiet=True,
+        )
+        assert flightdeck_sensor._session is not None
+        assert flightdeck_sensor._session.config.allow_insecure_transport is True
+
+
+def test_init_warns_on_env_server_override(
+    monkeypatch: pytest.MonkeyPatch,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    with _clean_env(), _no_session():
+        monkeypatch.setattr(
+            "flightdeck_sensor.core.session.Session.start",
+            lambda self: None,
+        )
+        os.environ["FLIGHTDECK_SERVER"] = "http://localhost:5000/ingest"
+        with caplog.at_level("WARNING"):
+            flightdeck_sensor.init(
+                server="http://localhost:9999/ingest",
+                token="tok",
+                quiet=True,
+            )
+        # Both the env value and the passed value are named in the warning.
+        joined = "\n".join(r.getMessage() for r in caplog.records)
+        assert "FLIGHTDECK_SERVER" in joined
+        assert "localhost:5000" in joined
+        assert "localhost:9999" in joined
+        # Env precedence still holds.
+        assert flightdeck_sensor._session is not None
+        assert flightdeck_sensor._session.config.server == "http://localhost:5000/ingest"
+
+
+def test_init_no_warn_when_env_matches_or_absent(
+    monkeypatch: pytest.MonkeyPatch,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    with _clean_env(), _no_session():
+        monkeypatch.setattr(
+            "flightdeck_sensor.core.session.Session.start",
+            lambda self: None,
+        )
+        with caplog.at_level("WARNING"):
+            flightdeck_sensor.init(
+                server="http://localhost:9999/ingest",
+                token="tok",
+                quiet=True,
+            )
+        joined = "\n".join(r.getMessage() for r in caplog.records)
+        assert "overrides the server" not in joined

{flightdeck_sensor-0.5.2 → flightdeck_sensor-0.5.3}/tests/unit/test_session.py

@@ -420,7 +420,12 @@ def test_init_appends_ingest_suffix_when_missing(
     monkeypatch.delenv("FLIGHTDECK_SERVER", raising=False)
     monkeypatch.delenv("FLIGHTDECK_TOKEN", raising=False)
     flightdeck_sensor.teardown()
-    flightdeck_sensor.init(server="http://stack.internal", token="tok", quiet=True)
+    flightdeck_sensor.init(
+        server="http://stack.internal",
+        token="tok",
+        quiet=True,
+        allow_insecure_transport=True,
+    )
     try:
         assert flightdeck_sensor._session is not None
         assert flightdeck_sensor._session.config.server == "http://stack.internal/ingest"
@@ -445,6 +450,7 @@ def test_init_preserves_ingest_suffix_when_present(
         server="http://stack.internal/ingest",
         token="tok",
         quiet=True,
+        allow_insecure_transport=True,
     )
     try:
         assert flightdeck_sensor._session is not None
@@ -472,6 +478,7 @@ def test_init_preserves_ingest_with_trailing_slash(
         server="http://stack.internal/ingest/",
         token="tok",
         quiet=True,
+        allow_insecure_transport=True,
     )
     try:
         assert flightdeck_sensor._session is not None

{flightdeck_sensor-0.5.2 → flightdeck_sensor-0.5.3}/tests/unit/test_session_lifecycle_enrichment.py

@@ -128,3 +128,51 @@ def test_other_event_types_skip_session_end_close_reason() -> None:
     s = _make_session()
     payload = s._build_payload(EventType.POST_CALL)
     assert "close_reason" not in payload
+
+
+# ------------------------------------------------------------------
+# C-01 — capture posture on session_start
+# ------------------------------------------------------------------
+
+
+def _make_session_with_capture(capture: bool) -> Session:
+    config = SensorConfig(
+        server="http://localhost/ingest",
+        token="tok_dev",
+        agent_id=str(uuid.uuid4()),
+        agent_name="test-agent",
+        user_name="test",
+        hostname="test-host",
+        client_type="flightdeck_sensor",
+        api_url="http://localhost/api",
+        agent_flavor="e2e-test",
+        agent_type="coding",
+        session_id=str(uuid.uuid4()),
+        capture_prompts=capture,
+        quiet=True,
+    )
+    s = Session(config, client=MagicMock())
+    s.event_queue = MagicMock()
+    return s
+
+
+def test_session_start_carries_capture_prompts_true() -> None:
+    s = _make_session_with_capture(True)
+    payload = s._build_payload(EventType.SESSION_START)
+    assert payload["capture_prompts"] is True
+
+
+def test_session_start_carries_capture_prompts_false() -> None:
+    s = _make_session_with_capture(False)
+    payload = s._build_payload(EventType.SESSION_START)
+    # Present and correct — the field must ship even when off so the
+    # server records the posture authoritatively.
+    assert payload["capture_prompts"] is False
+
+
+def test_session_start_capture_prompts_default_false() -> None:
+    """The default _make_session helper (no capture kwarg) reflects the
+    sensor's False default posture on session_start."""
+    s = _make_session()
+    payload = s._build_payload(EventType.SESSION_START)
+    assert payload["capture_prompts"] is False