SYMBOL INDEX (2970 symbols across 274 files)

FILE: maggy/maggy/adapters/cli_discovery.py
  class CliProfile (line 21) | class CliProfile:
    method build_command (line 39) | def build_command(
  class DiscoveryResult (line 70) | class DiscoveryResult:
  function discover_all (line 80) | def discover_all() -> DiscoveryResult:
  function discover_cli (line 91) | def discover_cli(name: str) -> CliProfile:
  function _extract_flags (line 110) | def _extract_flags(profile: CliProfile, text: str) -> None:
  function _refine_from_exec (line 154) | def _refine_from_exec(profile: CliProfile, text: str) -> None:
  function _refine_from_run (line 162) | def _refine_from_run(profile: CliProfile, text: str) -> None:
  function _post_process (line 168) | def _post_process(profile: CliProfile) -> None:
  function _detect_ollama_model (line 193) | def _detect_ollama_model(profile: CliProfile) -> str:
  function _has (line 223) | def _has(text: str, pattern: str) -> bool:
  function _get_version (line 228) | def _get_version(binary: str) -> str:
  function _get_help (line 245) | def _get_help(binary: str, subcommand: str) -> str:
  function _clean_env (line 262) | def _clean_env() -> dict[str, str]:

FILE: maggy/maggy/adapters/pi.py
  function _extract_usage (line 28) | def _extract_usage(raw: str) -> tuple[float, int, int, str]:
  class ModelEntry (line 44) | class ModelEntry:
  class RunResult (line 69) | class RunResult:
  class PiAdapter (line 81) | class PiAdapter:
    method __init__ (line 82) | def __init__(
    method get_model (line 100) | def get_model(self, name: str) -> ModelEntry | None:
    method list_models (line 103) | def list_models(self) -> list[ModelEntry]:
    method fallback_chain (line 106) | def fallback_chain(self, start: str) -> list[str]:
    method send_prompt (line 113) | async def send_prompt(
    method send_with_fallback (line 135) | async def send_with_fallback(
    method send_rpc (line 152) | def send_rpc(self, command: dict[str, object]) -> dict[str, object]:
    method switch_model (line 163) | def switch_model(self, provider: str, model: str) -> bool:
    method stream_events (line 167) | async def stream_events(self) -> AsyncIterator[dict[str, object]]:
    method _build_command (line 181) | def _build_command(
    method _detect_quota (line 189) | def _detect_quota(self, text: str) -> bool:
    method _detect_pi (line 192) | def _detect_pi(self) -> bool:
    method _spawn_prompt (line 195) | async def _spawn_prompt(
    method _log_discovery (line 212) | def _log_discovery(self) -> None:
    method discovered_profiles (line 218) | def discovered_profiles(self) -> dict[str, CliProfile]:
    method _prompt_result (line 221) | def _prompt_result(self, model_name: str, code: int, stdout: bytes) ->...
    method _ensure_rpc_process (line 232) | def _ensure_rpc_process(self) -> subprocess.Popen[str]:
    method _require_stream (line 243) | def _require_stream(self, stream: object, name: str):

FILE: maggy/maggy/api/auth.py
  function check_auth (line 8) | def check_auth(
  function require_configured (line 23) | def require_configured(request: Request) -> None:
  function require_provider (line 32) | def require_provider(request: Request) -> None:

FILE: maggy/maggy/api/routes.py
  function _auth (line 16) | def _auth(request: Request, x_api_key: str | None) -> None:
  function _require_configured (line 26) | def _require_configured(request: Request) -> None:
  function health (line 40) | async def health(request: Request) -> dict:
  function get_activity (line 57) | async def get_activity(request: Request) -> dict:
  function get_discovery (line 63) | async def get_discovery(request: Request) -> dict:
  function get_config (line 77) | async def get_config(request: Request, x_api_key: str | None = Header(No...
  function get_inbox (line 94) | async def get_inbox(request: Request, refresh: bool = Query(False), x_ap...
  function get_followed (line 102) | async def get_followed(request: Request, x_api_key: str | None = Header(...
  function get_task (line 125) | async def get_task(request: Request, task_id: str, x_api_key: str | None...
  class CommentRequest (line 152) | class CommentRequest(BaseModel):
  function post_comment (line 157) | async def post_comment(request: Request, task_id: str, body: CommentRequ...
  class StatusRequest (line 172) | class StatusRequest(BaseModel):
  function update_status (line 177) | async def update_status(request: Request, task_id: str, body: StatusRequ...
  class ExecuteRequest (line 190) | class ExecuteRequest(BaseModel):
  function execute (line 197) | async def execute(request: Request, body: ExecuteRequest, x_api_key: str...
  function list_sessions (line 210) | async def list_sessions(request: Request, x_api_key: str | None = Header...
  function get_session (line 217) | async def get_session(request: Request, session_id: str, x_api_key: str ...
  function list_competitors (line 229) | async def list_competitors(request: Request, x_api_key: str | None = Hea...
  function discover_competitors (line 236) | async def discover_competitors(request: Request, x_api_key: str | None =...
  function trigger_monitoring (line 243) | async def trigger_monitoring(request: Request, x_api_key: str | None = H...
  function get_competitor_news (line 250) | async def get_competitor_news(request: Request, limit: int = Query(100),...
  function get_briefing (line 257) | async def get_briefing(request: Request, refresh: bool = Query(False), x...

FILE: maggy/maggy/api/routes_budget.py
  function get_budget (line 13) | async def get_budget(
  function by_provider (line 26) | async def by_provider(

FILE: maggy/maggy/api/routes_chat.py
  function _require_chat (line 20) | def _require_chat(request: Request):
  class CreateSessionRequest (line 30) | class CreateSessionRequest(BaseModel):
  class SendMessageRequest (line 35) | class SendMessageRequest(BaseModel):
  class RoutedMessageRequest (line 39) | class RoutedMessageRequest(BaseModel):
  function auto_connect (line 47) | async def auto_connect(
  function _enrich_session (line 69) | def _enrich_session(s, history, recent: list[dict]) -> str:
  function _session_summary (line 86) | def _session_summary(s, context: str) -> dict:
  function create_session (line 100) | async def create_session(
  function list_sessions (line 123) | async def list_sessions(
  function get_session (line 143) | async def get_session(
  function send_message (line 166) | async def send_message(
  function send_routed (line 197) | async def send_routed(
  function _record_chat_spend (line 256) | def _record_chat_spend(budget, chunk: dict) -> None:
  function _record_routing_outcome (line 265) | def _record_routing_outcome(routing, decision, *, had_error: bool) -> None:
  function delete_session (line 277) | async def delete_session(

FILE: maggy/maggy/api/routes_cikg.py
  function landscape (line 13) | async def landscape(
  function feature_gaps (line 27) | async def feature_gaps(

FILE: maggy/maggy/api/routes_deploy.py
  class CreateSessionRequest (line 15) | class CreateSessionRequest(BaseModel):
  function list_sessions (line 21) | async def list_sessions(
  function get_session (line 36) | async def get_session(
  function create_session (line 53) | async def create_session(

FILE: maggy/maggy/api/routes_engram.py
  function query_engrams (line 15) | async def query_engrams(
  function diagnostics (line 36) | async def diagnostics(

FILE: maggy/maggy/api/routes_escalation.py
  class _EscalationIn (line 13) | class _EscalationIn(BaseModel):
  class _ResolveIn (line 19) | class _ResolveIn(BaseModel):
  function list_pending (line 24) | async def list_pending(
  function create_escalation (line 43) | async def create_escalation(
  function resolve_escalation (line 60) | async def resolve_escalation(

FILE: maggy/maggy/api/routes_events.py
  function query_events (line 13) | async def query_events(
  function trace_task (line 30) | async def trace_task(
  function count_events (line 44) | async def count_events(

FILE: maggy/maggy/api/routes_forge.py
  class GapReport (line 15) | class GapReport(BaseModel):
  function forge_status (line 20) | async def forge_status(
  function search_tools (line 33) | async def search_tools(
  function list_gaps (line 47) | async def list_gaps(
  function report_gap (line 60) | async def report_gap(

FILE: maggy/maggy/api/routes_heartbeat.py
  function heartbeat_status (line 13) | async def heartbeat_status(
  function trigger_job (line 25) | async def trigger_job(

FILE: maggy/maggy/api/routes_history.py
  function _require_history (line 14) | def _require_history(request: Request):
  function analyze_history (line 25) | async def analyze_history(
  function get_report (line 44) | async def get_report(
  function get_sessions (line 58) | async def get_sessions(
  function list_providers (line 71) | async def list_providers(

FILE: maggy/maggy/api/routes_improve.py
  function get_report (line 15) | async def get_report(
  function run_analysis (line 30) | async def run_analysis(

FILE: maggy/maggy/api/routes_lexon.py
  class LearnRequest (line 15) | class LearnRequest(BaseModel):
  function parse_intent (line 21) | async def parse_intent(
  function learn_mapping (line 36) | async def learn_mapping(

FILE: maggy/maggy/api/routes_mesh.py
  class AddPeerRequest (line 16) | class AddPeerRequest(BaseModel):
  class PromoteRequest (line 24) | class PromoteRequest(BaseModel):
  function mesh_status (line 30) | async def mesh_status(
  function list_networks (line 47) | async def list_networks(
  function list_peers (line 60) | async def list_peers(
  function add_peer (line 93) | async def add_peer(
  function quarantine_list (line 124) | async def quarantine_list(
  function promote (line 152) | async def promote(

FILE: maggy/maggy/api/routes_mesh_admin.py
  function announce (line 14) | async def announce(
  function discover (line 36) | async def discover(
  function setup (line 58) | async def setup(

FILE: maggy/maggy/api/routes_monitor.py
  function monitor_status (line 11) | async def monitor_status(request: Request) -> dict:
  function monitor_start (line 20) | async def monitor_start(request: Request) -> dict:
  function monitor_stop (line 29) | async def monitor_stop(request: Request) -> dict:

FILE: maggy/maggy/api/routes_observability.py
  class _SignalIn (line 15) | class _SignalIn(BaseModel):
  function get_signals (line 22) | async def get_signals(
  function record_signal (line 37) | async def record_signal(

FILE: maggy/maggy/api/routes_planning.py
  class PlanGenerateRequest (line 15) | class PlanGenerateRequest(BaseModel):
  function generate_plan (line 22) | async def generate_plan(

FILE: maggy/maggy/api/routes_process.py
  function _auth (line 15) | def _auth(request: Request, x_api_key: str | None) -> None:
  function _require_process (line 24) | def _require_process(request: Request) -> None:
  class AnalyzeRequest (line 29) | class AnalyzeRequest(BaseModel):
  function analyze (line 34) | async def analyze(
  function get_report (line 61) | async def get_report(
  function get_health (line 76) | async def get_health(

FILE: maggy/maggy/api/routes_projects.py
  class _ProjectIn (line 13) | class _ProjectIn(BaseModel):
  function list_projects (line 21) | async def list_projects(
  function get_project (line 37) | async def get_project(
  function add_project (line 58) | async def add_project(
  function remove_project (line 81) | async def remove_project(

FILE: maggy/maggy/api/routes_routing.py
  function heatmap (line 13) | async def heatmap(
  function decide (line 26) | async def decide(
  function rules (line 50) | async def rules(

FILE: maggy/maggy/api/routes_setup.py
  class ConfigureRequest (line 13) | class ConfigureRequest(BaseModel):
  function _step (line 22) | def _step(label: str, ok: bool, hint: str = "") -> dict:
  function _build_steps (line 31) | def _build_steps(cfg) -> list[dict]:
  function _has_claude_cli (line 50) | def _has_claude_cli() -> bool:
  function _discover_summary (line 56) | def _discover_summary() -> dict:
  function setup_status (line 71) | async def setup_status(request: Request) -> dict:
  function configure (line 89) | async def configure(
  function reload_config (line 107) | async def reload_config(request: Request) -> dict:
  function discover_repos (line 116) | async def discover_repos(request: Request) -> dict:
  function auto_configure (line 133) | async def auto_configure(request: Request) -> dict:
  function cli_models (line 149) | async def cli_models() -> dict:

FILE: maggy/maggy/budget.py
  function _today_utc (line 16) | def _today_utc() -> str:
  function _connect (line 21) | def _connect(path: Path) -> Iterator[sqlite3.Connection]:
  function _open_conn (line 33) | def _open_conn(path: Path) -> sqlite3.Connection:
  class ProviderBudget (line 58) | class ProviderBudget:
  class TaskSpendTracker (line 66) | class TaskSpendTracker:
    method __init__ (line 69) | def __init__(self, max_spend: float):
    method record (line 74) | def record(self, cost: float) -> None:
    method total (line 77) | def total(self) -> float:
    method is_exceeded (line 80) | def is_exceeded(self) -> bool:
    method record_edit (line 83) | def record_edit(self, file_path: str) -> None:
    method detect_loop (line 87) | def detect_loop(self, threshold: int = 3) -> list[str]:
  class BudgetManager (line 94) | class BudgetManager:
    method __init__ (line 97) | def __init__(self, cfg: MaggyConfig):
    method _init_db (line 109) | def _init_db(self) -> None:
    method record_spend (line 113) | def record_spend(
    method today_spend (line 128) | def today_spend(self, provider: str | None = None) -> float:
    method today_tokens (line 139) | def today_tokens(self, provider: str | None = None) -> dict:
    method budget_status (line 151) | def budget_status(self) -> dict:
    method by_provider (line 167) | def by_provider(self) -> list[dict]:
    method is_exhausted (line 180) | def is_exhausted(
    method is_provider_exhausted (line 187) | def is_provider_exhausted(self, provider: str) -> bool:
    method cheapest_available (line 194) | def cheapest_available(self) -> str | None:

FILE: maggy/maggy/calibration/tracker.py
  function _connect (line 24) | def _connect(path: Path) -> Iterator[sqlite3.Connection]:
  class CalibrationTracker (line 34) | class CalibrationTracker:
    method __init__ (line 35) | def __init__(self, db_path: Path):
    method record (line 39) | def record(
    method accuracy (line 50) | def accuracy(self, model: str) -> float:
    method calibration_error (line 57) | def calibration_error(self, model: str) -> float:
    method _errors (line 63) | def _errors(self, model: str) -> list[float]:
    method _init_db (line 71) | def _init_db(self) -> None:

FILE: maggy/maggy/checkpoint.py
  class CheckpointManager (line 11) | class CheckpointManager:
    method __init__ (line 12) | def __init__(self, base_dir: Path = DEFAULT_DIR):
    method write (line 15) | def write(self, session_id: str, data: dict) -> None:
    method read (line 23) | def read(self, session_id: str) -> dict | None:
    method delete (line 32) | def delete(self, session_id: str) -> bool:
    method list_checkpoints (line 39) | def list_checkpoints(self) -> list[str]:
    method _path (line 45) | def _path(self, session_id: str) -> Path:
  function _sanitize_id (line 53) | def _sanitize_id(session_id: str) -> str:
  function _normalize (line 60) | def _normalize(data: dict) -> dict:

FILE: maggy/maggy/cikg/graph.py
  class KnowledgeGraphService (line 13) | class KnowledgeGraphService:
    method __init__ (line 16) | def __init__(self, db_path: Path):
    method add_node (line 21) | def add_node(self, node: Node) -> None:
    method get_node (line 31) | def get_node(self, node_id: str) -> Node | None:
    method list_nodes (line 40) | def list_nodes(self, node_type: str | None = None) -> list[Node]:
    method add_edge (line 51) | def add_edge(self, edge: Edge) -> None:
    method get_edges (line 60) | def get_edges(self, node_id: str, direction: str = "out") -> list[Edge]:
    method neighbors (line 77) | def neighbors(self, node_id: str) -> list[Node]:
    method delete_node (line 86) | def delete_node(self, node_id: str) -> None:
  function _row_to_node (line 96) | def _row_to_node(r: sqlite3.Row) -> Node:
  function _row_to_edge (line 104) | def _row_to_edge(r: sqlite3.Row) -> Edge:

FILE: maggy/maggy/cikg/models.py
  class Node (line 21) | class Node:
    method __post_init__ (line 35) | def __post_init__(self) -> None:
  class Edge (line 41) | class Edge:
    method __post_init__ (line 50) | def __post_init__(self) -> None:
  class MarketScore (line 56) | class MarketScore:

FILE: maggy/maggy/cikg/queries.py
  function find_gaps (line 9) | def find_gaps(graph: KnowledgeGraphService, feature_name: str) -> Market...
  function find_gaps_raw (line 29) | def find_gaps_raw(graph: KnowledgeGraphService, feature: str) -> list[di...
  function compare_entities (line 42) | def compare_entities(graph: KnowledgeGraphService, id_a: str, id_b: str)...
  function get_landscape (line 59) | def get_landscape(graph: KnowledgeGraphService) -> dict:
  function get_segment_landscape (line 72) | def get_segment_landscape(graph: KnowledgeGraphService, segment: str) ->...
  function _matching_ids (line 103) | def _matching_ids(graph: KnowledgeGraphService, node_type: str, query: s...
  function _matching_nodes (line 107) | def _matching_nodes(graph: KnowledgeGraphService, node_type: str, query:...
  function _targets_for (line 112) | def _targets_for(graph: KnowledgeGraphService, node_id: str, edge_type: ...
  function _threat_level (line 116) | def _threat_level(have_it: int, total: int) -> str:
  function _recommend (line 125) | def _recommend(feature: str, have: int, total: int, threat: str) -> str:
  function _empty_landscape (line 133) | def _empty_landscape(segment: str) -> dict:

FILE: maggy/maggy/cikg/storage.py
  function _connect (line 35) | def _connect(path: Path) -> Iterator[sqlite3.Connection]:

FILE: maggy/maggy/cli.py
  function _ensure (line 28) | def _ensure() -> bool:
  function main (line 38) | def main(ctx: typer.Context) -> None:
  function serve (line 52) | def serve() -> None:
  function status (line 59) | def status(json_out: bool = typer.Option(False, "--json")) -> None:
  function inbox (line 67) | def inbox(
  function sessions (line 83) | def sessions(json_out: bool = typer.Option(False, "--json")) -> None:
  function chat (line 91) | def chat(
  function spawn (line 102) | def spawn(
  function ps (line 117) | def ps() -> None:
  function kill (line 125) | def kill(
  function execute (line 135) | def execute(
  function route (line 151) | def route(
  function budget (line 163) | def budget(json_out: bool = typer.Option(False, "--json")) -> None:
  function models (line 171) | def models(json_out: bool = typer.Option(False, "--json")) -> None:
  function competitors (line 179) | def competitors(
  function process (line 198) | def process(
  function config (line 209) | def config(json_out: bool = typer.Option(False, "--json")) -> None:

FILE: maggy/maggy/cli_chat.py
  function detect_project (line 22) | def detect_project(client) -> str | None:
  function run_chat (line 27) | def run_chat(
  function _find_or_create (line 40) | def _find_or_create(client, project: str) -> tuple[dict, bool]:
  function _show_resume_info (line 47) | def _show_resume_info(client, sid: str, wd: str) -> None:
  function _repl_loop (line 59) | def _repl_loop(client, state: SessionState, routed: bool) -> None:
  function _parse_blast (line 107) | def _parse_blast(text: str) -> int | None:
  function _stream_chunks (line 120) | def _stream_chunks(chunks) -> None:
  function _call_safe (line 154) | def _call_safe(fn, default=None):
  function _handle_screenshot (line 161) | def _handle_screenshot(text: str) -> None:
  function _show_routing (line 174) | def _show_routing(chunk: dict) -> None:
  function _show_history (line 178) | def _show_history(client, session_id: str) -> None:
  function _show_sessions (line 189) | def _show_sessions(client) -> None:

FILE: maggy/maggy/cli_client.py
  class MaggyClient (line 24) | class MaggyClient:
    method __init__ (line 27) | def __init__(self, base_url: str = DEFAULT_URL):
    method _check_health (line 32) | def _check_health(self) -> bool:
    method _get_port (line 42) | def _get_port(self) -> int:
    method _kill_stale_port (line 46) | def _kill_stale_port(self) -> None:
    method _start_server (line 63) | def _start_server(self) -> None:
    method ensure_server (line 72) | def ensure_server(self) -> bool:
    method _handle_error (line 87) | def _handle_error(self, r: httpx.Response) -> None:
    method get (line 100) | def get(self, path: str, **params) -> dict | list:
    method post (line 109) | def post(self, path: str, body: dict) -> dict:
    method health (line 118) | def health(self) -> dict:
    method inbox (line 121) | def inbox(self, refresh: bool = False) -> dict:
    method activity (line 124) | def activity(self) -> dict:
    method route (line 127) | def route(self, blast: int, task_type: str) -> dict:
    method budget_summary (line 134) | def budget_summary(self) -> dict:
    method competitors_news (line 137) | def competitors_news(self, limit: int = 50) -> list:
    method competitors_briefing (line 140) | def competitors_briefing(self) -> dict:
    method models_heatmap (line 143) | def models_heatmap(self) -> list:
    method routing_rules (line 146) | def routing_rules(self) -> dict:
    method budget_by_provider (line 149) | def budget_by_provider(self) -> list:
    method process_health (line 152) | def process_health(self, project: str) -> dict:
    method config (line 155) | def config(self) -> dict:
    method execute (line 158) | def execute(self, task_id: str, mode: str) -> dict:
    method sessions (line 164) | def sessions(self) -> list:
    method chat_create (line 169) | def chat_create(self, project_key: str) -> dict:
    method chat_sessions (line 175) | def chat_sessions(self) -> list:
    method chat_history (line 178) | def chat_history(self, session_id: str) -> dict:
    method chat_send_stream (line 181) | def chat_send_stream(
    method chat_send_routed (line 198) | def chat_send_routed(
    method detect_project (line 220) | def detect_project(self, cwd: str) -> str | None:
    method spawn (line 233) | def spawn(self, task: str, project: str) -> dict:
    method all_sessions (line 240) | def all_sessions(self) -> list:
    method kill_session (line 265) | def kill_session(self, session_id: str) -> dict:
    method monitor_status (line 276) | def monitor_status(self) -> dict:
    method monitor_start (line 279) | def monitor_start(self) -> dict:
    method monitor_stop (line 282) | def monitor_stop(self) -> dict:
    method health_dashboard (line 287) | def health_dashboard(self) -> dict:
    method engram_diagnostics (line 290) | def engram_diagnostics(self) -> dict:

FILE: maggy/maggy/cli_output.py
  function _is_pipe (line 15) | def _is_pipe() -> bool:
  function dump_json (line 19) | def dump_json(data) -> None:
  function render_health (line 27) | def render_health(data: dict) -> None:
  function render_inbox (line 42) | def render_inbox(data: dict) -> None:
  function render_sessions (line 66) | def render_sessions(data: dict | list) -> None:
  function _model_name (line 93) | def _model_name(val) -> str:
  function render_route (line 99) | def render_route(data: dict) -> None:
  function render_budget (line 119) | def render_budget(data: dict) -> None:
  function render_competitors (line 152) | def render_competitors(news: list) -> None:
  function render_models (line 172) | def render_models(heatmap: list) -> None:

FILE: maggy/maggy/cli_repl_cmds.py
  function _call (line 18) | def _call(fn, d=None):
  class SessionState (line 26) | class SessionState:
  function dispatch (line 34) | def dispatch(cmd: str, client, state: SessionState) -> bool:
  function cmd_stats (line 57) | def cmd_stats(client) -> None:
  function cmd_budget (line 75) | def cmd_budget(client) -> None:
  function cmd_route (line 95) | def cmd_route(client) -> None:
  function cmd_models (line 117) | def cmd_models(client) -> None:
  function cmd_use (line 135) | def cmd_use(args: str, state: SessionState) -> None:
  function cmd_config (line 149) | def cmd_config(client) -> None:
  function cmd_claude_md (line 164) | def cmd_claude_md(state: SessionState) -> None:
  function cmd_health (line 175) | def cmd_health(client) -> None:
  function cmd_help (line 199) | def cmd_help() -> None:

FILE: maggy/maggy/cli_sessions.py
  function spawn_session (line 11) | def spawn_session(client, task: str, project: str) -> None:
  function list_all (line 21) | def list_all(client) -> None:
  function kill_session (line 44) | def kill_session(client, session_id: str) -> None:

FILE: maggy/maggy/cli_welcome.py
  function render_welcome (line 16) | def render_welcome(
  function _add_project_rows (line 33) | def _add_project_rows(
  function _add_system_rows (line 49) | def _add_system_rows(
  function _add_health_row (line 69) | def _add_health_row(t: Table, client) -> None:
  function _safe_call (line 79) | def _safe_call(fn):
  function _shorten (line 87) | def _shorten(path: str, max_len: int) -> str:

FILE: maggy/maggy/config.py
  function _default_storage_path (line 20) | def _default_storage_path() -> str:
  function _safe_storage_path (line 24) | def _safe_storage_path(path: str | Path) -> str:
  class GitHubConfig (line 39) | class GitHubConfig:
  class AsanaConfig (line 47) | class AsanaConfig:
  class LinearConfig (line 54) | class LinearConfig:
  class IssueTrackerConfig (line 60) | class IssueTrackerConfig:
  class CodebaseConfig (line 68) | class CodebaseConfig:
  class ProjectConfig (line 74) | class ProjectConfig:
  class OKRItem (line 84) | class OKRItem:
  class OKRConfig (line 91) | class OKRConfig:
  class CompetitorsConfig (line 97) | class CompetitorsConfig:
  class AIConfig (line 103) | class AIConfig:
  class StorageConfig (line 111) | class StorageConfig:
  class DashboardConfig (line 117) | class DashboardConfig:
  class OrgConfig (line 125) | class OrgConfig:
  class BootstrapConfig (line 131) | class BootstrapConfig:
  class ModelTierConfig (line 136) | class ModelTierConfig:
  class BudgetConfig (line 146) | class BudgetConfig:
  class RoutingConfig (line 155) | class RoutingConfig:
  class MeshConfig (line 161) | class MeshConfig:
  class HeartbeatConfig (line 175) | class HeartbeatConfig:
  class MaggyConfig (line 184) | class MaggyConfig:
    method codebase_paths (line 200) | def codebase_paths(self) -> dict[str, Path]:
    method resolve_bootstrap_path (line 204) | def resolve_bootstrap_path(self) -> Path | None:
  function _merge_env (line 214) | def _merge_env(cfg: MaggyConfig) -> MaggyConfig:
  function _git_credential_token (line 228) | def _git_credential_token() -> str:
  function _from_dict (line 234) | def _from_dict(data: dict[str, Any]) -> MaggyConfig:
  function _has_provider_credentials (line 297) | def _has_provider_credentials(cfg: MaggyConfig) -> bool:
  function _has_cli_history (line 308) | def _has_cli_history(
  function auto_configure (line 319) | def auto_configure(
  function _repos_for_org (line 344) | def _repos_for_org(
  function load (line 357) | def load(refresh: bool = False) -> MaggyConfig:
  function save (line 373) | def save(cfg: MaggyConfig) -> None:
  function is_configured (line 390) | def is_configured() -> bool:

FILE: maggy/maggy/contracts/generator.py
  class ContractGenerator (line 8) | class ContractGenerator:
    method from_postcondition (line 9) | def from_postcondition(self, postcondition: str, symbol: str) -> str:
  function _test_name (line 20) | def _test_name(symbol: str) -> str:

FILE: maggy/maggy/coordination/lock_manager.py
  function _connect (line 27) | def _connect(path: Path) -> Iterator[sqlite3.Connection]:
  class LockManager (line 39) | class LockManager:
    method __init__ (line 40) | def __init__(self, db_path: Path):
    method acquire (line 44) | def acquire(self, file_path: str, agent_id: str) -> bool:
    method release (line 71) | def release(self, file_path: str, agent_id: str) -> bool:
    method release_all (line 81) | def release_all(self, agent_id: str) -> int:
    method conflicts (line 88) | def conflicts(self, file_paths: list[str]) -> list[str]:
    method _expire_locks (line 101) | def _expire_locks(self, conn: sqlite3.Connection, now: str) -> None:
    method _init_db (line 104) | def _init_db(self) -> None:
  function _now (line 109) | def _now() -> str:
  function _timestamps (line 113) | def _timestamps() -> tuple[str, str]:

FILE: maggy/maggy/deploy.py
  class DeploySession (line 13) | class DeploySession:
  class DeployService (line 28) | class DeployService:
    method __init__ (line 31) | def __init__(self):
    method create_session (line 34) | def create_session(
    method get_session (line 51) | def get_session(self, sid: str) -> DeploySession | None:
    method list_sessions (line 54) | def list_sessions(self) -> list[DeploySession]:
    method update_status (line 57) | def update_status(
    method teardown (line 69) | def teardown(self, sid: str) -> bool:

FILE: maggy/maggy/discovery.py
  class DiscoveryResult (line 25) | class DiscoveryResult:
  function discover_clis (line 46) | def discover_clis() -> dict[str, str]:
  function discover_cli_auth (line 56) | def discover_cli_auth() -> dict[str, bool]:
  function _has_json_key (line 74) | def _has_json_key(path: Path, key: str) -> bool:
  function discover_git_token (line 85) | def discover_git_token() -> str:
  function discover_repos (line 101) | def discover_repos(
  function _scan_dir (line 117) | def _scan_dir(
  function discover_active_projects (line 141) | def discover_active_projects(
  function discover_env_tokens (line 171) | def discover_env_tokens() -> dict[str, bool]:
  function infer_github_org (line 192) | def infer_github_org(repo_path: Path) -> str:
  function _parse_org_from_url (line 206) | def _parse_org_from_url(url: str) -> str:
  function discover_all_orgs (line 217) | def discover_all_orgs(repos: list[dict]) -> list[str]:
  function full_discovery (line 227) | def full_discovery(

FILE: maggy/maggy/engram/diagnostics.py
  class AmnesiaProfile (line 11) | class AmnesiaProfile:
    method health_score (line 23) | def health_score(self) -> float:
  function diagnose (line 39) | def diagnose(

FILE: maggy/maggy/engram/record.py
  class Origin (line 10) | class Origin(str, Enum):
  class Validity (line 16) | class Validity(str, Enum):
  class EngramRecord (line 23) | class EngramRecord:
    method is_active (line 43) | def is_active(self) -> bool:
    method supersede (line 46) | def supersede(self) -> None:

FILE: maggy/maggy/engram/retrieval.py
  class EngramRetrieval (line 9) | class EngramRetrieval:
    method __init__ (line 12) | def __init__(self, store: EngramStore):
    method by_namespace (line 15) | def by_namespace(
    method by_type (line 23) | def by_type(
    method by_keyword (line 31) | def by_keyword(
    method by_tag (line 45) | def by_tag(
    method recent (line 58) | def recent(self, limit: int = 20) -> list[EngramRecord]:

FILE: maggy/maggy/engram/seed.py
  function seed_if_empty (line 28) | def seed_if_empty(store: EngramStore) -> None:

FILE: maggy/maggy/engram/store.py
  function _connect (line 37) | def _connect(path: Path) -> Iterator[sqlite3.Connection]:
  class EngramStore (line 49) | class EngramStore:
    method __init__ (line 52) | def __init__(self, db_path: Path):
    method write (line 57) | def write(self, record: EngramRecord) -> None:
    method get (line 78) | def get(
    method query (line 91) | def query(
    method count (line 121) | def count(
    method _row_to_record (line 137) | def _row_to_record(

FILE: maggy/maggy/escalation/protocol.py
  class EscalationPacket (line 32) | class EscalationPacket:
  function _connect (line 45) | def _connect(path: Path) -> Iterator[sqlite3.Connection]:
  class Escalator (line 57) | class Escalator:
    method __init__ (line 58) | def __init__(self, db_path: Path):
    method escalate (line 62) | def escalate(
    method resolve (line 74) | def resolve(self, escalation_id: str, guidance: str) -> EscalationPacket:
    method list_pending (line 89) | def list_pending(self) -> list[EscalationPacket]:
    method get (line 96) | def get(self, escalation_id: str) -> EscalationPacket | None:
    method _init_db (line 104) | def _init_db(self) -> None:
  function _build_packet (line 109) | def _build_packet(
  function _dict_field (line 125) | def _dict_field(context: dict[str, object], key: str) -> dict[str, object]:
  function _list_field (line 130) | def _list_field(context: dict[str, object], key: str) -> list[str]:
  function _serialize (line 135) | def _serialize(packet: EscalationPacket) -> tuple[object, ...]:
  function _safe_json (line 149) | def _safe_json(raw: str, fallback: object) -> object:
  function _from_row (line 156) | def _from_row(row: sqlite3.Row) -> EscalationPacket:

FILE: maggy/maggy/event_spine/emitter.py
  class EventEmitter (line 14) | class EventEmitter:
    method __init__ (line 17) | def __init__(self, store: EventStore):
    method emit (line 20) | def emit(self, event: object) -> str:
    method query (line 34) | def query(
    method trace (line 49) | def trace(self, task_id: str) -> list[dict]:
    method count (line 55) | def count(

FILE: maggy/maggy/event_spine/events.py
  class IntentEvent (line 11) | class IntentEvent:
  class BindingEvent (line 23) | class BindingEvent:
  class ExecutionEvent (line 36) | class ExecutionEvent:
  class MemoryEvent (line 50) | class MemoryEvent:
  class PersistenceEvent (line 62) | class PersistenceEvent:
  class OutcomeEvent (line 76) | class OutcomeEvent:
  class MutationEvent (line 88) | class MutationEvent:
  class MeshEvent (line 102) | class MeshEvent:

FILE: maggy/maggy/event_spine/header.py
  function _uuid (line 10) | def _uuid() -> str:
  function _now (line 14) | def _now() -> str:
  class EventHeader (line 19) | class EventHeader:

FILE: maggy/maggy/event_spine/store.py
  function _connect (line 39) | def _connect(path: Path) -> Iterator[sqlite3.Connection]:
  class EventStore (line 51) | class EventStore:
    method __init__ (line 54) | def __init__(self, db_path: Path):
    method _init_db (line 58) | def _init_db(self) -> None:
    method write (line 62) | def write(
    method query (line 84) | def query(
    method count (line 118) | def count(
    method archive_old (line 144) | def archive_old(

FILE: maggy/maggy/fatigue.py
  class FatigueProfile (line 13) | class FatigueProfile:
    method raw_utilization (line 23) | def raw_utilization(self) -> float:
    method fatigue_score (line 30) | def fatigue_score(self) -> float:
    method should_checkpoint (line 40) | def should_checkpoint(self, threshold: float = 0.6) -> bool:
  function create_profile (line 55) | def create_profile(model: str) -> FatigueProfile:
  function compare_fatigue (line 61) | def compare_fatigue(

FILE: maggy/maggy/forge/connector.py
  class ForgeStatus (line 23) | class ForgeStatus:
  class ForgeConnector (line 32) | class ForgeConnector:
    method __init__ (line 35) | def __init__(
    method available (line 46) | def available(self) -> bool:
    method status (line 49) | def status(self) -> ForgeStatus:
    method search_tools (line 58) | def search_tools(self, query: str) -> list[dict]:
    method report_gap (line 71) | def report_gap(self, capability: str) -> dict:
    method get_gaps (line 84) | def get_gaps(self) -> list[dict]:

FILE: maggy/maggy/forge/detector.py
  class GapRecord (line 16) | class GapRecord:
  class GapDetector (line 24) | class GapDetector:
    method __init__ (line 27) | def __init__(self, threshold: int = TRIGGER_THRESHOLD):
    method record_gap (line 32) | def record_gap(self, capability: str) -> bool:
    method list_gaps (line 44) | def list_gaps(self) -> list[GapRecord]:
    method top_gaps (line 55) | def top_gaps(self, n: int = 5) -> list[GapRecord]:
    method reset (line 59) | def reset(self, capability: str) -> None:

FILE: maggy/maggy/forge/registry.py
  class ToolInfo (line 15) | class ToolInfo:
  class ForgeRegistry (line 25) | class ForgeRegistry:
    method __init__ (line 28) | def __init__(self, forge_path: Path | None = None):
    method _load_registry (line 33) | def _load_registry(self) -> None:
    method search (line 43) | def search(self, query: str) -> list[ToolInfo]:
    method get (line 51) | def get(self, slug: str) -> ToolInfo | None:
    method list_all (line 54) | def list_all(self) -> list[ToolInfo]:
    method set_enabled (line 57) | def set_enabled(self, slug: str, enabled: bool) -> bool:
    method count (line 65) | def count(self) -> int:
  function _parse_registry (line 69) | def _parse_registry(path: Path) -> dict[str, ToolInfo]:

FILE: maggy/maggy/heartbeat/jobs.py
  function refresh_history (line 13) | async def refresh_history(app) -> None:
  function expire_engrams (line 25) | async def expire_engrams(app) -> None:
  function _is_expired (line 42) | def _is_expired(rec, now) -> bool:
  function self_improve (line 59) | async def self_improve(app) -> None:
  function mesh_heartbeat (line 71) | async def mesh_heartbeat(app) -> None:
  function collect_signals (line 89) | async def collect_signals(app) -> None:

FILE: maggy/maggy/heartbeat/scheduler.py
  class Job (line 17) | class Job:
    method is_due (line 26) | def is_due(self) -> bool:
  class HeartbeatScheduler (line 34) | class HeartbeatScheduler:
    method __init__ (line 35) | def __init__(self) -> None:
    method register (line 39) | def register(
    method tick (line 48) | async def tick(self) -> None:
    method _run_job (line 54) | async def _run_job(self, job: Job) -> None:
    method trigger (line 64) | async def trigger(self, name: str) -> dict:
    method start (line 71) | async def start(self) -> None:
    method stop (line 75) | async def stop(self) -> None:
    method _loop (line 85) | async def _loop(self) -> None:
    method status (line 90) | def status(self) -> list[dict]:

FILE: maggy/maggy/history/analyzer.py
  function build_report (line 18) | def build_report(
  function aggregate_by_provider (line 40) | def aggregate_by_provider(
  function aggregate_by_project (line 66) | def aggregate_by_project(
  function compute_time_distribution (line 91) | def compute_time_distribution(
  function extract_top_topics (line 117) | def extract_top_topics(
  function detect_patterns (line 128) | def detect_patterns(
  function _detect_provider_dominance (line 141) | def _detect_provider_dominance(
  function _detect_session_stats (line 156) | def _detect_session_stats(
  function _detect_project_focus (line 181) | def _detect_project_focus(
  function _merge_topics (line 195) | def _merge_topics(

FILE: maggy/maggy/history/models.py
  class SessionEntry (line 10) | class SessionEntry:
    method duration_minutes (line 26) | def duration_minutes(self) -> float | None:
  class ProjectActivity (line 39) | class ProjectActivity:
  class ProviderUsage (line 51) | class ProviderUsage:
  class TimeDistribution (line 62) | class TimeDistribution:
  class HistoryReport (line 71) | class HistoryReport:
  function _now_iso (line 89) | def _now_iso() -> str:

FILE: maggy/maggy/history/parsers/base.py
  class HistoryParser (line 10) | class HistoryParser(ABC):
    method is_available (line 16) | def is_available(self) -> bool:
    method parse_sessions (line 21) | def parse_sessions(
    method session_count (line 28) | def session_count(self) -> int:

FILE: maggy/maggy/history/parsers/claude.py
  function _millis_to_iso (line 18) | def _millis_to_iso(ms: int | float) -> str:
  function _read_jsonl (line 24) | def _read_jsonl(path: Path) -> list[dict]:
  function _extract_topics (line 43) | def _extract_topics(prompts: list[str]) -> list[str]:
  class ClaudeHistoryParser (line 55) | class ClaudeHistoryParser(HistoryParser):
    method __init__ (line 60) | def __init__(self, claude_dir: Path | None = None):
    method is_available (line 65) | def is_available(self) -> bool:
    method session_count (line 69) | def session_count(self) -> int:
    method parse_sessions (line 75) | def parse_sessions(
    method _group_by_session (line 89) | def _group_by_session(
    method _build_entry (line 99) | def _build_entry(
    method _slug (line 133) | def _slug(self, project_path: str) -> str:
    method _find_transcript (line 139) | def _find_transcript(
    method _parse_transcript (line 159) | def _parse_transcript(

FILE: maggy/maggy/history/parsers/codex.py
  function _seconds_to_iso (line 18) | def _seconds_to_iso(ts: int | float) -> str:
  function _read_jsonl (line 24) | def _read_jsonl(path: Path) -> list[dict]:
  function _extract_topics (line 43) | def _extract_topics(texts: list[str]) -> list[str]:
  class CodexHistoryParser (line 55) | class CodexHistoryParser(HistoryParser):
    method __init__ (line 60) | def __init__(self, codex_dir: Path | None = None):
    method is_available (line 65) | def is_available(self) -> bool:
    method session_count (line 69) | def session_count(self) -> int:
    method parse_sessions (line 75) | def parse_sessions(
    method _group_prompts (line 100) | def _group_prompts(
    method _build_entry (line 110) | def _build_entry(

FILE: maggy/maggy/history/parsers/kimi.py
  function _float_to_iso (line 17) | def _float_to_iso(ts: float) -> str:
  function _read_jsonl (line 23) | def _read_jsonl(path: Path) -> list[dict]:
  function _extract_topics (line 42) | def _extract_topics(texts: list[str]) -> list[str]:
  class KimiHistoryParser (line 54) | class KimiHistoryParser(HistoryParser):
    method __init__ (line 59) | def __init__(self, kimi_dir: Path | None = None):
    method is_available (line 64) | def is_available(self) -> bool:
    method session_count (line 68) | def session_count(self) -> int:
    method parse_sessions (line 71) | def parse_sessions(
    method _find_session_dirs (line 82) | def _find_session_dirs(self) -> list[Path]:
    method _parse_session_dir (line 99) | def _parse_session_dir(
    method _parse_wire (line 136) | def _parse_wire(self, session_dir: Path) -> dict:

FILE: maggy/maggy/history/service.py
  class HistoryService (line 18) | class HistoryService:
    method __init__ (line 21) | def __init__(
    method analyze (line 37) | def analyze(self) -> HistoryReport:
    method _collect_sessions (line 55) | def _collect_sessions(self) -> list:
    method get_report (line 79) | def get_report(self) -> dict | None:
    method get_sessions (line 83) | def get_sessions(
    method available_providers (line 91) | def available_providers(self) -> list[str]:

FILE: maggy/maggy/history/store.py
  function _connect (line 45) | def _connect(path: Path) -> Iterator[sqlite3.Connection]:
  class HistoryStore (line 57) | class HistoryStore:
    method __init__ (line 60) | def __init__(self, db_path: Path):
    method save_sessions (line 65) | def save_sessions(
    method load_sessions (line 93) | def load_sessions(
    method save_report (line 117) | def save_report(self, report: HistoryReport) -> None:
    method load_latest_report (line 128) | def load_latest_report(self) -> dict | None:
    method _row_to_dict (line 139) | def _row_to_dict(self, r: sqlite3.Row) -> dict:

FILE: maggy/maggy/improve/analyzer.py
  function analyze_routing (line 14) | def analyze_routing(signals: SignalBundle) -> list[Recommendation]:
  function analyze_failures (line 32) | def analyze_failures(signals: SignalBundle) -> list[Recommendation]:
  function analyze_usage (line 46) | def analyze_usage(signals: SignalBundle) -> list[Recommendation]:
  function analyze_gaps (line 69) | def analyze_gaps(signals: SignalBundle) -> list[Recommendation]:
  function analyze_memory (line 86) | def analyze_memory(signals: SignalBundle) -> list[Recommendation]:
  function analyze_cost (line 100) | def analyze_cost(signals: SignalBundle) -> list[Recommendation]:
  function analyze_all (line 114) | def analyze_all(signals: SignalBundle) -> list[Recommendation]:

FILE: maggy/maggy/improve/models.py
  class Recommendation (line 9) | class Recommendation:
  class SignalBundle (line 18) | class SignalBundle:
  class ImprovementReport (line 29) | class ImprovementReport:

FILE: maggy/maggy/improve/service.py
  class Introspector (line 15) | class Introspector:
    method __init__ (line 18) | def __init__(self, app_state) -> None:
    method analyze (line 22) | def analyze(self) -> ImprovementReport:
    method get_report (line 31) | def get_report(self) -> ImprovementReport | None:
    method _build_report (line 35) | def _build_report(self, signals, recs) -> ImprovementReport:
    method _health_summary (line 56) | def _health_summary(self, s: SignalBundle) -> dict:
    method _persist (line 71) | def _persist(self, report: ImprovementReport) -> None:
    method _write_engram (line 80) | def _write_engram(self, engram, report) -> None:
    method _emit_mutations (line 95) | def _emit_mutations(self, events, report) -> None:

FILE: maggy/maggy/improve/signals.py
  function collect_routing (line 15) | def collect_routing(routing) -> dict:
  function collect_events (line 26) | def collect_events(events) -> dict:
  function collect_history (line 42) | def collect_history(history) -> dict:
  function collect_forge (line 54) | def collect_forge(forge) -> dict:
  function collect_engram (line 60) | def collect_engram(engram) -> dict:
  function collect_budget (line 72) | def collect_budget(budget) -> dict:
  function collect_all (line 77) | def collect_all(app_state) -> SignalBundle:

FILE: maggy/maggy/lexon/disambiguate.py
  class DisambiguationResult (line 12) | class DisambiguationResult:
  function disambiguate (line 21) | def disambiguate(

FILE: maggy/maggy/lexon/personalization.py
  class UserSignals (line 10) | class UserSignals:
  class PersonalizationEngine (line 30) | class PersonalizationEngine:
    method __init__ (line 33) | def __init__(self):
    method record_use (line 36) | def record_use(self, tool: str) -> None:
    method record_correction (line 40) | def record_correction(
    method record_alias (line 48) | def record_alias(
    method record_rejection (line 56) | def record_rejection(self, tool: str) -> None:
    method get_preferred (line 60) | def get_preferred(self, phrase: str) -> str | None:
    method top_tools (line 66) | def top_tools(self, n: int = 5) -> list[str]:
    method signals (line 73) | def signals(self) -> UserSignals:

FILE: maggy/maggy/lexon/record.py
  class LexonRecord (line 10) | class LexonRecord:
    method is_ambiguous (line 25) | def is_ambiguous(self) -> bool:
    method needs_user_input (line 29) | def needs_user_input(self) -> bool:

FILE: maggy/maggy/lexon/router.py
  class LexonRouter (line 24) | class LexonRouter:
    method __init__ (line 31) | def __init__(self, config: dict[str, object] | None = None):
    method route (line 37) | def route(self, phrase: str) -> LexonRecord:
    method learn (line 52) | def learn(self, phrase: str, tool: str) -> None:
    method terminology (line 58) | def terminology(self) -> TerminologyMap:
    method personalization (line 62) | def personalization(self) -> PersonalizationEngine:
    method _load_tool_manifest (line 65) | def _load_tool_manifest(self) -> dict[str, list[str]]:
    method _llm_classify (line 75) | def _llm_classify(self, phrase: str) -> LexonRecord:
    method _route_tier1 (line 82) | def _route_tier1(self, phrase: str) -> LexonRecord | None:
    method _resolve_manifest_match (line 89) | def _resolve_manifest_match(
    method _keyword_confidence (line 108) | def _keyword_confidence(self, candidates: list[str]) -> float:
    method _top2_gap (line 115) | def _top2_gap(self, candidates: list[str]) -> float:

FILE: maggy/maggy/lexon/terminology.py
  class TermEntry (line 14) | class TermEntry:
  class TerminologyMap (line 34) | class TerminologyMap:
    method __init__ (line 37) | def __init__(
    method _build_index (line 54) | def _build_index(self) -> dict[str, str]:
    method resolve (line 64) | def resolve(self, word: str) -> str | None:
    method add_alias (line 68) | def add_alias(self, canonical: str, alias: str) -> bool:
    method list_terms (line 77) | def list_terms(self) -> list[TermEntry]:

FILE: maggy/maggy/main.py
  function _init_tier1 (line 61) | def _init_tier1(app: FastAPI, cfg) -> None:
  function _init_mesh (line 97) | def _init_mesh(app: FastAPI, cfg) -> None:
  function _set_mode (line 115) | def _set_mode(app: FastAPI, cfg) -> None:
  function _start_heartbeat (line 130) | async def _start_heartbeat(app: FastAPI) -> None:
  function lifespan (line 152) | async def lifespan(app: FastAPI):
  function _bootstrap (line 161) | async def _bootstrap(app: FastAPI) -> None:
  function _seed_cikg (line 186) | def _seed_cikg(cikg, cfg) -> None:
  function _add_language_nodes (line 205) | def _add_language_nodes(cikg, codebase_key, path, now) -> None:
  class _NoCacheStatic (line 251) | class _NoCacheStatic(BaseHTTPMiddleware):
    method dispatch (line 254) | async def dispatch(
  function create_app (line 275) | def create_app() -> FastAPI:
  function reconfigure (line 315) | def reconfigure(app: FastAPI) -> None:
  function _print_banner (line 329) | def _print_banner(host: str, port: int) -> None:
  function main (line 352) | def main() -> None:

FILE: maggy/maggy/mesh/discovery.py
  class PeerInfo (line 10) | class PeerInfo:
  class PeerRegistry (line 26) | class PeerRegistry:
    method __init__ (line 29) | def __init__(self, store=None, org: str = ""):
    method _load_from_store (line 36) | def _load_from_store(self) -> None:
    method register (line 48) | def register(self, peer: PeerInfo) -> None:
    method unregister (line 56) | def unregister(self, peer_id: str) -> bool:
    method get (line 64) | def get(self, peer_id: str) -> PeerInfo | None:
    method list_peers (line 67) | def list_peers(self) -> list[PeerInfo]:
    method update_seen (line 70) | def update_seen(self, peer_id: str) -> None:
    method count (line 83) | def count(self) -> int:

FILE: maggy/maggy/mesh/git_discovery.py
  class Announcement (line 20) | class Announcement:
  function _headers (line 30) | def _headers(token: str) -> dict[str, str]:
  function ensure_mesh_repo (line 38) | async def ensure_mesh_repo(
  function announce (line 69) | async def announce(
  function read_peers (line 112) | async def read_peers(
  function _decode_peer (line 139) | def _decode_peer(item: dict) -> dict | None:
  function remove_announcement (line 150) | async def remove_announcement(

FILE: maggy/maggy/mesh/manager.py
  class MeshManager (line 21) | class MeshManager:
    method __init__ (line 24) | def __init__(self, cfg, store: MeshStore) -> None:
    method add_network (line 29) | def add_network(self, org: str) -> Network:
    method get_network (line 36) | def get_network(self, org: str) -> Network | None:
    method list_networks (line 39) | def list_networks(self) -> list[dict]:
    method total_peers (line 43) | def total_peers(self) -> int:
    method discover (line 48) | async def discover(self, token: str) -> dict:
    method announce_all (line 69) | async def announce_all(self, token: str) -> dict:
    method setup_repos (line 85) | async def setup_repos(self, token: str) -> dict:
    method _resolve_address (line 93) | def _resolve_address(self) -> str:

FILE: maggy/maggy/mesh/memory.py
  class MemoryType (line 10) | class MemoryType(str, Enum):
  class SharedMemory (line 18) | class SharedMemory:
    method is_trusted (line 33) | def is_trusted(self) -> bool:

FILE: maggy/maggy/mesh/network.py
  class Network (line 18) | class Network:
    method status (line 27) | def status(self) -> dict:
  function build_network (line 36) | def build_network(

FILE: maggy/maggy/mesh/org_scanner.py
  function scan_orgs (line 10) | def scan_orgs(home: Path | None = None) -> list[str]:
  function effective_orgs (line 21) | def effective_orgs(

FILE: maggy/maggy/mesh/protocol.py
  class MessageType (line 11) | class MessageType(str, Enum):
  class MeshMessage (line 22) | class MeshMessage:
    method serialize (line 34) | def serialize(self) -> str:
    method deserialize (line 38) | def deserialize(cls, data: str) -> MeshMessage:
  function create_hello (line 43) | def create_hello(peer_id: str, name: str) -> MeshMessage:
  function create_share (line 51) | def create_share(

FILE: maggy/maggy/mesh/provenance.py
  class Provenance (line 13) | class Provenance:
    method effective_confidence (line 26) | def effective_confidence(self) -> float:
    method add_hop (line 30) | def add_hop(self) -> Provenance:

FILE: maggy/maggy/mesh/publisher.py
  function collect_scores (line 8) | def collect_scores(routing, peer_id: str) -> list[SharedMemory]:
  function collect_gaps (line 25) | def collect_gaps(forge, peer_id: str) -> list[SharedMemory]:
  function collect_policies (line 39) | def collect_policies(introspector, peer_id: str) -> list[SharedMemory]:
  function collect_all_shares (line 59) | def collect_all_shares(app_state, peer_id: str) -> list[SharedMemory]:

FILE: maggy/maggy/mesh/quarantine.py
  class QuarantineEntry (line 10) | class QuarantineEntry:
  class QuarantineStore (line 25) | class QuarantineStore:
    method __init__ (line 28) | def __init__(self, store=None, org: str = ""):
    method _load_from_store (line 35) | def _load_from_store(self) -> None:
    method quarantine (line 45) | def quarantine(
    method get (line 62) | def get(self, key: str) -> QuarantineEntry | None:
    method list_all (line 65) | def list_all(self) -> list[QuarantineEntry]:
    method promote (line 68) | def promote(self, key: str) -> QuarantineEntry | None:
    method reject (line 75) | def reject(self, key: str) -> bool:
    method count (line 85) | def count(self) -> int:

FILE: maggy/maggy/mesh/store.py
  function _now (line 44) | def _now() -> str:
  class MeshStore (line 48) | class MeshStore:
    method __init__ (line 51) | def __init__(self, db_path: Path) -> None:
    method upsert_peer (line 66) | def upsert_peer(
    method get_peer (line 79) | def get_peer(
    method list_peers (line 90) | def list_peers(
    method remove_peer (line 105) | def remove_peer(
    method write_memory (line 119) | def write_memory(
    method list_memories (line 134) | def list_memories(self, org: str) -> list[dict]:
    method quarantine_item (line 147) | def quarantine_item(
    method promote_item (line 160) | def promote_item(
    method list_quarantined (line 172) | def list_quarantined(self, org: str) -> list[dict]:
    method close (line 183) | def close(self) -> None:

FILE: maggy/maggy/mesh/sync.py
  class SyncResult (line 17) | class SyncResult:
  class SyncEngine (line 25) | class SyncEngine:
    method __init__ (line 28) | def __init__(
    method _load_from_store (line 39) | def _load_from_store(self) -> None:
    method sync_incoming (line 49) | def sync_incoming(
    method _accept (line 69) | def _accept(self, mem: SharedMemory) -> None:
    method promote_from_quarantine (line 77) | def promote_from_quarantine(self, key: str) -> bool:
    method get_local (line 92) | def get_local(self, key: str) -> SharedMemory | None:
    method list_local (line 95) | def list_local(self) -> list[SharedMemory]:
    method local_count (line 99) | def local_count(self) -> int:

FILE: maggy/maggy/mesh/transport.py
  function derive_org_key (line 18) | def derive_org_key(org: str, secret: str) -> str:
  function compute_hmac (line 25) | def compute_hmac(payload: str, key: str) -> str:
  function verify_hmac (line 32) | def verify_hmac(
  function sign_message (line 40) | def sign_message(msg: MeshMessage, org_key: str) -> str:
  function verify_message (line 48) | def verify_message(

FILE: maggy/maggy/mesh/ws_client.py
  class MeshClient (line 17) | class MeshClient:
    method __init__ (line 20) | def __init__(self, peer_id: str) -> None:
    method connect (line 25) | async def connect(
    method send (line 49) | async def send(
    method broadcast (line 65) | async def broadcast(
    method close_all (line 75) | async def close_all(self) -> None:
    method connected_count (line 88) | def connected_count(self) -> int:
    method is_connected (line 91) | def is_connected(self, peer_id: str) -> bool:

FILE: maggy/maggy/mesh/ws_server.py
  function mesh_ws (line 24) | async def mesh_ws(websocket: WebSocket) -> None:
  function _handle_connection (line 41) | async def _handle_connection(websocket, manager) -> None:
  function _message_loop (line 65) | async def _message_loop(websocket, net) -> None:
  function _authenticate (line 83) | def _authenticate(
  function _dispatch (line 105) | async def _dispatch(msg: MeshMessage, net) -> None:

FILE: maggy/maggy/mnemos/fatigue.py
  class FatigueTracker (line 13) | class FatigueTracker:
    method __init__ (line 16) | def __init__(self, context_window: int = 200_000):
    method record (line 22) | def record(self, dimension: str, value: float) -> None:
    method on_model_switch (line 30) | def on_model_switch(self, new_context_window: int) -> None:
    method composite (line 35) | def composite(self) -> float:
    method state (line 38) | def state(self) -> str:

FILE: maggy/maggy/mnemos/signals.py
  class SignalLog (line 9) | class SignalLog:
    method __init__ (line 12) | def __init__(self, path: Path):
    method append (line 15) | def append(self, signal: dict) -> None:
    method recent (line 20) | def recent(self, n: int) -> list[dict]:

FILE: maggy/maggy/models/plan.py
  class PlanStep (line 9) | class PlanStep:
  class Plan (line 18) | class Plan:
    method step_count (line 28) | def step_count(self) -> int:
  class PlanDiff (line 33) | class PlanDiff:
    method conflict_count (line 42) | def conflict_count(self) -> int:
    method agreement_ratio (line 46) | def agreement_ratio(self) -> float:

FILE: maggy/maggy/observability/collector.py
  function _connect (line 23) | def _connect(path: Path) -> Iterator[sqlite3.Connection]:
  class ObservabilityCollector (line 33) | class ObservabilityCollector:
    method __init__ (line 34) | def __init__(self, db_path: Path):
    method record_signal (line 38) | def record_signal(
    method recent_signals (line 50) | def recent_signals(
    method _init_db (line 62) | def _init_db(self) -> None:

FILE: maggy/maggy/planning.py
  class PlanRequest (line 21) | class PlanRequest:
  class PlanningService (line 29) | class PlanningService:
    method __init__ (line 32) | def __init__(self, cfg: MaggyConfig):
    method should_dual_plan (line 35) | def should_dual_plan(self, blast_score: int) -> bool:
    method generate_plan (line 39) | def generate_plan(
    method diff_plans (line 65) | def diff_plans(
    method plan_task (line 97) | def plan_task(self, req: PlanRequest) -> dict:
  function _similar (line 121) | def _similar(a: str, b: str) -> bool:

FILE: maggy/maggy/process/discovery.py
  function discover_local (line 15) | def discover_local(project_path: Path) -> dict:
  function discover_github (line 67) | async def discover_github(

FILE: maggy/maggy/process/github_prs.py
  function _headers (line 21) | def _headers(token: str) -> dict[str, str]:
  function fetch_prs (line 29) | async def fetch_prs(
  function _fetch_pr_list (line 61) | async def _fetch_pr_list(
  function _fetch_pr_detail (line 97) | async def _fetch_pr_detail(
  function _parse_pr (line 111) | def _parse_pr(data: dict) -> PRRecord:
  function _pr_state (line 128) | def _pr_state(data: dict) -> str:
  function _fetch_reviews (line 134) | async def _fetch_reviews(
  function _fetch_checks (line 156) | async def _fetch_checks(
  function _fetch_files (line 178) | async def _fetch_files(
  function _log_error (line 197) | def _log_error(

FILE: maggy/maggy/process/model_router.py
  class RoutingDecision (line 56) | class RoutingDecision:
  function route_task (line 65) | def route_task(
  function _select_primary (line 107) | def _select_primary(
  function _select_validator (line 138) | def _select_validator(
  function _build_fallback (line 152) | def _build_fallback(
  function _build_reason (line 165) | def _build_reason(

FILE: maggy/maggy/process/models.py
  class ReviewRecord (line 9) | class ReviewRecord:
  class CheckRecord (line 19) | class CheckRecord:
  class PRRecord (line 29) | class PRRecord:
    method total_lines (line 48) | def total_lines(self) -> int:
    method review_rounds (line 52) | def review_rounds(self) -> int:
    method time_to_merge_hours (line 59) | def time_to_merge_hours(self) -> float | None:
    method ci_passed (line 74) | def ci_passed(self) -> bool:
  class ReviewSignal (line 84) | class ReviewSignal:
  class CISignal (line 94) | class CISignal:
    method failure_rate (line 103) | def failure_rate(self) -> float:
  class VelocitySignal (line 110) | class VelocitySignal:
  class ProcessReport (line 121) | class ProcessReport:
  class ModelTier (line 138) | class ModelTier:

FILE: maggy/maggy/process/patterns.py
  function identify_bottlenecks (line 19) | def identify_bottlenecks(
  function generate_preemptive_fixes (line 73) | def generate_preemptive_fixes(
  function generate_routing_recs (line 101) | def generate_routing_recs(
  function _avg_merge_time (line 170) | def _avg_merge_time(prs: list[PRRecord]) -> float | None:
  function _is_security_related (line 181) | def _is_security_related(pr: PRRecord) -> bool:
  function _is_test_only (line 189) | def _is_test_only(pr: PRRecord) -> bool:
  function _is_docs (line 198) | def _is_docs(pr: PRRecord) -> bool:

FILE: maggy/maggy/process/report.py
  function generate_summary (line 20) | def generate_summary(report: ProcessReport) -> str:
  function format_health_metrics (line 99) | def format_health_metrics(
  function _ci_pass_rate (line 145) | def _ci_pass_rate(

FILE: maggy/maggy/process/service.py
  class ProcessService (line 32) | class ProcessService:
    method __init__ (line 35) | def __init__(self, cfg: MaggyConfig):
    method analyze (line 43) | async def analyze(
    method get_report (line 105) | def get_report(self, project_key: str) -> dict | None:
    method get_health (line 109) | def get_health(self, project_key: str) -> dict | None:
    method _resolve_repo (line 116) | def _resolve_repo(

FILE: maggy/maggy/process/signals.py
  function extract_review_signals (line 57) | def extract_review_signals(
  function extract_ci_signals (line 95) | def extract_ci_signals(
  function extract_velocity_signals (line 139) | def extract_velocity_signals(
  function _matches_theme (line 175) | def _matches_theme(

FILE: maggy/maggy/process/store.py
  function _connect (line 20) | def _connect(path: Path) -> sqlite3.Connection:
  class ProcessStore (line 29) | class ProcessStore:
    method __init__ (line 32) | def __init__(self, db_path: Path):
    method _init_tables (line 37) | def _init_tables(self) -> None:
    method save_pr_data (line 64) | def save_pr_data(
    method load_pr_data (line 81) | def load_pr_data(
    method save_report (line 96) | def save_report(self, report: ProcessReport) -> None:
    method load_latest_report (line 155) | def load_latest_report(

FILE: maggy/maggy/providers/__init__.py
  function build (line 16) | def build(cfg) -> IssueTrackerProvider:

FILE: maggy/maggy/providers/asana.py
  class AsanaProvider (line 12) | class AsanaProvider:
    method __init__ (line 19) | def __init__(self, workspace_id: str, boards: dict[str, str], token: s...
    method provider_name (line 26) | def provider_name(self) -> str:
    method _headers (line 29) | def _headers(self) -> dict[str, str]:
    method _to_task (line 32) | def _to_task(self, t: dict) -> Task:
    method _get_my_gid (line 50) | async def _get_my_gid(self, client: httpx.AsyncClient) -> str:
    method list_tasks (line 58) | async def list_tasks(self, board: str | None = None, state: str = "ope...
    method get_task (line 97) | async def get_task(self, task_id: str) -> Task | None:
    method get_comments (line 107) | async def get_comments(self, task_id: str) -> list[Comment]:
    method add_comment (line 127) | async def add_comment(self, task_id: str, text: str) -> Comment | None:
    method update_status (line 144) | async def update_status(self, task_id: str, status: str) -> bool:
    method list_followed (line 154) | async def list_followed(self, user_id: str | None = None, limit: int =...
    method search_tasks (line 175) | async def search_tasks(self, query: str, limit: int = 20) -> list[Task]:

FILE: maggy/maggy/providers/base.py
  class Task (line 14) | class Task:
  class Comment (line 35) | class Comment:
  class IssueTrackerProvider (line 42) | class IssueTrackerProvider(Protocol):
    method list_tasks (line 45) | async def list_tasks(self, board: str | None = None, state: str = "ope...
    method get_task (line 49) | async def get_task(self, task_id: str) -> Task | None:
    method get_comments (line 52) | async def get_comments(self, task_id: str) -> list[Comment]:
    method add_comment (line 55) | async def add_comment(self, task_id: str, text: str) -> Comment | None:
    method update_status (line 58) | async def update_status(self, task_id: str, status: str) -> bool:
    method list_followed (line 62) | async def list_followed(self, user_id: str | None = None, limit: int =...
    method search_tasks (line 66) | async def search_tasks(self, query: str, limit: int = 20) -> list[Task]:
    method provider_name (line 69) | def provider_name(self) -> str:

FILE: maggy/maggy/providers/github_issues.py
  class GitHubIssuesProvider (line 16) | class GitHubIssuesProvider:
    method __init__ (line 24) | def __init__(self, org: str, repos: list[str], token: str, labels: lis...
    method provider_name (line 30) | def provider_name(self) -> str:
    method _headers (line 33) | def _headers(self) -> dict[str, str]:
    method _encode_id (line 40) | def _encode_id(self, repo: str, number: int) -> str:
    method _decode_id (line 45) | def _decode_id(self, task_id: str) -> tuple[str, int] | None:
    method _to_task (line 65) | def _to_task(self, repo: str, issue: dict) -> Task:
    method list_tasks (line 81) | async def list_tasks(self, board: str | None = None, state: str = "ope...
    method get_task (line 116) | async def get_task(self, task_id: str) -> Task | None:
    method get_comments (line 127) | async def get_comments(self, task_id: str) -> list[Comment]:
    method add_comment (line 146) | async def add_comment(self, task_id: str, text: str) -> Comment | None:
    method update_status (line 166) | async def update_status(self, task_id: str, status: str) -> bool:
    method list_followed (line 181) | async def list_followed(self, user_id: str | None = None, limit: int =...
    method search_tasks (line 218) | async def search_tasks(self, query: str, limit: int = 20) -> list[Task]:

FILE: maggy/maggy/providers/monday.py
  class MondayProvider (line 12) | class MondayProvider:
    method __init__ (line 15) | def __init__(self, api_token: str, board_id: str):
    method provider_name (line 19) | def provider_name(self) -> str:
    method _headers (line 22) | def _headers(self) -> dict[str, str]:
    method _to_task (line 28) | def _to_task(self, item: dict) -> Task:
    method _query (line 44) | async def _query(self, q: str) -> dict:
    method list_tasks (line 55) | async def list_tasks(self, board=None, state="open", limit=50) -> list...
    method get_task (line 65) | async def get_task(self, task_id: str) -> Task | None:
    method get_comments (line 73) | async def get_comments(self, task_id: str) -> list[Comment]:
    method add_comment (line 90) | async def add_comment(self, task_id: str, text: str) -> Comment | None:
    method update_status (line 102) | async def update_status(self, task_id: str, status: str) -> bool:
    method list_followed (line 105) | async def list_followed(self, user_id=None, limit=50) -> list[Task]:
    method search_tasks (line 108) | async def search_tasks(self, query: str, limit=20) -> list[Task]:
  function _col_value (line 112) | def _col_value(cols: list[dict], col_id: str) -> str:
  function _items_query (line 119) | def _items_query(board_id: str, limit: int) -> str:

FILE: maggy/maggy/recovery/rollback.py
  function _validate_session_id (line 11) | def _validate_session_id(session_id: str) -> None:
  class RollbackManager (line 16) | class RollbackManager:
    method create_savepoint (line 17) | async def create_savepoint(self, session_id: str, working_dir: str) ->...
    method rollback (line 25) | async def rollback(self, session_id: str, working_dir: str) -> bool:
    method list_savepoints (line 30) | async def list_savepoints(self, working_dir: str) -> list[str]:
    method delete_savepoint (line 36) | async def delete_savepoint(self, session_id: str, working_dir: str) ->...
  function _run_git (line 41) | async def _run_git(working_dir: str, *args: str) -> tuple[int, str]:
  function _tag_name (line 54) | def _tag_name(session_id: str) -> str:

FILE: maggy/maggy/registry.py
  class ProjectRegistry (line 8) | class ProjectRegistry:
    method __init__ (line 11) | def __init__(self, cfg: MaggyConfig):
    method list (line 14) | def list(self) -> list[ProjectConfig]:
    method get (line 17) | def get(self, name: str) -> ProjectConfig | None:
    method add (line 20) | def add(self, project: ProjectConfig) -> None:
    method remove (line 25) | def remove(self, name: str) -> bool:

FILE: maggy/maggy/routing.py
  class RoutingContext (line 29) | class RoutingContext:
  class RoutingService (line 40) | class RoutingService:
    method __init__ (line 43) | def __init__(self, cfg: MaggyConfig):
    method route (line 52) | def route(self, ctx: RoutingContext) -> RoutingDecision:
    method record_outcome (line 82) | def record_outcome(
    method reload_rules (line 96) | def reload_rules(self) -> None:
    method get_heatmap (line 100) | def get_heatmap(self) -> list[dict]:
    method _blast_tier (line 104) | def _blast_tier(self, score: int) -> str:
    method _is_calibrated (line 111) | def _is_calibrated(self, model: str) -> bool:
    method _forced_decision (line 115) | def _forced_decision(
    method _penalize_uncalibrated (line 139) | def _penalize_uncalibrated(
  function _find_tier (line 154) | def _find_tier(name: str):

FILE: maggy/maggy/routing_rules.py
  class ModelOverride (line 18) | class ModelOverride:
  class PerformanceRecord (line 28) | class PerformanceRecord:
  class Convention (line 38) | class Convention:
  class StakesLevel (line 47) | class StakesLevel:
  class StakesPatterns (line 56) | class StakesPatterns:
  class CascadePolicy (line 65) | class CascadePolicy:
  class RoutingRules (line 76) | class RoutingRules:
  function _now_iso (line 98) | def _now_iso() -> str:
  function apply_override (line 102) | def apply_override(
  function record_outcome (line 118) | def record_outcome(
  function learn_override (line 135) | def learn_override(
  function conventions_for (line 152) | def conventions_for(
  function _trusted (line 169) | def _trusted(override: ModelOverride) -> bool:
  function _update_perf (line 173) | def _update_perf(

FILE: maggy/maggy/routing_rules_defaults.py
  function default_conventions (line 53) | def default_conventions() -> list[Convention]:
  function default_stakes (line 58) | def default_stakes() -> StakesPatterns:
  function default_rules (line 74) | def default_rules() -> RoutingRules:

FILE: maggy/maggy/routing_rules_io.py
  function save (line 25) | def save(rules: RoutingRules, path: Path | None = None) -> None:
  function load (line 33) | def load(path: Path | None = None) -> RoutingRules:
  function to_dict (line 49) | def to_dict(rules: RoutingRules) -> dict:
  function from_yaml (line 79) | def from_yaml(path: Path) -> RoutingRules:
  function _stakes_to_dict (line 124) | def _stakes_to_dict(stakes: StakesPatterns) -> dict:
  function _level_to_dict (line 132) | def _level_to_dict(level: StakesLevel) -> dict:
  function _cascade_to_dict (line 140) | def _cascade_to_dict(cascade: CascadePolicy) -> dict:
  function _override_to_dict (line 150) | def _override_to_dict(v: ModelOverride) -> dict:
  function _perf_to_dict (line 157) | def _perf_to_dict(v: PerformanceRecord) -> dict:
  function _stakes_from_dict (line 165) | def _stakes_from_dict(raw: dict) -> StakesPatterns:

FILE: maggy/maggy/scores.py
  function _connect (line 34) | def _connect(path: Path) -> Iterator[sqlite3.Connection]:
  class RewardTable (line 46) | class RewardTable:
    method __init__ (line 49) | def __init__(self, cfg: MaggyConfig):
    method _init_db (line 54) | def _init_db(self) -> None:
    method record (line 58) | def record(
    method best_model (line 74) | def best_model(
    method heatmap (line 112) | def heatmap(self) -> list[dict]:

FILE: maggy/maggy/services/account_guide.py
  class AccountProfile (line 19) | class AccountProfile:
  function detect_accounts (line 28) | def detect_accounts(home: Path | None = None) -> list[AccountProfile]:
  function suggest_switch (line 43) | def suggest_switch(provider: str) -> str:
  function render_switch_guide (line 60) | def render_switch_guide(provider: str) -> None:

FILE: maggy/maggy/services/activity.py
  class ActiveSession (line 17) | class ActiveSession:
  class RecentPrompt (line 32) | class RecentPrompt:
  class ActivityService (line 42) | class ActivityService:
    method get_activity (line 45) | def get_activity(self) -> dict:
  function _scan_processes (line 57) | def _scan_processes() -> list[ActiveSession]:
  function _parse_claude_processes (line 72) | def _parse_claude_processes(
  function _is_cli_process (line 98) | def _is_cli_process(line: str) -> bool:
  function _extract_pid (line 112) | def _extract_pid(line: str) -> int:
  function _extract_flag (line 123) | def _extract_flag(line: str, flag: str) -> str:
  function _get_cwd (line 134) | def _get_cwd(pid: int) -> str:
  function _recent_prompts (line 154) | def _recent_prompts(
  function _read_claude_history (line 175) | def _read_claude_history(
  function _read_codex_history (line 205) | def _read_codex_history(
  function _read_kimi_history (line 234) | def _read_kimi_history(
  function _tail_lines (line 271) | def _tail_lines(path: Path, n: int) -> list[str]:
  function _ms_to_iso (line 280) | def _ms_to_iso(ms: int | float) -> str:
  function _s_to_iso (line 293) | def _s_to_iso(s: int | float) -> str:

FILE: maggy/maggy/services/ai_client.py
  function ai_complete (line 12) | async def ai_complete(
  function _api_complete (line 28) | async def _api_complete(
  function _cli_complete (line 46) | async def _cli_complete(

FILE: maggy/maggy/services/cascade.py
  class CascadeAttempt (line 20) | class CascadeAttempt:
  class CascadeResult (line 31) | class CascadeResult:
  function cascade_execute (line 41) | async def cascade_execute(

FILE: maggy/maggy/services/chat.py
  class ChatMessage (line 23) | class ChatMessage:
  class ChatSession (line 36) | class ChatSession:
  function enqueue_msg (line 57) | def enqueue_msg(session: ChatSession, message: str) -> int:
  class ChatManager (line 65) | class ChatManager:
    method __init__ (line 68) | def __init__(self, cfg: MaggyConfig):
    method create_session (line 73) | def create_session(
    method find_by_project (line 93) | def find_by_project(self, key: str) -> ChatSession | None:
    method auto_connect (line 100) | def auto_connect(
    method get_session (line 123) | def get_session(self, sid: str) -> ChatSession | None:
    method list_sessions (line 126) | def list_sessions(self) -> list[ChatSession]:
    method delete_session (line 129) | def delete_session(self, session_id: str) -> bool:
    method send (line 136) | async def send(
    method _drain_queue (line 159) | async def _drain_queue(
    method _validate_path (line 172) | def _validate_path(self, path: str) -> str:
    method _resolve_project (line 190) | def _resolve_project(self, project_key: str) -> str:

FILE: maggy/maggy/services/chat_context.py
  function build_project_context (line 18) | def build_project_context(
  function _match_history (line 33) | def _match_history(
  function _match_from_report (line 47) | def _match_from_report(
  function _path_candidates (line 85) | def _path_candidates(
  function _format_recent_prompts (line 100) | def _format_recent_prompts(
  function resolve_claude_session_id (line 118) | def resolve_claude_session_id(

FILE: maggy/maggy/services/chat_router.py
  function estimate_blast (line 66) | def estimate_blast(message: str) -> int:
  function _keyword_score (line 81) | def _keyword_score(high: int, mid: int, low: int) -> int:
  function _apply_intent (line 98) | def _apply_intent(message: str, score: int) -> int:
  function estimate_type (line 107) | def estimate_type(message: str) -> str:
  class RouteDecision (line 121) | class RouteDecision:
  class RoutedChat (line 130) | class RoutedChat:
    method __init__ (line 133) | def __init__(self, routing, budget):
    method decide (line 137) | def decide(
    method _model_name (line 158) | def _model_name(self, primary) -> str:

FILE: maggy/maggy/services/chat_stream.py
  function build_cmd (line 24) | def build_cmd(session: ChatSession, message: str) -> list[str]:
  function parse_chunk (line 37) | def parse_chunk(
  function _extract_assistant (line 64) | def _extract_assistant(data: dict) -> dict:
  function check_context_pressure (line 77) | def check_context_pressure(session: ChatSession) -> dict | None:
  function stream_message (line 87) | async def stream_message(

FILE: maggy/maggy/services/checkpoint.py
  class Checkpoint (line 15) | class Checkpoint:
    method serialize (line 26) | def serialize(self) -> str:
    method deserialize (line 35) | def deserialize(cls, data: str) -> Checkpoint:
    method to_prompt (line 40) | def to_prompt(self) -> str:
  function create_checkpoint (line 69) | def create_checkpoint(

FILE: maggy/maggy/services/competitor.py
  function _connect_sqlite (line 29) | def _connect_sqlite(path: Path) -> sqlite3.Connection:
  function _parse_feed_date (line 42) | def _parse_feed_date(raw: str) -> datetime | None:
  function _is_safe_feed_url (line 70) | def _is_safe_feed_url(url: str) -> bool:
  class CompetitorService (line 110) | class CompetitorService:
    method __init__ (line 111) | def __init__(self, cfg: MaggyConfig):
    method _init_db (line 117) | def _init_db(self) -> None:
    method load_registry (line 149) | def load_registry(self) -> dict[str, dict]:
    method save_registry (line 157) | def save_registry(self, registry: dict[str, dict]) -> None:
    method discover (line 163) | async def discover(self) -> dict:
    method list_all (line 231) | def list_all(self) -> list[dict]:
    method monitor_all (line 236) | async def monitor_all(self) -> dict:
    method _get_cursor (line 252) | def _get_cursor(self, key: str) -> str:
    method _set_cursor (line 257) | def _set_cursor(self, key: str, cursor: str) -> None:
    method _classify (line 265) | def _classify(self, title: str) -> str:
    method _log_event (line 279) | def _log_event(self, competitor_id: str, competitor_name: str, event_t...
    method _check_rss (line 293) | async def _check_rss(self, cid: str, comp: dict) -> int:
    method _check_google_news (line 335) | async def _check_google_news(self, cid: str, comp: dict) -> int:
    method get_news (line 376) | def get_news(self, limit: int = 100) -> list[dict]:
    method get_daily_briefing (line 387) | async def get_daily_briefing(self, refresh: bool = False) -> dict:

FILE: maggy/maggy/services/context_compactor.py
  class CompactionResult (line 23) | class CompactionResult:
  function estimate_tokens (line 29) | def estimate_tokens(messages: list[dict]) -> int:
  function should_compact (line 35) | def should_compact(messages: list[dict], context_window: int) -> bool:
  function compact (line 41) | async def compact(
  function _format_for_summary (line 69) | def _format_for_summary(messages: list[dict]) -> str:

FILE: maggy/maggy/services/convention_inferrer.py
  function collect_fingerprint (line 50) | def collect_fingerprint(working_dir: str) -> str:
  function parse_conventions (line 57) | def parse_conventions(text: str) -> list[Convention]:
  function infer_conventions (line 71) | async def infer_conventions(
  function ensure_inferred (line 87) | async def ensure_inferred(
  function _file_tree (line 109) | def _file_tree(root: Path) -> str:
  function _config_snippets (line 127) | def _config_snippets(root: Path) -> str:
  function _git_log (line 141) | def _git_log(root: Path) -> str:

FILE: maggy/maggy/services/convention_scanner.py
  class ScanRule (line 20) | class ScanRule:
  function scan_project (line 90) | def scan_project(working_dir: str) -> list[Convention]:
  function ensure_scanned (line 107) | def ensure_scanned(
  function _matches (line 117) | def _matches(root: Path, rule: ScanRule) -> bool:

FILE: maggy/maggy/services/executor.py
  class ExecutorService (line 28) | class ExecutorService:
    method __init__ (line 29) | def __init__(self, cfg: MaggyConfig, provider: IssueTrackerProvider, s...
    method start (line 44) | async def start(self, task_id: str, mode: str = "tdd",
    method get_session (line 64) | def get_session(self, sid: str) -> dict | None: return self._sessions....
    method list_sessions (line 65) | def list_sessions(self) -> list[dict]: return list(self._sessions.valu...
    method _run (line 66) | async def _run(self, ctx: SessionCtx, mode: str) -> None:
    method _run_plan (line 82) | async def _run_plan(self, ctx: SessionCtx) -> None:
    method _run_tdd (line 91) | async def _run_tdd(self, ctx: SessionCtx) -> None:
    method _reviewed_step (line 117) | async def _reviewed_step(self, ctx: SessionCtx, step: StepSpec) -> tup...
    method _run_step (line 129) | async def _run_step(self, ctx: SessionCtx, step: StepSpec) -> tuple[bo...
    method _review_step (line 137) | async def _review_step(self, ctx: SessionCtx, step: StepSpec, output: ...
    method _run_model (line 143) | async def _run_model(self, ctx: SessionCtx, prompt: str, turns: int) -...
    method _send (line 159) | async def _send(self, decision, name, prompt, ctx):
    method _emit_status (line 172) | def _emit_status(self, agent: str, status: str) -> None:
    method _verify_red (line 175) | async def _verify_red(self, ctx: SessionCtx) -> bool:
    method _verify_green (line 184) | async def _verify_green(self, ctx: SessionCtx) -> bool:
    method _dual_plan (line 195) | async def _dual_plan(self, ctx: SessionCtx) -> None:

FILE: maggy/maggy/services/executor_helpers.py
  function route_model (line 25) | def route_model(task: Task, routing: RoutingService) -> RoutingDecision:
  function blast_score (line 43) | def blast_score(task: Task) -> int:
  function int_value (line 49) | def int_value(value: object) -> int:
  function model_name (line 57) | def model_name(primary: object) -> str:
  function track_fatigue (line 64) | def track_fatigue(fatigue: FatigueTracker, result: RunResult) -> None:
  function log_signal (line 70) | def log_signal(signals: SignalLog, sid: str, label: str, result: RunResu...
  function write_checkpoint (line 78) | def write_checkpoint(
  function save_rollback (line 89) | async def save_rollback(
  function try_rollback (line 99) | async def try_rollback(
  function maybe_escalate (line 109) | def maybe_escalate(
  function build_icpg_context (line 122) | async def build_icpg_context(cfg: "MaggyConfig", task: Task) -> str:
  function resolve_working_dir (line 149) | def resolve_working_dir(cfg: "MaggyConfig", requested: str | None, task:...
  function pick_working_dir (line 167) | def pick_working_dir(cfg: "MaggyConfig", task: "Task") -> str:
  function post_plan (line 186) | async def post_plan(provider, task_id: str, output: str) -> None:
  function _task_type (line 196) | def _task_type(task: "Task") -> str:
  function _security_flag (line 200) | def _security_flag(raw: dict, task_type: str) -> bool:

FILE: maggy/maggy/services/executor_prompts.py
  function plan_prompt (line 24) | def plan_prompt(task: Task, icpg_ctx: str, routing: RoutingService) -> str:
  function analysis_prompt (line 35) | def analysis_prompt(task: Task, icpg_ctx: str, routing: RoutingService) ...
  function tests_prompt (line 46) | def tests_prompt(
  function impl_prompt (line 61) | def impl_prompt(task: Task, icpg_ctx: str, routing: RoutingService) -> str:
  function extract_keywords (line 73) | def extract_keywords(text: str) -> list[str]:
  function _icpg_block (line 86) | def _icpg_block(icpg_ctx: str) -> str:
  function _task_type (line 92) | def _task_type(task: Task) -> str:
  function _conventions_block (line 98) | def _conventions_block(task: Task, routing: RoutingService) -> str:

FILE: maggy/maggy/services/executor_types.py
  class SessionCtx (line 13) | class SessionCtx:
  class StepSpec (line 23) | class StepSpec:

FILE: maggy/maggy/services/inbox.py
  function _connect_sqlite (line 23) | def _connect_sqlite(path: Path) -> sqlite3.Connection:
  class InboxService (line 38) | class InboxService:
    method __init__ (line 39) | def __init__(self, cfg: MaggyConfig, provider: IssueTrackerProvider):
    method _init_db (line 46) | def _init_db(self) -> None:
    method _read_cache (line 56) | def _read_cache(self, ignore_ttl: bool = False) -> list[dict] | None:
    method _write_cache (line 70) | def _write_cache(self, items: list[dict]) -> None:
    method get_prioritized (line 78) | async def get_prioritized(self, force_refresh: bool = False) -> list[d...
    method _rank_with_ai (line 106) | async def _rank_with_ai(self, tasks: list[Task]) -> list[dict]:
    method _build_rank_prompt (line 149) | def _build_rank_prompt(self, tasks: list[Task]) -> str:
    method _call_ai (line 173) | async def _call_ai(self, prompt: str) -> str | None:
    method _task_to_dict (line 177) | def _task_to_dict(self, t: Task, rank: int, reason: str) -> dict:

FILE: maggy/maggy/services/monitor.py
  class MonitorConfig (line 20) | class MonitorConfig:
  class MonitorEvent (line 31) | class MonitorEvent:
  class MonitorService (line 42) | class MonitorService:
    method __init__ (line 45) | def __init__(self, db_path: Path) -> None:
    method _init_tables (line 49) | def _init_tables(self) -> None:
    method add (line 66) | def add(self, cfg: MonitorConfig) -> None:
    method remove (line 74) | def remove(self, project_key: str) -> None:
    method list_active (line 81) | def list_active(self) -> list[MonitorConfig]:
    method is_new (line 87) | def is_new(self, event_id: str, project_key: str) -> bool:
    method mark_seen (line 94) | def mark_seen(self, event_id: str, project_key: str) -> None:
    method status (line 102) | def status(self) -> dict:
    method poll (line 109) | async def poll(self, cfg: MonitorConfig) -> list[MonitorEvent]:
  function _row_to_config (line 118) | def _row_to_config(row: tuple) -> MonitorConfig:
  function _poll_github (line 126) | async def _poll_github(svc: MonitorService, cfg: MonitorConfig) -> list[...
  function _poll_monday (line 149) | async def _poll_monday(svc: MonitorService, cfg: MonitorConfig) -> list[...

FILE: maggy/maggy/services/output_reviewer.py
  class ReviewResult (line 28) | class ReviewResult:
  function _parse_review (line 33) | def _parse_review(text: str) -> ReviewResult:
  function _build_prompt (line 44) | def _build_prompt(step_label: str, output: str) -> str:
  function review_output (line 56) | async def review_output(

FILE: maggy/maggy/services/planner.py
  class PlanResult (line 11) | class PlanResult:
  class DualPlanner (line 17) | class DualPlanner:
    method __init__ (line 18) | def __init__(self, pi: PiAdapter):
    method plan (line 21) | async def plan(
    method counter_check (line 27) | async def counter_check(self, plan_text: str, wd: str) -> str:
    method dual_plan (line 31) | async def dual_plan(
    method _send (line 38) | async def _send(self, model: str, prompt: str, wd: str) -> str:
  function _plan_prompt (line 43) | def _plan_prompt(task_title: str, task_desc: str) -> str:
  function _review_prompt (line 52) | def _review_prompt(plan_text: str) -> str:
  function _result_text (line 61) | def _result_text(result: RunResult, model: str) -> str:
  function _conflicts (line 68) | def _conflicts(text: str) -> list[str]:

FILE: maggy/maggy/services/session_detect.py
  function _home (line 17) | def _home() -> Path:
  class CliSessionInfo (line 23) | class CliSessionInfo:
  class DetectedSessions (line 32) | class DetectedSessions:
  function detect_all (line 40) | def detect_all(working_dir: str) -> DetectedSessions:
  function detect_claude (line 53) | def detect_claude(working_dir: str) -> CliSessionInfo | None:
  function detect_kimi (line 70) | def detect_kimi(working_dir: str) -> CliSessionInfo | None:
  function detect_codex (line 87) | def detect_codex(working_dir: str) -> CliSessionInfo | None:
  function _parse_json (line 108) | def _parse_json(text: str) -> dict | None:
  function _read_first_line (line 119) | def _read_first_line(path: Path) -> str:

FILE: maggy/maggy/services/stakes.py
  class StakesResult (line 15) | class StakesResult:
  function classify_stakes (line 22) | def classify_stakes(
  function _matches (line 43) | def _matches(

FILE: maggy/maggy/services/tdd_verifier.py
  class VerifyResult (line 17) | class VerifyResult:
  function verify_tests_exist (line 26) | async def verify_tests_exist(wd: str) -> VerifyResult:
  function verify_tests_fail (line 37) | async def verify_tests_fail(wd: str) -> VerifyResult:
  function verify_tests_pass (line 52) | async def verify_tests_pass(wd: str) -> VerifyResult:
  function verify_lint (line 64) | async def verify_lint(wd: str) -> VerifyResult:
  function verify_coverage (line 74) | async def verify_coverage(
  function _run_cmd (line 89) | async def _run_cmd(
  function _count_collected (line 111) | def _count_collected(output: str) -> int:
  function _count_failures (line 117) | def _count_failures(output: str) -> int:
  function _parse_coverage (line 123) | def _parse_coverage(output: str) -> float:

FILE: maggy/maggy/services/vision.py
  function _validate (line 26) | def _validate(path: str) -> Path | None:
  function _encode (line 36) | def _encode(path: Path) -> str:
  function analyze_image (line 41) | def analyze_image(
  function _err (line 86) | def _err(msg: str) -> dict:

FILE: maggy/maggy/static/app.js
  constant API (line 4) | const API = '/api';
  constant CURRENT_TAB (line 5) | let CURRENT_TAB = 'chat';
  function api (line 8) | async function api(path, opts = {}) {
  function esc (line 21) | function esc(s) {
  function safeHref (line 30) | function safeHref(url) {
  function jsStr (line 45) | function jsStr(s) {
  function relDate (line 55) | function relDate(iso) {
  function switchTab (line 67) | function switchTab(tab) {
  function toggleSystemMenu (line 102) | function toggleSystemMenu() {
  function openDrawer (line 118) | function openDrawer(title, html) {
  function closeDrawer (line 123) | function closeDrawer() {
  function loadInbox (line 128) | async function loadInbox(refresh = false) {
  function loadFollowed (line 204) | async function loadFollowed() {
  function openTaskDetail (line 233) | async function openTaskDetail(taskId) {
  function postReply (line 280) | async function postReply(taskId) {
  function executeTask (line 291) | async function executeTask(taskId, mode) {
  constant COMP_VIEW (line 302) | let COMP_VIEW = 'news';
  function loadCompetitors (line 304) | async function loadCompetitors() {
  function renderNewsFeed (line 344) | function renderNewsFeed(news) {
  function loadBriefing (line 375) | async function loadBriefing() {
  function regenerateBriefing (line 390) | async function regenerateBriefing() {
  function discoverCompetitors (line 401) | async function discoverCompetitors() {
  function scanCompetitors (line 412) | async function scanCompetitors() {
  constant CHAT_SESSION_ID (line 423) | let CHAT_SESSION_ID = null;
  constant CHAT_SESSIONS_CACHE (line 424) | let CHAT_SESSIONS_CACHE = [];
  function loadChat (line 426) | async function loadChat() {
  function renderChatUI (line 441) | function renderChatUI(pane) {
  function renderChatSidebar (line 451) | function renderChatSidebar(sessions) {
  function renderChatMain (line 473) | function renderChatMain() {
  function newChatSession (line 496) | async function newChatSession() {
  function openChatSession (line 525) | function openChatSession(id) {
  function loadChatMessages (line 531) | async function loadChatMessages(id) {
  function renderSessionHeader (line 550) | function renderSessionHeader(data) {
  function renderHistoryContext (line 554) | function renderHistoryContext(ctx) {
  function renderUserMsg (line 561) | function renderUserMsg(m) {
  function renderAssistantMsg (line 568) | function renderAssistantMsg(m) {
  function sendChatMessage (line 575) | async function sendChatMessage() {
  function streamChatResponse (line 598) | async function streamChatResponse(message, el) {
  function loadSettings (line 627) | async function loadSettings() {
  function loadBudget (line 652) | async function loadBudget() {
  function loadRouting (line 691) | async function loadRouting() {
  function loadProcess (line 717) | async function loadProcess() {
  function renderPIStats (line 740) | function renderPIStats(events, history, landscape) {
  function renderPIPatterns (line 749) | function renderPIPatterns(history) {
  function renderPIHealth (line 758) | function renderPIHealth(improve) {
  function renderPIActivity (line 783) | function renderPIActivity(activity) {
  function renderPIActions (line 809) | function renderPIActions() {
  function triggerAnalysis (line 820) | async function triggerAnalysis(type) {
  function showToast (line 839) | function showToast(msg) {
  function loadForge (line 848) | async function loadForge() {
  function checkSetup (line 886) | async function checkSetup() {
  function showSetupWizard (line 895) | function showSetupWizard(status) {
  function enterLocalMode (line 960) | function enterLocalMode() {
  function reloadConfig (line 978) | async function reloadConfig() {
  function autoConfigureSetup (line 992) | async function autoConfigureSetup() {
  function loadAll (line 1012) | async function loadAll() {

FILE: maggy/tests/conftest.py
  function tmp_dir (line 23) | def tmp_dir(tmp_path: Path) -> Path:
  function mock_cfg (line 28) | def mock_cfg(tmp_path: Path) -> MaggyConfig:

FILE: maggy/tests/integration/test_full_task_flow.py
  class TestFullTaskFlow (line 22) | class TestFullTaskFlow:
    method test_route_emit_reward (line 23) | def test_route_emit_reward(self, mock_cfg, tmp_path: Path):
    method test_multi_task_routing (line 70) | def test_multi_task_routing(self, mock_cfg):

FILE: maggy/tests/integration/test_model_fallback.py
  class TestModelFallback (line 12) | class TestModelFallback:
    method test_fatigue_triggers_checkpoint (line 13) | def test_fatigue_triggers_checkpoint(self):
    method test_cross_model_checkpoint_round_trip (line 41) | def test_cross_model_checkpoint_round_trip(self):
    method test_fresh_model_low_fatigue (line 59) | def test_fresh_model_low_fatigue(self):

FILE: maggy/tests/integration/test_process_loop.py
  class TestProcessLoop (line 20) | class TestProcessLoop:
    method test_cikg_gap_to_engram (line 21) | def test_cikg_gap_to_engram(self, tmp_path: Path):
    method test_lexon_to_engram (line 55) | def test_lexon_to_engram(self, tmp_path: Path):
    method test_full_diagnostics (line 78) | def test_full_diagnostics(self, tmp_path: Path):

FILE: maggy/tests/test_account_guide.py
  function test_account_profile_dataclass (line 12) | def test_account_profile_dataclass():
  function test_detect_accounts_finds_claude (line 22) | def test_detect_accounts_finds_claude(tmp_path):
  function test_detect_accounts_finds_codex (line 31) | def test_detect_accounts_finds_codex(tmp_path):
  function test_suggest_switch_anthropic (line 39) | def test_suggest_switch_anthropic():
  function test_suggest_switch_openai (line 46) | def test_suggest_switch_openai():

FILE: maggy/tests/test_activity.py
  class TestParseClaudeProcesses (line 20) | class TestParseClaudeProcesses:
    method test_detects_running_session (line 21) | def test_detects_running_session(self):
    method test_detects_agent_subprocess (line 36) | def test_detects_agent_subprocess(self):
    method test_ignores_non_cli_processes (line 55) | def test_ignores_non_cli_processes(self):
    method test_empty_input (line 63) | def test_empty_input(self):
  class TestRecentPrompts (line 67) | class TestRecentPrompts:
    method test_reads_claude_history (line 68) | def test_reads_claude_history(self, tmp_path: Path):
    method test_reads_codex_history (line 86) | def test_reads_codex_history(self, tmp_path: Path):
    method test_merges_and_sorts_by_time (line 102) | def test_merges_and_sorts_by_time(self, tmp_path: Path):
    method test_limits_output (line 120) | def test_limits_output(self, tmp_path: Path):
    method test_no_history_files (line 135) | def test_no_history_files(self, tmp_path: Path):
    method test_malformed_json_skipped (line 142) | def test_malformed_json_skipped(self, tmp_path: Path):
  class TestActivityService (line 157) | class TestActivityService:
    method test_get_activity_shape (line 158) | def test_get_activity_shape(self):
    method test_serializes_sessions (line 171) | def test_serializes_sessions(self):
    method test_serializes_prompts (line 193) | def test_serializes_prompts(self):

FILE: maggy/tests/test_api_endpoints.py
  function app_with_services (line 46) | def app_with_services(tmp_path: Path) -> FastAPI:
  function client (line 131) | def client(app_with_services: FastAPI) -> TestClient:
  class TestBudgetAPI (line 138) | class TestBudgetAPI:
    method test_get_budget_empty (line 139) | def test_get_budget_empty(self, client: TestClient):
    method test_budget_by_provider_empty (line 147) | def test_budget_by_provider_empty(self, client: TestClient):
    method test_budget_with_spend (line 152) | def test_budget_with_spend(
  class TestRoutingAPI (line 176) | class TestRoutingAPI:
    method test_heatmap_empty (line 177) | def test_heatmap_empty(self, client: TestClient):
    method test_decide_low_blast (line 182) | def test_decide_low_blast(self, client: TestClient):
    method test_decide_high_blast (line 191) | def test_decide_high_blast(self, client: TestClient):
    method test_heatmap_after_recording (line 198) | def test_heatmap_after_recording(
  class TestUsersAPI (line 208) | class TestUsersAPI:
    method test_create_user (line 209) | def test_create_user(self, client: TestClient):
  class TestEventsAPI (line 224) | class TestEventsAPI:
    method test_events_empty (line 225) | def test_events_empty(self, client: TestClient):
    method test_event_count_empty (line 230) | def test_event_count_empty(self, client: TestClient):
    method test_trace_empty (line 235) | def test_trace_empty(self, client: TestClient):
    method test_events_after_emit (line 240) | def test_events_after_emit(
  class TestCIKGAPI (line 265) | class TestCIKGAPI:
    method test_landscape_empty (line 266) | def test_landscape_empty(self, client: TestClient):
    method test_gaps_no_feature (line 272) | def test_gaps_no_feature(self, client: TestClient):
    method test_landscape_with_data (line 278) | def test_landscape_with_data(
  class TestPlanningAPI (line 304) | class TestPlanningAPI:
    method test_single_plan (line 305) | def test_single_plan(self, client: TestClient):
    method test_dual_plan (line 315) | def test_dual_plan(self, client: TestClient):
  class TestDeployAPI (line 328) | class TestDeployAPI:
    method test_sessions_empty (line 329) | def test_sessions_empty(self, client: TestClient):
    method test_create_and_get (line 334) | def test_create_and_get(self, client: TestClient):
    method test_missing_session (line 347) | def test_missing_session(self, client: TestClient):
  class TestForgeAPI (line 356) | class TestForgeAPI:
    method test_forge_status (line 357) | def test_forge_status(self, client: TestClient):
    method test_forge_search (line 364) | def test_forge_search(self, client: TestClient):
    method test_forge_gaps_empty (line 369) | def test_forge_gaps_empty(self, client: TestClient):
    method test_report_gap (line 374) | def test_report_gap(self, client: TestClient):
  class TestEngramAPI (line 391) | class TestEngramAPI:
    method test_query_empty (line 392) | def test_query_empty(self, client: TestClient):
    method test_diagnostics_empty (line 397) | def test_diagnostics_empty(self, client: TestClient):
    method test_query_with_data (line 403) | def test_query_with_data(
    method test_diagnostics_with_data (line 421) | def test_diagnostics_with_data(
  class TestLexonAPI (line 441) | class TestLexonAPI:
    method test_parse_known (line 442) | def test_parse_known(self, client: TestClient):
    method test_parse_unknown (line 449) | def test_parse_unknown(self, client: TestClient):
    method test_learn (line 456) | def test_learn(self, client: TestClient):
  class TestMeshAPI (line 472) | class TestMeshAPI:
    method test_mesh_status_enabled (line 473) | def test_mesh_status_enabled(self, client: TestClient):
    method test_mesh_peers_empty (line 481) | def test_mesh_peers_empty(self, client: TestClient):
    method test_mesh_networks (line 486) | def test_mesh_networks(self, client: TestClient):
    method test_mesh_quarantine_requires_org (line 493) | def test_mesh_quarantine_requires_org(
    method test_mesh_quarantine_with_org (line 500) | def test_mesh_quarantine_with_org(
    method test_mesh_add_peer (line 507) | def test_mesh_add_peer(self, client: TestClient):
  class TestUnconfiguredState (line 525) | class TestUnconfiguredState:
    method unconfigured_client (line 529) | def unconfigured_client(self) -> TestClient:
    method test_budget_unconfigured (line 559) | def test_budget_unconfigured(
    method test_routing_unconfigured (line 566) | def test_routing_unconfigured(
    method test_events_unconfigured (line 573) | def test_events_unconfigured(
    method test_mesh_unconfigured (line 579) | def test_mesh_unconfigured(
    method test_engram_unconfigured (line 586) | def test_engram_unconfigured(
    method test_lexon_unconfigured (line 592) | def test_lexon_unconfigured(
    method test_deploy_unconfigured (line 598) | def test_deploy_unconfigured(
    method test_forge_unconfigured (line 604) | def test_forge_unconfigured(
    method test_planning_unconfigured (line 610) | def test_planning_unconfigured(
    method test_cikg_unconfigured (line 619) | def test_cikg_unconfigured(
  class TestHistoryEndpoints (line 629) | class TestHistoryEndpoints:
    method test_providers (line 632) | def test_providers(self, client: TestClient):
    method test_analyze (line 637) | def test_analyze(self, client: TestClient):
    method test_report_empty (line 644) | def test_report_empty(self, client: TestClient):
    method test_sessions (line 648) | def test_sessions(self, client: TestClient):
    method test_sessions_filter (line 655) | def test_sessions_filter(self, client: TestClient):
  class TestDiscoveryEndpoint (line 665) | class TestDiscoveryEndpoint:
    method test_discovery_returns_data (line 666) | def test_discovery_returns_data(
    method test_health_has_mode (line 676) | def test_health_has_mode(
  class TestHeartbeatEndpoints (line 689) | class TestHeartbeatEndpoints:
    method test_status_no_scheduler (line 690) | def test_status_no_scheduler(self, client: TestClient):
    method test_trigger_no_scheduler (line 695) | def test_trigger_no_scheduler(self, client: TestClient):
    method test_status_with_scheduler (line 699) | def test_status_with_scheduler(
  class TestImproveEndpoints (line 718) | class TestImproveEndpoints:
    method test_report_empty (line 719) | def test_report_empty(self, client: TestClient):
    method test_analyze_returns_report (line 724) | def test_analyze_returns_report(
    method test_report_after_analyze (line 735) | def test_report_after_analyze(

FILE: maggy/tests/test_benchmark_scenario.py
  function _cfg (line 48) | def _cfg(tmp_path) -> MaggyConfig:
  class TestRoutingAccuracy (line 93) | class TestRoutingAccuracy:
    method test_all_10_tasks_route_correctly (line 96) | def test_all_10_tasks_route_correctly(self, tmp_path):
    method test_routing_accuracy_score (line 130) | def test_routing_accuracy_score(self, tmp_path):
  class TestBudgetEfficiency (line 167) | class TestBudgetEfficiency:
    method test_spend_distribution (line 168) | def test_spend_distribution(self, tmp_path):
  class TestFallbackResilience (line 198) | class TestFallbackResilience:
    method test_quota_recovery (line 200) | async def test_quota_recovery(self):
    method test_full_chain_failure (line 219) | async def test_full_chain_failure(self):
  class TestFatigueAwareness (line 233) | class TestFatigueAwareness:
    method test_progressive_fatigue (line 234) | def test_progressive_fatigue(self):
    method test_model_switch_degrades_fatigue (line 245) | def test_model_switch_degrades_fatigue(self):
    method test_critical_state_detection (line 256) | def test_critical_state_detection(self):
  class TestLockSafety (line 265) | class TestLockSafety:
    method test_concurrent_agent_protection (line 266) | def test_concurrent_agent_protection(self, tmp_path):
    method test_release_allows_reacquire (line 275) | def test_release_allows_reacquire(self, tmp_path):
    method test_release_all_by_session (line 281) | def test_release_all_by_session(self, tmp_path):
  class TestEscalation (line 292) | class TestEscalation:
    method test_auto_escalate_after_failures (line 293) | def test_auto_escalate_after_failures(self, tmp_path):
    method test_resolve_clears_pending (line 302) | def test_resolve_clears_pending(self, tmp_path):
  class TestCheckpointContinuity (line 311) | class TestCheckpointContinuity:
    method test_model_handoff_preserves_state (line 312) | def test_model_handoff_preserves_state(self, tmp_path):
    method test_checkpoint_cleanup (line 326) | def test_checkpoint_cleanup(self, tmp_path):
  class TestCalibrationLearning (line 336) | class TestCalibrationLearning:
    method test_bad_model_gets_penalized (line 337) | def test_bad_model_gets_penalized(self, tmp_path):
    method test_routing_penalizes_uncalibrated (line 352) | def test_routing_penalizes_uncalibrated(self, tmp_path):
  class TestDualPlanning (line 369) | class TestDualPlanning:
    method test_counter_check_runs (line 371) | async def test_counter_check_runs(self):
  class TestObservability (line 392) | class TestObservability:
    method test_signal_recording (line 393) | def test_signal_recording(self, tmp_path):
    method test_signal_log_jsonl (line 406) | def test_signal_log_jsonl(self, tmp_path):
  class TestFullExecutorPipeline (line 417) | class TestFullExecutorPipeline:
    method test_10_task_sprint (line 419) | async def test_10_task_sprint(self, tmp_path):
    method test_sprint_budget_summary (line 470) | async def test_sprint_budget_summary(self, tmp_path):
  class TestProjectRegistry (line 509) | class TestProjectRegistry:
    method test_full_lifecycle (line 510) | def test_full_lifecycle(self, tmp_path):

FILE: maggy/tests/test_bootstrap.py
  function _make_cfg (line 11) | def _make_cfg(tmp_path: Path):
  class TestSeedCIKG (line 30) | class TestSeedCIKG:
    method test_creates_codebase_nodes (line 33) | def test_creates_codebase_nodes(self, tmp_path):
    method test_creates_language_nodes (line 44) | def test_creates_language_nodes(self, tmp_path):
    method test_creates_edges (line 56) | def test_creates_edges(self, tmp_path):
    method test_skips_missing_dirs (line 66) | def test_skips_missing_dirs(self, tmp_path):
    method test_idempotent (line 77) | def test_idempotent(self, tmp_path):
  class TestBootstrap (line 88) | class TestBootstrap:
    method test_calls_services (line 92) | async def test_calls_services(self):
    method test_handles_missing_services (line 104) | async def test_handles_missing_services(self):
    method test_handles_analyze_error (line 114) | async def test_handles_analyze_error(self):

FILE: maggy/tests/test_budget.py
  class TestBudgetTracking (line 10) | class TestBudgetTracking:
    method test_initial_spend_is_zero (line 11) | def test_initial_spend_is_zero(self, mock_cfg):
    method test_record_and_read (line 15) | def test_record_and_read(self, mock_cfg):
    method test_multiple_records_sum (line 20) | def test_multiple_records_sum(self, mock_cfg):
  class TestBudgetStatus (line 27) | class TestBudgetStatus:
    method test_ok_status (line 28) | def test_ok_status(self, mock_cfg):
    method test_warning_status (line 34) | def test_warning_status(self, mock_cfg):
    method test_exhausted_status (line 40) | def test_exhausted_status(self, mock_cfg):
  class TestByProvider (line 47) | class TestByProvider:
    method test_breakdown (line 48) | def test_breakdown(self, mock_cfg):
  class TestIsExhausted (line 59) | class TestIsExhausted:
    method test_not_exhausted (line 60) | def test_not_exhausted(self, mock_cfg):
    method test_exhausted (line 64) | def test_exhausted(self, mock_cfg):
  class TestProviderBudgets (line 70) | class TestProviderBudgets:
    method test_provider_exhaustion_uses_provider_limit (line 71) | def test_provider_exhaustion_uses_provider_limit(self, mock_cfg):
    method test_cheapest_available_skips_exhausted_provider (line 84) | def test_cheapest_available_skips_exhausted_provider(self, mock_cfg):
  class TestTokenTracking (line 96) | class TestTokenTracking:
    method test_initial_tokens_zero (line 97) | def test_initial_tokens_zero(self, mock_cfg):
    method test_record_and_read_tokens (line 102) | def test_record_and_read_tokens(self, mock_cfg):
    method test_tokens_by_provider (line 110) | def test_tokens_by_provider(self, mock_cfg):
    method test_budget_status_includes_tokens (line 117) | def test_budget_status_includes_tokens(self, mock_cfg):
  class TestTaskSpendTracker (line 125) | class TestTaskSpendTracker:
    method test_records_total_cost (line 126) | def test_records_total_cost(self) -> None:
    method test_detects_exceeded_spend (line 132) | def test_detects_exceeded_spend(self) -> None:
    method test_tracks_edit_loops (line 137) | def test_tracks_edit_loops(self) -> None:
    method test_budget_config_has_task_limit (line 144) | def test_budget_config_has_task_limit(self) -> None:

FILE: maggy/tests/test_calibration.py
  function test_records_accuracy_and_error (line 10) | def test_records_accuracy_and_error(tmp_path) -> None:
  function test_unknown_model_returns_zero (line 19) | def test_unknown_model_returns_zero(tmp_path) -> None:
  function test_accuracy_clamps_at_zero_for_large_errors (line 25) | def test_accuracy_clamps_at_zero_for_large_errors(tmp_path) -> None:

FILE: maggy/tests/test_cascade.py
  class TestCascadeNoEscalation (line 11) | class TestCascadeNoEscalation:
    method test_first_model_passes (line 13) | async def test_first_model_passes(self):
  class TestCascadeEscalation (line 36) | class TestCascadeEscalation:
    method test_low_quality_escalates (line 38) | async def test_low_quality_escalates(self):
    method test_max_3_attempts (line 63) | async def test_max_3_attempts(self):
  class TestCascadeFailure (line 86) | class TestCascadeFailure:
    method test_send_failure_escalates (line 88) | async def test_send_failure_escalates(self):
    method test_single_model_no_escalation (line 114) | async def test_single_model_no_escalation(self):
  class TestCascadeAttemptTracking (line 134) | class TestCascadeAttemptTracking:
    method test_attempts_recorded (line 136) | async def test_attempts_recorded(self):

FILE: maggy/tests/test_chat.py
  function _make_cfg (line 12) | def _make_cfg(tmp_path: Path) -> MaggyConfig:
  class TestChatManager (line 20) | class TestChatManager:
    method test_create_session (line 23) | def test_create_session(self, tmp_path):
    method test_create_session_invalid_project (line 35) | def test_create_session_invalid_project(self, tmp_path):
    method test_create_with_project_path (line 42) | def test_create_with_project_path(self, tmp_path):
    method test_create_rejects_outside_path (line 53) | def test_create_rejects_outside_path(self, tmp_path):
    method test_list_sessions (line 62) | def test_list_sessions(self, tmp_path):
    method test_get_session (line 71) | def test_get_session(self, tmp_path):
    method test_get_missing_session (line 80) | def test_get_missing_session(self, tmp_path):
    method test_build_cmd_new_session (line 86) | def test_build_cmd_new_session(self, tmp_path):
    method test_build_cmd_resume (line 99) | def test_build_cmd_resume(self, tmp_path):
    method test_delete_session (line 111) | def test_delete_session(self, tmp_path):
    method test_delete_missing (line 119) | def test_delete_missing(self, tmp_path):
    method test_working_dir_security_bad_key (line 125) | def test_working_dir_security_bad_key(self, tmp_path):
    method test_working_dir_security_bad_path (line 132) | def test_working_dir_security_bad_path(self, tmp_path):
  class TestAutoConnect (line 140) | class TestAutoConnect:
    method test_auto_connect_creates_sessions (line 143) | def test_auto_connect_creates_sessions(self, tmp_path):
    method test_auto_connect_deduplicates (line 155) | def test_auto_connect_deduplicates(self, tmp_path):
    method test_auto_connect_multiple_projects (line 167) | def test_auto_connect_multiple_projects(self, tmp_path):
    method test_auto_connect_skips_empty (line 187) | def test_auto_connect_skips_empty(self, tmp_path):
    method test_find_by_project (line 199) | def test_find_by_project(self, tmp_path):
    method test_find_by_project_missing (line 208) | def test_find_by_project_missing(self, tmp_path):
  class TestMessageQueue (line 215) | class TestMessageQueue:
    method test_enqueue_returns_position (line 218) | def test_enqueue_returns_position(self, tmp_path):
    method test_enqueue_full_returns_negative (line 226) | def test_enqueue_full_returns_negative(self, tmp_path):
    method test_session_has_pending_queue (line 235) | def test_session_has_pending_queue(self, tmp_path):
    method test_send_while_locked_enqueues (line 244) | async def test_send_while_locked_enqueues(self, tmp_path):

FILE: maggy/tests/test_chat_context.py
  class TestPathCandidates (line 20) | class TestPathCandidates:
    method test_basic_path (line 23) | def test_basic_path(self):
    method test_nested_path (line 32) | def test_nested_path(self):
    method test_empty_path (line 41) | def test_empty_path(self):
  class TestMatchFromReport (line 46) | class TestMatchFromReport:
    method test_exact_project_match (line 49) | def test_exact_project_match(self):
    method test_parent_dir_match (line 68) | def test_parent_dir_match(self):
    method test_multiple_matches (line 90) | def test_multiple_matches(self):
    method test_no_match (line 118) | def test_no_match(self):
  class TestMatchHistory (line 132) | class TestMatchHistory:
    method test_uses_report_when_available (line 135) | def test_uses_report_when_available(self):
    method test_returns_empty_when_no_history (line 153) | def test_returns_empty_when_no_history(self):
    method test_returns_empty_when_no_report (line 159) | def test_returns_empty_when_no_report(self):
  class TestFormatRecentPrompts (line 168) | class TestFormatRecentPrompts:
    method test_matching_prompts (line 171) | def test_matching_prompts(self):
    method test_no_matching_prompts (line 182) | def test_no_matching_prompts(self):
    method test_limits_to_five (line 190) | def test_limits_to_five(self):
  class TestResolveSessionId (line 200) | class TestResolveSessionId:
    method test_finds_session_id (line 203) | def test_finds_session_id(self, tmp_path):
    method test_no_match (line 229) | def test_no_match(self, tmp_path):
    method test_missing_file (line 247) | def test_missing_file(self, tmp_path):
  class TestBuildProjectContext (line 257) | class TestBuildProjectContext:
    method test_combines_history_and_prompts (line 260) | def test_combines_history_and_prompts(self):
    method test_empty_when_nothing (line 283) | def test_empty_when_nothing(self):

FILE: maggy/tests/test_chat_routed.py
  class TestBlastEstimation (line 12) | class TestBlastEstimation:
    method test_low_blast_simple_fix (line 15) | def test_low_blast_simple_fix(self):
    method test_high_blast_security (line 18) | def test_high_blast_security(self):
    method test_high_blast_architecture (line 21) | def test_high_blast_architecture(self):
    method test_medium_blast_feature (line 24) | def test_medium_blast_feature(self):
    method test_empty_returns_default (line 28) | def test_empty_returns_default(self):
    method test_retrieval_find_key_low_blast (line 33) | def test_retrieval_find_key_low_blast(self):
    method test_retrieval_show_config (line 37) | def test_retrieval_show_config(self):
    method test_retrieval_check_env (line 40) | def test_retrieval_check_env(self):
    method test_retrieval_where_is_file (line 43) | def test_retrieval_where_is_file(self):
    method test_retrieval_list_endpoints (line 46) | def test_retrieval_list_endpoints(self):
    method test_retrieval_read_file (line 49) | def test_retrieval_read_file(self):
    method test_creation_still_mid (line 52) | def test_creation_still_mid(self):
    method test_multi_step_high (line 57) | def test_multi_step_high(self):
    method test_retrieval_with_action_not_capped (line 61) | def test_retrieval_with_action_not_capped(self):
  class TestTypeEstimation (line 67) | class TestTypeEstimation:
    method test_security_type (line 70) | def test_security_type(self):
    method test_docs_type (line 73) | def test_docs_type(self):
    method test_test_type (line 76) | def test_test_type(self):
    method test_general_default (line 79) | def test_general_default(self):
  class TestRoutedEndpoint (line 83) | class TestRoutedEndpoint:
    method test_send_routed_yields_routing_chunk (line 87) | async def test_send_routed_yields_routing_chunk(self):
  class TestRewardRecording (line 106) | class TestRewardRecording:
    method test_success_records_reward (line 109) | def test_success_records_reward(self):
    method test_error_records_zero_reward (line 121) | def test_error_records_zero_reward(self):
    method test_no_routing_service_noop (line 133) | def test_no_routing_service_noop(self):

FILE: maggy/tests/test_chat_router.py
  function test_blast_hi_scores_low (line 12) | def test_blast_hi_scores_low():
  function test_blast_exit_scores_low (line 17) | def test_blast_exit_scores_low():
  function test_blast_empty_returns_default (line 22) | def test_blast_empty_returns_default():
  function test_blast_security_audit_scores_high (line 27) | def test_blast_security_audit_scores_high():
  function test_blast_fix_typo_scores_low (line 33) | def test_blast_fix_typo_scores_low():
  function test_type_security_detected (line 39) | def test_type_security_detected():
  function test_type_general_default (line 44) | def test_type_general_default():
  function test_type_search_detected (line 49) | def test_type_search_detected():
  function test_type_search_grep (line 54) | def test_type_search_grep():
  function test_blast_search_scores_low (line 59) | def test_blast_search_scores_low():

FILE: maggy/tests/test_chat_stream.py
  class _FakeSession (line 10) | class _FakeSession:
    method __init__ (line 11) | def __init__(self):
  function test_parse_result_extracts_usage (line 15) | def test_parse_result_extracts_usage():
  function test_parse_result_without_usage (line 31) | def test_parse_result_without_usage():
  function test_parse_assistant_text (line 40) | def test_parse_assistant_text():
  function test_parse_captures_session_id (line 51) | def test_parse_captures_session_id():
  function test_parse_result_zero_cost_preserved (line 58) | def test_parse_result_zero_cost_preserved():
  function test_parse_invalid_json (line 73) | def test_parse_invalid_json():

FILE: maggy/tests/test_checkpoint.py
  class TestCheckpoint (line 11) | class TestCheckpoint:
    method test_serialize_round_trip (line 12) | def test_serialize_round_trip(self):
    method test_serialize_sets_timestamp (line 24) | def test_serialize_sets_timestamp(self):
    method test_to_prompt_format (line 30) | def test_to_prompt_format(self):
    method test_to_prompt_minimal (line 45) | def test_to_prompt_minimal(self):
  class TestCreateCheckpoint (line 52) | class TestCreateCheckpoint:
    method test_helper_function (line 53) | def test_helper_function(self):
    method test_defaults (line 66) | def test_defaults(self):

FILE: maggy/tests/test_checkpoint_mgr.py
  function _checkpoint (line 8) | def _checkpoint() -> dict:
  class TestCheckpointManager (line 19) | class TestCheckpointManager:
    method test_write_and_read (line 20) | def test_write_and_read(self, tmp_path) -> None:
    method test_read_missing_returns_none (line 26) | def test_read_missing_returns_none(self, tmp_path) -> None:
    method test_delete_returns_true_when_removed (line 30) | def test_delete_returns_true_when_removed(self, tmp_path) -> None:
    method test_list_checkpoints_returns_session_ids (line 37) | def test_list_checkpoints_returns_session_ids(self, tmp_path) -> None:
    method test_path_traversal_rejected (line 44) | def test_path_traversal_rejected(self, tmp_path) -> None:
    method test_read_corrupt_json_returns_none (line 50) | def test_read_corrupt_json_returns_none(self, tmp_path) -> None:

FILE: maggy/tests/test_cikg.py
  class TestKnowledgeGraph (line 20) | class TestKnowledgeGraph:
    method test_add_and_get_node (line 21) | def test_add_and_get_node(self, tmp_path: Path):
    method test_get_missing_node (line 31) | def test_get_missing_node(self, tmp_path: Path):
    method test_list_nodes_by_type (line 35) | def test_list_nodes_by_type(self, tmp_path: Path):
    method test_list_all_nodes (line 43) | def test_list_all_nodes(self, tmp_path: Path):
  class TestEdges (line 50) | class TestEdges:
    method test_add_and_get_edge (line 51) | def test_add_and_get_edge(self, tmp_path: Path):
    method test_inbound_edges (line 63) | def test_inbound_edges(self, tmp_path: Path):
    method test_neighbors (line 75) | def test_neighbors(self, tmp_path: Path):
  class TestDeleteNode (line 88) | class TestDeleteNode:
    method test_delete_removes_node_and_edges (line 89) | def test_delete_removes_node_and_edges(self, tmp_path: Path):
  class TestQueries (line 102) | class TestQueries:
    method _seed_graph (line 103) | def _seed_graph(self, tmp_path: Path) -> KnowledgeGraphService:
    method test_find_gaps_existing (line 121) | def test_find_gaps_existing(self, tmp_path: Path):
    method test_find_gaps_unknown (line 128) | def test_find_gaps_unknown(self, tmp_path: Path):
    method test_get_landscape (line 135) | def test_get_landscape(self, tmp_path: Path):
    method test_compare_entities (line 142) | def test_compare_entities(self, tmp_path: Path):
  class TestServiceQueries (line 148) | class TestServiceQueries:
    method _seed_graph (line 149) | def _seed_graph(self, tmp_path: Path) -> KnowledgeGraphService:
    method test_find_gaps_raw (line 171) | def test_find_gaps_raw(self, tmp_path: Path):
    method test_compare_entities (line 184) | def test_compare_entities(self, tmp_path: Path):
    method test_segment_landscape (line 192) | def test_segment_landscape(self, tmp_path: Path):
  class TestTypeValidation (line 202) | class TestTypeValidation:
    method test_valid_node_type_accepted (line 203) | def test_valid_node_type_accepted(self):
    method test_invalid_node_type_rejected (line 207) | def test_invalid_node_type_rejected(self):
    method test_valid_edge_type_accepted (line 211) | def test_valid_edge_type_accepted(self):
    method test_invalid_edge_type_rejected (line 215) | def test_invalid_edge_type_rejected(self):

FILE: maggy/tests/test_cli.py
  function _mock_server_running (line 21) | def _mock_server_running(monkeypatch):
  function _mock_get (line 29) | def _mock_get(response_json: dict | list):
  function test_status_shows_health (line 41) | def test_status_shows_health():
  function test_status_json_flag (line 55) | def test_status_json_flag():
  function test_inbox_renders_table (line 67) | def test_inbox_renders_table():
  function test_inbox_empty (line 81) | def test_inbox_empty():
  function test_sessions_renders (line 91) | def test_sessions_renders():
  function test_route_decision (line 107) | def test_route_decision():
  function test_budget_renders (line 123) | def test_budget_renders():
  function test_competitors_news (line 141) | def test_competitors_news():
  function test_models_heatmap (line 154) | def test_models_heatmap():
  function test_server_not_running_starts_it (line 168) | def test_server_not_running_starts_it(monkeypatch):
  function test_stale_port_killed_before_start (line 193) | def test_stale_port_killed_before_start(monkeypatch):
  function test_server_log_written_to_file (line 227) | def test_server_log_written_to_file(monkeypatch, tmp_path):

FILE: maggy/tests/test_cli_chat.py
  function _no_detect (line 40) | def _no_detect(monkeypatch):
  function _setup_new (line 49) | def _setup_new(mock_client):
  function test_chat_creates_session (line 62) | def test_chat_creates_session(mock_client):
  function test_chat_resumes_existing (line 74) | def test_chat_resumes_existing(mock_client):
  function test_chat_routed_streams (line 92) | def test_chat_routed_streams(mock_client):
  function test_chat_direct_mode (line 111) | def test_chat_direct_mode(mock_client):
  function test_chat_history_command (line 130) | def test_chat_history_command(mock_client):
  function test_chat_blast_override (line 140) | def test_chat_blast_override(mock_client):
  function test_chat_ctrl_c_exits (line 159) | def test_chat_ctrl_c_exits(mock_client):
  function test_chat_empty_input_ignored (line 168) | def test_chat_empty_input_ignored(mock_client):
  function test_chat_error_displayed (line 178) | def test_chat_error_displayed(mock_client):
  function test_chat_shows_queued_status (line 191) | def test_chat_shows_queued_status(mock_client):
  function test_chat_shows_warning (line 203) | def test_chat_shows_warning(mock_client):
  function test_chat_exit_word_quits (line 217) | def test_chat_exit_word_quits(mock_client):
  function test_chat_agent_status_rendered (line 228) | def test_chat_agent_status_rendered(mock_client):
  function test_chat_quota_error_shows_guide (line 245) | def test_chat_quota_error_shows_guide(mock_client):
  function test_chat_prompt_uses_angle_bracket (line 262) | def test_chat_prompt_uses_angle_bracket(mock_client):
  function test_screenshot_command_dispatches (line 274) | def test_screenshot_command_dispatches(mock_client):

FILE: maggy/tests/test_cli_discovery.py
  function test_discover_all_returns_profiles (line 12) | def test_discover_all_returns_profiles():
  function test_claude_discovered (line 19) | def test_claude_discovered():
  function test_codex_discovered (line 29) | def test_codex_discovered():
  function test_kimi_discovered (line 38) | def test_kimi_discovered():
  function test_missing_cli (line 47) | def test_missing_cli():
  function test_claude_build_command (line 52) | def test_claude_build_command():
  function test_codex_build_command (line 66) | def test_codex_build_command():
  function test_kimi_build_command (line 79) | def test_kimi_build_command():
  function test_ollama_discovered (line 92) | def test_ollama_discovered():
  function test_ollama_build_command (line 100) | def test_ollama_build_command():
  function test_pi_adapter_uses_discovery (line 111) | def test_pi_adapter_uses_discovery():

FILE: maggy/tests/test_cli_sessions.py
  function test_spawn_creates_session (line 15) | def test_spawn_creates_session(mock_client):
  function test_ps_lists_sessions (line 30) | def test_ps_lists_sessions(mock_client):
  function test_kill_stops_session (line 48) | def test_kill_stops_session(mock_client):

FILE: maggy/tests/test_cli_welcome.py
  function _mock_client (line 10) | def _mock_client():
  function test_render_welcome_shows_project (line 33) | def test_render_welcome_shows_project(capsys):
  function test_render_welcome_shows_budget (line 39) | def test_render_welcome_shows_budget(capsys):
  function test_render_welcome_shows_models (line 45) | def test_render_welcome_shows_models(capsys):
  function test_render_welcome_shows_health (line 51) | def test_render_welcome_shows_health(capsys):
  function test_render_welcome_shows_session_history (line 60) | def test_render_welcome_shows_session_history(capsys):
  function test_dir_shows_cwd_fallback (line 68) | def test_dir_shows_cwd_fallback(capsys):
  function test_models_shows_available_count (line 79) | def test_models_shows_available_count(capsys):
  function test_budget_subscription_welcome (line 88) | def test_budget_subscription_welcome(capsys):

FILE: maggy/tests/test_context_compactor.py
  class TestEstimateTokens (line 14) | class TestEstimateTokens:
    method test_empty_list (line 15) | def test_empty_list(self):
    method test_single_message (line 18) | def test_single_message(self):
    method test_approximation (line 22) | def test_approximation(self):
  class TestShouldCompact (line 28) | class TestShouldCompact:
    method test_below_threshold_no_compact (line 29) | def test_below_threshold_no_compact(self):
    method test_above_threshold_compact (line 33) | def test_above_threshold_compact(self):
    method test_threshold_at_80_pct (line 38) | def test_threshold_at_80_pct(self):
  class TestCompact (line 44) | class TestCompact:
    method test_keeps_recent_messages (line 46) | async def test_keeps_recent_messages(self):
    method test_nothing_to_compact (line 64) | async def test_nothing_to_compact(self):
    method test_summarizer_failure_passthrough (line 76) | async def test_summarizer_failure_passthrough(self):

FILE: maggy/tests/test_contracts.py
  function test_generates_test_code_from_postcondition (line 8) | def test_generates_test_code_from_postcondition() -> None:

FILE: maggy/tests/test_convention_inferrer.py
  function test_collect_fingerprint_includes_files (line 19) | def test_collect_fingerprint_includes_files(tmp_path: Path):
  function test_collect_fingerprint_excludes_noise (line 28) | def test_collect_fingerprint_excludes_noise(tmp_path: Path):
  function test_collect_fingerprint_includes_config (line 40) | def test_collect_fingerprint_includes_config(tmp_path: Path):
  function test_collect_fingerprint_includes_git_log (line 46) | def test_collect_fingerprint_includes_git_log(tmp_path: Path):
  function test_parse_conventions_from_llm_output (line 58) | def test_parse_conventions_from_llm_output():
  function test_parse_ignores_non_convention_lines (line 66) | def test_parse_ignores_non_convention_lines():
  function test_parse_caps_at_10 (line 73) | def test_parse_caps_at_10():
  function test_parse_empty_response (line 78) | def test_parse_empty_response():
  function _seed_project (line 83) | def _seed_project(tmp_path: Path) -> None:
  function test_infer_calls_local_model (line 89) | async def test_infer_calls_local_model(tmp_path: Path):
  function test_infer_falls_back_on_local_failure (line 105) | async def test_infer_falls_back_on_local_failure(tmp_path: Path):
  function test_infer_returns_empty_on_all_failures (line 123) | async def test_infer_returns_empty_on_all_failures(tmp_path: Path):
  function test_ensure_inferred_caches (line 135) | async def test_ensure_inferred_caches(tmp_path: Path):
  function test_ensure_inferred_deduplicates (line 152) | async def test_ensure_inferred_deduplicates(tmp_path: Path):
  function test_all_inferred_have_llm_source (line 170) | async def test_all_inferred_have_llm_source(tmp_path: Path):

FILE: maggy/tests/test_convention_scanner.py
  function test_detects_supabase_migrations (line 14) | def test_detects_supabase_migrations(tmp_path: Path):
  function test_detects_alembic (line 22) | def test_detects_alembic(tmp_path: Path):
  function test_detects_npm (line 30) | def test_detects_npm(tmp_path: Path):
  function test_detects_pnpm (line 38) | def test_detects_pnpm(tmp_path: Path):
  function test_detects_pytest_in_pyproject (line 46) | def test_detects_pytest_in_pyproject(tmp_path: Path):
  function test_detects_ruff_in_pyproject (line 56) | def test_detects_ruff_in_pyproject(tmp_path: Path):
  function test_empty_dir_no_conventions (line 64) | def test_empty_dir_no_conventions(tmp_path: Path):
  function test_all_conventions_have_auto_source (line 70) | def test_all_conventions_have_auto_source(tmp_path: Path):
  function test_conventions_for_merges_project (line 78) | def test_conventions_for_merges_project():
  function test_conventions_for_without_project (line 95) | def test_conventions_for_without_project():
  function test_ensure_scanned_caches (line 112) | def test_ensure_scanned_caches(tmp_path: Path):
  function test_yaml_roundtrip_project_conventions (line 123) | def test_yaml_roundtrip_project_conventions(tmp_path: Path):
  function test_detects_docker_compose (line 145) | def test_detects_docker_compose(tmp_path: Path):
  function test_detects_github_actions (line 153) | def test_detects_github_actions(tmp_path: Path):

FILE: maggy/tests/test_coordination.py
  class TestLockManager (line 11) | class TestLockManager:
    method test_acquire_and_release (line 12) | def test_acquire_and_release(self, tmp_path):
    method test_blocks_other_agent (line 18) | def test_blocks_other_agent(self, tmp_path):
    method test_release_all_returns_count (line 23) | def test_release_all_returns_count(self, tmp_path):
    method test_conflicts_returns_locked_paths (line 31) | def test_conflicts_returns_locked_paths(self, tmp_path):
    method test_expired_locks_are_removed (line 38) | def test_expired_locks_are_removed(self, tmp_path):

FILE: maggy/tests/test_deploy.py
  class TestDeployService (line 8) | class TestDeployService:
    method test_create_session (line 9) | def test_create_session(self):
    method test_get_session (line 16) | def test_get_session(self):
    method test_get_missing_session (line 23) | def test_get_missing_session(self):
    method test_list_sessions (line 27) | def test_list_sessions(self):
    method test_update_status (line 34) | def test_update_status(self):
    method test_update_missing_returns_none (line 44) | def test_update_missing_returns_none(self):
    method test_teardown (line 48) | def test_teardown(self):
    method test_teardown_missing (line 54) | def test_teardown_missing(self):

FILE: maggy/tests/test_discovery.py
  class TestDiscoverLocal (line 23) | class TestDiscoverLocal:
    method test_empty_project (line 24) | def test_empty_project(self, tmp_path: Path):
    method test_detects_github_actions (line 31) | def test_detects_github_actions(self, tmp_path: Path):
    method test_detects_jenkins (line 36) | def test_detects_jenkins(self, tmp_path: Path):
    method test_detects_circleci (line 41) | def test_detects_circleci(self, tmp_path: Path):
    method test_detects_gitlab_ci (line 46) | def test_detects_gitlab_ci(self, tmp_path: Path):
    method test_detects_eslint (line 51) | def test_detects_eslint(self, tmp_path: Path):
    method test_detects_ruff_in_pyproject (line 56) | def test_detects_ruff_in_pyproject(self, tmp_path: Path):
    method test_detects_pre_commit (line 62) | def test_detects_pre_commit(self, tmp_path: Path):
    method test_detects_codeowners (line 67) | def test_detects_codeowners(self, tmp_path: Path):
    method test_detects_dependabot (line 72) | def test_detects_dependabot(self, tmp_path: Path):
    method test_detects_renovate (line 78) | def test_detects_renovate(self, tmp_path: Path):
  class TestDiscoverClis (line 87) | class TestDiscoverClis:
    method test_finds_installed (line 88) | def test_finds_installed(self):
    method test_finds_none (line 96) | def test_finds_none(self):
    method test_finds_all (line 101) | def test_finds_all(self):
  class TestDiscoverRepos (line 111) | class TestDiscoverRepos:
    method test_finds_git_repos (line 112) | def test_finds_git_repos(self, tmp_path: Path):
    method test_skips_hidden_dirs (line 123) | def test_skips_hidden_dirs(self, tmp_path: Path):
    method test_depth_limited (line 133) | def test_depth_limited(self, tmp_path: Path):
    method test_max_30_repos (line 142) | def test_max_30_repos(self, tmp_path: Path):
    method test_no_scan_dirs (line 153) | def test_no_scan_dirs(self, tmp_path: Path):
  class TestDiscoverActiveProjects (line 161) | class TestDiscoverActiveProjects:
    method test_parses_history (line 162) | def test_parses_history(self, tmp_path: Path):
    method test_no_history_file (line 176) | def test_no_history_file(self, tmp_path: Path):
    method test_malformed_json (line 180) | def test_malformed_json(self, tmp_path: Path):
  class TestDiscoverEnvTokens (line 191) | class TestDiscoverEnvTokens:
    method test_detects_tokens (line 192) | def test_detects_tokens(self):
    method test_no_env_tokens (line 199) | def test_no_env_tokens(self):
  class TestParseOrgFromUrl (line 211) | class TestParseOrgFromUrl:
    method test_ssh_url (line 212) | def test_ssh_url(self):
    method test_https_url (line 216) | def test_https_url(self):
    method test_non_github (line 220) | def test_non_github(self):
  class TestFullDiscovery (line 228) | class TestFullDiscovery:
    method test_returns_result (line 229) | def test_returns_result(self, tmp_path: Path):
    method test_populates_repos (line 235) | def test_populates_repos(self, tmp_path: Path):

FILE: maggy/tests/test_dual_planner.py
  function _result (line 13) | def _result(output: str) -> RunResult:
  function test_plan_uses_claude_prompt (line 18) | async def test_plan_uses_claude_prompt() -> None:
  function test_counter_check_uses_codex_prompt (line 36) | async def test_counter_check_uses_codex_prompt() -> None:
  function test_dual_plan_collects_conflicts (line 53) | async def test_dual_plan_collects_conflicts() -> None:

FILE: maggy/tests/test_engram.py
  class TestEngramRecord (line 13) | class TestEngramRecord:
    method test_defaults (line 14) | def test_defaults(self):
    method test_supersede (line 22) | def test_supersede(self):
  class TestEngramStore (line 32) | class TestEngramStore:
    method test_write_and_get (line 33) | def test_write_and_get(self, tmp_path: Path):
    method test_get_missing (line 44) | def test_get_missing(self, tmp_path: Path):
    method test_query_by_namespace (line 48) | def test_query_by_namespace(self, tmp_path: Path):
    method test_query_by_type (line 62) | def test_query_by_type(self, tmp_path: Path):
    method test_count (line 75) | def test_count(self, tmp_path: Path):
  class TestRetrieval (line 86) | class TestRetrieval:
    method _seed (line 87) | def _seed(self, tmp_path: Path) -> EngramStore:
    method test_by_keyword (line 101) | def test_by_keyword(self, tmp_path: Path):
    method test_by_tag (line 107) | def test_by_tag(self, tmp_path: Path):
    method test_by_type (line 113) | def test_by_type(self, tmp_path: Path):
    method test_recent (line 119) | def test_recent(self, tmp_path: Path):
  class TestDiagnostics (line 126) | class TestDiagnostics:
    method test_empty_store (line 127) | def test_empty_store(self, tmp_path: Path):
    method test_healthy_store (line 132) | def test_healthy_store(self, tmp_path: Path):
  class TestEngramSeed (line 147) | class TestEngramSeed:
    method test_seed_writes_all_types (line 150) | def test_seed_writes_all_types(self, tmp_path: Path):
    method test_seed_gives_healthy_score (line 160) | def test_seed_gives_healthy_score(self, tmp_path: Path):
    method test_seed_fills_missing_types (line 167) | def test_seed_fills_missing_types(self, tmp_path: Path):
    method test_seed_skips_when_all_types_present (line 182) | def test_seed_skips_when_all_types_present(self, tmp_path: Path):

FILE: maggy/tests/test_escalation.py
  class TestEscalator (line 8) | class TestEscalator:
    method test_escalate_and_get (line 9) | def test_escalate_and_get(self, tmp_path):
    method test_list_pending_returns_unresolved (line 25) | def test_list_pending_returns_unresolved(self, tmp_path):
    method test_resolve_marks_packet (line 33) | def test_resolve_marks_packet(self, tmp_path):

FILE: maggy/tests/test_event_spine.py
  class TestEventHeader (line 19) | class TestEventHeader:
    method test_defaults (line 20) | def test_defaults(self):
    method test_custom_fields (line 28) | def test_custom_fields(self):
  class TestTypedEvents (line 39) | class TestTypedEvents:
    method test_all_eight_types (line 40) | def test_all_eight_types(self):
    method test_intent_event (line 43) | def test_intent_event(self):
    method test_execution_event (line 51) | def test_execution_event(self):
    method test_outcome_event (line 60) | def test_outcome_event(self):
  class TestEventStore (line 66) | class TestEventStore:
    method test_write_and_query (line 67) | def test_write_and_query(self, tmp_path: Path):
    method test_query_by_type (line 74) | def test_query_by_type(self, tmp_path: Path):
    method test_count (line 83) | def test_count(self, tmp_path: Path):
    method test_limit (line 93) | def test_limit(self, tmp_path: Path):
  class TestEventEmitter (line 102) | class TestEventEmitter:
    method test_emit_returns_id (line 103) | def test_emit_returns_id(self, tmp_path: Path):
    method test_emit_invalid_raises (line 110) | def test_emit_invalid_raises(self, tmp_path: Path):
    method test_trace (line 117) | def test_trace(self, tmp_path: Path):
    method test_count (line 129) | def test_count(self, tmp_path: Path):
    method test_query_by_project (line 136) | def test_query_by_project(self, tmp_path: Path):

FILE: maggy/tests/test_executor_routing.py
  function _session (line 17) | def _session() -> dict[str, str]:
  function _task (line 30) | def _task(blast_score: int, task_type: str) -> Task:
  function _ctx (line 43) | def _ctx(session: dict, task: Task, wd: str) -> SessionCtx:
  function _patch_executor (line 47) | def _patch_executor(executor, monkeypatch):
  function test_plan_mode_routes_high_blast_to_claude (line 68) | async def test_plan_mode_routes_high_blast_to_claude(
  function test_plan_records_spend (line 97) | async def test_plan_records_spend(mock_cfg, tmp_path, monkeypatch):
  function test_tdd_high_blast_calls_dual_planner (line 124) | async def test_tdd_high_blast_calls_dual_planner(
  function test_locks_released_after_run (line 145) | async def test_locks_released_after_run(
  function test_fatigue_tracked (line 162) | async def test_fatigue_tracked(mock_cfg, tmp_path, monkeypatch):
  function test_conventions_in_prompts (line 175) | async def test_conventions_in_prompts(
  function test_tdd_calls_reviewer (line 205) | async def test_tdd_calls_reviewer(mock_cfg, tmp_path, monkeypatch):
  function test_review_retry_on_low_score (line 227) | async def test_review_retry_on_low_score(
  function test_status_callback_fires (line 253) | async def test_status_callback_fires(
  function test_status_shows_model_name (line 273) | async def test_status_shows_model_name(

FILE: maggy/tests/test_fatigue.py
  class TestFatigueProfile (line 13) | class TestFatigueProfile:
    method test_zero_usage_no_fatigue (line 14) | def test_zero_usage_no_fatigue(self):
    method test_full_context_high_fatigue (line 19) | def test_full_context_high_fatigue(self):
    method test_half_context_moderate_fatigue (line 26) | def test_half_context_moderate_fatigue(self):
    method test_zero_context_window_safe (line 34) | def test_zero_context_window_safe(self):
  class TestShouldCheckpoint (line 39) | class TestShouldCheckpoint:
    method test_below_threshold (line 40) | def test_below_threshold(self):
    method test_above_threshold (line 47) | def test_above_threshold(self):
    method test_custom_threshold (line 54) | def test_custom_threshold(self):
  class TestCreateProfile (line 62) | class TestCreateProfile:
    method test_known_model (line 63) | def test_known_model(self):
    method test_unknown_model_defaults (line 67) | def test_unknown_model_defaults(self):
  class TestCompareFatigue (line 72) | class TestCompareFatigue:
    method test_sorted_by_fatigue (line 73) | def test_sorted_by_fatigue(self):

FILE: maggy/tests/test_forge.py
  class TestForgeRegistry (line 12) | class TestForgeRegistry:
    method test_empty_without_forge (line 13) | def test_empty_without_forge(self):
    method test_loads_from_forge_path (line 17) | def test_loads_from_forge_path(self):
    method test_search (line 24) | def test_search(self):
    method test_get_missing (line 32) | def test_get_missing(self):
    method test_set_enabled (line 36) | def test_set_enabled(self):
  class TestGapDetector (line 44) | class TestGapDetector:
    method test_first_record_no_trigger (line 45) | def test_first_record_no_trigger(self):
    method test_trigger_at_threshold (line 49) | def test_trigger_at_threshold(self):
    method test_no_double_trigger (line 55) | def test_no_double_trigger(self):
    method test_list_gaps (line 61) | def test_list_gaps(self):
    method test_reset (line 71) | def test_reset(self):
  class TestForgeConnector (line 80) | class TestForgeConnector:
    method test_status (line 81) | def test_status(self):
    method test_report_gap (line 87) | def test_report_gap(self):
    method test_search_tools_empty (line 92) | def test_search_tools_empty(self):
    method test_with_real_forge (line 96) | def test_with_real_forge(self):

FILE: maggy/tests/test_heartbeat.py
  class TestJob (line 16) | class TestJob:
    method test_defaults (line 17) | def test_defaults(self):
    method test_is_due_no_last_run (line 27) | def test_is_due_no_last_run(self):
    method test_is_due_after_interval (line 32) | def test_is_due_after_interval(self):
    method test_not_due_before_interval (line 40) | def test_not_due_before_interval(self):
  class TestSchedulerRegister (line 51) | class TestSchedulerRegister:
    method test_register_job (line 52) | def test_register_job(self):
    method test_register_duplicate_raises (line 58) | def test_register_duplicate_raises(self):
    method test_status_returns_list (line 65) | def test_status_returns_list(self):
  class TestSchedulerTick (line 76) | class TestSchedulerTick:
    method test_tick_runs_due_jobs (line 78) | async def test_tick_runs_due_jobs(self):
    method test_tick_skips_disabled (line 86) | async def test_tick_skips_disabled(self):
    method test_tick_records_error (line 95) | async def test_tick_records_error(self):
    method test_tick_increments_count (line 103) | async def test_tick_increments_count(self):
  class TestSchedulerTrigger (line 112) | class TestSchedulerTrigger:
    method test_trigger_runs_job (line 114) | async def test_trigger_runs_job(self):
    method test_trigger_unknown_raises (line 123) | async def test_trigger_unknown_raises(self):
  class TestSchedulerLifecycle (line 129) | class TestSchedulerLifecycle:
    method test_start_stop (line 131) | async def test_start_stop(self):
  class TestJobs (line 146) | class TestJobs:
    method test_refresh_history_calls_analyze (line 148) | async def test_refresh_history_calls_analyze(self):
    method test_refresh_history_skips_none (line 158) | async def test_refresh_history_skips_none(self):
    method test_self_improve_calls_analyze (line 165) | async def test_self_improve_calls_analyze(self):
    method test_self_improve_skips_none (line 175) | async def test_self_improve_skips_none(self):

FILE: maggy/tests/test_history.py
  function _make_session (line 21) | def _make_session(
  function sample_sessions (line 45) | def sample_sessions() -> list[SessionEntry]:
  class TestAnalyzer (line 65) | class TestAnalyzer:
    method test_build_report_empty (line 68) | def test_build_report_empty(self):
    method test_build_report_with_data (line 75) | def test_build_report_with_data(self, sample_sessions):
    method test_aggregate_by_provider (line 82) | def test_aggregate_by_provider(self, sample_sessions):
    method test_aggregate_by_project (line 90) | def test_aggregate_by_project(self, sample_sessions):
    method test_compute_time_distribution (line 97) | def test_compute_time_distribution(self, sample_sessions):
    method test_detect_patterns (line 105) | def test_detect_patterns(self, sample_sessions):
    method test_extract_top_topics (line 113) | def test_extract_top_topics(self, sample_sessions):
  class TestHistoryStore (line 123) | class TestHistoryStore:
    method test_save_and_load_sessions (line 126) | def test_save_and_load_sessions(self, tmp_path: Path):
    method test_load_sessions_by_provider (line 134) | def test_load_sessions_by_provider(self, tmp_path: Path):
    method test_save_and_load_report (line 146) | def test_save_and_load_report(self, tmp_path: Path):
    method test_load_report_empty (line 160) | def test_load_report_empty(self, tmp_path: Path):
  class TestHistoryService (line 169) | class TestHistoryService:
    method _isolated_dirs (line 172) | def _isolated_dirs(self, tmp_path: Path) -> dict:
    method test_analyze_no_parsers (line 180) | def test_analyze_no_parsers(self, tmp_path: Path):
    method test_analyze_with_claude (line 189) | def test_analyze_with_claude(self, tmp_path: Path):
    method test_get_report_cached (line 208) | def test_get_report_cached(self, tmp_path: Path):
    method test_get_sessions (line 227) | def test_get_sessions(self, tmp_path: Path):

FILE: maggy/tests/test_history_parsers.py
  class TestClaudeParser (line 18) | class TestClaudeParser:
    method test_not_available_missing_dir (line 21) | def test_not_available_missing_dir(self, tmp_path: Path):
    method test_available_with_history (line 25) | def test_available_with_history(self, tmp_path: Path):
    method test_session_count_empty (line 32) | def test_session_count_empty(self, tmp_path: Path):
    method test_session_count (line 39) | def test_session_count(self, tmp_path: Path):
    method test_parse_sessions (line 51) | def test_parse_sessions(self, tmp_path: Path):
    method test_parse_empty_history (line 69) | def test_parse_empty_history(self, tmp_path: Path):
    method test_parse_with_transcript (line 76) | def test_parse_with_transcript(self, tmp_path: Path):
  class TestCodexParser (line 103) | class TestCodexParser:
    method test_not_available_missing_dir (line 106) | def test_not_available_missing_dir(self, tmp_path: Path):
    method test_available_with_index (line 110) | def test_available_with_index(self, tmp_path: Path):
    method test_session_count (line 117) | def test_session_count(self, tmp_path: Path):
    method test_parse_sessions (line 128) | def test_parse_sessions(self, tmp_path: Path):
    method test_parse_empty (line 148) | def test_parse_empty(self, tmp_path: Path):
  class TestKimiParser (line 160) | class TestKimiParser:
    method test_not_available_missing_dir (line 163) | def test_not_available_missing_dir(self, tmp_path: Path):
    method test_available_with_sessions (line 167) | def test_available_with_sessions(self, tmp_path: Path):
    method test_session_count (line 173) | def test_session_count(self, tmp_path: Path):
    method test_parse_sessions (line 184) | def test_parse_sessions(self, tmp_path: Path):
    method test_parse_empty (line 209) | def test_parse_empty(self, tmp_path: Path):
    method test_parse_missing_wire (line 215) | def test_parse_missing_wire(self, tmp_path: Path):

FILE: maggy/tests/test_improve.py
  class TestModels (line 20) | class TestModels:
    method test_recommendation_defaults (line 21) | def test_recommendation_defaults(self):
    method test_signal_bundle_defaults (line 30) | def test_signal_bundle_defaults(self):
    method test_improvement_report (line 35) | def test_improvement_report(self):
  class TestCollectRouting (line 49) | class TestCollectRouting:
    method test_collects_heatmap (line 50) | def test_collects_heatmap(self):
    method test_flags_underperformers (line 60) | def test_flags_underperformers(self):
  class TestCollectEvents (line 70) | class TestCollectEvents:
    method test_calculates_failure_rate (line 71) | def test_calculates_failure_rate(self):
    method test_empty_events (line 83) | def test_empty_events(self):
  class TestCollectHistory (line 91) | class TestCollectHistory:
    method test_returns_patterns (line 92) | def test_returns_patterns(self):
    method test_no_report (line 103) | def test_no_report(self):
  class TestCollectForge (line 111) | class TestCollectForge:
    method test_returns_gaps (line 112) | def test_returns_gaps(self):
  class TestCollectEngram (line 122) | class TestCollectEngram:
    method test_returns_health (line 123) | def test_returns_health(self):
  class TestCollectBudget (line 136) | class TestCollectBudget:
    method test_returns_status (line 137) | def test_returns_status(self):
  class TestCollectAll (line 147) | class TestCollectAll:
    method test_skips_none_services (line 148) | def test_skips_none_services(self):
  class TestAnalyzeRouting (line 162) | class TestAnalyzeRouting:
    method test_flags_underperformers (line 163) | def test_flags_underperformers(self):
    method test_no_issues (line 174) | def test_no_issues(self):
  class TestAnalyzeFailures (line 180) | class TestAnalyzeFailures:
    method test_flags_high_failure (line 181) | def test_flags_high_failure(self):
    method test_ok_rate (line 188) | def test_ok_rate(self):
  class TestAnalyzeUsage (line 194) | class TestAnalyzeUsage:
    method test_flags_low_usage (line 195) | def test_flags_low_usage(self):
    method test_no_sessions (line 205) | def test_no_sessions(self):
  class TestAnalyzeGaps (line 211) | class TestAnalyzeGaps:
    method test_surfaces_gaps (line 212) | def test_surfaces_gaps(self):
  class TestAnalyzeMemory (line 222) | class TestAnalyzeMemory:
    method test_flags_low_health (line 223) | def test_flags_low_health(self):
    method test_healthy (line 230) | def test_healthy(self):
  class TestAnalyzeCost (line 236) | class TestAnalyzeCost:
    method test_flags_high_util (line 237) | def test_flags_high_util(self):
    method test_ok_util (line 244) | def test_ok_util(self):
  class TestAnalyzeAll (line 250) | class TestAnalyzeAll:
    method test_merges_all (line 251) | def test_merges_all(self):
  class TestIntrospector (line 273) | class TestIntrospector:
    method test_analyze_empty_state (line 274) | def test_analyze_empty_state(self):
    method test_get_report_none_initially (line 285) | def test_get_report_none_initially(self):
    method test_get_report_after_analyze (line 294) | def test_get_report_after_analyze(self):
    method test_health_summary_populated (line 306) | def test_health_summary_populated(self):

FILE: maggy/tests/test_lexon.py
  class TestTerminology (line 12) | class TestTerminology:
    method test_resolve_canonical (line 13) | def test_resolve_canonical(self):
    method test_resolve_synonym (line 17) | def test_resolve_synonym(self):
    method test_resolve_unknown (line 21) | def test_resolve_unknown(self):
    method test_add_alias (line 25) | def test_add_alias(self):
    method test_add_alias_unknown_canonical (line 30) | def test_add_alias_unknown_canonical(self):
  class TestDisambiguate (line 35) | class TestDisambiguate:
    method test_high_confidence_resolves (line 36) | def test_high_confidence_resolves(self):
    method test_mid_confidence_self_clarify (line 42) | def test_mid_confidence_self_clarify(self):
    method test_low_confidence_user_clarify (line 47) | def test_low_confidence_user_clarify(self):
    method test_very_low_rejects (line 52) | def test_very_low_rejects(self):
  class TestPersonalization (line 57) | class TestPersonalization:
    method test_record_and_top (line 58) | def test_record_and_top(self):
    method test_preferred_alias (line 66) | def test_preferred_alias(self):
    method test_correction (line 71) | def test_correction(self):
  class TestLexonRouter (line 77) | class TestLexonRouter:
    method test_known_intent (line 78) | def test_known_intent(self):
    method test_unknown_intent (line 84) | def test_unknown_intent(self):
    method test_learn_and_recall (line 89) | def test_learn_and_recall(self):
    method test_multiple_candidates (line 96) | def test_multiple_candidates(self):
    method test_manifest_overrides_default_tools (line 101) | def test_manifest_overrides_default_tools(self):
  class TestLexonRecord (line 111) | class TestLexonRecord:
    method test_ambiguous (line 112) | def test_ambiguous(self):
    method test_not_ambiguous (line 116) | def test_not_ambiguous(self):
    method test_needs_user_input (line 120) | def test_needs_user_input(self):

FILE: maggy/tests/test_mesh.py
  class TestProtocol (line 19) | class TestProtocol:
    method test_serialize_round_trip (line 20) | def test_serialize_round_trip(self):
    method test_share_message (line 27) | def test_share_message(self):
  class TestPeerDiscovery (line 36) | class TestPeerDiscovery:
    method test_register_and_list (line 37) | def test_register_and_list(self):
    method test_unregister (line 46) | def test_unregister(self):
    method test_update_seen (line 55) | def test_update_seen(self):
  class TestProvenance (line 67) | class TestProvenance:
    method test_no_hop_full_confidence (line 68) | def test_no_hop_full_confidence(self):
    method test_decay_per_hop (line 72) | def test_decay_per_hop(self):
    method test_add_hop (line 78) | def test_add_hop(self):
    method test_min_confidence (line 83) | def test_min_confidence(self):
  class TestQuarantine (line 90) | class TestQuarantine:
    method test_quarantine_and_list (line 91) | def test_quarantine_and_list(self):
    method test_promote (line 97) | def test_promote(self):
    method test_promote_missing (line 103) | def test_promote_missing(self):
  class TestSync (line 108) | class TestSync:
    method test_accept_high_confidence (line 109) | def test_accept_high_confidence(self):
    method test_quarantine_low_confidence (line 122) | def test_quarantine_low_confidence(self):
  class TestTransport (line 136) | class TestTransport:
    method test_hmac_round_trip (line 137) | def test_hmac_round_trip(self):
    method test_hmac_mismatch (line 141) | def test_hmac_mismatch(self):

FILE: maggy/tests/test_mesh_network.py
  class TestEffectiveOrgs (line 18) | class TestEffectiveOrgs:
    method test_merge_scanned_and_manual (line 19) | def test_merge_scanned_and_manual(self):
    method test_excludes_orgs (line 26) | def test_excludes_orgs(self):
    method test_deduplicates (line 35) | def test_deduplicates(self):
    method test_empty_inputs (line 42) | def test_empty_inputs(self):
  class TestDeriveOrgKey (line 50) | class TestDeriveOrgKey:
    method test_different_orgs_produce_different_keys (line 51) | def test_different_orgs_produce_different_keys(self):
    method test_deterministic (line 57) | def test_deterministic(self):
    method test_returns_hex_string (line 63) | def test_returns_hex_string(self):
  class TestSignVerify (line 69) | class TestSignVerify:
    method test_roundtrip (line 70) | def test_roundtrip(self):
    method test_wrong_key_fails (line 79) | def test_wrong_key_fails(self):
    method test_invalid_json_fails (line 87) | def test_invalid_json_fails(self):
  class TestBuildNetwork (line 96) | class TestBuildNetwork:
    method test_creates_network (line 97) | def test_creates_network(self, tmp_path: Path):
    method test_isolated_org_keys (line 105) | def test_isolated_org_keys(self, tmp_path: Path):
    method test_status_returns_counts (line 113) | def test_status_returns_counts(self, tmp_path: Path):
  function _make_cfg (line 128) | def _make_cfg(**overrides):
  class TestMeshManager (line 141) | class TestMeshManager:
    method test_add_and_get_network (line 142) | def test_add_and_get_network(self, tmp_path: Path):
    method test_missing_network_returns_none (line 151) | def test_missing_network_returns_none(self, tmp_path: Path):
    method test_list_networks (line 158) | def test_list_networks(self, tmp_path: Path):
    method test_total_peers_across_networks (line 168) | def test_total_peers_across_networks(self, tmp_path: Path):
    method test_resolve_address_tunnel (line 180) | def test_resolve_address_tunnel(self, tmp_path: Path):
    method test_resolve_address_local (line 188) | def test_resolve_address_local(self, tmp_path: Path):
  class TestPublisher (line 199) | class TestPublisher:
    method test_collect_scores_skips_low_count (line 200) | def test_collect_scores_skips_low_count(self):
    method test_collect_scores_includes_high_count (line 210) | def test_collect_scores_includes_high_count(self):
    method test_collect_gaps (line 221) | def test_collect_gaps(self):
    method test_collect_policies_filters_severity (line 230) | def test_collect_policies_filters_severity(self):
    method test_collect_all_none_services (line 251) | def test_collect_all_none_services(self):
  class TestGitDiscovery (line 261) | class TestGitDiscovery:
    method test_ensure_repo_exists (line 263) | async def test_ensure_repo_exists(self):
    method test_ensure_repo_creates_new (line 278) | async def test_ensure_repo_creates_new(self):
    method test_read_peers_empty (line 296) | async def test_read_peers_empty(self):
    method test_announce_success (line 311) | async def test_announce_success(self):
    method test_remove_announcement (line 333) | async def test_remove_announcement(self):
  class TestPromoteFlow (line 357) | class TestPromoteFlow:
    method test_promote_accepts_into_sync (line 358) | def test_promote_accepts_into_sync(self, tmp_path: Path):
    method test_promote_nonexistent_returns_false (line 380) | def test_promote_nonexistent_returns_false(
  class TestReplayProtection (line 394) | class TestReplayProtection:
    method test_stale_message_rejected (line 395) | def test_stale_message_rejected(self):
  class TestSqliteReload (line 417) | class TestSqliteReload:
    method test_peers_reload_from_store (line 418) | def test_peers_reload_from_store(self, tmp_path: Path):
    method test_sync_reload_from_store (line 432) | def test_sync_reload_from_store(self, tmp_path: Path):

FILE: maggy/tests/test_mesh_store.py
  function store (line 13) | def store(tmp_path: Path) -> MeshStore:
  class TestPeerCRUD (line 17) | class TestPeerCRUD:
    method test_upsert_and_get (line 18) | def test_upsert_and_get(self, store: MeshStore):
    method test_list_by_org (line 24) | def test_list_by_org(self, store: MeshStore):
    method test_list_all (line 30) | def test_list_all(self, store: MeshStore):
    method test_remove_peer (line 35) | def test_remove_peer(self, store: MeshStore):
    method test_remove_missing (line 40) | def test_remove_missing(self, store: MeshStore):
    method test_upsert_updates (line 43) | def test_upsert_updates(self, store: MeshStore):
  class TestMemoryCRUD (line 51) | class TestMemoryCRUD:
    method test_write_and_list (line 52) | def test_write_and_list(self, store: MeshStore):
    method test_scoped_by_org (line 58) | def test_scoped_by_org(self, store: MeshStore):
    method test_upsert_memory (line 64) | def test_upsert_memory(self, store: MeshStore):
  class TestQuarantineCRUD (line 72) | class TestQuarantineCRUD:
    method test_quarantine_and_list (line 73) | def test_quarantine_and_list(self, store: MeshStore):
    method test_promote (line 79) | def test_promote(self, store: MeshStore):
    method test_promote_missing (line 84) | def test_promote_missing(self, store: MeshStore):
    method test_scoped_by_org (line 87) | def test_scoped_by_org(self, store: MeshStore):

FILE: maggy/tests/test_mesh_ws.py
  function _build_app_with_mesh (line 27) | def _build_app_with_mesh(tmp_dir: Path | None = None):
  class TestWsServerNoMesh (line 51) | class TestWsServerNoMesh:
    method test_no_mesh_closes_connection (line 52) | def test_no_mesh_closes_connection(self):
  class TestWsServerAuth (line 66) | class TestWsServerAuth:
    method test_invalid_json_closes (line 67) | def test_invalid_json_closes(self):
    method test_wrong_org_closes (line 75) | def test_wrong_org_closes(self):
  class TestWsServerHello (line 88) | class TestWsServerHello:
    method test_valid_hello_gets_reply (line 89) | def test_valid_hello_gets_reply(self):
  class TestMeshClient (line 107) | class TestMeshClient:
    method test_init (line 108) | def test_init(self):
    method test_is_connected_false (line 113) | def test_is_connected_false(self):
    method test_send_no_connection (line 119) | async def test_send_no_connection(self):
    method test_broadcast_empty (line 127) | async def test_broadcast_empty(self):
    method test_close_all_empty (line 135) | async def test_close_all_empty(self):

FILE: maggy/tests/test_mnemos_fatigue.py
  class TestFatigueTracker (line 13) | class TestFatigueTracker:
    method test_composite_and_state_ok (line 14) | def test_composite_and_state_ok(self):
    method test_rejects_invalid_dimension (line 23) | def test_rejects_invalid_dimension(self):
    method test_model_switch_increases_reread_ratio (line 28) | def test_model_switch_increases_reread_ratio(self):
    method test_state_thresholds (line 35) | def test_state_thresholds(self):
  class TestSignalLog (line 45) | class TestSignalLog:
    method test_append_and_recent (line 46) | def test_append_and_recent(self, tmp_path: Path):

FILE: maggy/tests/test_monday_provider.py
  function provider (line 11) | def provider():
  function test_provider_name (line 17) | def test_provider_name(provider):
  function test_to_task_maps_fields (line 21) | def test_to_task_maps_fields(provider):
  function test_list_tasks_parses_items (line 41) | async def test_list_tasks_parses_items(provider, monkeypatch):
  function test_list_tasks_empty_board (line 66) | async def test_list_tasks_empty_board(provider, monkeypatch):
  function test_get_task_by_id (line 86) | async def test_get_task_by_id(provider, monkeypatch):
  function test_get_task_not_found (line 109) | async def test_get_task_not_found(provider, monkeypatch):

FILE: maggy/tests/test_monitor.py
  function svc (line 14) | def svc(tmp_path):
  function test_add_and_list (line 18) | def test_add_and_list(svc):
  function test_remove (line 27) | def test_remove(svc):
  function test_is_new_unseen (line 34) | def test_is_new_unseen(svc):
  function test_mark_seen_not_new (line 39) | def test_mark_seen_not_new(svc):
  function test_add_duplicate_updates (line 45) | def test_add_duplicate_updates(svc):
  function test_default_interval (line 54) | def test_default_interval(svc):
  function test_status_summary (line 61) | def test_status_summary(svc):
  function test_poll_github_prs (line 70) | async def test_poll_github_prs(svc, monkeypatch):

FILE: maggy/tests/test_multimodel_integration.py
  function _project_cfg (line 35) | def _project_cfg(tmp_path) -> MaggyConfig:
  function _task (line 53) | def _task(blast: int, ttype: str, title: str) -> Task:
  class TestRoutingDecisions (line 77) | class TestRoutingDecisions:
    method test_low_blast_routes_to_cheap_tier (line 80) | def test_low_blast_routes_to_cheap_tier(self, tmp_path):
    method test_mid_blast_routes_to_cheapest_capable (line 92) | def test_mid_blast_routes_to_cheapest_capable(self, tmp_path):
    method test_blast_6_routes_to_codex (line 99) | def test_blast_6_routes_to_codex(self, tmp_path):
    method test_high_blast_routes_to_codex_or_claude (line 106) | def test_high_blast_routes_to_codex_or_claude(self, tmp_path):
    method test_security_routes_to_claude (line 113) | def test_security_routes_to_claude(self, tmp_path):
  class TestExecutorPipeline (line 130) | class TestExecutorPipeline:
    method test_distributes_across_models (line 134) | async def test_distributes_across_models(self, tmp_path):
  class TestCrossProviderBudget (line 183) | class TestCrossProviderBudget:
    method test_spend_tracked_per_provider (line 184) | def test_spend_tracked_per_provider(self, tmp_path):
    method test_task_spend_halts_at_limit (line 195) | def test_task_spend_halts_at_limit(self):
  class TestFallbackChain (line 206) | class TestFallbackChain:
    method test_falls_back_on_failure (line 208) | async def test_falls_back_on_failure(self):
  class TestCheckpointHandoff (line 236) | class TestCheckpointHandoff:
    method test_checkpoint_roundtrip (line 237) | def test_checkpoint_roundtrip(self, tmp_path):
  class TestDualPlanning (line 256) | class TestDualPlanning:
    method test_plan_and_review_use_separate_models (line 258) | async def test_plan_and_review_use_separate_models(self):
  class TestFatigueAcrossModels (line 280) | class TestFatigueAcrossModels:
    method test_model_switch_increases_fatigue (line 281) | def test_model_switch_increases_fatigue(self):
  class TestLockCoordination (line 297) | class TestLockCoordination:
    method test_agents_cant_clobber_each_other (line 298) | def test_agents_cant_clobber_each_other(self, tmp_path):

FILE: maggy/tests/test_observability.py
  function test_records_and_reads_recent_signals (line 8) | def test_records_and_reads_recent_signals(tmp_path) -> None:
  function test_limits_recent_signals (line 20) | def test_limits_recent_signals(tmp_path) -> None:

FILE: maggy/tests/test_output_reviewer.py
  class TestParseReview (line 13) | class TestParseReview:
    method test_parses_score_and_reason (line 14) | def test_parses_score_and_reason(self):
    method test_parses_score_only (line 20) | def test_parses_score_only(self):
    method test_no_score_returns_default (line 25) | def test_no_score_returns_default(self):
    method test_score_out_of_range_clamped (line 30) | def test_score_out_of_range_clamped(self):
    method test_score_from_inline_text (line 34) | def test_score_from_inline_text(self):
  class TestReviewOutput (line 39) | class TestReviewOutput:
    method test_returns_review_result (line 41) | async def test_returns_review_result(self):
    method test_failure_returns_passthrough (line 59) | async def test_failure_returns_passthrough(self):
    method test_exception_returns_passthrough (line 77) | async def test_exception_returns_passthrough(self):
    method test_uses_local_model (line 90) | async def test_uses_local_model(self):
    method test_prompt_contains_step_and_output (line 110) | async def test_prompt_contains_step_and_output(self):

FILE: maggy/tests/test_pi_adapter.py
  class TestModelRegistry (line 16) | class TestModelRegistry:
    method test_default_models_loaded (line 17) | def test_default_models_loaded(self):
    method test_get_known_model (line 21) | def test_get_known_model(self):
    method test_get_unknown_returns_none (line 27) | def test_get_unknown_returns_none(self):
    method test_custom_models (line 31) | def test_custom_models(self):
  class TestFallbackChain (line 40) | class TestFallbackChain:
    method test_chain_excludes_start (line 41) | def test_chain_excludes_start(self):
    method test_chain_ordered_by_cost (line 46) | def test_chain_ordered_by_cost(self):
    method test_unknown_start_returns_all (line 51) | def test_unknown_start_returns_all(self):
  class TestQuotaDetection (line 57) | class TestQuotaDetection:
    method test_detects_rate_limit (line 58) | def test_detects_rate_limit(self):
    method test_detects_429 (line 62) | def test_detects_429(self):
    method test_clean_output_no_quota (line 66) | def test_clean_output_no_quota(self):
  class TestBuildCommand (line 71) | class TestBuildCommand:
    method test_claude_command_format (line 72) | def test_claude_command_format(self):
    method test_non_claude_command (line 80) | def test_non_claude_command(self):
  class _FakeStream (line 91) | class _FakeStream:
    method __init__ (line 92) | def __init__(self, lines: list[str]):
    method readline (line 96) | def readline(self) -> str:
    method write (line 101) | def write(self, text: str) -> None:
    method flush (line 104) | def flush(self) -> None:
  class _FakeProcess (line 108) | class _FakeProcess:
    method __init__ (line 109) | def __init__(self, stdout_lines: list[str]):
  class TestRpcMode (line 114) | class TestRpcMode:
    method test_detect_pi_uses_path_lookup (line 115) | def test_detect_pi_uses_path_lookup(self):
    method test_send_rpc_serializes_command (line 120) | def test_send_rpc_serializes_command(self):
    method test_switch_model_uses_rpc (line 128) | def test_switch_model_uses_rpc(self):
  class TestPromptResult (line 141) | class TestPromptResult:
    method test_parses_json_output (line 142) | def test_parses_json_output(self):
    method test_plain_text_fallback (line 156) | def test_plain_text_fallback(self):
    method test_json_error_preserves_usage (line 164) | def test_json_error_preserves_usage(self):
  class TestStreaming (line 177) | class TestStreaming:
    method test_stream_events_reads_jsonl (line 179) | async def test_stream_events_reads_jsonl(self):

FILE: maggy/tests/test_planning.py
  class TestPlanModels (line 14) | class TestPlanModels:
    method test_plan_step_count (line 15) | def test_plan_step_count(self):
    method test_plan_diff_agreement_ratio (line 25) | def test_plan_diff_agreement_ratio(self):
    method test_plan_diff_empty (line 34) | def test_plan_diff_empty(self):
  class TestPlanningService (line 40) | class TestPlanningService:
    method test_below_threshold_single_plan (line 41) | def test_below_threshold_single_plan(self, mock_cfg):
    method test_above_threshold_dual_plan (line 48) | def test_above_threshold_dual_plan(self, mock_cfg):
    method test_generate_plan (line 57) | def test_generate_plan(self, mock_cfg):
    method test_diff_plans_identical (line 64) | def test_diff_plans_identical(self, mock_cfg):
    method test_should_dual_plan_boundary (line 71) | def test_should_dual_plan_boundary(self, mock_cfg):
  class TestSimilarity (line 78) | class TestSimilarity:
    method test_similar_strings (line 79) | def test_similar_strings(self):
    method test_dissimilar_strings (line 85) | def test_dissimilar_strings(self):
    method test_empty_string (line 91) | def test_empty_string(self):

FILE: maggy/tests/test_registry.py
  class TestProjectConfigParsing (line 9) | class TestProjectConfigParsing:
    method test_from_dict_parses_projects (line 10) | def test_from_dict_parses_projects(self):
  class TestProjectRegistry (line 37) | class TestProjectRegistry:
    method test_registry_crud (line 38) | def test_registry_crud(self):
    method test_add_duplicate_raises (line 60) | def test_add_duplicate_raises(self):

FILE: maggy/tests/test_repl_cmds.py
  class FakeState (line 21) | class FakeState:
  function _mock_client (line 27) | def _mock_client():
  function test_dispatch_stats (line 61) | def test_dispatch_stats(capsys):
  function test_dispatch_unknown (line 69) | def test_dispatch_unknown():
  function test_cmd_stats (line 75) | def test_cmd_stats(capsys):
  function test_cmd_budget (line 82) | def test_cmd_budget(capsys):
  function test_cmd_route (line 89) | def test_cmd_route(capsys):
  function test_cmd_models (line 96) | def test_cmd_models(capsys):
  function test_cmd_use_sets_models (line 103) | def test_cmd_use_sets_models():
  function test_cmd_use_reset (line 110) | def test_cmd_use_reset():
  function test_cmd_claude_md_missing (line 117) | def test_cmd_claude_md_missing(capsys):
  function test_cmd_stats_shows_tokens (line 125) | def test_cmd_stats_shows_tokens(capsys):
  function test_cmd_route_shows_tiers (line 133) | def test_cmd_route_shows_tiers(capsys):
  function test_cmd_help (line 141) | def test_cmd_help(capsys):
  function test_cmd_health (line 150) | def test_cmd_health(capsys):
  function test_dispatch_health (line 164) | def test_dispatch_health(capsys):
  function test_help_lists_health (line 176) | def test_help_lists_health(capsys):
  function test_models_empty_shows_known (line 183) | def test_models_empty_shows_known(capsys):
  function test_use_warns_unknown_model (line 194) | def test_use_warns_unknown_model(capsys):
  function test_budget_subscription_plan (line 202) | def test_budget_subscription_plan(capsys):
  function test_health_graceful_failure (line 215) | def test_health_graceful_failure(capsys):
  function test_stats_server_down (line 225) | def test_stats_server_down(capsys):

FILE: maggy/tests/test_rollback.py
  function _git (line 12) | def _git(repo, *args: str) -> None:
  function _init_repo (line 16) | def _init_repo(repo) -> None:
  class TestRollbackManager (line 25) | class TestRollbackManager:
    method test_create_and_list_savepoints (line 27) | async def test_create_and_list_savepoints(self, tmp_path):
    method test_rollback_resets_worktree (line 35) | async def test_rollback_resets_worktree(self, tmp_path):
    method test_delete_savepoint (line 44) | async def test_delete_savepoint(self, tmp_path):

FILE: maggy/tests/test_routes_escalation.py
  function _app (line 8) | def _app(tmp_path):
  function test_list_pending_empty (line 27) | def test_list_pending_empty(tmp_path):
  function test_create_and_list (line 34) | def test_create_and_list(tmp_path):
  function test_resolve_escalation (line 50) | def test_resolve_escalation(tmp_path):
  function test_resolve_not_found (line 71) | def test_resolve_not_found(tmp_path):

FILE: maggy/tests/test_routes_observability.py
  function _app (line 8) | def _app(tmp_path):
  function test_get_signals_empty (line 27) | def test_get_signals_empty(tmp_path):
  function test_record_and_read (line 34) | def test_record_and_read(tmp_path):

FILE: maggy/tests/test_routes_projects.py
  function _app (line 10) | def _app(mock_cfg):
  function test_list_projects_empty (line 22) | def test_list_projects_empty(mock_cfg):
  function test_add_and_list_project (line 29) | def test_add_and_list_project(mock_cfg):
  function test_get_project_not_found (line 45) | def test_get_project_not_found(mock_cfg):
  function test_add_duplicate_project (line 51) | def test_add_duplicate_project(mock_cfg):
  function test_delete_project (line 63) | def test_delete_project(mock_cfg):

FILE: maggy/tests/test_routing_config.py
  class TestStakesPatterns (line 14) | class TestStakesPatterns:
    method test_default_has_high_patterns (line 15) | def test_default_has_high_patterns(self):
    method test_default_has_medium_patterns (line 20) | def test_default_has_medium_patterns(self):
    method test_default_low_has_empty_patterns (line 25) | def test_default_low_has_empty_patterns(self):
  class TestCascadePolicy (line 30) | class TestCascadePolicy:
    method test_defaults (line 31) | def test_defaults(self):
    method test_custom_values (line 39) | def test_custom_values(self):
  class TestYamlRoundtrip (line 48) | class TestYamlRoundtrip:
    method test_roundtrip_preserves_stakes (line 49) | def test_roundtrip_preserves_stakes(self, tmp_path: Path):
    method test_roundtrip_preserves_cascade (line 56) | def test_roundtrip_preserves_cascade(self, tmp_path: Path):
    method test_roundtrip_preserves_conventions (line 63) | def test_roundtrip_preserves_conventions(self, tmp_path: Path):
    method test_user_edits_preserved (line 69) | def test_user_edits_preserved(self, tmp_path: Path):
    method test_missing_file_seeds_defaults (line 80) | def test_missing_file_seeds_defaults(self, tmp_path: Path):
  class TestToDict (line 87) | class TestToDict:
    method test_stakes_in_output (line 88) | def test_stakes_in_output(self):
    method test_cascade_in_output (line 94) | def test_cascade_in_output(self):
  class TestDefaultTiers (line 101) | class TestDefaultTiers:
    method test_no_gpt_in_defaults (line 104) | def test_no_gpt_in_defaults(self):
    method test_codex_is_primary (line 109) | def test_codex_is_primary(self):
    method test_codex_handles_complex (line 115) | def test_codex_handles_complex(self):
    method test_local_kimi_handle_simple (line 120) | def test_local_kimi_handle_simple(self):

FILE: maggy/tests/test_routing_rules.py
  function rules_path (line 22) | def rules_path(tmp_path: Path) -> Path:
  class TestDefaultRules (line 26) | class TestDefaultRules:
    method test_seeds_task_type_overrides (line 27) | def test_seeds_task_type_overrides(self):
    method test_seeds_pipeline_phases (line 33) | def test_seeds_pipeline_phases(self):
    method test_seeds_model_performance (line 39) | def test_seeds_model_performance(self):
  class TestLoadSave (line 45) | class TestLoadSave:
    method test_load_creates_default (line 46) | def test_load_creates_default(self, rules_path: Path):
    method test_roundtrip (line 51) | def test_roundtrip(self, rules_path: Path):
    method test_load_existing (line 60) | def test_load_existing(self, rules_path: Path):
  class TestApplyOverride (line 66) | class TestApplyOverride:
    method test_phase_takes_priority (line 67) | def test_phase_takes_priority(self):
    method test_auto_phase_returns_none (line 72) | def test_auto_phase_returns_none(self):
    method test_task_type_override (line 77) | def test_task_type_override(self):
    method test_no_override_returns_none (line 82) | def test_no_override_returns_none(self):
    method test_low_confidence_ignored (line 87) | def test_low_confidence_ignored(self):
  class TestRecordOutcome (line 97) | class TestRecordOutcome:
    method test_updates_success_rate (line 98) | def test_updates_success_rate(self, rules_path: Path):
    method test_creates_new_model (line 105) | def test_creates_new_model(self, rules_path: Path):
    method test_records_failure (line 111) | def test_records_failure(self, rules_path: Path):
  class TestLearnOverride (line 124) | class TestLearnOverride:
    method test_adds_new_override (line 125) | def test_adds_new_override(self, rules_path: Path):
    method test_persists_to_disk (line 135) | def test_persists_to_disk(self, rules_path: Path):

FILE: maggy/tests/test_routing_service.py
  class TestRoutingDecisions (line 9) | class TestRoutingDecisions:
    method test_low_complexity_routes_cheap (line 10) | def test_low_complexity_routes_cheap(self, mock_cfg):
    method test_high_complexity_routes_premium (line 21) | def test_high_complexity_routes_premium(self, mock_cfg):
    method test_security_sensitive_avoids_cheap (line 32) | def test_security_sensitive_avoids_cheap(self, mock_cfg):
  class TestRoutingLearning (line 48) | class TestRoutingLearning:
    method test_record_outcome (line 49) | def test_record_outcome(self, mock_cfg):
    method test_learned_override (line 55) | def test_learned_override(self, mock_cfg):
    method test_blast_tier_mapping (line 69) | def test_blast_tier_mapping(self, mock_cfg):

FILE: maggy/tests/test_scores.py
  class TestRewardRecord (line 8) | class TestRewardRecord:
    method test_record_and_heatmap (line 9) | def test_record_and_heatmap(self, mock_cfg):
    method test_multiple_records (line 16) | def test_multiple_records(self, mock_cfg):
  class TestBestModel (line 24) | class TestBestModel:
    method test_no_data_returns_none (line 25) | def test_no_data_returns_none(self, mock_cfg):
    method test_insufficient_samples_returns_none (line 29) | def test_insufficient_samples_returns_none(self, mock_cfg):
    method test_sufficient_samples_returns_best (line 35) | def test_sufficient_samples_returns_best(self, mock_cfg):
  class TestHeatmap (line 45) | class TestHeatmap:
    method test_empty_heatmap (line 46) | def test_empty_heatmap(self, mock_cfg):
    method test_heatmap_groups_correctly (line 50) | def test_heatmap_groups_correctly(self, mock_cfg):

FILE: maggy/tests/test_setup_routes.py
  function setup_app (line 21) | def setup_app(tmp_path: Path) -> FastAPI:
  function client (line 36) | def client(setup_app: FastAPI) -> TestClient:
  class TestSetupStatus (line 40) | class TestSetupStatus:
    method test_returns_steps (line 41) | def test_returns_steps(self, client: TestClient):
    method test_missing_token_detected (line 49) | def test_missing_token_detected(
    method test_progress_format (line 58) | def test_progress_format(self, client: TestClient):
    method test_configured_false_in_local (line 63) | def test_configured_false_in_local(
  class TestSetupConfigure (line 70) | class TestSetupConfigure:
    method test_updates_org (line 72) | def test_updates_org(self, mock_save, client):
    method test_updates_github_repos (line 82) | def test_updates_github_repos(
    method test_empty_body_is_noop (line 95) | def test_empty_body_is_noop(
  class TestDiscoverRepos (line 104) | class TestDiscoverRepos:
    method test_returns_repos (line 105) | def test_returns_repos(self, client: TestClient):

FILE: maggy/tests/test_stakes.py
  function _task (line 10) | def _task(title: str, desc: str = "", raw: dict | None = None) -> Task:
  class TestHighStakes (line 14) | class TestHighStakes:
    method test_auth_file_in_title (line 15) | def test_auth_file_in_title(self):
    method test_billing_task_type (line 19) | def test_billing_task_type(self):
    method test_security_task_type (line 24) | def test_security_task_type(self):
    method test_production_keyword_in_desc (line 29) | def test_production_keyword_in_desc(self):
    method test_env_file_pattern (line 34) | def test_env_file_pattern(self):
    method test_migration_in_title (line 38) | def test_migration_in_title(self):
  class TestMediumStakes (line 43) | class TestMediumStakes:
    method test_api_route_file (line 44) | def test_api_route_file(self):
    method test_feature_task_type (line 48) | def test_feature_task_type(self):
    method test_database_schema_change (line 53) | def test_database_schema_change(self):
  class TestLowStakes (line 58) | class TestLowStakes:
    method test_readme_update (line 59) | def test_readme_update(self):
    method test_docs_task_type (line 63) | def test_docs_task_type(self):
    method test_formatting_task (line 68) | def test_formatting_task(self):
  class TestStakesResult (line 74) | class TestStakesResult:
    method test_reasons_populated (line 75) | def test_reasons_populated(self):
    method test_custom_patterns (line 79) | def test_custom_patterns(self):

FILE: maggy/tests/test_tdd_verifier.py
  class TestParsers (line 14) | class TestParsers:
    method test_count_collected_normal (line 17) | def test_count_collected_normal(self):
    method test_count_collected_singular (line 20) | def test_count_collected_singular(self):
    method test_count_collected_missing (line 23) | def test_count_collected_missing(self):
    method test_count_failures_normal (line 26) | def test_count_failures_normal(self):
    method test_count_failures_none (line 29) | def test_count_failures_none(self):
    method test_parse_coverage_normal (line 32) | def test_parse_coverage_normal(self):
    method test_parse_coverage_missing (line 36) | def test_parse_coverage_missing(self):
  class TestVerifyResult (line 40) | class TestVerifyResult:
    method test_passed_result (line 43) | def test_passed_result(self):
    method test_failed_result (line 49) | def test_failed_result(self):
  class TestVerifyFunctions (line 56) | class TestVerifyFunctions:
    method test_verify_tests_exist_passes (line 60) | async def test_verify_tests_exist_passes(self, monkeypatch):
    method test_verify_tests_exist_fails (line 72) | async def test_verify_tests_exist_fails(self, monkeypatch):
    method test_verify_tests_fail_red (line 83) | async def test_verify_tests_fail_red(self, monkeypatch):
    method test_verify_tests_fail_rejects_pass (line 95) | async def test_verify_tests_fail_rejects_pass(self, monkeypatch):
    method test_verify_tests_pass_green (line 107) | async def test_verify_tests_pass_green(self, monkeypatch):
    method test_verify_lint_clean (line 118) | async def test_verify_lint_clean(self, monkeypatch):

FILE: maggy/tests/test_vision.py
  function png_file (line 15) | def png_file(tmp_path: Path) -> Path:
  function test_analyze_missing_file (line 28) | def test_analyze_missing_file():
  function test_analyze_bad_extension (line 34) | def test_analyze_bad_extension(tmp_path: Path):
  function test_analyze_streams_response (line 42) | def test_analyze_streams_response(png_file: Path):
  function test_analyze_with_custom_prompt (line 65) | def test_analyze_with_custom_prompt(png_file: Path):
  function test_analyze_ollama_down (line 89) | def test_analyze_ollama_down(png_file: Path):

FILE: maggy/tests/test_zero_config.py
  class TestHasProviderCredentials (line 17) | class TestHasProviderCredentials:
    method test_github_with_creds (line 18) | def test_github_with_creds(self):
    method test_github_no_token (line 27) | def test_github_no_token(self):
    method test_asana_with_creds (line 35) | def test_asana_with_creds(self):
    method test_linear_stub (line 43) | def test_linear_stub(self):
  class TestHasCliHistory (line 53) | class TestHasCliHistory:
    method test_claude_dir_exists (line 54) | def test_claude_dir_exists(self, tmp_path: Path):
    method test_no_dirs (line 59) | def test_no_dirs(self, tmp_path: Path):
    method test_codex_dir_exists (line 63) | def test_codex_dir_exists(self, tmp_path: Path):
  class TestAutoConfigure (line 72) | class TestAutoConfigure:
    method test_builds_config (line 73) | def test_builds_config(self, tmp_path: Path):
    method test_populates_codebases (line 81) | def test_populates_codebases(self, tmp_path: Path):
    method test_persist_writes_file (line 96) | def test_persist_writes_file(self, tmp_path: Path):
  class TestIsConfiguredRelaxed (line 111) | class TestIsConfiguredRelaxed:
    method test_false_without_anything (line 112) | def test_false_without_anything(self, tmp_path: Path):
    method test_true_with_cli_history (line 120) | def test_true_with_cli_history(self, tmp_path: Path):

FILE: scripts/icpg/__main__.py
  function main (line 21) | def main(argv: list[str] | None = None) -> int:
  function cmd_init (line 154) | def cmd_init(store: ICPGStore) -> int:
  function cmd_create (line 162) | def cmd_create(store: ICPGStore, args) -> int:
  function cmd_record (line 197) | def cmd_record(store: ICPGStore, args) -> int:
  function cmd_query (line 249) | def cmd_query(store: ICPGStore, args) -> int:
  function _resolve_path (line 268) | def _resolve_path(store: ICPGStore, file_path: str) -> str:
  function _query_context (line 276) | def _query_context(store: ICPGStore, file_path: str) -> int:
  function _query_blast (line 295) | def _query_blast(store: ICPGStore, reason_id: str) -> int:
  function _query_constraints (line 316) | def _query_constraints(store: ICPGStore, file_path: str) -> int:
  function _query_risk (line 334) | def _query_risk(store: ICPGStore, symbol_name: str) -> int:
  function _query_prior (line 355) | def _query_prior(store: ICPGStore, args) -> int:
  function cmd_drift (line 372) | def cmd_drift(store: ICPGStore, args) -> int:
  function _drift_scores (line 426) | def _drift_scores(event) -> list[float]:
  function cmd_bootstrap (line 437) | def cmd_bootstrap(store: ICPGStore, args) -> int:
  function cmd_status (line 458) | def cmd_status(store: ICPGStore) -> int:

FILE: scripts/icpg/bootstrap.py
  function bootstrap_from_git (line 24) | def bootstrap_from_git(
  function _get_commits (line 130) | def _get_commits(project_dir: Path, since: str) -> list[dict]:
  function _cluster_commits (line 187) | def _cluster_commits(
  function _infer_via_llm (line 222) | def _infer_via_llm(
  function _infer_from_messages (line 271) | def _infer_from_messages(
  function _parse_reason_response (line 306) | def _parse_reason_response(

FILE: scripts/icpg/contracts.py
  function infer_contracts (line 17) | def infer_contracts(
  function _infer_via_claude (line 41) | def _infer_via_claude(
  function _infer_via_openai (line 58) | def _infer_via_openai(
  function _infer_heuristic (line 78) | def _infer_heuristic(
  function _build_inference_prompt (line 106) | def _build_inference_prompt(
  function _parse_contract_response (line 140) | def _parse_contract_response(response: str) -> dict[str, list[str]]:
  function _empty_contracts (line 159) | def _empty_contracts() -> dict[str, list[str]]:
  function _guess_test_path (line 163) | def _guess_test_path(source_path: str) -> str | None:
  function format_contracts (line 181) | def format_contracts(reason: ReasonNode) -> str:

FILE: scripts/icpg/drift.py
  function check_file_drift (line 13) | def check_file_drift(store: ICPGStore, file_path: str) -> list[DriftEvent]:
  function check_all_drift (line 24) | def check_all_drift(store: ICPGStore) -> list[DriftEvent]:
  function check_symbol_drift (line 45) | def check_symbol_drift(
  function _check_spec_drift (line 117) | def _check_spec_drift(store, sym, reason) -> float | None:
  function _check_decision_drift (line 133) | def _check_decision_drift(store, reason) -> float | None:
  function _check_ownership_drift (line 148) | def _check_ownership_drift(store, sym) -> float | None:
  function _check_test_drift (line 162) | def _check_test_drift(store, reason) -> float | None:
  function _check_usage_drift (line 180) | def _check_usage_drift(store, sym, reason) -> float | None:
  function _check_dependency_drift (line 213) | def _check_dependency_drift(store, reason) -> float | None:
  function evaluate_predicate (line 230) | def evaluate_predicate(predicate: str, project_dir: Path) -> bool:
  function _match_predicate (line 265) | def _match_predicate(predicate: str, func_name: str) -> str | None:
  function _count_symbols_in_dir (line 271) | def _count_symbols_in_dir(dir_path: Path) -> int:
  function _compare (line 281) | def _compare(value: int, op: str, threshold: int) -> bool:

FILE: scripts/icpg/models.py
  function _now (line 11) | def _now() -> str:
  function _uuid (line 15) | def _uuid() -> str:
  function symbol_id (line 19) | def symbol_id(file_path: str, name: str, symbol_type: str) -> str:
  class ReasonNode (line 64) | class ReasonNode:
  class Symbol (line 86) | class Symbol:
    method __post_init__ (line 98) | def __post_init__(self):
  class Edge (line 104) | class Edge:
  class DriftEvent (line 116) | class DriftEvent:

FILE: scripts/icpg/store.py
  class ICPGStore (line 77) | class ICPGStore:
    method __init__ (line 80) | def __init__(self, project_dir: str = '.'):
    method init_db (line 85) | def init_db(self) -> None:
    method exists (line 94) | def exists(self) -> bool:
    method _conn (line 97) | def _conn(self) -> sqlite3.Connection:
    method create_reason (line 106) | def create_reason(self, node: ReasonNode) -> str:
    method get_reason (line 126) | def get_reason(self, reason_id: str) -> ReasonNode | None:
    method list_reasons (line 135) | def list_reasons(self, status: str | None = None) -> list[ReasonNode]:
    method update_reason_status (line 148) | def update_reason_status(
    method upsert_symbol (line 160) | def upsert_symbol(self, sym: Symbol) -> str:
    method get_symbols_for_file (line 177) | def get_symbols_for_file(self, file_path: str) -> list[Symbol]:
    method get_symbol_by_name (line 184) | def get_symbol_by_name(self, name: str) -> list[Symbol]:
    method create_edge (line 193) | def create_edge(self, edge: Edge) -> str:
    method get_edges_from (line 206) | def get_edges_from(
    method get_edges_to (line 221) | def get_edges_to(
    method create_drift_event (line 238) | def create_drift_event(self, event: DriftEvent) -> str:
    method get_unresolved_drift (line 253) | def get_unresolved_drift(self) -> list[DriftEvent]:
    method resolve_drift (line 261) | def resolve_drift(self, event_id: str) -> None:
    method get_reasons_for_file (line 270) | def get_reasons_for_file(self, file_path: str) -> list[ReasonNode]:
    method get_constraints_for_scope (line 283) | def get_constraints_for_scope(
    method get_blast_radius (line 302) | def get_blast_radius(self, reason_id: str) -> dict[str, Any]:
    method get_risk_profile (line 328) | def get_risk_profile(self, symbol_name: str) -> dict[str, Any]:
    method get_stats (line 363) | def get_stats(self) -> dict[str, int]:
    method _get_symbol (line 380) | def _get_symbol(self, symbol_id: str) -> Symbol | None:
    method _row_to_reason (line 388) | def _row_to_reason(row: sqlite3.Row) -> ReasonNode:
    method _row_to_symbol (line 408) | def _row_to_symbol(row: sqlite3.Row) -> Symbol:
    method _row_to_edge (line 421) | def _row_to_edge(row: sqlite3.Row) -> Edge:
    method _row_to_drift (line 432) | def _row_to_drift(row: sqlite3.Row) -> DriftEvent:

FILE: scripts/icpg/symbols.py
  function detect_language (line 36) | def detect_language(file_path: str) -> str | None:
  function checksum_content (line 41) | def checksum_content(content: str) -> str:
  function _extract_python (line 48) | def _extract_python(file_path: str, source: str) -> list[Symbol]:
  function _python_func_sig (line 88) | def _python_func_sig(node: ast.FunctionDef) -> str:
  function _python_class_sig (line 102) | def _python_class_sig(node: ast.ClassDef) -> str:
  function _extract_typescript (line 136) | def _extract_typescript(file_path: str, source: str) -> list[Symbol]:
  function _extract_go (line 174) | def _extract_go(file_path: str, source: str) -> list[Symbol]:
  function _extract_rust (line 210) | def _extract_rust(file_path: str, source: str) -> list[Symbol]:
  function _extract_elixir (line 245) | def _extract_elixir(file_path: str, source: str) -> list[Symbol]:
  function extract_symbols (line 282) | def extract_symbols(file_path: str) -> list[Symbol]:
  function extract_symbols_from_files (line 304) | def extract_symbols_from_files(file_paths: list[str]) -> list[Symbol]:

FILE: scripts/icpg/vectors.py
  class VectorStore (line 21) | class VectorStore:
    method __init__ (line 24) | def __init__(self, project_dir: str = '.'):
    method add_reason (line 29) | def add_reason(self, reason_id: str, goal: str, scope: list[str]) -> N...
    method search_similar (line 40) | def search_similar(
    method remove_reason (line 55) | def remove_reason(self, reason_id: str) -> None:
  function _detect_backend (line 65) | def _detect_backend() -> str:
  function _get_chroma_collection (line 86) | def _get_chroma_collection(icpg_dir: Path):
  function _chromadb_add (line 95) | def _chromadb_add(icpg_dir: Path, reason_id: str, text: str) -> None:
  function _chromadb_search (line 100) | def _chromadb_search(
  function _chromadb_remove (line 120) | def _chromadb_remove(icpg_dir: Path, reason_id: str) -> None:
  function _tfidf_load (line 130) | def _tfidf_load(icpg_dir: Path) -> dict[str, str]:
  function _tfidf_save (line 137) | def _tfidf_save(icpg_dir: Path, data: dict[str, str]) -> None:
  function _tfidf_add (line 142) | def _tfidf_add(icpg_dir: Path, reason_id: str, text: str) -> None:
  function _tfidf_search (line 148) | def _tfidf_search(
  function _tfidf_remove (line 178) | def _tfidf_remove(icpg_dir: Path, reason_id: str) -> None:
  function _exact_load (line 186) | def _exact_load(icpg_dir: Path) -> dict[str, str]:
  function _exact_save (line 193) | def _exact_save(icpg_dir: Path, data: dict[str, str]) -> None:
  function _exact_add (line 198) | def _exact_add(icpg_dir: Path, reason_id: str, text: str) -> None:
  function _exact_search (line 204) | def _exact_search(
  function _exact_remove (line 226) | def _exact_remove(icpg_dir: Path, reason_id: str) -> None:

FILE: scripts/mnemos/__main__.py
  function main (line 19) | def main(argv: list[str] | None = None) -> int:
  function cmd_init (line 107) | def cmd_init(store: MnemosStore) -> int:
  function cmd_status (line 115) | def cmd_status(store: MnemosStore, args) -> int:
  function cmd_fatigue (line 159) | def cmd_fatigue(store: MnemosStore, args) -> int:
  function cmd_checkpoint (line 215) | def cmd_checkpoint(store: MnemosStore, args) -> int:
  function cmd_resume (line 248) | def cmd_resume(args) -> int:
  function cmd_consolidate (line 262) | def cmd_consolidate(store: MnemosStore, args) -> int:
  function cmd_nodes (line 277) | def cmd_nodes(store: MnemosStore, args) -> int:
  function cmd_add (line 326) | def cmd_add(store: MnemosStore, args) -> int:
  function cmd_bridge_icpg (line 346) | def cmd_bridge_icpg(store: MnemosStore, args) -> int:
  function _try_load_icpg (line 362) | def _try_load_icpg(project_dir: str):
  function _fatigue_bar (line 380) | def _fatigue_bar(score: float) -> str:

FILE: scripts/mnemos/checkpoint.py
  function write_checkpoint (line 16) | def write_checkpoint(
  function load_checkpoint (line 120) | def load_checkpoint(
  function _format_checkpoint (line 143) | def _format_checkpoint(data: dict) -> str:
  function _get_git_state (line 252) | def _get_git_state(project_dir: Path) -> dict:
  function _get_icpg_state (line 294) | def _get_icpg_state(icpg_store) -> dict:
  function build_task_narrative (line 315) | def build_task_narrative(project_dir: str | Path) -> tuple[str, list[dic...
  function format_for_post_compact_injection (line 421) | def format_for_post_compact_injection(
  function write_compaction_marker (line 538) | def write_compaction_marker(project_dir: str = '.') -> None:
  function check_compaction_marker (line 548) | def check_compaction_marker(project_dir: str = '.') -> bool:
  function consume_compaction_marker (line 561) | def consume_compaction_marker(project_dir: str = '.') -> bool:
  function _checkpoint_to_dict (line 576) | def _checkpoint_to_dict(cp: CheckpointNode) -> dict:

FILE: scripts/mnemos/consolidation.py
  function micro_consolidate (line 18) | def micro_consolidate(
  function _compress_result_node (line 69) | def _compress_result_node(node: MnemoNode) -> str:
  function _should_evict (line 89) | def _should_evict(node: MnemoNode, current_scope: str) -> bool:

FILE: scripts/mnemos/fatigue.py
  function compute_fatigue (line 27) | def compute_fatigue(
  function read_fatigue_file (line 77) | def read_fatigue_file(project_dir: str = '.') -> dict:
  function write_fatigue_file (line 92) | def write_fatigue_file(

FILE: scripts/mnemos/models.py
  function _now (line 10) | def _now() -> str:
  function _uuid (line 14) | def _uuid() -> str:
  class MnemoNode (line 76) | class MnemoNode:
    method eviction_policy (line 106) | def eviction_policy(self) -> str:
    method is_evictable (line 110) | def is_evictable(self) -> bool:
    method is_compressible (line 114) | def is_compressible(self) -> bool:
  class FatigueState (line 119) | class FatigueState:
    method score_to_state (line 140) | def score_to_state(score: float) -> str:
  class CheckpointNode (line 155) | class CheckpointNode:

FILE: scripts/mnemos/signals.py
  function append_signal (line 29) | def append_signal(project_dir: str, signal: dict) -> None:
  function read_recent_signals (line 38) | def read_recent_signals(project_dir: str, limit: int = WINDOW_SIZE) -> l...
  function compute_scope_scatter (line 60) | def compute_scope_scatter(signals: list[dict]) -> float:
  function compute_reread_ratio (line 96) | def compute_reread_ratio(signals: list[dict]) -> float:
  function compute_error_density (line 118) | def compute_error_density(signals: list[dict]) -> float:
  function extract_signal_from_pre_tool (line 132) | def extract_signal_from_pre_tool(hook_input: dict) -> dict | None:
  function extract_signal_from_post_tool (line 163) | def extract_signal_from_post_tool(hook_input: dict) -> dict | None:
  function _normalize_path (line 200) | def _normalize_path(file_path: str) -> str:
  function _tail (line 212) | def _tail(filepath: str, n: int) -> list[str]:
  function get_session_stats (line 232) | def get_session_stats(project_dir: str) -> dict:

FILE: scripts/mnemos/store.py
  class MnemosStore (line 67) | class MnemosStore:
    method __init__ (line 70) | def __init__(self, project_dir: str = '.'):
    method init_db (line 75) | def init_db(self) -> None:
    method exists (line 84) | def exists(self) -> bool:
    method _conn (line 87) | def _conn(self) -> sqlite3.Connection:
    method create_node (line 96) | def create_node(self, node: MnemoNode) -> str:
    method get_node (line 114) | def get_node(self, node_id: str) -> MnemoNode | None:
    method get_active_nodes (line 121) | def get_active_nodes(self, task_id: str | None = None) -> list[MnemoNo...
    method get_by_type (line 136) | def get_by_type(
    method nodes_for_scope (line 147) | def nodes_for_scope(self, scope_tags: list[str]) -> list[MnemoNode]:
    method nodes_above_weight (line 155) | def nodes_above_weight(self, threshold: float) -> list[MnemoNode]:
    method update_node_status (line 164) | def update_node_status(self, node_id: str, status: str) -> None:
    method update_node_weight (line 171) | def update_node_weight(self, node_id: str, weight: float) -> None:
    method compress_node (line 178) | def compress_node(self, node_id: str, summary: str) -> None:
    method evict_node (line 187) | def evict_node(self, node_id: str) -> None:
    method touch_node (line 196) | def touch_node(self, node_id: str) -> None:
    method decay_weights (line 205) | def decay_weights(self, factor: float = 0.95) -> int:
    method save_checkpoint (line 222) | def save_checkpoint(self, cp: CheckpointNode) -> str:
    method get_latest_checkpoint (line 244) | def get_latest_checkpoint(
    method log_fatigue (line 263) | def log_fatigue(self, fatigue: FatigueState) -> None:
    method get_fatigue_history (line 278) | def get_fatigue_history(self, limit: int = 20) -> list[FatigueState]:
    method get_stats (line 288) | def get_stats(self) -> dict:
    method load_from_icpg (line 328) | def load_from_icpg(self, icpg_store, task_id: str = 'icpg-bridge') -> ...
    method _row_to_node (line 382) | def _row_to_node(row: sqlite3.Row) -> MnemoNode:
    method _row_to_checkpoint (line 401) | def _row_to_checkpoint(row: sqlite3.Row) -> CheckpointNode:
    method _row_to_fatigue (line 421) | def _row_to_fatigue(row: sqlite3.Row) -> FatigueState:

FILE: scripts/polyphony/__main__.py
  function cmd_init (line 27) | def cmd_init(args: argparse.Namespace) -> int:
  function cmd_status (line 35) | def cmd_status(args: argparse.Namespace) -> int:
  function cmd_spawn (line 51) | def cmd_spawn(args: argparse.Namespace) -> int:
  function build_parser (line 72) | def build_parser() -> argparse.ArgumentParser:
  function main (line 98) | def main() -> int:

FILE: scripts/polyphony/adapters/__init__.py
  function get_adapter (line 19) | def get_adapter(agent_type: str):
  function list_adapters (line 27) | def list_adapters() -> list[str]:

FILE: scripts/polyphony/adapters/claude.py
  class ClaudeAdapter (line 12) | class ClaudeAdapter:
    method build_command (line 15) | def build_command(
    method detect_completion (line 27) | def detect_completion(self, event: dict) -> bool:
    method detect_quota (line 31) | def detect_quota(self, text: str) -> bool:

FILE: scripts/polyphony/adapters/codex.py
  class CodexAdapter (line 12) | class CodexAdapter:
    method build_command (line 15) | def build_command(
    method detect_completion (line 26) | def detect_completion(self, event: dict) -> bool:
    method detect_quota (line 30) | def detect_quota(self, text: str) -> bool:

FILE: scripts/polyphony/adapters/kimi.py
  class KimiAdapter (line 12) | class KimiAdapter:
    method build_command (line 15) | def build_command(
    method detect_completion (line 24) | def detect_completion(self, event: dict) -> bool:
    method detect_quota (line 28) | def detect_quota(self, text: str) -> bool:

FILE: scripts/polyphony/config.py
  function default_config_dir (line 29) | def default_config_dir() -> Path:
  function load_config (line 33) | def load_config(config_dir: Path) -> dict:
  function load_identities (line 44) | def load_identities(config_dir: Path) -> list[Identity]:
  function load_agents (line 64) | def load_agents(config_dir: Path) -> list[AgentProfile]:
  function load_routing (line 86) | def load_routing(config_dir: Path) -> dict:

FILE: scripts/polyphony/events.py
  function _now (line 13) | def _now() -> str:
  class TaskEvent (line 18) | class TaskEvent:
    method from_dict (line 26) | def from_dict(cls, d: dict) -> TaskEvent:
  function parse_ndjson_line (line 35) | def parse_ndjson_line(line: str) -> dict | None:
  function parse_stream_json (line 46) | def parse_stream_json(lines: list[str]) -> list[dict]:
  function classify_event (line 56) | def classify_event(data: dict) -> TaskEvent:

FILE: scripts/polyphony/identity.py
  function resolve_identity (line 12) | def resolve_identity(
  function build_volume_mounts (line 23) | def build_volume_mounts(
  function build_env_overlay (line 34) | def build_env_overlay(identity: Identity) -> dict[str, str]:
  function validate_identity (line 45) | def validate_identity(identity: Identity) -> list[str]:

FILE: scripts/polyphony/models.py
  function _now (line 10) | def _now() -> str:
  function _uuid (line 14) | def _uuid() -> str:
  class Task (line 40) | class Task:
    method to_dict (line 58) | def to_dict(self) -> dict:
  class Identity (line 63) | class Identity:
  class AgentProfile (line 73) | class AgentProfile:
  class RunSpec (line 86) | class RunSpec:
  class Result (line 109) | class Result:

FILE: scripts/polyphony/orchestrator.py
  function discover_tasks (line 17) | def discover_tasks(store: PolyphonyStore) -> list[Task]:
  function claim_task (line 22) | def claim_task(
  function provision_workspace (line 32) | def provision_workspace(
  function run_agent (line 41) | def run_agent(run_spec: RunSpec) -> Result:
  function verify_result (line 46) | def verify_result(result: Result) -> bool:
  class Orchestrator (line 51) | class Orchestrator:
    method __init__ (line 54) | def __init__(
    method step (line 66) | def step(self) -> int:
  function _create_ws (line 76) | def _create_ws(
  function _execute_container (line 92) | def _execute_container(run_spec: RunSpec) -> Result:

FILE: scripts/polyphony/router.py
  function route (line 12) | def route(
  function select_agent (line 31) | def select_agent(
  function match_rule (line 47) | def match_rule(task: Task, rule: dict) -> bool:
  function _get_fallback (line 60) | def _get_fallback(task: Task, policy: dict) -> list[str]:

FILE: scripts/polyphony/runtime.py
  function build_docker_args (line 15) | def build_docker_args(run_spec: RunSpec) -> list[str]:
  function create_container (line 37) | def create_container(run_spec: RunSpec) -> str:
  function start_container (line 46) | def start_container(container_id: str) -> None:
  function stop_container (line 51) | def stop_container(
  function remove_container (line 63) | def remove_container(container_id: str) -> None:
  function container_logs (line 68) | def container_logs(container_id: str) -> str:
  function wait_container (line 74) | def wait_container(container_id: str) -> int:
  function _run_docker (line 82) | def _run_docker(cmd: list[str]) -> subprocess.CompletedProcess:

FILE: scripts/polyphony/scoring.py
  function score_task (line 30) | def score_task(task: Task) -> int:
  function score_cyclomatic (line 41) | def score_cyclomatic(task: Task) -> int:
  function score_fan_out (line 52) | def score_fan_out(task: Task) -> int:
  function score_security (line 62) | def score_security(task: Task) -> int:
  function score_concurrency (line 73) | def score_concurrency(task: Task) -> int:
  function score_domain (line 84) | def score_domain(task: Task) -> int:
  function _extract_keywords (line 93) | def _extract_keywords(task: Task) -> set[str]:

FILE: scripts/polyphony/sources/__init__.py
  function get_source (line 17) | def get_source(kind: str, **kwargs):
  function list_sources (line 25) | def list_sources() -> list[str]:

FILE: scripts/polyphony/sources/github.py
  class GitHubSource (line 14) | class GitHubSource:
    method __init__ (line 17) | def __init__(
    method poll (line 25) | def poll(self) -> list[Task]:
    method _issue_to_task (line 42) | def _issue_to_task(self, issue: dict) -> Task:
  function _run_gh (line 51) | def _run_gh(cmd: list[str]) -> subprocess.CompletedProcess:

FILE: scripts/polyphony/sources/local.py
  class LocalSource (line 14) | class LocalSource:
    method __init__ (line 17) | def __init__(self, db_path: Path | None = None):
    method _init_db (line 22) | def _init_db(self) -> None:
    method add_task (line 37) | def add_task(
    method poll (line 61) | def poll(self) -> list[Task]:
    method mark_claimed (line 81) | def mark_claimed(self, task_id: str) -> None:

FILE: scripts/polyphony/state_machine.py
  function can_transition (line 25) | def can_transition(current: str, target: str) -> bool:
  function transition (line 31) | def transition(task: Task, target: str) -> Task:
  function is_terminal (line 41) | def is_terminal(state: str) -> bool:

FILE: scripts/polyphony/store.py
  class PolyphonyStore (line 73) | class PolyphonyStore:
    method __init__ (line 76) | def __init__(self, base_dir: Path) -> None:
    method init_db (line 80) | def init_db(self) -> None:
    method _connect (line 87) | def _connect(self) -> sqlite3.Connection:
    method _write_gitignore (line 94) | def _write_gitignore(self) -> None:
    method save_task (line 101) | def save_task(self, task: Task) -> None:
    method get_task (line 118) | def get_task(self, task_id: str) -> Task | None:
    method list_tasks (line 126) | def list_tasks(self, state: str | None = None) -> list[Task]:
    method _row_to_task (line 137) | def _row_to_task(self, row: sqlite3.Row) -> Task:
    method save_run_spec (line 153) | def save_run_spec(self, rs: RunSpec) -> None:
    method get_run_spec (line 172) | def get_run_spec(self, rs_id: str) -> RunSpec | None:
    method _row_to_run_spec (line 180) | def _row_to_run_spec(self, row: sqlite3.Row) -> RunSpec:
    method save_result (line 197) | def save_result(self, result: Result) -> None:
    method get_result (line 214) | def get_result(self, result_id: str) -> Result | None:
    method list_results (line 222) | def list_results(self, task_id: str) -> list[Result]:
    method _row_to_result (line 231) | def _row_to_result(self, row: sqlite3.Row) -> Result:
    method log_transition (line 246) | def log_transition(self, task_id: str, from_s: str, to_s: str) -> None:
    method get_state_log (line 256) | def get_state_log(self, task_id: str) -> list[dict]:

FILE: scripts/polyphony/workspace.py
  function workspace_path (line 14) | def workspace_path(
  function create_workspace (line 24) | def create_workspace(
  function cleanup_workspace (line 51) | def cleanup_workspace(ws_path: Path) -> None:
  function list_workspaces (line 57) | def list_workspaces(base_dir: Path) -> list[Path]:
  function _run_git (line 70) | def _run_git(cmd: list[str]) -> subprocess.CompletedProcess:

FILE: scripts/skill_lint/__init__.py
  class Severity (line 11) | class Severity(Enum):
  class Finding (line 18) | class Finding:

FILE: scripts/skill_lint/__main__.py
  function discover_skills (line 16) | def discover_skills(skills_dir: Path, skill_filter: str | None = None) -...
  function lint_skill (line 32) | def lint_skill(skill_dir: Path, skills_dir: Path) -> list:
  function severity_from_str (line 44) | def severity_from_str(s: str) -> Severity:
  function main (line 57) | def main(argv: list[str] | None = None) -> int:

FILE: scripts/skill_lint/content.py
  function _in_code_block (line 42) | def _in_code_block(lines: list[str], target_idx: int) -> bool:
  function check (line 53) | def check(skill_path: Path, skill_dir: Path, skills_dir: Path) -> list[F...

FILE: scripts/skill_lint/frontmatter.py
  function parse_frontmatter (line 11) | def parse_frontmatter(content: str) -> tuple[dict[str, str], int]:
  function check (line 42) | def check(skill_path: Path, skill_dir: Path, skills_dir: Path) -> list[F...

FILE: scripts/skill_lint/references.py
  function check (line 16) | def check(skill_path: Path, skill_dir: Path, skills_dir: Path) -> list[F...

FILE: scripts/skill_lint/report.py
  function format_text (line 11) | def format_text(
  function format_json (line 68) | def format_json(

FILE: scripts/skill_lint/spec.py
  function check (line 10) | def check(skill_path: Path, skill_dir: Path, skills_dir: Path) -> list[F...

FILE: tests/test_cross_agent.py
  class TestCodexAutoReview (line 14) | class TestCodexAutoReview:
    method test_script_exists (line 17) | def test_script_exists(self) -> None:
    method test_script_is_executable (line 21) | def test_script_is_executable(self) -> None:
    method test_script_has_shebang (line 25) | def test_script_has_shebang(self) -> None:
    method test_script_checks_codex_installed (line 30) | def test_script_checks_codex_installed(self) -> None:
    method test_script_uses_exit_codes (line 35) | def test_script_uses_exit_codes(self) -> None:
  class TestCrossAgentDelegation (line 42) | class TestCrossAgentDelegation:
    method test_skill_exists (line 45) | def test_skill_exists(self) -> None:
    method test_skill_has_frontmatter (line 49) | def test_skill_has_frontmatter(self) -> None:
    method test_skill_references_icpg (line 55) | def test_skill_references_icpg(self) -> None:
    method test_skill_references_mnemos (line 63) | def test_skill_references_mnemos(self) -> None:
    method test_skill_has_complexity_scoring_rules (line 70) | def test_skill_has_complexity_scoring_rules(self) -> None:
    method test_skill_has_tool_detection (line 77) | def test_skill_has_tool_detection(self) -> None:
  class TestSettingsJsonHook (line 84) | class TestSettingsJsonHook:
    method test_settings_has_codex_review_hook (line 87) | def test_settings_has_codex_review_hook(self) -> None:
    method test_codex_hook_after_tdd (line 94) | def test_codex_hook_after_tdd(self) -> None:
    method test_codex_hook_before_icpg (line 107) | def test_codex_hook_before_icpg(self) -> None:
    method test_codex_hook_has_timeout (line 120) | def test_codex_hook_has_timeout(self) -> None:
  class TestConfigTomlHook (line 130) | class TestConfigTomlHook:
    method test_config_toml_has_codex_hook (line 133) | def test_config_toml_has_codex_hook(self) -> None:
    method test_config_toml_codex_hook_timeout (line 138) | def test_config_toml_codex_hook_timeout(self) -> None:
  class TestTemplateSkillRefs (line 152) | class TestTemplateSkillRefs:
    method test_claude_md_has_delegation_skill (line 155) | def test_claude_md_has_delegation_skill(self) -> None:
    method test_agents_md_has_delegation_skill (line 160) | def test_agents_md_has_delegation_skill(self) -> None:
    method test_claude_md_has_workflow_section (line 165) | def test_claude_md_has_workflow_section(self) -> None:
    method test_agents_md_has_workflow_section (line 172) | def test_agents_md_has_workflow_section(self) -> None:
  class TestInitializeProjectRef (line 180) | class TestInitializeProjectRef:
    method test_init_copies_delegation_skill (line 183) | def test_init_copies_delegation_skill(self) -> None:

FILE: tests/test_cross_tool.py
  class TestDetectAgents (line 14) | class TestDetectAgents:
    method test_script_exists_and_executable (line 17) | def test_script_exists_and_executable(self) -> None:
    method test_outputs_valid_format (line 22) | def test_outputs_valid_format(self) -> None:
  class TestInstallSkills (line 36) | class TestInstallSkills:
    method test_script_exists_and_executable (line 39) | def test_script_exists_and_executable(self) -> None:
    method test_copies_skills_to_target (line 44) | def test_copies_skills_to_target(self, tmp_path: Path) -> None:
    method test_no_args_shows_usage (line 61) | def test_no_args_shows_usage(self) -> None:
  class TestTemplates (line 72) | class TestTemplates:
    method test_agents_md_exists (line 75) | def test_agents_md_exists(self) -> None:
    method test_agents_md_has_skills_section (line 79) | def test_agents_md_has_skills_section(self) -> None:
    method test_config_toml_exists (line 85) | def test_config_toml_exists(self) -> None:
    method test_config_toml_has_hooks (line 89) | def test_config_toml_has_hooks(self) -> None:
    method test_agents_md_has_conventions (line 96) | def test_agents_md_has_conventions(self) -> None:
  class TestSyncAgentsCommand (line 103) | class TestSyncAgentsCommand:
    method test_command_exists (line 106) | def test_command_exists(self) -> None:
    method test_command_has_phases (line 110) | def test_command_has_phases(self) -> None:

FILE: tests/test_polyphony_adapters.py
  function claude_profile (line 12) | def claude_profile():
  function codex_profile (line 23) | def codex_profile():
  function kimi_profile (line 34) | def kimi_profile():
  function run_spec (line 45) | def run_spec():
  class TestRegistry (line 58) | class TestRegistry:
    method test_list_adapters (line 59) | def test_list_adapters(self):
    method test_get_claude_adapter (line 65) | def test_get_claude_adapter(self):
    method test_get_codex_adapter (line 69) | def test_get_codex_adapter(self):
    method test_get_kimi_adapter (line 73) | def test_get_kimi_adapter(self):
    method test_unknown_adapter_raises (line 77) | def test_unknown_adapter_raises(self):
  class TestClaudeAdapter (line 82) | class TestClaudeAdapter:
    method test_build_command (line 83) | def test_build_command(self, claude_profile, run_spec):
    method test_prompt_included (line 91) | def test_prompt_included(self, claude_profile, run_spec):
    method test_detect_completion (line 98) | def test_detect_completion(self):
    method test_detect_quota (line 103) | def test_detect_quota(self):
  class TestCodexAdapter (line 109) | class TestCodexAdapter:
    method test_build_command (line 110) | def test_build_command(self, codex_profile, run_spec):
    method test_detect_completion (line 117) | def test_detect_completion(self):
    method test_detect_quota (line 122) | def test_detect_quota(self):
  class TestKimiAdapter (line 128) | class TestKimiAdapter:
    method test_build_command (line 129) | def test_build_command(self, kimi_profile, run_spec):
    method test_detect_completion (line 136) | def test_detect_completion(self):
    method test_detect_quota (line 141) | def test_detect_quota(self):

FILE: tests/test_polyphony_config.py
  class TestDefaultConfigDir (line 14) | class TestDefaultConfigDir:
    method test_returns_path (line 15) | def test_returns_path(self):
  class TestLoadConfig (line 20) | class TestLoadConfig:
    method test_missing_dir_returns_defaults (line 21) | def test_missing_dir_returns_defaults(self, tmp_path):
    method test_loads_yaml (line 27) | def test_loads_yaml(self, tmp_path):
    method test_defaults_fill_missing_keys (line 37) | def test_defaults_fill_missing_keys(self, tmp_path):
  class TestLoadIdentities (line 44) | class TestLoadIdentities:
    method test_missing_file_returns_empty (line 45) | def test_missing_file_returns_empty(self, tmp_path):
    method test_loads_identities (line 49) | def test_loads_identities(self, tmp_path):
  class TestLoadAgents (line 64) | class TestLoadAgents:
    method test_missing_file_returns_empty (line 65) | def test_missing_file_returns_empty(self, tmp_path):
    method test_loads_agents (line 69) | def test_loads_agents(self, tmp_path):
  class TestLoadRouting (line 83) | class TestLoadRouting:
    method test_missing_file_returns_defaults (line 84) | def test_missing_file_returns_defaults(self, tmp_path):
    method test_loads_routing (line 89) | def test_loads_routing(self, tmp_path):

FILE: tests/test_polyphony_events.py
  class TestTaskEvent (line 13) | class TestTaskEvent:
    method test_create (line 14) | def test_create(self):
    method test_from_dict (line 23) | def test_from_dict(self):
  class TestParseNdjsonLine (line 33) | class TestParseNdjsonLine:
    method test_valid_json (line 34) | def test_valid_json(self):
    method test_empty_line (line 39) | def test_empty_line(self):
    method test_whitespace_line (line 42) | def test_whitespace_line(self):
    method test_invalid_json (line 45) | def test_invalid_json(self):
    method test_strips_whitespace (line 48) | def test_strips_whitespace(self):
  class TestParseStreamJson (line 54) | class TestParseStreamJson:
    method test_parses_multiple_lines (line 55) | def test_parses_multiple_lines(self):
    method test_skips_invalid_lines (line 65) | def test_skips_invalid_lines(self):
    method test_empty_input (line 74) | def test_empty_input(self):
  class TestClassifyEvent (line 78) | class TestClassifyEvent:
    method test_result_event (line 79) | def test_result_event(self):
    method test_message_event (line 83) | def test_message_event(self):
    method test_error_event (line 87) | def test_error_event(self):
    method test_unknown_event (line 91) | def test_unknown_event(self):
    method test_preserves_data (line 95) | def test_preserves_data(self):

FILE: tests/test_polyphony_identity.py
  function identities (line 14) | def identities():
  class TestResolveIdentity (line 28) | class TestResolveIdentity:
    method test_finds_by_name (line 29) | def test_finds_by_name(self, identities):
    method test_missing_raises (line 33) | def test_missing_raises(self, identities):
  class TestBuildVolumeMounts (line 38) | class TestBuildVolumeMounts:
    method test_mounts_for_claude (line 39) | def test_mounts_for_claude(self, identities):
    method test_no_mount_for_missing_agent (line 45) | def test_no_mount_for_missing_agent(self, identities):
  class TestBuildEnvOverlay (line 50) | class TestBuildEnvOverlay:
    method test_env_from_api_keys (line 51) | def test_env_from_api_keys(self, identities):
    method test_empty_when_no_keys (line 55) | def test_empty_when_no_keys(self, identities):
  class TestValidateIdentity (line 60) | class TestValidateIdentity:
    method test_valid (line 61) | def test_valid(self, identities):
    method test_missing_name (line 65) | def test_missing_name(self):
    method test_missing_volumes (line 70) | def test_missing_volumes(self):

FILE: tests/test_polyphony_models.py
  class TestHelpers (line 18) | class TestHelpers:
    method test_now_returns_iso_string (line 19) | def test_now_returns_iso_string(self):
    method test_uuid_returns_unique (line 24) | def test_uuid_returns_unique(self):
  class TestTaskConstants (line 30) | class TestTaskConstants:
    method test_task_types (line 31) | def test_task_types(self):
    method test_risk_levels (line 38) | def test_risk_levels(self):
    method test_scopes (line 41) | def test_scopes(self):
  class TestTask (line 49) | class TestTask:
    method test_create_minimal (line 50) | def test_create_minimal(self):
    method test_defaults (line 63) | def test_defaults(self):
    method test_to_dict (line 71) | def test_to_dict(self):
  class TestIdentity (line 79) | class TestIdentity:
    method test_create (line 80) | def test_create(self):
    method test_with_api_keys (line 90) | def test_with_api_keys(self):
  class TestAgentProfile (line 99) | class TestAgentProfile:
    method test_create (line 100) | def test_create(self):
    method test_event_protocol_default (line 110) | def test_event_protocol_default(self):
  class TestRunSpec (line 119) | class TestRunSpec:
    method test_create (line 120) | def test_create(self):
    method test_immutable_concept (line 135) | def test_immutable_concept(self):
  class TestResult (line 147) | class TestResult:
    method test_create (line 148) | def test_create(self):
    method test_status_values (line 162) | def test_status_values(self):

FILE: tests/test_polyphony_orchestrator.py
  function store (line 21) | def store(tmp_path):
  function task (line 28) | def task():
  function agents (line 39) | def agents():
  function policy (line 51) | def policy():
  function identities (line 62) | def identities():
  class TestDiscoverTasks (line 71) | class TestDiscoverTasks:
    method test_returns_tasks (line 72) | def test_returns_tasks(self, store, task):
    method test_empty_store (line 78) | def test_empty_store(self, store):
  class TestClaimTask (line 82) | class TestClaimTask:
    method test_transitions_to_claimed (line 83) | def test_transitions_to_claimed(self, store, task):
    method test_updates_store (line 88) | def test_updates_store(self, store, task):
  class TestProvisionWorkspace (line 95) | class TestProvisionWorkspace:
    method test_returns_path (line 97) | def test_returns_path(self, mock_ws, tmp_path, task):
    method test_calls_create (line 105) | def test_calls_create(self, mock_ws, tmp_path, task):
  class TestRunAgent (line 111) | class TestRunAgent:
    method test_returns_result (line 113) | def test_returns_result(self, mock_exec, task):
    method test_handles_failure (line 131) | def test_handles_failure(self, mock_exec, task):
  class TestVerifyResult (line 149) | class TestVerifyResult:
    method test_succeeded_passes (line 150) | def test_succeeded_passes(self):
    method test_failed_fails (line 159) | def test_failed_fails(self):
  class TestOrchestrator (line 169) | class TestOrchestrator:
    method test_init (line 170) | def test_init(self, store, agents, policy, identities):
    method test_has_step (line 179) | def test_has_step(self, store, agents, policy, identities):

FILE: tests/test_polyphony_router.py
  function agents (line 9) | def agents():
  function policy (line 33) | def policy():
  class TestMatchRule (line 56) | class TestMatchRule:
    method test_matches_single_field (line 57) | def test_matches_single_field(self):
    method test_no_match (line 65) | def test_no_match(self):
    method test_matches_multiple_fields (line 73) | def test_matches_multiple_fields(self):
    method test_partial_match_fails (line 81) | def test_partial_match_fails(self):
  class TestSelectAgent (line 90) | class TestSelectAgent:
    method test_selects_by_rule (line 91) | def test_selects_by_rule(self, agents, policy):
    method test_falls_to_default (line 99) | def test_falls_to_default(self, agents, policy):
    method test_high_risk_matches_claude (line 107) | def test_high_risk_matches_claude(self, agents, policy):
  class TestRoute (line 116) | class TestRoute:
    method test_returns_run_spec (line 117) | def test_returns_run_spec(self, agents, policy):
    method test_run_spec_has_fallback (line 128) | def test_run_spec_has_fallback(self, agents, policy):

FILE: tests/test_polyphony_runtime.py
  function run_spec (line 18) | def run_spec():
  class TestBuildDockerArgs (line 31) | class TestBuildDockerArgs:
    method test_includes_image (line 32) | def test_includes_image(self, run_spec):
    method test_includes_volumes (line 36) | def test_includes_volumes(self, run_spec):
    method test_includes_env (line 49) | def test_includes_env(self, run_spec):
    method test_includes_workspace_mount (line 53) | def test_includes_workspace_mount(self, run_spec):
    method test_container_name (line 58) | def test_container_name(self, run_spec):
  class TestCreateContainer (line 63) | class TestCreateContainer:
    method test_creates_container (line 65) | def test_creates_container(self, mock_docker, run_spec):
    method test_failure_raises (line 74) | def test_failure_raises(self, mock_docker, run_spec):
  class TestStartContainer (line 82) | class TestStartContainer:
    method test_starts (line 84) | def test_starts(self, mock_docker):
  class TestStopContainer (line 93) | class TestStopContainer:
    method test_stops (line 95) | def test_stops(self, mock_docker):
    method test_stop_with_timeout (line 102) | def test_stop_with_timeout(self, mock_docker):
  class TestRemoveContainer (line 110) | class TestRemoveContainer:
    method test_removes (line 112) | def test_removes(self, mock_docker):
  class TestContainerLogs (line 120) | class TestContainerLogs:
    method test_returns_logs (line 122) | def test_returns_logs(self, mock_docker):
  class TestWaitContainer (line 131) | class TestWaitContainer:
    method test_returns_exit_code (line 133) | def test_returns_exit_code(self, mock_docker):
    method test_nonzero_exit (line 141) | def test_nonzero_exit(self, mock_docker):

FILE: tests/test_polyphony_scoring.py
  function simple_task (line 17) | def simple_task():
  function complex_task (line 29) | def complex_task():
  class TestDimensions (line 45) | class TestDimensions:
    method test_five_dimensions (line 46) | def test_five_dimensions(self):
    method test_dimension_names (line 49) | def test_dimension_names(self):
  class TestScoreCyclomatic (line 57) | class TestScoreCyclomatic:
    method test_small_scope (line 58) | def test_small_scope(self, simple_task):
    method test_large_scope (line 61) | def test_large_scope(self, complex_task):
  class TestScoreFanOut (line 65) | class TestScoreFanOut:
    method test_no_callers (line 66) | def test_no_callers(self, simple_task):
    method test_many_callers (line 69) | def test_many_callers(self, complex_task):
  class TestScoreSecurity (line 73) | class TestScoreSecurity:
    method test_no_security_keywords (line 74) | def test_no_security_keywords(self, simple_task):
    method test_auth_keywords (line 77) | def test_auth_keywords(self, complex_task):
  class TestScoreConcurrency (line 81) | class TestScoreConcurrency:
    method test_no_concurrency (line 82) | def test_no_concurrency(self, simple_task):
    method test_async_locks (line 85) | def test_async_locks(self, complex_task):
  class TestScoreDomain (line 89) | class TestScoreDomain:
    method test_docs_task (line 90) | def test_docs_task(self, simple_task):
    method test_high_risk_refactor (line 93) | def test_high_risk_refactor(self, complex_task):
  class TestScoreTask (line 97) | class TestScoreTask:
    method test_simple_task_low (line 98) | def test_simple_task_low(self, simple_task):
    method test_complex_task_high (line 102) | def test_complex_task_high(self, complex_task):
    method test_score_range (line 106) | def test_score_range(self, simple_task):
    method test_returns_dict_with_breakdown (line 110) | def test_returns_dict_with_breakdown(self, simple_task):

FILE: tests/test_polyphony_sources.py
  class TestRegistry (line 13) | class TestRegistry:
    method test_list_sources (line 14) | def test_list_sources(self):
    method test_get_local_source (line 19) | def test_get_local_source(self):
    method test_get_github_source (line 23) | def test_get_github_source(self):
    method test_unknown_raises (line 27) | def test_unknown_raises(self):
  class TestLocalSource (line 32) | class TestLocalSource:
    method test_add_and_poll (line 33) | def test_add_and_poll(self, tmp_path):
    method test_poll_empty (line 41) | def test_poll_empty(self, tmp_path):
    method test_mark_claimed (line 45) | def test_mark_claimed(self, tmp_path):
    method test_multiple_tasks (line 54) | def test_multiple_tasks(self, tmp_path):
  class TestGitHubSource (line 63) | class TestGitHubSource:
    method test_poll_returns_tasks (line 65) | def test_poll_returns_tasks(self, mock_gh):
    method test_poll_empty (line 85) | def test_poll_empty(self, mock_gh):
    method test_poll_gh_failure (line 93) | def test_poll_gh_failure(self, mock_gh):
    method test_label_filter (line 102) | def test_label_filter(self, mock_gh):

FILE: tests/test_polyphony_state.py
  class TestConstants (line 14) | class TestConstants:
    method test_all_states_present (line 15) | def test_all_states_present(self):
    method test_transitions_keys_are_valid_states (line 22) | def test_transitions_keys_are_valid_states(self):
  class TestCanTransition (line 27) | class TestCanTransition:
    method test_discovered_to_claimed (line 28) | def test_discovered_to_claimed(self):
    method test_claimed_to_routed (line 31) | def test_claimed_to_routed(self):
    method test_routed_to_provisioned (line 34) | def test_routed_to_provisioned(self):
    method test_provisioned_to_running (line 37) | def test_provisioned_to_running(self):
    method test_running_to_verifying (line 40) | def test_running_to_verifying(self):
    method test_running_to_failed (line 43) | def test_running_to_failed(self):
    method test_verifying_to_landed (line 46) | def test_verifying_to_landed(self):
    method test_verifying_to_failed (line 49) | def test_verifying_to_failed(self):
    method test_failed_to_claimed_retry (line 52) | def test_failed_to_claimed_retry(self):
    method test_failed_to_blocked (line 55) | def test_failed_to_blocked(self):
    method test_invalid_discovered_to_running (line 58) | def test_invalid_discovered_to_running(self):
    method test_invalid_landed_to_anything (line 61) | def test_invalid_landed_to_anything(self):
    method test_invalid_same_state (line 65) | def test_invalid_same_state(self):
  class TestTransition (line 69) | class TestTransition:
    method test_valid_transition_updates_state (line 70) | def test_valid_transition_updates_state(self):
    method test_invalid_transition_raises (line 76) | def test_invalid_transition_raises(self):
    method test_transition_updates_timestamp (line 81) | def test_transition_updates_timestamp(self):
  class TestIsTerminal (line 88) | class TestIsTerminal:
    method test_landed_is_terminal (line 89) | def test_landed_is_terminal(self):
    method test_blocked_is_terminal (line 92) | def test_blocked_is_terminal(self):
    method test_discovered_not_terminal (line 95) | def test_discovered_not_terminal(self):
    method test_running_not_terminal (line 98) | def test_running_not_terminal(self):
    method test_failed_not_terminal (line 101) | def test_failed_not_terminal(self):

FILE: tests/test_polyphony_store.py
  function store (line 9) | def store(tmp_path):
  function sample_task (line 16) | def sample_task():
  class TestInit (line 24) | class TestInit:
    method test_creates_db (line 25) | def test_creates_db(self, tmp_path):
    method test_creates_gitignore (line 30) | def test_creates_gitignore(self, tmp_path):
    method test_idempotent (line 37) | def test_idempotent(self, tmp_path):
  class TestTaskCRUD (line 43) | class TestTaskCRUD:
    method test_save_and_get (line 44) | def test_save_and_get(self, store, sample_task):
    method test_get_missing_returns_none (line 51) | def test_get_missing_returns_none(self, store):
    method test_list_tasks (line 54) | def test_list_tasks(self, store):
    method test_list_tasks_by_state (line 62) | def test_list_tasks_by_state(self, store, sample_task):
    method test_update_task (line 69) | def test_update_task(self, store, sample_task):
  class TestRunSpecCRUD (line 77) | class TestRunSpecCRUD:
    method test_save_and_get (line 78) | def test_save_and_get(self, store):
    method test_get_missing (line 91) | def test_get_missing(self, store):
  class TestResultCRUD (line 95) | class TestResultCRUD:
    method test_save_and_get (line 96) | def test_save_and_get(self, store):
    method test_list_results_by_task (line 108) | def test_list_results_by_task(self, store):
  class TestStateLog (line 127) | class TestStateLog:
    method test_log_transition (line 128) | def test_log_transition(self, store, sample_task):

FILE: tests/test_polyphony_workspace.py
  class TestWorkspacePath (line 14) | class TestWorkspacePath:
    method test_creates_path (line 15) | def test_creates_path(self, tmp_path):
    method test_sanitizes_id (line 20) | def test_sanitizes_id(self, tmp_path):
  class TestCreateWorkspace (line 26) | class TestCreateWorkspace:
    method test_clones_repo (line 28) | def test_clones_repo(self, mock_git, tmp_path):
    method test_checks_out_branch (line 41) | def test_checks_out_branch(self, mock_git, tmp_path):
    method test_uses_mirror_when_available (line 54) | def test_uses_mirror_when_available(self, mock_git, tmp_path):
  class TestCleanupWorkspace (line 70) | class TestCleanupWorkspace:
    method test_removes_directory (line 71) | def test_removes_directory(self, tmp_path):
    method test_missing_dir_no_error (line 78) | def test_missing_dir_no_error(self, tmp_path):
  class TestListWorkspaces (line 82) | class TestListWorkspaces:
    method test_lists_dirs (line 83) | def test_lists_dirs(self, tmp_path):
    method test_empty_base (line 89) | def test_empty_base(self, tmp_path):

FILE: tests/test_session_detect.py
  function _patch_home (line 19) | def _patch_home(tmp_path):
  function test_detect_claude_from_history (line 23) | def test_detect_claude_from_history(tmp_path):
  function test_detect_claude_no_match (line 36) | def test_detect_claude_no_match(tmp_path):
  function test_detect_claude_missing_file (line 46) | def test_detect_claude_missing_file():
  function test_detect_kimi_from_state (line 52) | def test_detect_kimi_from_state(tmp_path):
  function test_detect_kimi_null_session (line 67) | def test_detect_kimi_null_session(tmp_path):
  function test_detect_kimi_no_file (line 79) | def test_detect_kimi_no_file():
  function test_detect_codex_from_session (line 84) | def test_detect_codex_from_session(tmp_path):
  function test_detect_codex_no_dir (line 102) | def test_detect_codex_no_dir():
  function test_detect_all_aggregates (line 107) | def test_detect_all_aggregates(tmp_path):
  function test_detect_all_empty (line 119) | def test_detect_all_empty(tmp_path):

FILE: tests/test_skill_lint.py
  function skills_dir (line 25) | def skills_dir(tmp_path: Path) -> Path:
  function _make_skill (line 32) | def _make_skill(skills_dir: Path, name: str, content: str) -> tuple[Path...
  class TestParseFrontmatter (line 43) | class TestParseFrontmatter:
    method test_valid_frontmatter (line 44) | def test_valid_frontmatter(self):
    method test_no_frontmatter (line 51) | def test_no_frontmatter(self):
    method test_unclosed_frontmatter (line 57) | def test_unclosed_frontmatter(self):
    method test_quoted_values (line 62) | def test_quoted_values(self):
  class TestFrontmatter (line 71) | class TestFrontmatter:
    method test_no_frontmatter (line 72) | def test_no_frontmatter(self, skills_dir):
    method test_missing_name (line 77) | def test_missing_name(self, skills_dir):
    method test_missing_description (line 82) | def test_missing_description(self, skills_dir):
    method test_name_mismatch (line 87) | def test_name_mismatch(self, skills_dir):
    method test_invalid_name_format (line 92) | def test_invalid_name_format(self, skills_dir):
    method test_clean_skill (line 97) | def test_clean_skill(self, skills_dir):
  class TestSpec (line 115) | class TestSpec:
    method test_missing_skill_md (line 116) | def test_missing_skill_md(self, skills_dir):
    method test_over_500_lines (line 122) | def test_over_500_lines(self, skills_dir):
    method test_between_300_500 (line 128) | def test_between_300_500(self, skills_dir):
    method test_inline_suppression (line 134) | def test_inline_suppression(self, skills_dir):
  class TestContent (line 149) | class TestContent:
    method test_ascii_art_detected (line 150) | def test_ascii_art_detected(self, skills_dir):
    method test_ascii_art_in_code_block_ok (line 156) | def test_ascii_art_in_code_block_ok(self, skills_dir):
    method test_vague_phrases (line 162) | def test_vague_phrases(self, skills_dir):
    method test_filler_intensity (line 168) | def test_filler_intensity(self, skills_dir):
    method test_stale_load_ref (line 178) | def test_stale_load_ref(self, skills_dir):
    method test_no_h1_heading (line 184) | def test_no_h1_heading(self, skills_dir):
  class TestReferences (line 193) | class TestReferences:
    method test_broken_skill_ref (line 194) | def test_broken_skill_ref(self, skills_dir):
    method test_valid_skill_ref (line 200) | def test_valid_skill_ref(self, skills_dir):
  class TestReport (line 210) | class TestReport:
    method test_text_format (line 211) | def test_text_format(self, skills_dir):
    method test_json_format (line 222) | def test_json_format(self, skills_dir):
  class TestCLI (line 235) | class TestCLI:
    method test_version (line 236) | def test_version(self, capsys):
    method test_missing_dir (line 241) | def test_missing_dir(self):
    method test_single_skill (line 245) | def test_single_skill(self, skills_dir):
    method test_fail_on_warning (line 261) | def test_fail_on_warning(self, skills_dir):