feat(profiler/behave_shell): emit motor.command_chunking

BEHAVE-EXTRACTOR.md Phase B Step B.4. First implementation —
prototype doesn't ship this primitive.

* SessionContext gains intra_command_iats: per-command tuple of
  IATs between consecutive input events whose timestamps fall
  inside [cmd.start_ts, cmd.end_ts). Excludes the terminator IAT.
  Built by _per_command_iats.
* _features/motor.py:command_chunking(ctx) emits one Observation
  in {fluent, fragmented, single_command}.
  - 0 commands → skip emit
  - 1 command → single_command (registry-allowed point)
  - ≥2 commands → median CV across per-command typed-IATs;
    < CMD_CHUNKING_FLUENT_CV_MAX (0.50) → fluent, else fragmented
  - paste-only sessions (no command has ≥3 typed IATs) → skip emit
    (no honest within-command rhythm to measure)
  Confidence 0.80 / 0.65 / 0.60.
* Calibration grid widened to include motor.command_chunking;
  green across all five shards. Phase B primitive set complete.

Tests: no commands → skip, 1 command → single_command, uniform
typing → fluent, alternating fast/slow → fragmented, paste-only
multi-command → skip emit.

decnet/profiler/behave_shell/_ctx.py

@@ -56,6 +56,9 @@ class SessionContext:
     backspace_iats: tuple[float, ...] = field(default_factory=tuple)
     kill_line_count: int = 0
 
+    # Step B.4 derivations — per-command intra-typing IATs
+    intra_command_iats: tuple[tuple[float, ...], ...] = field(default_factory=tuple)
+
 
 def _detect_paste_bursts(
     inputs: list[AsciinemaEvent],
@@ -191,6 +194,30 @@ def _segment_commands(inputs: list[AsciinemaEvent]) -> tuple[Command, ...]:
     return tuple(cmds)
 
 
+def _per_command_iats(
+    commands: tuple[Command, ...],
+    inputs: list[AsciinemaEvent],
+) -> tuple[tuple[float, ...], ...]:
+    """Per-command IATs between consecutive input events whose
+    timestamps fall in ``[cmd.start_ts, cmd.end_ts)``.
+
+    Excludes the terminator IAT (the last event at ``cmd.end_ts`` is
+    the ``\\r``/``\\n`` itself). Returns one tuple per command.
+    """
+    out: list[tuple[float, ...]] = []
+    for cmd in commands:
+        prev_t: float | None = None
+        cmd_iats: list[float] = []
+        for t, _kind, _data in inputs:
+            if t < cmd.start_ts or t >= cmd.end_ts:
+                continue
+            if prev_t is not None:
+                cmd_iats.append(max(0.0, t - prev_t))
+            prev_t = t
+        out.append(tuple(cmd_iats))
+    return tuple(out)
+
+
 def _output_bytes_between(
     outputs: list[AsciinemaEvent],
     start: float,
@@ -246,6 +273,7 @@ def build_session_context(
         _output_bytes_between(outputs, commands[i].end_ts, commands[i + 1].start_ts)
         for i in range(len(commands) - 1)
     )
+    intra_command_iats = _per_command_iats(commands, inputs)
 
     return SessionContext(
         sid=sid,
@@ -266,4 +294,5 @@ def build_session_context(
         backspace_count=backspace_count,
         backspace_iats=backspace_iats,
         kill_line_count=kill_line_count,
+        intra_command_iats=intra_command_iats,
     )

decnet/profiler/behave_shell/_features/__init__.py

@@ -18,6 +18,7 @@ from decnet.profiler.behave_shell._features.cognitive import (
     inter_command_latency_class,
 )
 from decnet.profiler.behave_shell._features.motor import (
+    command_chunking,
     error_correction,
     input_modality,
     keystroke_cadence,
@@ -33,6 +34,7 @@ FEATURES: tuple[FeatureFn, ...] = (
     keystroke_cadence,
     motor_stability,
     error_correction,
+    command_chunking,
     inter_command_latency_class,
     command_branch_diversity,
     feedback_loop_engagement,

decnet/profiler/behave_shell/_features/motor.py

@@ -16,6 +16,7 @@ from decnet.profiler.behave_shell._ctx import SessionContext
 from decnet.profiler.behave_shell._features._emit import make_observation
 from decnet.profiler.behave_shell._thresholds import (
     BACKSPACE_IMMEDIATE_MAX_S,
+    CMD_CHUNKING_FLUENT_CV_MAX,
     CV_BURSTY_MAX,
     CV_MACHINE_MAX,
     CV_STEADY_MAX,
@@ -205,3 +206,49 @@ def error_correction(ctx: SessionContext) -> Iterator[Observation]:
         value=value,
         confidence=confidence,
     )
+
+
+def command_chunking(ctx: SessionContext) -> Iterator[Observation]:
+    """Emit ``motor.command_chunking`` ∈ {fluent, fragmented, single_command}.
+
+    * 0 commands → skip (no honest answer).
+    * 1 command → ``single_command`` (registry-allowed, distinct from
+      the fluent/fragmented continuum that needs multiple commands).
+    * ≥2 commands → median CV across per-command intra-typing IATs;
+      below ``CMD_CHUNKING_FLUENT_CV_MAX`` → fluent, else fragmented.
+
+    Skips emission if no command has ≥3 typed IATs to compute a CV
+    over (paste-driven sessions where every command arrived as one
+    bulk write — no honest within-command rhythm to measure).
+    """
+    n = len(ctx.commands)
+    if n == 0:
+        return
+    if n == 1:
+        yield make_observation(
+            ctx,
+            primitive="motor.command_chunking",
+            value="single_command",
+            confidence=0.80,
+        )
+        return
+    cvs: list[float] = []
+    for iats in ctx.intra_command_iats:
+        if len(iats) < 3:
+            continue
+        m = statistics.fmean(iats)
+        if m > 0:
+            cvs.append(statistics.pstdev(iats) / m)
+    if not cvs:
+        return
+    cv = statistics.median(cvs)
+    if cv < CMD_CHUNKING_FLUENT_CV_MAX:
+        value, confidence = "fluent", 0.65
+    else:
+        value, confidence = "fragmented", 0.60
+    yield make_observation(
+        ctx,
+        primitive="motor.command_chunking",
+        value=value,
+        confidence=confidence,
+    )

decnet/profiler/behave_shell/_thresholds.py

@@ -104,3 +104,8 @@ TREMOR_RATE_MIN: float = 0.10  # ≥10% sub-floor → tremor
 # typo mid-keystroke" (immediate). Beyond this = the operator paused,
 # noticed, then went back (deferred).
 BACKSPACE_IMMEDIATE_MAX_S: float = 0.50
+
+# ── motor.command_chunking (Step B.4) ───────────────────────────────────────
+# Median CV of within-command IATs. Below this → fluent (steady within
+# each command); above → fragmented (operator pauses mid-command).
+CMD_CHUNKING_FLUENT_CV_MAX: float = 0.50