feat(decisioning): lifecycle observer hook on PgTaskRegistry / TaskRegistry for task metrics #1296

Summary

On 8.0.0, PgTaskRegistry has no way to observe task lifecycle transitions. Its constructor (adcp/decisioning/pg/task_registry.py:135-163) accepts only pool, task_webhook_outbox, webhook_signing_scope_resolver and a private _table. issue, update_progress, complete and fail all return None. An adopter therefore cannot count tasks created, completed or failed, or measure time to terminal, without forking or subclassing the registry. PgBuyerAgentRegistry already has this kind of hook (add_mutation_observer, decisioning/pg/buyer_agent_registry.py:371-408), and the task registry has no equivalent.

Details

Subclassing and overriding the write methods doesn't produce correct metrics:

• complete() returns None both when it performs the working -> completed transition and when it is an idempotent repeat with an equal result (task_registry.py:403-454; the repeat path is at 449-452). A wrapper can't tell the first terminal transition from a retry, so it double-counts.
• update_progress() silently no-ops on unknown or terminal tasks, and doesn't report whether submitted -> working happened (task_registry.py:376-402).
• issue() takes eight keyword arguments plus **_extra, five of them for webhook registration. A subclass has to mirror that signature and keep it in sync on every upgrade.

Only the registry knows, inside its transaction, whether a row actually changed state. That makes it the right place for the hook.

Why an adopter hits this

Embedded Sales Agent moved async get_products onto the SDK's PgTaskRegistry (core/decisioning/task_registry.py). Its earlier registry emitted get_products_async_tasks_created_total, ..._completed_total and ..._failed_total. Those series are now kept at zero on purpose, so existing dashboards don't show no-data alerts. src/core/metrics.py (~lines 87-106) states the reason: "The exact SDK PgTaskRegistry has no lifecycle-observer hook, so these counters intentionally remain at zero." Operators have lost visibility into async task throughput and failure rate. The only metric ESA still records, task expiry, comes from its own tasks_get shim, not the registry.

Ask

Add an observer seam that both InMemoryTaskRegistry and PgTaskRegistry honor. For example:

TaskTransition = Literal["issued", "working", "completed", "failed", "discarded"]

class TaskLifecycleObserver(Protocol):
    def __call__(self, event: TaskTransition, *, task_id: str, account_id: str,
                 task_type: str, created_at: float, updated_at: float) -> None: ...

PgTaskRegistry(pool=..., observers=[my_observer])   # or registry.add_lifecycle_observer(...)

The contract:

• Fire only after commit.
• Fire only when a row actually changed state, never on idempotent repeats or silent no-ops.
• Log and swallow observer exceptions, as add_mutation_observer does.

A smaller fallback: have complete, fail and update_progress return a bool saying whether the transition was applied, so a thin subclass can count correctly.