Feature Request: Add delegated_role field to delegated sessions

Problem

When delegate_task spawns a subagent, the child session inherits the parent's session metadata but has no field recording which role or persona it was delegated as. The child session gets a parent_session_id pointing back to the parent, and it gets whatever model/provider was resolved for delegation, but there's no way to answer "was this session spawned as the builder agent or the research agent?" from the session record alone.

This makes attribution impossible in:

• Usage reporting — All delegated sessions roll up under the parent profile's token counts. A daily usage report can't split "the main agent used X tokens" from "the builder agent used Y tokens" from "the research agent used Z tokens" without fragile heuristics (e.g., parsing the first user message for role names).
• Session browsing — hermes sessions list shows delegated sessions without any role metadata, making it hard to filter by role — "show me all builder sessions" or "show me all research sessions."
• Billing attribution — When different profiles map to different cost centers or budgets, there's no reliable way to attribute spend.

Current Workaround

Appending a manual attribution log after each delegate_task call, mapping child_session_id → role_name. This works but:

• Requires manual bookkeeping (or a wrapper skill that's fragile)
• Is not queryable from the session database
• Breaks if the user forgets to log

Proposed Solution

Add a delegated_role text column to the sessions table, and populate it at child session creation time in _build_child_agent().

Schema change

ALTER TABLE sessions ADD COLUMN delegated_role TEXT;

Population

In tools/delegate_tool.py, when _build_child_agent() creates the child AIAgent:

• If the parent delegate call came from a named profile (e.g., my-builder), set delegated_role to that profile name.
• If the parent used the role kwarg on delegate_task (e.g., "leaf" vs "orchestrator"), store that too — or make it a separate field like delegate_role.

The parent_session_id already links the child to the parent. The delegated_role field would link the child to the role/persona it was spawned as, without requiring the parent to manually log it.

API exposure

• hermes sessions list / hermes sessions browse could show delegated_role in the table.
• hermes insights --days N could group by delegated_role for cost attribution.
• The delegate_task summary could include delegated_role so the parent agent can report it.

Backward compatibility

• Existing sessions get NULL for delegated_role — no migration needed.
• The column is informational only — no code path depends on it for correctness.

Alternatives Considered

1. Parse the first user message for role names — Fragile; the task description may not mention the role.
2. Use a separate attribution log file — Our current workaround. Works but isn't queryable, isn't durable across DB operations, and requires manual bookkeeping.
3. Store it in model_config JSON — The model_config column already exists but contains provider/model info, not role/persona metadata. Overloading it would make parsing harder.

Related Issues & PRs

Existing Code That Already Does Half the Job

delegate_tool.py:1146 already sets a runtime-only _delegate_role attribute on child AIAgent instances:

child._delegate_role = effective_role  # "leaf" or "orchestrator"

This is used in stop hooks and diagnostics but never persisted to the sessions table. The proposed feature would extend this: persist a richer value (role name or profile name) at session-creation time alongside the existing parent_session_id.

Additional Context

• Multi-profile Hermes setups commonly designate one profile as a builder agent and another as a research agent, each needing its own token attribution for usage reporting and cost tracking.
• The sessions table already has parent_session_id and model_config — this is a natural extension of the existing delegation metadata.
• Related: delegate_task already resolves delegation.model / delegation.provider per-profile. The delegated_role would carry the profile name alongside those resolved values.
• Current workaround for hiding delegated sessions is a heuristic in list_sessions_rich() (hermes_state.py:1626-1635): child sessions with parent_session_id are excluded from default views when the parent wasn't branched. A delegated_role column would make this deterministic rather than heuristic.