Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@DESIGN_SPEC.md`:
- Line 653: Update the spec text to use the current symbol names: replace
references to TokenBudgetTracker with TokenTracker and AgendaItem with
MeetingAgendaItem wherever they appear (including the section currently
mentioning all 3 meeting protocols and the noted repeat at lines ~2421-2425);
ensure any inline code formatting or API references match the implemented
symbols RoundRobinProtocol, PositionPapersProtocol, StructuredPhasesProtocol,
MeetingOrchestrator, and TokenTracker so readers are directed to existing APIs.

In `@src/ai_company/communication/config.py`:
- Around line 113-116: Update the Google-style docstring for the public class
MeetingTypeConfig to include the new public attribute `protocol_config` (type
MeetingProtocolConfig) and a short description such as "Meeting protocol
configuration" so generated docs and IDE hints reflect the new field; ensure the
docstring follows the existing Google-style sections (Args/Attributes) and
mentions `duration_tokens` and the new `protocol_config` entry consistently with
other attributes.

In `@src/ai_company/communication/meeting/_prompts.py`:
- Around line 23-27: The agenda item formatter in _prompts.py currently drops
MeetingAgendaItem.presenter_id when building entries from agenda.items; update
the loop that builds entry (for i, item in enumerate(agenda.items, 1)) to
include the optional presenter assignment when present (e.g., append a presenter
indicator using item.presenter_id or resolved presenter name) so presenter
ownership is preserved in the shared agenda prompt and any downstream protocol
that consumes MeetingAgendaItem can route presenter-specific flows correctly.
- Around line 3-9: The public annotation for MeetingAgenda in
build_agenda_prompt is only available under TYPE_CHECKING which causes runtime
resolution errors; replace the TYPE_CHECKING-only import with a real import of
MeetingAgenda from ai_company.communication.meeting.models at module level
(remove the conditional block or add a normal import alongside it) so that
build_agenda_prompt can be resolved at runtime by typing.get_type_hints() and
other consumers.

In `@src/ai_company/communication/meeting/_token_tracker.py`:
- Around line 6-38: TokenTracker currently mutates shared state via record(),
violating the repo convention of copy-on-write runtime state; replace in-place
mutation by making TokenTracker immutable and having record return a new
instance with updated input_tokens/output_tokens (or convert to a frozen
Pydantic model and use model_copy(update=...)). Update the TokenTracker
dataclass to be frozen (or use Pydantic BaseModel frozen) and change the record
method signature to return TokenTracker with the new totals; keep the used,
remaining, and is_exhausted properties as-is but computed from the new instance
to preserve behavior. Ensure all call sites that previously relied on in-place
updates now reassign the returned TokenTracker from record(...) to propagate
state.
- Around line 25-38: The record method currently accepts any integers and can
silently under/over-count tokens; update record(input_tokens, output_tokens) to
validate both deltas are non-negative ints, compute projected_used = self.used +
input_tokens + output_tokens and raise a ValueError (or custom exception) before
mutating if projected_used > self.budget or if either delta < 0; keep remaining
and is_exhausted as-is but rely on this check to prevent negative/overspend
states and perform the validation atomically so
self.input_tokens/self.output_tokens/self.used are only updated after the checks
pass.

In `@src/ai_company/communication/meeting/config.py`:
- Around line 61-66: Remove the stale attribute mention from
StructuredPhasesConfig's docstring: delete the "auto_create_tasks" entry under
Attributes so the docstring only documents skip_discussion_if_no_conflicts and
max_discussion_tokens; reference that the auto_create_tasks setting now lives on
MeetingProtocolConfig.auto_create_tasks so do not reintroduce it into
StructuredPhasesConfig's public docs.

In `@src/ai_company/communication/meeting/models.py`:
- Around line 265-289: The validator _validate_status_consistency should reject
blank/whitespace error messages for failed states: when self.status is
MeetingStatus.FAILED or MeetingStatus.BUDGET_EXHAUSTED, check that
self.error_message is not None and that self.error_message.strip() is non-empty
(or enforce min_length=1 on the error_message Field) and raise the existing
ValueError if the check fails so empty strings/whitespace are not accepted.
- Around line 184-218: The MeetingMinutes model currently allows independently
set total_input_tokens and total_output_tokens that can diverge from
per-contribution counts in contributions; update MeetingMinutes to enforce
consistency by deriving or validating these totals from MeetingContribution
entries: either convert total_input_tokens and total_output_tokens into computed
fields (like total_tokens is computed) or add a model validator that sums
MeetingContribution.total_input_tokens and .total_output_tokens and
raises/normalizes when they differ from the stored
total_input_tokens/total_output_tokens; refer to MeetingContribution,
MeetingMinutes, contributions, total_input_tokens, total_output_tokens, and
total_tokens when making the change.

In `@src/ai_company/communication/meeting/orchestrator.py`:
- Around line 332-378: Extend _validate_inputs to also reject blank/whitespace
IDs and duplicate participant IDs before execution: after the existing
token_budget check, validate leader_id.strip() is non-empty and that every
participant_id.strip() is non-empty (treat trimmed values as the canonical IDs),
logging MEETING_VALIDATION_FAILED and raising MeetingParticipantError with
context={"meeting_id": meeting_id, "leader_id": leader_id} (or include offending
participant id) when any are blank; then check for duplicates among the trimmed
participant_ids (e.g., by comparing length of set(trimmed_participant_ids) to
list length), log MEETING_VALIDATION_FAILED with error="duplicate
participant_ids" and raise MeetingParticipantError with context={"meeting_id":
meeting_id, "duplicates": list_of_duplicates}; keep the existing
leader-in-participants check using the trimmed canonical IDs so leader_id
present in participant_ids still fails as before.
- Around line 85-88: The constructor currently assigns the caller-owned
protocol_registry directly to self._protocol_registry which allows external
mutation; in __init__ make a defensive deep copy of the passed protocol_registry
(use copy.deepcopy) and wrap that copy in types.MappingProxyType before
assigning to self._protocol_registry so the orchestrator holds an immutable
snapshot for its lifetime; update any imports (copy and MappingProxyType) if
needed and keep the attribute name self._protocol_registry and its type
annotation list[MeetingRecord] unchanged.
- Around line 346-348: Before raising the ValueError in the token_budget <= 0
branch, emit a warning using the existing logger with context and the
MEETING_VALIDATION_FAILED event: log a message that includes the token_budget
value and MEETING_VALIDATION_FAILED (use logger.warning or self.logger.warning
consistent with surrounding code) and any other relevant identifiers, then raise
ValueError(msg); ensure MEETING_VALIDATION_FAILED is referenced/imported the
same way other validation errors are logged in this module so observability
captures this public error path.

In `@src/ai_company/communication/meeting/position_papers.py`:
- Around line 156-167: The MeetingMinutes returned for POSITION_PAPERS only sets
summary, leaving decisions and action_items empty so
MeetingOrchestrator._create_tasks() cannot generate tasks; update the return in
position_papers flow to populate MeetingMinutes.decisions and .action_items from
the synthesis contribution (e.g., use synthesis_contribution.decisions and
synthesis_contribution.action_items or parse structured fields from
synthesis_contribution.content if needed), converting them to the expected tuple
types, and keep summary as synthesis_contribution.content so tasks are created
correctly.
- Around line 203-215: The current pre-division uses tokens_per_agent = max(1,
tracker.remaining // max(1, n)) which can over-allocate when tracker.remaining <
number of parallel workers; change the logic before spawning _collect_paper
tasks to compute an effective fan-out: set n_effective = min(n,
tracker.remaining) (or if tracker.remaining == 0 raise/return early), then
compute tokens_per_agent = tracker.remaining // max(1, n_effective); if
tokens_per_agent == 0 either reduce n_effective to tracker.remaining or fail
fast; update all places that use n (e.g., the TaskGroup spawn and participant
loop that starts _collect_paper) to use n_effective so no worker receives a zero
or implicit extra token.

In `@src/ai_company/communication/meeting/round_robin.py`:
- Around line 125-126: The code always subtracts a summary reserve
(summary_reserve = int(token_budget * _SUMMARY_RESERVE_FRACTION)) from
discussion_budget even when summaries are disabled; change the logic in the
block that computes summary_reserve/discussion_budget so that summary_reserve is
set to 0 when leader_summarizes is False (and only compute int(token_budget *
_SUMMARY_RESERVE_FRACTION) when leader_summarizes is True), then set
discussion_budget = token_budget - summary_reserve; update any code paths that
use summary_reserve to assume zero when summaries are disabled (references:
summary_reserve, _SUMMARY_RESERVE_FRACTION, discussion_budget,
leader_summarizes).

In `@src/ai_company/communication/meeting/structured_phases.py`:
- Around line 388-392: The conflict detection call currently passes
tracker.remaining directly to agent_caller (conflict_response = await
agent_caller(leader_id, conflict_prompt, tracker.remaining)), which can exhaust
the whole meeting budget; change it to cap the tokens by
StructuredPhasesConfig.max_discussion_tokens (e.g., compute allowed =
min(tracker.remaining, StructuredPhasesConfig.max_discussion_tokens) and pass
allowed) and ensure the value is non-negative so phase 3 discussion/synthesis
retain their token budget; update any related variable names in the same scope
and keep the agent_caller invocation using leader_id and conflict_prompt.
- Around line 278-279: The current calculation forces tokens_per_agent = 1 even
when tracker.remaining < num_participants, causing total allocation to
oversubscribe the remaining budget; change the logic around
participant_ids/tokens_per_agent so you either (A) cap fan-out by computing
max_agents = min(len(participant_ids), tracker.remaining) and use
tokens_per_agent = tracker.remaining // max(1, max_agents) (and reduce/choose a
subset of participant_ids to max_agents), or (B) fail fast when
tracker.remaining < len(participant_ids) by raising or returning an error;
update the code that sets tokens_per_agent and any subsequent use of
participant_ids accordingly (refer to participant_ids, tokens_per_agent,
tracker.remaining).
- Around line 238-250: The MeetingMinutes being returned from the
structured-phases flow omits decisions and action_items even though the
synthesis collects them; update the MeetingMinutes constructor call in
structured_phases.py to include decisions and action_items (e.g.,
decisions=tuple(decisions) and action_items=tuple(action_items)), ensuring the
local variables (decisions, action_items) are defined or defaulted to empty
lists/tuples before the return so downstream task creation sees the populated
fields; keep protocol_type as MeetingProtocolType.STRUCTURED_PHASES and preserve
existing fields like summary.

In `@tests/integration/communication/test_meeting_integration.py`:
- Around line 121-145: The test test_round_robin_full_lifecycle currently only
asserts len(record.minutes.contributions) > 0 which doesn't verify the
RoundRobinConfig was applied; update the assertion to check that the
contributions match the expected deterministic number given
RoundRobinConfig(max_turns_per_agent=1) (i.e., two participant turns plus one
meeting summary => assert len(record.minutes.contributions) == 3) and optionally
assert the participant contributions contain the expected participant_ids
("agent-a", "agent-b") in the expected order to ensure max_turns_per_agent was
honored; locate these checks around the existing MeetingProtocolConfig /
RoundRobinConfig usage and the record.minutes.contributions assertions.

In `@tests/unit/communication/meeting/conftest.py`:
- Around line 58-79: The fake caller _caller currently ignores the max_tokens
argument so budget tests can't observe or enforce token limits; modify _caller
to record the requested max_tokens (e.g., push it into a shared list or dict
keyed by agent_id/call index) and/or clamp the returned
input_tokens/output_tokens to not exceed max_tokens before constructing the
AgentResponse; update references inside _caller (max_tokens, input_tokens,
output_tokens, call_counts, _responses, default_content, AgentResponse) so tests
can inspect the captured requested budgets or rely on the clamped token counts.

In `@tests/unit/communication/meeting/test_orchestrator.py`:
- Around line 374-402: The tests test_task_creator_not_called_when_disabled and
its paired test never exercise task creation because the mocked protocol/minutes
return no ActionItem; update the tests to use a stub protocol or mocked minutes
that include at least one ActionItem so the orchestrator path through
_create_tasks() is executed (for example, provide a custom protocol/minutes
object returned by the orchestrator run that contains an ActionItem), then
verify behavior when MeetingProtocolConfig(auto_create_tasks=False) and when
task_creator raises—this will exercise the gate and exception-handling paths;
reference the test functions test_task_creator_not_called_when_disabled, the
MeetingProtocolConfig(auto_create_tasks=False) usage, the task_creator stub
passed into _make_orchestrator, and the orchestrator.run_meeting call to locate
where to inject the stubbed minutes or protocol.
- Around line 292-310: The test test_budget_exhaustion_produces_record currently
accepts MeetingStatus.FAILED which permits regressions; change the assertion to
require the dedicated budget-exhaustion status only by asserting record.status
== MeetingStatus.BUDGET_EXHAUSTED (keep the existing check that
record.error_message is not None) so the test verifies
orchestrator.run_meeting(..., token_budget=1) produces the explicit
BUDGET_EXHAUSTED outcome.

In `@tests/unit/communication/meeting/test_position_papers.py`:
- Around line 60-118: The tests test_contributions_structure and
test_parallel_execution_all_participants currently only assert counts and set
membership which won't catch nondeterministic ordering regressions; update them
to assert a deterministic order by inspecting minutes.contributions (filtering
by MeetingPhase.POSITION_PAPER) and then check the sequence of each
contribution's turn_number or agent_id matches the expected participant_ids
order (or a sorted/explicit expected sequence), e.g., build the ordered list
from [c for c in minutes.contributions if c.phase ==
MeetingPhase.POSITION_PAPER] and assert their turn_number or agent_id sequence
equals the expected ordering to lock in the deterministic contract.

In `@tests/unit/communication/meeting/test_round_robin.py`:
- Around line 220-247: The test currently treats a call that would push total
tokens past token_budget as valid; update the test
(test_budget_exhaustion_stops_turns and the similar block at 249-280) so the
RoundRobinProtocol enforces the budget pre-turn: invoke protocol.run with
make_mock_agent_caller and token_budget=50 but assert that the protocol either
raises MeetingBudgetExhaustedError before executing the turn that would cross
the budget or verify the mock caller was not invoked for that crossing turn;
specifically reference RoundRobinProtocol.run, make_mock_agent_caller,
MeetingBudgetExhaustedError and the token_budget argument when changing the
expectation so the test fails if an over-budget turn is allowed to complete.

In `@tests/unit/communication/meeting/test_structured_phases.py`:
- Around line 105-112: The test mocks use a hardcoded key "leader-agent" in the
responses mapping which breaks if the fixture leader_id changes; update each
responses dict (e.g., the one passed to make_mock_agent_caller in
test_structured_phases.py) to use the injected leader_id variable as the key
instead of the literal string, and apply the same change to the other response
dictionaries in this file (the blocks at the other ranges noted) so mocks match
the fixture-provided leader_id.

In `@tests/unit/communication/test_enums.py`:
- Around line 19-20: Update the test to assert the new enum member directly
instead of relying only on the enum length: in
tests/unit/communication/test_enums.py modify the test_values() (or add to
test_member_count) to include an explicit assertion that
MessageType.MEETING_CONTRIBUTION exists (e.g., assert
MessageType.MEETING_CONTRIBUTION in MessageType or assert hasattr(MessageType,
"MEETING_CONTRIBUTION")) so the test fails if that public enum value is removed
or renamed.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/ai_company/communication/meeting/position_papers.py`:
- Around line 212-229: The current code sets max_tokens using budget_slice but
ignores prompt token cost so agent_caller(...) can generate within max_tokens
while the prompt pushes tracker.used past token_budget; fix by estimating the
prompt token count before calling agent_caller (e.g., via the project's
tokenizer or a conservative heuristic) and compute output_allowance = max(0,
min(self._config.max_tokens_per_position, budget_slice -
estimated_prompt_tokens)); pass output_allowance as max_tokens to agent_caller,
record both estimated_prompt_tokens + response.output_tokens to tracker (instead
of waiting for response.input_tokens), and apply the same change to the other
occurrence around the block handling lines ~338-347 to ensure the
duration_tokens/token_budget bound is respected.

In `@src/ai_company/communication/meeting/protocol.py`:
- Around line 61-100: The MeetingProtocol interface currently only exposes run()
and get_protocol_type(), which prevents callers from composing standard
lifecycle phases; update the MeetingProtocol class to declare the standard
lifecycle methods start_meeting(...), run_round(...), summarize(...), and
extract_action_items(...) (with appropriate async signatures and the same domain
types used by run: meeting_id: str, agenda: MeetingAgenda, leader_id: str,
participant_ids: tuple[str, ...], agent_caller: AgentCaller, token_budget: int,
returning MeetingMinutes or specific partial results as appropriate) so
implementations must implement these phases, and keep run() as a convenience
orchestrator that can call those methods; reference MeetingProtocol, run,
get_protocol_type, start_meeting, run_round, summarize, and extract_action_items
when making the change.

In `@src/ai_company/communication/meeting/structured_phases.py`:
- Around line 467-472: The logger call using MEETING_CONFLICT_DETECTED currently
writes the full meeting analysis via raw_response=conflict_response.content;
replace this with non-sensitive metadata only (e.g., a boolean or redacted
summary) so sensitive participant text is not stored. Update the logger.info
call that includes MEETING_CONFLICT_DETECTED, meeting_id, conflicts_found
(conflicts_detected) to remove or redact raw_response and instead pass a
redact-safe field like conflict_summary (e.g., "redacted" or a short
summary/flag) or a hashed/length-only marker derived from
conflict_response.content; ensure references are to logger.info,
MEETING_CONFLICT_DETECTED, meeting_id, conflicts_found, and conflict_response so
reviewers can find and verify the change.

In `@tests/unit/communication/meeting/test_token_tracker.py`:
- Around line 36-47: Update the two tests to expect over-budget recording to
fail instead of being allowed: wrap the calls to TokenTracker.record in
pytest.raises(ValueError) (or the specific exception your TokenTracker raises)
so test_record_exceeds_budget and test_remaining_never_negative assert that
calling TokenTracker.record would raise when the requested tokens exceed the
budget; after the exception assert that tracker.used remains at its previous
value (e.g., 30 for test_record_exceeds_budget or 0 for the other),
tracker.remaining is 0, and tracker.is_exhausted is True; this changes
expectations for the TokenTracker.record method and uses the TokenTracker,
record, used, remaining, and is_exhausted symbols to locate the code to update.

---

Duplicate comments:
In `@DESIGN_SPEC.md`:
- Around line 2418-2425: Update the project tree and §15.3 references to use the
actual implemented symbol name: replace the stale "AgendaItem" entry with
"MeetingAgendaItem" (and update any other mentions of AgendaItem to
MeetingAgendaItem) so readers are directed to the existing API; ensure the
package list line under the meeting subsystem and the §15.3 text use
MeetingAgendaItem consistently.

In `@src/ai_company/communication/meeting/_token_tracker.py`:
- Around line 16-18: TokenTracker is a mutable dataclass that violates the
repo's copy-on-write model; change it to an immutable/frozen model and make its
state-update methods return a new instance rather than mutating self.
Specifically, convert TokenTracker to a frozen dataclass or a frozen Pydantic
model and update the record() (and any other state-changing helpers referenced
around TokenTracker) to perform a copy/update and return the new TokenTracker
instance (e.g., via dataclasses.replace or model_copy(update=...)) so callers
always receive a new object instead of mutating shared state.
- Around line 41-68: The record() method currently updates
input_tokens/output_tokens before checking budget, allowing silent overruns;
modify MeetingTokenTracker.record to compute projected_used = (self.used or
self.input_tokens + self.output_tokens) + input_tokens + output_tokens (or
simply self.input_tokens + self.output_tokens + input_tokens + output_tokens)
and if projected_used > self.budget raise MeetingBudgetExhaustedError before
mutating state, otherwise proceed to increment self.input_tokens and
self.output_tokens; keep the existing non-negative validation and use the
existing property names remaining, is_exhausted, budget, used, input_tokens,
output_tokens and the MeetingBudgetExhaustedError exception.

In `@src/ai_company/communication/meeting/models.py`:
- Around line 201-218: The stored fields total_input_tokens and
total_output_tokens can diverge from per-contribution sums; change them to
computed fields that sum over the meeting's contributions (e.g.,
sum(c.input_tokens) for total_input_tokens and sum(c.output_tokens) for
total_output_tokens) instead of keeping default stored ints, and ensure
total_tokens remains (or is updated to be) the computed sum of those computed
fields to remove redundant state; update the Field definitions/annotations for
total_input_tokens and total_output_tokens to use `@computed_field` and reference
the contributions relationship when calculating the totals (keeping the existing
total_tokens property as-is or adjust to return the sum of the newly computed
fields).
- Around line 265-268: The error_message field uses type str | None which allows
empty/whitespace strings; change its annotation to NotBlankStr | None (import
NotBlankStr from core.types) so validators for statuses FAILED and
BUDGET_EXHAUSTED enforce non-blank messages, i.e., replace "error_message: str |
None = Field(...)" with "error_message: NotBlankStr | None = Field(...)" and add
the necessary import.

In `@src/ai_company/communication/meeting/orchestrator.py`:
- Around line 86-96: The constructor currently stores the caller-owned
protocol_registry directly (parameter protocol_registry -> attribute
self._protocol_registry), allowing external mutation; fix by creating a
defensive copy and exposing it as read-only: deepcopy the incoming
protocol_registry (use copy.deepcopy) and then wrap the result with
types.MappingProxyType before assigning to self._protocol_registry so the
internal registry cannot be mutated after construction (update imports as needed
to include copy and MappingProxyType).
- Around line 358-409: The _validate_inputs method currently only checks for
empty participant_ids, leader inclusion, and token_budget; extend it to also
reject blank/whitespace participant IDs and duplicate participant IDs at the
system boundary: iterate over participant_ids in _validate_inputs, trim each ID
and if any are empty/only whitespace log MEETING_VALIDATION_FAILED and raise
MeetingParticipantError with context {"meeting_id": meeting_id} and a clear
message about blank IDs, and if len(set(participant_ids)) !=
len(participant_ids) log and raise MeetingParticipantError indicating duplicate
participant IDs (include meeting_id and optionally leader_id in context),
keeping existing token_budget and leader checks intact and using the same logger
and error patterns used elsewhere in _validate_inputs.

In `@src/ai_company/communication/meeting/position_papers.py`:
- Around line 156-168: The return currently only sets MeetingMinutes.summary
from synthesis_contribution.content, leaving MeetingMinutes.decisions and
.action_items empty; update the position-papers finalization in the function
that builds MeetingMinutes (the block returning MeetingMinutes with
protocol_type=MeetingProtocolType.POSITION_PAPERS) to parse/derive structured
decisions and action items from the synthesis_contribution (or from combined
contributions) and populate MeetingMinutes.decisions and
MeetingMinutes.action_items accordingly so auto_create_tasks can consume them;
you can add a small helper (e.g., parse_decisions_and_actions_from_text) to
extract items from synthesis_contribution.content or change the synthesis step
to return a richer object and map its fields into MeetingMinutes.decisions and
.action_items.
- Around line 203-205: The current pre-division line tokens_per_agent = max(1,
tracker.remaining // max(1, n)) can overcommit when tracker.remaining < n;
instead compute a base and remainder and distribute without exceeding
tracker.remaining: set base = tracker.remaining // n and rem = tracker.remaining
% n, then assign each agent tokens = base + (1 if agent_index < rem else 0)
(this yields some agents 0 when tracker.remaining < n and guarantees the total
sum <= tracker.remaining). Update the logic around tokens_per_agent and any loop
that consumes it (referencing tokens_per_agent, tracker.remaining and n) to use
this distribution scheme so no more tokens are allocated than available.

In `@src/ai_company/communication/meeting/round_robin.py`:
- Around line 125-126: The code always reserves summary_reserve =
int(token_budget * _SUMMARY_RESERVE_FRACTION) and subtracts it from
discussion_budget even when leader_summarizes is False; change the logic in
src/ai_company/communication/meeting/round_robin.py so that summary_reserve is
only computed and withheld when leader_summarizes is True (otherwise set
summary_reserve = 0 and discussion_budget = token_budget), updating the
variables summary_reserve and discussion_budget accordingly where they are used
so the protocol doesn't prematurely stop discussion when summaries are disabled.
- Around line 185-197: The MeetingMinutes returned at the end of the round-robin
flow only sets summary and omits the structured decisions/action_items captured
during the summary phase; update the return in round_robin.py (the
MeetingMinutes construction) to include the parsed decisions and action_items
variables produced during the summary step (e.g., decisions and action_items or
parsed_decisions/parsed_action_items) so MeetingMinutes.decisions and
MeetingMinutes.action_items are populated for the successful round-robin path
and allow auto_create_tasks to work.

In `@src/ai_company/communication/meeting/structured_phases.py`:
- Around line 441-445: The pre-discussion conflict check currently calls
agent_caller(leader_id, conflict_prompt, tracker.remaining) and can consume the
whole meeting budget; change it to cap the token allowance with
StructuredPhasesConfig.max_discussion_tokens (e.g., compute allowed_tokens =
min(tracker.remaining, StructuredPhasesConfig.max_discussion_tokens)) and pass
allowed_tokens to agent_caller so conflict_response uses the same
max_discussion_tokens limit as the discussion phase.
- Around line 282-295: The MeetingMinutes returned by finalize in
structured_phases omits decisions and action_items, so downstream task creation
never runs; update the finalize flow (inside structured_phases where
MeetingMinutes(...) is constructed) to parse the synthesis output produced by
the leader synthesis step (or switch that step to request a structured JSON
response) and populate the MeetingMinutes.decisions and
MeetingMinutes.action_items fields before returning; locate the synthesis result
variable used earlier in the phase (the leader synthesis response) and
extract/validate decisions and action items, converting them into the same types
used by MeetingMinutes and include them in the MeetingMinutes(...) constructor
along with summary.
- Around line 322-323: The current calculation in structured_phases.py that sets
tokens_per_agent = max(1, tracker.remaining // max(1, num_participants)) can
oversubscribe the TaskGroup when tracker.remaining < num_participants; change
the logic to either fail fast or cap fan-out—e.g., compute allowed_agents =
min(num_participants, tracker.remaining) and then set tokens_per_agent = max(1,
tracker.remaining // allowed_agents) (or alternatively raise an error when
tracker.remaining < num_participants); update the code paths that spawn the
TaskGroup (referencing num_participants, tokens_per_agent, tracker.remaining and
the TaskGroup spawn logic) to use allowed_agents so aggregate token usage never
exceeds tracker.remaining.

In `@tests/unit/communication/meeting/test_orchestrator.py`:
- Around line 455-483: The tests test_task_creator_not_called_when_disabled (and
the duplicate at 485-511) never exercise the task-creation path because the
default stub protocol returns no ActionItem minutes; update these tests to reuse
the stub-protocol used in test_task_creator_called_with_correct_args() so the
protocol returns Minutes containing at least one ActionItem, then assert
auto_create_tasks=False prevents _create_tasks() from calling the provided
_creator. Specifically, adjust the protocol stub used when constructing
orchestrator via _make_orchestrator to produce Minutes with an ActionItem
(matching the stub pattern in test_task_creator_called_with_correct_args()),
keep MeetingProtocolConfig(auto_create_tasks=False), pass the same _creator, and
call orchestrator.run_meeting so the task-creation branch is actually reached
and can be validated.

In `@tests/unit/communication/meeting/test_position_papers.py`:
- Around line 63-121: The tests currently only assert counts and set membership,
which allows nondeterministic ordering to pass; update the two tests
test_contributions_structure and test_parallel_execution_all_participants to
assert a deterministic ordering for POSITION_PAPER contributions by extracting
the list of contributions where c.phase == MeetingPhase.POSITION_PAPER from
minutes.contributions and then assert their order (e.g., by comparing the
sequence of c.agent_id or c.turn_number to the expected order derived from
participant_ids or expected turn numbers). Ensure you reference the
minutes.contributions list, MeetingPhase.POSITION_PAPER, and the contribution
fields agent_id and/or turn_number when implementing the ordered assertion so
the regression to nondeterministic ordering is pinned.

In `@tests/unit/communication/meeting/test_structured_phases.py`:
- Around line 107-112: Mocks in these tests hard-code the key "leader-agent" in
the responses dict instead of using the injected leader_id fixture, which will
break if leader_id changes; update each responses map (the dict named responses
in the test) to use the leader_id variable as the key (e.g., replace
"leader-agent": [...] with leader_id: [...]) for all occurrences so the mock
matches the injected fixture value and any parameterizations of leader_id.