feat(cognitive): emit TASK_PROGRESS at every step boundary — closes the streaming pipe

[flg77]

Summary

PR #19 wired the receive side (observer fan-out → channel callback → prompt-pane transcript). This PR adds the producer side so an operator using the prompt pane sees live progress lines without injecting synthetic events.

Pipeline (now end-to-end)

```
Operator types prompt → Send
│
▼
TUIPromptChannel.send(..., on_progress=cb)
│ publishes TASK_ASSIGN + registers progress listener
▼
Agent._handle_task receives TASK_ASSIGN
│ builds a sync callback that publishes TASK_PROGRESS
▼
CognitiveCore.process_task(... progress_callback=cb)
step 1/6 Pre-reasoning gate ─┐
step 2/6 Building system prompt │
step 3/6 Calling LLM │ each fires callback
step 4/6 Post-reasoning governance │ → publishes TASK_PROGRESS
step 5/6 Persisting episode │
step 6/6 Drift scoring ─┘
│
▼
dispatch_invocations(... progress_callback=cb)
step 1/N Calling skill:echo ─┐ same callback,
step 2/N Calling mcp:fs.read ─┘ same task_id
│
▼
NATSObserver._route_task_progress fans out to per-task_id listeners
│
▼
PromptScreen renders "→ step N/M — " lines in the transcript
```

What lands

File	Change
`acc/cognitive_core.py`	`process_task` gains optional `progress_callback` kwarg + an inline `_emit` helper. Six emits at the canonical step boundaries with `elapsed_ms` (since process_task entry) and post-LLM token counts. Exception-isolated.
`acc/capability_dispatch.py`	`dispatch_invocations` gains optional `progress_callback` kwarg. One emit per invocation BEFORE dispatch with `current_step`/`total_steps_estimated` and `step_label="Calling :"`. Lazy-imports `ProgressContext`.
`acc/agent.py`	`_handle_task` builds the agent-side callback when the inbound TASK_ASSIGN carries a `task_id`. Sync callback schedules an async publish via `asyncio.create_task` — fire-and-forget so cognitive pipeline never blocks on NATS. Same callback passed to both `process_task` and `dispatch_invocations` so the operator sees one continuous progress stream per task.
`tests/test_task_progress_emit.py` (new)	10 cases.

Tests (10 new, all green)

Tier	Cases
Tier 1 — process_task emits	exactly 6 emits in order with monotonic step counter; post-LLM emit carries non-zero token counts; elapsed_ms non-decreasing; None callback is zero overhead; misbehaving callback at step 2 doesn't stop steps 3-6
Tier 2 — dispatch_invocations emits	one emit per invocation in order; emit fires BEFORE dispatch; None callback zero overhead; bad callback for invocation 1 doesn't skip invocation 2
Tier 3 — End-to-end across PR #19's receive pipe	Full process_task → agent-callback → observer fan-out → consumer round-trip; payload shape matches what TUIPromptChannel expects (signal_type + task_id + agent_id + nested progress dict with every ProgressContext field)

Combined regression: 235 passed locally and on acc1
(test_task_progress_emit + test_task_progress_streaming + test_capability_dispatch_oversight + test_cognitive_core + test_prompt_screen_pilot + test_prompt_channel + test_observer_task_listener + test_redis_compat + test_capability_telemetry + test_config + test_role_store + test_guardrails + test_compliance, with the lighthouse-OpenSSL-impaired `TestEd25519Validation` deselected).

Test plan

• `pytest tests/test_task_progress_emit.py -v --no-cov` → 10 passed
• Combined regression on acc1 → 235 passed
• Manual on acc1 post-merge:
  ```bash
  ./acc-deploy.sh rebuild # pull + no-cache build
  ./acc-deploy.sh down && ./acc-deploy.sh up
  acc-tui # press 7

  Send a prompt → watch transcript fill with live step lines

  WITHOUT injecting synthetic events.

  ```

Operational expectation post-merge

Operator sends a prompt → transcript renders 6 step lines for the LLM half + N step lines for the capability half, all under one task_id, all under one prompt round-trip:

```
14:32:01 operator → coding_agent
Generate a unit test for FizzBuzz

→ step 1/6 — Pre-reasoning gate (Cat-B setpoints)
→ step 2/6 — Building system prompt
→ step 3/6 — Calling LLM
→ step 4/6 — Post-reasoning governance
→ step 5/6 — Persisting episode + embedding output
→ step 6/6 — Drift scoring
→ step 1/1 — Calling skill:echo
✓ skill:echo

14:32:08 coding_agent-x latency=147ms
def test_fizzbuzz_basic():
assert fizzbuzz(15) == "FizzBuzz"
```

Out of scope (future enhancements)

• Confidence-trend computation in CognitiveCore — currently fixed STABLE. Needs a small rolling-window of past confidence values.
• Per-step deadline / over_budget reporting from Cat-B setpoint enforcement.
• SlackPromptChannel honouring on_progress — would post follow-up Slack messages with the live step lines.