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

Inline comments:
In `@src/ai_company/templates/builtins/dev_shop.yaml`:
- Line 21: The YAML lint error is caused by spacing inside the Jinja braces for
the budget_monthly value; update the Jinja expression associated with the
budget_monthly key (the template "{{ budget | default(75.0) }}") to remove the
extra space immediately after "{{" and before "}}" so it conforms to the braces
rule (e.g., use the same expression without those inner-leading/trailing
spaces), then re-run the YAML linter to confirm the file passes.

In `@src/ai_company/templates/builtins/full_company.yaml`:
- Line 21: The Jinja expression used for budget_monthly violates the YAML lint
"braces" rule; update the template expression for budget_monthly (the Jinja
token containing budget | default(200.0)) to remove the extra spaces directly
inside the curly braces so the braces are tight (adjust the Jinja tag around
budget | default(200.0) accordingly) to satisfy yaml linting.

In `@src/ai_company/templates/builtins/product_team.yaml`:
- Line 21: The Jinja expression on the budget_monthly line has extra spaces
inside the braces which triggers YAML linting; update the template expression in
product_team.yaml (the budget_monthly: line containing the {{ ... }} expression)
to remove the spaces immediately after '{{' and before '}}' so the expression
reads with no inner brace padding (e.g., change the existing {{ budget |
default(80.0) }} form to use no spaces adjacent to the braces).

In `@src/ai_company/templates/builtins/solo_founder.yaml`:
- Line 21: The Jinja expression for the budget in the template key
budget_monthly uses spacing that triggers YAML linting; update the Jinja braces
to remove inner spaces so the line reads with tightly wrapped braces (e.g.,
change the Jinja expression used in budget_monthly to {{budget |
default(25.0)}}) and commit the change so check-yaml passes.

In `@src/ai_company/templates/builtins/startup.yaml`:
- Line 21: The YAML lint error is caused by spacing inside the Jinja braces for
the budget_monthly key; update the Jinja expression from "{{ budget |
default(50.0) }}" to remove the inner brace spacing so it reads "{{budget |
default(50.0)}}" (i.e., edit the budget_monthly line replacing the existing
Jinja tag with {{budget | default(50.0)}} to satisfy the 'braces' rule).

In `@src/ai_company/templates/loader.py`:
- Around line 289-293: Move the call to _normalize_template_data and the shape
check for template_data into the validation try/except so malformed payloads
raise a wrapped TemplateValidationError instead of raw AttributeError/TypeError:
inside the block that constructs CompanyTemplate(**...), first assert
template_data is a mapping (e.g. isinstance(template_data, Mapping) or dict)
and/or check required keys, then call _normalize_template_data(template_data)
and pass the result to CompanyTemplate; catch exceptions and re-raise as
TemplateValidationError with the original exception info so errors from
normalization or instantiation are consistently wrapped.
- Around line 335-349: The helper _to_float currently swallows malformed numeric
strings by returning 0.0; change it to surface errors instead: in the except
ValueError branch raise a ValueError (including the original value and the
original exception message) so invalid YAML numeric input fails validation, keep
the final return float(value) for non-strings, and ensure any callers of
_to_float (where it’s used to coerce template fields) either validate input
beforehand or handle the propagated ValueError.

In `@src/ai_company/templates/renderer.py`:
- Around line 199-207: The code assumes data["template"] is a dict and returns
it directly in renderer.py; add a type check after extracting result (e.g.,
result = data["template"]) to verify it's a mapping/dict and, if not, raise
TemplateRenderError with a clear message (include source_name and the same
locations tuple using ConfigLocation) so non-mapping render outputs
(scalars/lists) produce a TemplateRenderError instead of later AttributeError;
reference the existing TemplateRenderError, ConfigLocation, data, source_name,
and result symbols when locating where to add this validation.
- Around line 380-392: The _safe_float function uses invalid exception syntax
and masks conversion errors; update it to catch exceptions with Python 3 syntax
(e.g., except (TypeError, ValueError) as e:) and stop silently returning
0.0—instead either re-raise a ValueError with a clear message including the
offending value (e.g., raise ValueError(f"Invalid numeric value for config:
{value!r}") from e) or let the original exception propagate so callers can
handle validation at system boundaries; modify the _safe_float function to
implement one of these behaviors and keep the float(value) attempt intact.

In `@tests/unit/config/test_utils.py`:
- Around line 8-68: There are duplicate TestDeepMerge tests for deep_merge;
consolidate by keeping this canonical suite (class TestDeepMerge with its test
methods) in tests/unit/config/test_utils.py and remove the overlapping tests in
tests/unit/config/test_loader.py; ensure any required import of deep_merge is
present in test_utils.py, that pytest markers (pytest.mark.unit) remain, and
that you delete or disable the duplicate TestDeepMerge class/methods in
test_loader.py so there’s a single authoritative test location.

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

Inline comments:
In `@src/ai_company/templates/loader.py`:
- Around line 79-132: The list_templates function (and similarly
_parse_template_yaml) is too large and mixes responsibilities; split
list_templates into smaller helpers such as _collect_user_templates(path: Path)
-> dict[str, TemplateInfo], _collect_builtin_templates(seen: dict[str,
TemplateInfo]) -> None, and _make_template_info(name, loaded, source) ->
TemplateInfo to isolate loading, metadata extraction, error handling and
sorting; call existing helpers _load_from_file and _load_builtin inside these
new functions and move the try/except/logging into each helper (use
logger.warning for user template errors and logger.exception for builtin
errors), then have list_templates simply call the two collectors, sort seen and
return the tuple. Apply the same decomposition to _parse_template_yaml by
extracting YAML parsing, validation, and metadata extraction into focused helper
functions and reusing them from the caller.
- Around line 359-365: When building metadata, avoid calling company.get on
non-mappings: read company_raw = data.get("company", None), validate it with
isinstance(company_raw, Mapping) (or dict) and if it's None set company = {} but
if it's not a mapping raise a clear validation error (e.g., ValueError or custom
ValidationError) before proceeding to construct metadata; update subsequent uses
(the metadata dict creation that references company.get and the surrounding
normalization code) to use the validated company variable.
- Line 125: Replace the Python 2 style exception clause that uses commas with a
parenthesized tuple: change "except TemplateRenderError,
TemplateValidationError, OSError:" to "except (TemplateRenderError,
TemplateValidationError, OSError):" (and if you need the exception instance, use
"except (TemplateRenderError, TemplateValidationError, OSError) as e:"). Update
both occurrences that reference TemplateRenderError, TemplateValidationError,
and OSError (the except block around the template rendering/validation logic and
the other similar except at the later occurrence) so the syntax is valid in
Python 3.

In `@src/ai_company/templates/renderer.py`:
- Around line 219-275: _build_config_dict and _expand_agents are doing multiple
tasks (parsing company fields, numeric validation, agent expansion and
department construction) and exceed the size limit; split them into smaller
focused helpers so each function is under ~50 lines. Specifically, extract: a
parse_company_metadata or _extract_company_fields(rendered_data, template,
variables) to compute company_name/type and source_name, a
_parse_config_values(rendered_data, template) that handles
autonomy/budget_monthly parsing and raises TemplateRenderError on ValueError,
and leave _build_config_dict to orchestrate calling _expand_agents(raw_agents)
and _build_departments(raw_depts) and assembling the final dict; also move any
numeric conversion logic from _expand_agents into the new _parse_config_values
to keep responsibilities separated. Ensure new helper names
(_extract_company_fields, _parse_config_values) are referenced by
_build_config_dict and update imports/uses accordingly so tests still pass.
- Around line 320-331: The code currently catches KeyError from
get_personality_preset(preset_name) and only logs a warning, silently using a
default; instead, make invalid personality presets fail rendering by removing
the silent fallback and raising a clear error: when
get_personality_preset(preset_name) raises KeyError (or when preset_name not in
PERSONALITY_PRESETS), raise an explicit exception (e.g., ValueError or re-raise
KeyError) that includes preset_name, agent name, and the sorted
PERSONALITY_PRESETS so the renderer fails loudly; update the logic around
agent_dict["personality"], get_personality_preset, and any logger.warning usage
to ensure the error propagates rather than being swallowed.
- Around line 234-247: Rendered values from rendered_data (company, agents,
departments) must be validated and converted to proper shapes before use; update
the block that reads rendered_data in renderer.py to check that company is a
dict (and that company_name is a str or derive from template.metadata.name),
that raw_agents is a list before calling _expand_agents, and that raw_depts is a
list before calling _build_departments, and raise TemplateRenderError with a
clear message when any of those validations fail; add these checks around the
existing uses of rendered_data, company, _expand_agents(raw_agents) and
_build_departments(raw_depts) so invalid YAML shapes produce TemplateRenderError
with context instead of raw attribute/type errors.

In `@src/ai_company/templates/schema.py`:
- Line 29: The models that parse external YAML should reject unknown fields:
update each model's model_config (for TemplateVariable, TemplateAgentConfig,
TemplateDepartmentConfig, TemplateMetadata, and CompanyTemplate) to include
extra="forbid" (e.g., extend the existing ConfigDict(frozen=True) to also set
extra="forbid") so Pydantic will raise on unknown fields instead of silently
ignoring them. Ensure you modify the model_config in each named class
(TemplateVariable, TemplateAgentConfig, TemplateDepartmentConfig,
TemplateMetadata, CompanyTemplate).
- Around line 53-60: The validation currently uses type_map and
isinstance(self.default, expected) which accepts bool for var_type "int" and
"float" because bool subclasses int; modify the check in the schema validation
(symbols: type_map, expected, self.var_type, self.default, isinstance) to
explicitly reject booleans for numeric types—either by adding a guard like "if
isinstance(self.default, bool) and self.var_type in ('int','float'): raise
TypeError" before the isinstance check, or by comparing types directly
(type(self.default) is int or float) so bools are not accepted; implement one of
these approaches and ensure the error message mentions the variable
name/var_type for clarity.

---

Outside diff comments:
In `@src/ai_company/config/loader.py`:
- Around line 371-443: The load_config function should be split into small
helpers: extract path resolution into a helper (resolve_config_path using
discover_config), extract primary file reading/parsing and line-map construction
into read_and_parse_primary (calls _read_config_text, _parse_yaml_string and
_build_line_map), extract override merging into apply_overrides (iterates
override_paths and calls _parse_yaml_file + deep_merge), extract env
substitution into substitute_env (calls _substitute_env_vars with
source_file="<merged config>"), and keep validation in validate_config (wraps
_validate_config_dict). Refactor load_config to call these helpers in order
(default_config_dict -> read_and_parse_primary -> apply_overrides ->
substitute_env -> validate_config) so load_config stays short while reusing the
existing functions: load_config, discover_config, default_config_dict,
_read_config_text, _parse_yaml_string, deep_merge, _parse_yaml_file,
_substitute_env_vars, _build_line_map, and _validate_config_dict.

---

Duplicate comments:
In `@src/ai_company/templates/loader.py`:
- Around line 382-407: The helper _to_float currently swallows all
TypeError/ValueError and returns 0.0, masking real bad input; change it so that
it only returns 0.0 for known placeholder patterns (e.g. Jinja2 placeholders
like "__JINJA2__" or a regex match) and otherwise re-raise the original
exception so upstream validation fails; update the except block in _to_float to
detect placeholder strings (log a debug message and return 0.0) but for any
other conversion error re-raise the ValueError/TypeError so invalid numeric
values are not silently accepted.