Skip to content

Build AI methods with your coding agent, then run them anywhere: as an MCP for chatbots, as a webapp for people, or via API for your software.

287 KB
Raw Blame
version = 1

["pipelex/base_exceptions.py::ErrorDomain.from_problem_domain"]
param = "problem_domain"
rationale = "Converts its one operand, a registry domain: ErrorDomain.from_problem_domain(spec.domain) reads as a conversion."

["pipelex/base_exceptions.py::PipelexError.with_error_code"]
param = "error_code"
rationale = "Chained at every raise site on its one operand, the chosen code: raise SomeError(msg).with_error_code(CoreCode.INPUT_MISSING)."

["pipelex/base_exceptions.py::PipelexError.with_security_target_class"]
param = "target_class"
rationale = "Chained at every raise site on its one operand, the class of destination refused: raise SsrfBlockedError(msg).with_security_target_class(target_class)."

["pipelex/base_exceptions.py::error_domain_is_input"]
param = "error_domain"
rationale = "Predicate on the error domain; single operand."

["pipelex/base_exceptions.py::iter_cause_chain"]
param = "exc"
rationale = "Verb-object: iterates the exception's cause chain; single operand."

["pipelex/base_exceptions.py::iter_pipelex_cause_chain"]
param = "exc"
rationale = "Verb-object: iterates the Pipelex part of the exception's cause chain; single operand, as iter_cause_chain."

["pipelex/base_exceptions.py::iter_traceback_chain"]
param = "exc"
rationale = "Verb-object: iterates the chain a traceback of the exception prints; single operand, as iter_cause_chain."

["pipelex/cli/agent_cli/commands/agent_output.py::agent_argument_error"]
param = "message"
rationale = "Refuses an argument with the command's message; single operand, as agent_error."

["pipelex/cli/agent_cli/commands/agent_output.py::agent_error"]
param = "message"
rationale = "Emits an agent error for the message; single operand."

["pipelex/cli/agent_cli/commands/agent_output.py::agent_error_validate_bundle"]
param = "exc"
rationale = "Error handler: the exc is the single operand handled."

["pipelex/cli/agent_cli/commands/agent_output.py::agent_file_error"]
param = "message"
rationale = "Refuses a local file with the command's message; single operand, as agent_error."

["pipelex/cli/agent_cli/commands/agent_output.py::agent_success"]
param = "result"
rationale = "Emits the success result payload; single operand."

["pipelex/cli/agent_cli/commands/agent_output.py::agent_success_formatted"]
param = "result"
rationale = "Emits the formatted success result; single operand."

["pipelex/cli/agent_cli/commands/agent_output.py::set_agent_cli_error_format"]
param = "error_format"
rationale = "Setter: installs the agent-CLI error format; single operand."

["pipelex/cli/agent_cli/commands/bundle_path_resolver.py::resolve_bundle_target"]
param = "path"
rationale = "Verb-object: resolves the target path; library_dir stays keyword."

["pipelex/cli/agent_cli/commands/check_model_cmd.py::_format_check_markdown"]
param = "result"
rationale = "Renders the result; single operand."

["pipelex/cli/agent_cli/commands/codegen/check_cmd.py::_format_codegen_check_markdown"]
param = "result"
rationale = "Positional-Callable protocol: passed as markdown_renderer, invoked renderer(result)."

["pipelex/cli/agent_cli/commands/codegen/types_cmd.py::_format_codegen_types_markdown"]
param = "result"
rationale = "Positional-Callable protocol: passed as markdown_renderer, invoked renderer(result)."

["pipelex/cli/agent_cli/commands/doctor_cmd.py::_format_doctor_markdown"]
param = "result"
rationale = "Renders the result; single operand."

["pipelex/cli/agent_cli/commands/fix/bundle_cmd.py::_failure_message"]
param = "result"
rationale = "Noun-named derivation: the failure message for the fix result; single operand."

["pipelex/cli/agent_cli/commands/fix/bundle_cmd.py::_normalize_rule_codes"]
param = "codes"
rationale = "Single-operand normalization of the rule codes."

["pipelex/cli/agent_cli/commands/fix/bundle_cmd.py::_result_payload"]
param = "result"
rationale = "Noun-named derivation from the fix result; bundle_path stays keyword."

["pipelex/cli/agent_cli/commands/init_cmd.py::_configure_routing"]
param = "selected_backend_keys"
rationale = "Configures routing from the selected backend keys; single operand."

["pipelex/cli/agent_cli/commands/init_cmd.py::_copy_inference_templates"]
param = "target_dir"
rationale = "Copies the inference templates into the target dir; single operand."

["pipelex/cli/agent_cli/commands/init_cmd.py::_copy_telemetry_template"]
param = "target_dir"
rationale = "Copies the telemetry template into the target dir; single operand."

["pipelex/cli/agent_cli/commands/init_cmd.py::_format_init_markdown"]
param = "result"
rationale = "Renders the result; single operand."

["pipelex/cli/agent_cli/commands/init_cmd.py::_parse_config_arg"]
param = "config_arg"
rationale = "Parses the config_arg; single operand."

["pipelex/cli/agent_cli/commands/inputs/_inputs_core.py::emit_inputs_result"]
param = "result"
rationale = "Verb-object: emits the result; format options stay keyword."

["pipelex/cli/agent_cli/commands/migrate_cmd.py::_render_markdown"]
param = "result"
rationale = "Positional-Callable protocol: passed as markdown_renderer, invoked renderer(result)."

["pipelex/cli/agent_cli/commands/plxt_passthrough.py::run_plxt"]
param = "subcommand"
rationale = "Runs the given plxt subcommand; single operand."

["pipelex/cli/agent_cli/commands/run/_output_helpers.py::_render_json_payload_lines"]
param = "result_payload"
rationale = "Renders the result_payload; single operand."

["pipelex/cli/agent_cli/commands/run/_output_helpers.py::format_run_markdown"]
param = "result"
rationale = "Renders the result; single operand."

["pipelex/cli/agent_cli/commands/run/_run_core.py::run_pipeline_core"]
param = "pipe_code"
rationale = "Runs the pipe identified by pipe_code; single operand."

["pipelex/cli/agent_cli/commands/run/stdin_resolver.py::_extract_stuff_entry"]
param = "stuff_data"
rationale = "Extracts from the stuff_data; single operand."

["pipelex/cli/agent_cli/commands/run/stdin_resolver.py::_parse_inputs_arg"]
param = "inputs_arg"
rationale = "Parses the inputs_arg; single operand."

["pipelex/cli/agent_cli/commands/run/stdin_resolver.py::parse_cli_inputs"]
param = "inputs_arg"
rationale = "Parses the inputs_arg; single operand."

["pipelex/cli/agent_cli/commands/run/stdin_resolver.py::resolve_stdin_inputs"]
param = "stdin_data"
rationale = "Parses the stdin_data; single operand."

["pipelex/cli/agent_cli/commands/validate/_validate_core.py::validate_bundle_core"]
param = "bundle_path"
rationale = "Validates the bundle at the path; single operand."

["pipelex/cli/agent_cli/commands/validate/_validate_core.py::validate_pipe_core"]
param = "pipe_code"
rationale = "Validates the pipe identified by pipe_code; single operand."

["pipelex/cli/bundle_target_resolution.py::resolve_bundle_target_core"]
param = "path"
rationale = "Verb-object: resolves the target path; library_dir stays keyword."

["pipelex/cli/commands/bundle_path_resolver.py::_stringify_library_dirs"]
param = "library_dirs"
rationale = "Single-operand conversion of the dirs list."

["pipelex/cli/commands/bundle_path_resolver.py::resolve_bundle_target"]
param = "path"
rationale = "Verb-object: resolves the target path; presentation params stay keyword."

["pipelex/cli/commands/codegen/check_cmd.py::_print_report"]
param = "report"
rationale = "Verb-object: prints the report; root stays keyword."

["pipelex/cli/commands/doctor_cmd.py::check_kit_template_exists"]
param = "backend_name"
rationale = "Verb–object: checks the backend_name; single operand."

["pipelex/cli/commands/doctor_cmd.py::replace_backend_file"]
param = "backend_name"
rationale = "Replaces the named backend's file; single operand."

["pipelex/cli/commands/fix/_diff_sandbox.py::PreviewSandbox.to_original"]
param = "path_str"
rationale = "Single-operand conversion: maps a sandbox path back to its original."

["pipelex/cli/commands/fix/_diff_sandbox.py::mirror_bundle_for_preview"]
param = "entry_path"
rationale = "Verb-object: mirrors the bundle at entry_path, or a method folder with no entry; the rest is context."

["pipelex/cli/commands/fix/_fix_core.py::_remap_result_to_originals"]
param = "result"
rationale = "Verb-object: remaps the result; sandbox is context."

["pipelex/cli/commands/fix/_fix_core.py::_remap_validation_error_to_original"]
param = "item"
rationale = "Verb-object: remaps the error item; sandbox is context."

["pipelex/cli/commands/graph_cmd.py::_do_graph_render"]
param = "input_file"
rationale = "Renders the input file to a graph; single operand."

["pipelex/cli/commands/init/backends.py::get_selected_backend_keys"]
param = "backends_toml_path"
rationale = "Derives from the backends_toml_path; single operand."

["pipelex/cli/commands/init/backends.py::update_backends_in_toml"]
param = "toml_doc"
rationale = "Mutates the given TOML document in place; single operand."

["pipelex/cli/commands/init/command.py::init_cmd"]
param = "focus"
rationale = "The init focus is the single operand; flags keyword-only."

["pipelex/cli/commands/init/credentials.py::get_required_vars_for_enabled_backends"]
param = "backends_toml_path"
rationale = "Derives from the backends_toml_path; single operand."

["pipelex/cli/commands/init/credentials.py::read_env_file"]
param = "env_path"
rationale = "File op keyed by the env_path path; single operand."

["pipelex/cli/commands/init/credentials.py::write_env_file"]
param = "env_path"
rationale = "File op keyed by the env_path path; single operand."

["pipelex/cli/commands/init/ide_extension.py::_install_extension"]
param = "ide_name"
rationale = "Installs the extension for the named IDE; single operand."

["pipelex/cli/commands/init/ide_extension.py::_is_extension_installed"]
param = "cmd"
rationale = "Operates on the cmd; single operand."

["pipelex/cli/commands/init/routing.py::customize_routing_profile"]
param = "selected_backend_keys"
rationale = "Customizes the routing profile from the selected backend keys; single operand."

["pipelex/cli/commands/init/ui/backends_ui.py::build_backend_selection_panel"]
param = "backend_options"
rationale = "Derives from the backend_options; single operand."

["pipelex/cli/commands/init/ui/backends_ui.py::get_backend_options_from_toml"]
param = "template_path"
rationale = "Derives from the template_path; single operand."

["pipelex/cli/commands/init/ui/backends_ui.py::get_currently_enabled_backends"]
param = "backends_toml_path"
rationale = "Derives from the backends_toml_path; single operand."

["pipelex/cli/commands/init/ui/routing_ui.py::build_fallback_order_panel"]
param = "remaining_backends"
rationale = "Derives from the remaining_backends; single operand."

["pipelex/cli/commands/init/ui/routing_ui.py::build_primary_backend_panel"]
param = "backend_keys"
rationale = "Derives from the backend_keys; single operand."

["pipelex/cli/commands/run/_hosted_sources.py::looks_like_method_id"]
param = "target"
rationale = "Tests the target string; single operand, as looks_like_method_ref does."

["pipelex/cli/commands/run/_inputs_file_loader.py::_convert_temporal_inputs"]
param = "inputs_dict"
rationale = "Single-operand conversion of the inputs dict."

["pipelex/cli/commands/run/_inputs_file_loader.py::load_inputs_dict_from_path"]
param = "path"
rationale = "Factory from source: loads the inputs dict from the file at path."

["pipelex/cli/commands/run/_inputs_file_loader.py::resolve_inputs_arg_against_dir"]
param = "inputs_arg"
rationale = "Verb-object: resolves the inputs argument; base_dir is context."

["pipelex/cli/commands/run/_inputs_path_resolver.py::resolve_inputs_paths"]
param = "inputs_dict"
rationale = "Operates on the inputs_dict; single operand."

["pipelex/cli/commands/run/_inputs_path_resolver.py::resolve_url_in_value"]
param = "value"
rationale = "Operates on the value; single operand."

["pipelex/cli/commands/run/_main_stuff_file.py::_filename_from_url"]
param = "url"
rationale = "Derives a file name from one URL, its sole operand."

["pipelex/cli/commands/show_cmd.py::do_show_pipe"]
param = "pipe_code"
rationale = "Shows the pipe identified by pipe_code; single operand."

["pipelex/cli/commands/update_cmd.py::_action_description"]
param = "status"
rationale = "Renders the status; single operand."

["pipelex/cli/commands/update_cmd.py::_apply_updates"]
param = "installed_dir"
rationale = "Applies one kit-managed area's updates in its installed dir; single operand."

["pipelex/cli/commands/update_cmd.py::_print_status_table"]
param = "report"
rationale = "Renders the deck-sync report; single operand."

["pipelex/cli/commands/update_cmd.py::_summary_panel"]
param = "message"
rationale = "Renders the message; single operand."

["pipelex/cli/commands/which_cmd.py::do_which_pipe"]
param = "pipe_code"
rationale = "Locates the pipe identified by pipe_code; single operand."

["pipelex/cli/dev_cli/commands/check_keyword_only_cmd.py::_package_of"]
param = "key_or_path"
rationale = "Verb–object: derives the report-grouping package of the key/path; single operand."

["pipelex/cli/dev_cli/commands/check_keyword_only_cmd.py::_print_report"]
param = "violations"
rationale = "Verb–object: prints the inventory report of these violations; options are keyword-only."

["pipelex/cli/dev_cli/commands/check_urls_cmd.py::check_all_urls_async"]
param = "url_pairs"
rationale = "Verb–object: checks the url_pairs; single operand."

["pipelex/cli/dev_cli/commands/drift/core.py::_normalize_pattern"]
param = "pattern"
rationale = "Guard/CLI helper: operates on the pattern; single operand."

["pipelex/cli/dev_cli/commands/drift/core.py::_pattern_to_regex"]
param = "pattern"
rationale = "Guard/CLI helper: operates on the pattern; single operand."

["pipelex/cli/dev_cli/commands/drift/core.py::build_plan_packets"]
param = "manifest"
rationale = "Derives from the manifest; single operand."

["pipelex/cli/dev_cli/commands/drift/core.py::compute_contract_digest"]
param = "contract"
rationale = "Guard/CLI helper: operates on the contract; single operand."

["pipelex/cli/dev_cli/commands/drift/core.py::compute_current_digest"]
param = "contract"
rationale = "Guard/CLI helper: operates on the contract; single operand."

["pipelex/cli/dev_cli/commands/drift/core.py::find_dead_patterns"]
param = "files"
rationale = "Looks up from the files; single operand."

["pipelex/cli/dev_cli/commands/drift/core.py::find_issues"]
param = "manifest"
rationale = "Looks up from the manifest; single operand."

["pipelex/cli/dev_cli/commands/drift/core.py::match_files"]
param = "files"
rationale = "Guard/CLI helper: operates on the files; single operand."

["pipelex/cli/dev_cli/commands/drift/core.py::match_pattern"]
param = "path"
rationale = "Guard/CLI helper: operates on the path; single operand."

["pipelex/cli/dev_cli/commands/drift/drift_cmd.py::_check_working_tree_coverage"]
param = "contract"
rationale = "Checks the contract's working-tree coverage; single operand."

["pipelex/cli/dev_cli/commands/drift/drift_cmd.py::_issue_message"]
param = "issue"
rationale = "Operates on the issue; single operand."

["pipelex/cli/dev_cli/commands/drift/drift_cmd.py::_render_packet_markdown"]
param = "packet"
rationale = "Renders the packet; single operand."

["pipelex/cli/dev_cli/commands/drift/drift_cmd.py::_resolve_repo_root"]
param = "repo_root"
rationale = "Operates on the repo_root; single operand."

["pipelex/cli/dev_cli/commands/drift/drift_cmd.py::_run_verify_commands"]
param = "commands"
rationale = "Guard/CLI helper: operates on the commands; single operand."

["pipelex/cli/dev_cli/commands/drift/drift_cmd.py::drift_ack_cmd"]
param = "contract_id"
rationale = "Acks the drift contract identified by id; single operand."

["pipelex/cli/dev_cli/commands/drift/drift_cmd.py::drift_plan_cmd"]
param = "contract_id"
rationale = "Plans the drift contract identified by id (None = all); single operand."

["pipelex/cli/dev_cli/commands/drift/git_adapter.py::_run_git"]
param = "args"
rationale = "Guard/CLI helper: operates on the args; single operand."

["pipelex/cli/dev_cli/commands/drift/git_adapter.py::get_git_user_name"]
param = "repo_root"
rationale = "Derives from the repo_root; single operand."

["pipelex/cli/dev_cli/commands/drift/git_adapter.py::read_staged_files"]
param = "repo_root"
rationale = "File op keyed by the repo_root path; single operand."

["pipelex/cli/dev_cli/commands/drift/git_adapter.py::read_unstaged_modified"]
param = "repo_root"
rationale = "File op keyed by the repo_root path; single operand."

["pipelex/cli/dev_cli/commands/drift/git_adapter.py::read_untracked"]
param = "repo_root"
rationale = "File op keyed by the repo_root path; single operand."

["pipelex/cli/dev_cli/commands/drift/git_adapter.py::stage_file"]
param = "path"
rationale = "Stages the file at that path; verb-object with a single obvious operand, repo_root is keyword context."

["pipelex/cli/dev_cli/commands/drift/models.py::ack_file_path"]
param = "repo_root"
rationale = "File op keyed by the repo_root path; single operand."

["pipelex/cli/dev_cli/commands/drift/models.py::load_ack"]
param = "ack_path"
rationale = "File op keyed by the ack_path path; single operand."

["pipelex/cli/dev_cli/commands/drift/models.py::load_all_acks"]
param = "repo_root"
rationale = "File op keyed by the repo_root path; single operand."

["pipelex/cli/dev_cli/commands/drift/models.py::load_manifest"]
param = "repo_root"
rationale = "File op keyed by the repo_root path; single operand."

["pipelex/cli/dev_cli/commands/drift/models.py::save_ack"]
param = "ack"
rationale = "File op keyed by the ack path; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_Collector._visit_function"]
param = "node"
rationale = "Guard/CLI helper: operates on the node; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_annotation_has_typer_metadata"]
param = "annotation"
rationale = "Guard/CLI helper: operates on the annotation; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_callee_name"]
param = "func"
rationale = "Guard/CLI helper: operates on the func; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_decorator_matches_carveout"]
param = "decorator"
rationale = "Guard/CLI helper: operates on the decorator; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_def_line_has_escape_hatch"]
param = "node"
rationale = "Guard/CLI helper: operates on the node; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_evaluate_def"]
param = "node"
rationale = "Guard/CLI helper: operates on the node; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_find_fix_records_in_source"]
param = "source"
rationale = "Looks up from the source; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_fix_insertion_point"]
param = "node"
rationale = "Guard/CLI helper: operates on the node; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_has_carveout_decorator"]
param = "node"
rationale = "Guard/CLI helper: operates on the node; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_has_typer_param_annotation"]
param = "node"
rationale = "Guard/CLI helper: operates on the node; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_is_dunder"]
param = "name"
rationale = "Operates on the name; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_is_literal_type_name"]
param = "annotation"
rationale = "Predicate on its single operand: is this annotation node a bare bool/int/float name."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_is_literal_typed_annotation"]
param = "annotation"
rationale = "Predicate on its single operand: does this annotation denote a literal type."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_iter_subscript_metadata"]
param = "annotation"
rationale = "Guard/CLI helper: operates on the annotation; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_positional_or_keyword_count"]
param = "node"
rationale = "Guard/CLI helper: operates on the node; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_qualify"]
param = "name"
rationale = "Guard/CLI helper: operates on the name; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_split_source_lines"]
param = "source"
rationale = "Guard/CLI helper: operates on the source; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_subject_param"]
param = "node"
rationale = "Verb–object: extracts the subject param of the def node; the node is the single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::_union_members"]
param = "annotation"
rationale = "Verb–object: flattens the annotation into its union members; single obvious operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::collect_all_violations"]
param = "root"
rationale = "Guard/CLI helper: operates on the root; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::collect_def_infos_in_source"]
param = "source"
rationale = "Guard/CLI helper: operates on the source; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::collect_violations_for_files"]
param = "paths"
rationale = "Guard/CLI helper: operates on the paths; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::find_violations_in_source"]
param = "source"
rationale = "Looks up from the source; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::fix_all_violations"]
param = "root"
rationale = "Guard/CLI helper: operates on the root; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::fix_source"]
param = "source"
rationale = "Guard/CLI helper: operates on the source; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::iter_source_files"]
param = "root"
rationale = "Guard/CLI helper: operates on the root; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::main"]
param = "argv"
rationale = "Guard/CLI helper: operates on the argv; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::module_qname_for"]
param = "path"
rationale = "Guard/CLI helper: operates on the path; single operand."

["pipelex/cli/dev_cli/commands/keyword_only_guard.py::relative_source_path"]
param = "path"
rationale = "Guard/CLI helper: operates on the path; single operand."

["pipelex/cli/dev_cli/commands/preprocess_test_models_cmd.py::_display_summary"]
param = "availability"
rationale = "Renders the availability; single operand."

["pipelex/cli/dev_cli/commands/preprocess_test_models_cmd.py::_extract_models_from_backend_toml"]
param = "backend_path"
rationale = "Extracts from the backend_path; single operand."

["pipelex/cli/dev_cli/commands/preprocess_test_models_cmd.py::_filter_models_by_profile"]
param = "availability"
rationale = "Filters the availability map by profile; single operand."

["pipelex/cli/dev_cli/commands/preprocess_test_models_cmd.py::_generate_fixtures_python"]
param = "combo_pairs"
rationale = "Generates fixture source from the combo pairs; single operand."

["pipelex/cli/dev_cli/commands/preprocess_test_models_cmd.py::_load_test_profile"]
param = "profile_name"
rationale = "Loads the named test profile; single operand."

["pipelex/cli/dev_cli/commands/preprocess_test_models_cmd.py::_process_collections_from_toml"]
param = "collections_raw"
rationale = "Processes the raw collections payload; single operand."

["pipelex/cli/dev_cli/commands/preprocess_test_models_cmd.py::_resolve_model_list"]
param = "raw_list"
rationale = "Operates on the raw_list; single operand."

["pipelex/cli/dev_cli/commands/preprocess_test_models_cmd.py::preprocess_test_models_cmd"]
param = "profile"
rationale = "Preprocesses test models for the named profile; single operand."

["pipelex/cli/dev_cli/commands/refresh_graph_ui_sri_cmd.py::_fetch"]
param = "url"
rationale = "Fetches the URL; single operand."

["pipelex/cli/dev_cli/commands/refresh_graph_ui_sri_cmd.py::_python_string_literal"]
param = "value"
rationale = "Renders the value as a Python string literal; single operand."

["pipelex/cli/dev_cli/commands/refresh_graph_ui_sri_cmd.py::_sha384_sri"]
param = "payload"
rationale = "Computes the SRI hash of the payload; single operand."

["pipelex/cli/dev_cli/commands/refresh_graph_ui_sri_cmd.py::_validate_sri"]
param = "value"
rationale = "Validates the SRI value; single operand."

["pipelex/cli/dev_cli/commands/subject_grant_cmd.py::_fail"]
param = "message"
rationale = "Verb–object: fails with the given message; single operand, call sites read as a sentence."

["pipelex/cli/dev_cli/commands/sync_kit_configs_cmd.py::_display_result"]
param = "result"
rationale = "Renders the result; single operand."

["pipelex/cli/dev_cli/commands/sync_main_config_cmd.py::_display_sync_result"]
param = "result"
rationale = "Renders the result; single operand."

["pipelex/cli/dev_cli/commands/sync_main_config_cmd.py::_format_value"]
param = "value"
rationale = "Renders the value; single operand."

["pipelex/cli/error_handlers.py::_validation_category_header"]
param = "category"
rationale = "Noun-named derivation: the header text for the category; single operand."

["pipelex/cli/error_handlers.py::handle_model_availability_error"]
param = "exc"
rationale = "Error handler: the exc is the single operand handled."

["pipelex/cli/error_handlers.py::handle_model_choice_error"]
param = "exc"
rationale = "Error handler: the exc is the single operand handled."

["pipelex/cli/error_handlers.py::handle_model_deck_preset_error"]
param = "exc"
rationale = "Error handler: the exc is the single operand handled."

["pipelex/cli/error_handlers.py::handle_telemetry_config_validation_error"]
param = "exc"
rationale = "Error handler: the exc is the single operand handled."

["pipelex/cli/error_handlers.py::handle_validate_bundle_error"]
param = "exc"
rationale = "Error handler: the exc is the single operand handled."

["pipelex/cli/installed_methods.py::discover_method_at"]
param = "method_dir"
rationale = "Looks up from the method_dir; single operand."

["pipelex/cli/installed_methods.py::discover_methods_from_library_dirs"]
param = "library_dirs"
rationale = "Looks up from the library_dirs; single operand."

["pipelex/cli/installed_methods.py::find_method_by_full_address"]
param = "full_address"
rationale = "Looks up from the full_address; single operand."

["pipelex/cli/installed_methods.py::find_method_by_name"]
param = "method_name"
rationale = "Looks up from the method_name; single operand."

["pipelex/cli/method_resolver.py::_find_method_by_exported_pipe"]
param = "pipe_code"
rationale = "Looks up from the pipe_code; single operand."

["pipelex/cli/method_resolver.py::_get_all_exported_pipes"]
param = "method"
rationale = "Looks up from the method; single operand."

["pipelex/cli/method_resolver.py::is_local_path"]
param = "target"
rationale = "Operates on the target; single operand."

["pipelex/cli/method_resolver.py::resolve_method_from_path"]
param = "method_path"
rationale = "Operates on the method_path; single operand."

["pipelex/cli/method_resolver.py::resolve_method_from_ref"]
param = "ref_str"
rationale = "Operates on the ref string; single operand."

["pipelex/cli/method_resolver.py::resolve_method_target"]
param = "method_name"
rationale = "Operates on the method_name; single operand."

["pipelex/cli/method_resolver.py::resolve_pipe_from_exports"]
param = "pipe_code"
rationale = "Operates on the pipe_code; single operand."

["pipelex/codegen/check.py::_read_text_or_none"]
param = "path"
rationale = "Verb-object: reads the file at path; single operand."

["pipelex/codegen/crate_encoding.py::_dump_object"]
param = "obj"
rationale = "Single-operand conversion of the model."

["pipelex/codegen/crate_encoding.py::_encoding_payload"]
param = "crate"
rationale = "Noun-named derivation: the encoding payload for the crate; single operand."

["pipelex/codegen/crate_encoding.py::encode_crate"]
param = "crate"
rationale = "Verb-object: encodes the crate; encoding is a mode and stays keyword."

["pipelex/codegen/crate_encoding.py::encode_crate_json"]
param = "crate"
rationale = "Verb-object: encodes the crate; single operand."

["pipelex/codegen/crate_encoding.py::encode_crate_toml"]
param = "crate"
rationale = "Verb-object: encodes the crate; single operand."

["pipelex/codegen/emission.py::_previous_tracked_paths"]
param = "lock_path"
rationale = "Noun-named derivation: reads the tracked paths from the lock file at lock_path."

["pipelex/codegen/emission.py::build_stamped_projection"]
param = "emitted"
rationale = "Factory from source: builds the projection from the emitted files; stamp fields stay keyword."

["pipelex/codegen/emission.py::write_stamped_projection"]
param = "emitted"
rationale = "Verb-object: writes the projection built from the emitted files; the rest stays keyword."

["pipelex/codegen/emitters/naming.py::_ts_symbols_are_free"]
param = "type_name"
rationale = "Predicate on the type name; used_symbols is context."

["pipelex/codegen/emitters/naming.py::allocate_ts_type_names"]
param = "library"
rationale = "Single-operand transformation: derives the name mapping over the whole library."

["pipelex/codegen/emitters/naming.py::snake_to_pascal"]
param = "name"
rationale = "Single-operand conversion of the name."

["pipelex/codegen/emitters/python_common.py::_docstring_delimiter"]
param = "text"
rationale = "Single-operand derivation: picks the delimiter that fits the text."

["pipelex/codegen/emitters/python_common.py::_split_top_level"]
param = "inner"
rationale = "Verb-object: splits the bracket inner text; single operand."

["pipelex/codegen/emitters/python_common.py::class_docstring"]
param = "description"
rationale = "Noun-named derivation: builds the docstring from the description; extras stay keyword."

["pipelex/codegen/emitters/python_common.py::escape_py_string"]
param = "value"
rationale = "Single-operand conversion of the value."

["pipelex/codegen/emitters/python_common.py::explode_bracket"]
param = "text"
rationale = "Verb-object: explodes the bracketed annotation text; the budget is context."

["pipelex/codegen/emitters/python_common.py::field_line"]
param = "field"
rationale = "Noun-named derivation: the source line for the field; annotation stays keyword."

["pipelex/codegen/emitters/python_common.py::format_default_value"]
param = "value"
rationale = "Single-operand formatting of the value."

["pipelex/codegen/emitters/python_common.py::normalized_docstring_text"]
param = "text"
rationale = "Single-operand normalization of the text into its docstring-canonical form."

["pipelex/codegen/emitters/python_common.py::order_by_base"]
param = "concepts"
rationale = "Verb-object: orders the concepts; in_module is context."

["pipelex/codegen/emitters/python_common.py::order_by_base.visit"]
param = "concept"
rationale = "Visitor: visits the concept; single operand."

["pipelex/codegen/emitters/python_common.py::render_import_block"]
param = "imports"
rationale = "Verb-object: renders the collected imports into a source block; single operand."

["pipelex/codegen/emitters/python_pydantic.py::_annotation"]
param = "resolved_type"
rationale = "Noun-named derivation: the annotation for the resolved type; context stays keyword."

["pipelex/codegen/emitters/python_pydantic.py::_base_class"]
param = "concept"
rationale = "Noun-named derivation: the base class for the concept; context stays keyword."

["pipelex/codegen/emitters/python_pydantic.py::_concept_annotation"]
param = "resolved_type"
rationale = "Noun-named derivation: the annotation for the resolved type; context stays keyword."

["pipelex/codegen/emitters/python_pydantic.py::_render_class"]
param = "concept"
rationale = "Verb-object: renders the concept; context stays keyword."

["pipelex/codegen/emitters/python_pydantic.py::_render_field"]
param = "concept_field"
rationale = "Verb-object: renders the field; context stays keyword."

["pipelex/codegen/emitters/python_pydantic.py::emit_python_pydantic"]
param = "library"
rationale = "Verb-object: emits from the resolved library; single operand."

["pipelex/codegen/emitters/python_structures.py::_annotation"]
param = "resolved_type"
rationale = "Noun-named derivation: the annotation for the resolved type; context stays keyword."

["pipelex/codegen/emitters/python_structures.py::_base_class"]
param = "concept"
rationale = "Noun-named derivation: the base class for the concept; context stays keyword."

["pipelex/codegen/emitters/python_structures.py::_concept_annotation"]
param = "resolved_type"
rationale = "Noun-named derivation: the annotation for the resolved type; context stays keyword."

["pipelex/codegen/emitters/python_structures.py::_native_class"]
param = "concept_ref"
rationale = "Noun-named derivation: parses the concept_ref and derives its native structure class; imports is an out-param."

["pipelex/codegen/emitters/python_structures.py::_render_class"]
param = "concept"
rationale = "Verb-object: renders the concept; context stays keyword."

["pipelex/codegen/emitters/python_structures.py::_render_field"]
param = "concept_field"
rationale = "Verb-object: renders the field; context stays keyword."

["pipelex/codegen/emitters/python_structures.py::emit_python_structures"]
param = "library"
rationale = "Verb-object: emits from the resolved library; single operand."

["pipelex/codegen/emitters/ts_zod.py::_binder_pair"]
param = "type_name"
rationale = "Noun-named derivation: encodes the type name into its parse/serialize pair."

["pipelex/codegen/emitters/ts_zod.py::_break_zod_expr"]
param = "expr"
rationale = "Verb-object: breaks the zod expression across lines; the modifier is context."

["pipelex/codegen/emitters/ts_zod.py::_concept_dependencies"]
param = "concept"
rationale = "Noun-named derivation: the dependency refs of the concept; single operand."

["pipelex/codegen/emitters/ts_zod.py::_concept_schema"]
param = "resolved_type"
rationale = "Noun-named derivation: the schema expr for the resolved type; context stays keyword."

["pipelex/codegen/emitters/ts_zod.py::_concept_type"]
param = "resolved_type"
rationale = "Noun-named derivation: the TS type for the resolved type; context stays keyword."

["pipelex/codegen/emitters/ts_zod.py::_concept_type_expr"]
param = "concept"
rationale = "Noun-named derivation: the type expr for the concept; context stays keyword."

["pipelex/codegen/emitters/ts_zod.py::_emit_binder"]
param = "concepts"
rationale = "Verb-object: emits the binder for the concepts; mapping stays keyword."

["pipelex/codegen/emitters/ts_zod.py::_explode_enum_call"]
param = "call"
rationale = "Verb-object: explodes the enum call it is handed; the column stays keyword."

["pipelex/codegen/emitters/ts_zod.py::_find_recursive_concept_refs"]
param = "concepts"
rationale = "Single-operand analysis over the concepts collection."

["pipelex/codegen/emitters/ts_zod.py::_format_default_value"]
param = "value"
rationale = "Single-operand formatting of the value."

["pipelex/codegen/emitters/ts_zod.py::_is_enum_call"]
param = "call"
rationale = "Verb-object predicate over the one member call it classifies."

["pipelex/codegen/emitters/ts_zod.py::_jsdoc"]
param = "description"
rationale = "Noun-named derivation: builds the JSDoc from the description; extras stay keyword."

["pipelex/codegen/emitters/ts_zod.py::_presence_modifiers"]
param = "concept_field"
rationale = "Reads as a verb-object sentence over the one field it describes, matching every other renderer in this emitter."

["pipelex/codegen/emitters/ts_zod.py::_render_broken_call"]
param = "call"
rationale = "Verb-object: renders the one member call it is handed; the column stays keyword."

["pipelex/codegen/emitters/ts_zod.py::_render_field"]
param = "concept_field"
rationale = "Verb-object: renders the field; context stays keyword."

["pipelex/codegen/emitters/ts_zod.py::_render_schema"]
param = "concept"
rationale = "Verb-object: renders the concept's schema; context stays keyword."

["pipelex/codegen/emitters/ts_zod.py::_render_type_field"]
param = "concept_field"
rationale = "Verb-object: renders the field's type line; context stays keyword."

["pipelex/codegen/emitters/ts_zod.py::_resolved_type_concept_refs"]
param = "resolved_type"
rationale = "Noun-named derivation: the concept refs of the resolved type; single operand."

["pipelex/codegen/emitters/ts_zod.py::_sanitize_jsdoc_text"]
param = "value"
rationale = "Single-operand sanitization of the text."

["pipelex/codegen/emitters/ts_zod.py::_schema_expr"]
param = "concept"
rationale = "Noun-named derivation: the schema expr for the concept; context stays keyword."

["pipelex/codegen/emitters/ts_zod.py::_split_enum_members"]
param = "members_text"
rationale = "Verb-object: splits the enum member text it is handed, its one operand."

["pipelex/codegen/emitters/ts_zod.py::_split_member_chain"]
param = "expr"
rationale = "Verb-object: splits the zod expression into its member chain, its one operand."

["pipelex/codegen/emitters/ts_zod.py::_ts_literal"]
param = "value"
rationale = "Single-operand formatting of the value, matching the sibling default-value renderers."

["pipelex/codegen/emitters/ts_zod.py::_ts_object_key"]
param = "key"
rationale = "Single-operand formatting of the key it quotes."

["pipelex/codegen/emitters/ts_zod.py::_ts_signature"]
param = "name"
rationale = "Verb-object: renders the signature for the named function; param and return type are context."

["pipelex/codegen/emitters/ts_zod.py::_ts_string"]
param = "text"
rationale = "Single-operand formatting of the text it quotes."

["pipelex/codegen/emitters/ts_zod.py::_ts_type"]
param = "resolved_type"
rationale = "Noun-named derivation: the TS type for the resolved type; context stays keyword."

["pipelex/codegen/emitters/ts_zod.py::_zod_type"]
param = "resolved_type"
rationale = "Noun-named derivation: the zod expr for the resolved type; context stays keyword."

["pipelex/codegen/emitters/ts_zod.py::emit_ts_zod"]
param = "library"
rationale = "Verb-object: emits from the resolved library; single operand."

["pipelex/codegen/emitters/types_emitter.py::emit_types"]
param = "crate"
rationale = "Verb-object: emits types from the crate; target is a mode and stays keyword."

["pipelex/codegen/lock.py::_raise_path_error"]
param = "path"
rationale = "Error raiser: the offending path is the single operand reported; reason stays keyword."

["pipelex/codegen/lock.py::encode_lock"]
param = "lock"
rationale = "Single-operand conversion of the lock."

["pipelex/codegen/lock.py::load_lock"]
param = "lock_path"
rationale = "Factory from source: loads the lock from the file at lock_path."

["pipelex/codegen/lock.py::validate_artifact_path"]
param = "path"
rationale = "Validator: the path is the single operand validated."

["pipelex/codegen/lock.py::validate_artifact_paths"]
param = "paths"
rationale = "Validator: the paths are the operand validated."

["pipelex/codegen/native_expansion.py::_annotation_to_blueprint"]
param = "annotation"
rationale = "Single-operand conversion of the annotation; description stays keyword."

["pipelex/codegen/native_expansion.py::_is_nested_model"]
param = "annotation"
rationale = "Predicate on the annotation; single operand."

["pipelex/codegen/native_expansion.py::_list_blueprint"]
param = "list_annotation"
rationale = "Noun-named derivation from the list annotation; the rest stays keyword."

["pipelex/codegen/native_expansion.py::collect_native_refs_from_structure"]
param = "structure"
rationale = "Single-operand analysis over the structure mapping."

["pipelex/codegen/native_expansion.py::materialize_native_concept"]
param = "native_code"
rationale = "Factory from source: materializes the concept identified by the native code."

["pipelex/codegen/native_expansion.py::reflect_native_structure"]
param = "native_code"
rationale = "Noun-named derivation: the reflected structure for the native code; single operand."

["pipelex/codegen/resolved_concepts.py::_resolve_concept"]
param = "concept_ref"
rationale = "Verb-object: resolves the concept_ref; the rest is context."

["pipelex/codegen/resolved_concepts.py::resolve_concepts_from_crate"]
param = "crate"
rationale = "Factory from source: resolves the whole crate into a library."

["pipelex/codegen/stamp.py::_kind_from_value"]
param = "value"
rationale = "Single-operand parse of the value."

["pipelex/codegen/stamp.py::_parse_fields"]
param = "header_region"
rationale = "Parser: the header region is the operand; comment_prefix is context."

["pipelex/codegen/stamp.py::_parse_options"]
param = "options_raw"
rationale = "Parser: the raw options string is the single operand."

["pipelex/codegen/stamp.py::_parse_projection"]
param = "projection"
rationale = "Parser: the projection string is the single operand."

["pipelex/codegen/stamp.py::_reject_json_constant"]
param = "value"
rationale = "Callback invoked positionally by json.loads parse_constant; the constant literal is the single operand."

["pipelex/codegen/stamp.py::_target_from_value"]
param = "value"
rationale = "Single-operand parse of the value."

["pipelex/codegen/stamp.py::apply_stamp"]
param = "body"
rationale = "Verb-object: stamps the body; stamp fields stay keyword."

["pipelex/codegen/stamp.py::comment_prefix_for"]
param = "filename"
rationale = "Noun-named derivation: the comment prefix for the filename (suffix-encoded)."

["pipelex/codegen/stamp.py::compute_content_hash"]
param = "body"
rationale = "Noun-named derivation: the hash of the body; single operand."

["pipelex/codegen/stamp.py::has_stamp"]
param = "text"
rationale = "Predicate on the text; comment_prefix is context."

["pipelex/codegen/stamp.py::parse_stamped"]
param = "text"
rationale = "Parser: the text is the operand; comment_prefix is context."

["pipelex/cogt/config_cogt.py::ImgGenConfig.get_num_inference_steps"]
param = "model_name"
rationale = "Keyed accessor by the model_name; single operand."

["pipelex/cogt/config_cogt.py::LLMConfig.get_template"]
param = "template_name"
rationale = "Keyed accessor by the template_name; single operand."

["pipelex/cogt/content_generation/assignment_models.py::LLMAssignment.clone_with_new_prompt"]
param = "new_prompt"
rationale = "Operates on the new_prompt; single operand (qualifiers keyword-only)."

["pipelex/cogt/content_generation/assignment_models.py::ObjectAssignment.make_for_class"]
param = "object_class"
rationale = "Factory from source: builds the result from the object_class; single operand."

["pipelex/cogt/content_generation/assignment_models.py::SearchObjectAssignment.make_for_class"]
param = "output_class"
rationale = "Factory from source: builds the result from the output_class; single operand."

["pipelex/cogt/content_generation/content_generator_protocol.py::ContentGeneratorProtocol.make_judgment_answers"]
param = "judgment_assignment"
rationale = "Worker verb-object: processes the judgment_assignment; single operand, mirroring make_search_sourced_answer."

["pipelex/cogt/content_generation/content_generator_protocol.py::ContentGeneratorProtocol.make_search_sourced_answer"]
param = "search_assignment"
rationale = "Factory from source: builds the result from the search_assignment; single operand."

["pipelex/cogt/content_generation/content_generator_protocol.py::update_job_metadata"]
param = "func"
rationale = "Decorator: wraps the single func operand."

["pipelex/cogt/content_generation/doc_gen_generate.py::render_document_and_store"]
param = "render_assignment"
rationale = "Content-generation leaf: renders and stores the one render assignment, like its sibling leaves."

["pipelex/cogt/content_generation/dry_mock.py::_dry_image_content"]
param = "image_url"
rationale = "Consumes the image_url; single operand."

["pipelex/cogt/content_generation/dry_mock.py::_dry_report_func"]
param = "cogt_run_params"
rationale = "Consumes the cogt_run_params; single operand."

["pipelex/cogt/content_generation/dry_mock.py::_leaf_gen_object"]
param = "object_assignment"
rationale = "Consumes the object_assignment; single operand."

["pipelex/cogt/content_generation/dry_mock.py::_leaf_gen_object_list"]
param = "object_assignment"
rationale = "Consumes the object_assignment; single operand."

["pipelex/cogt/content_generation/dry_mock.py::_nb_list_items"]
param = "object_assignment"
rationale = "Consumes the object_assignment; single operand."

["pipelex/cogt/content_generation/dry_mock.py::build_mock_object"]
param = "model_class"
rationale = "Factory from source: builds the result from the model_class; single operand."

["pipelex/cogt/content_generation/dry_mock.py::build_mock_objects"]
param = "model_class"
rationale = "Factory from source: builds the result from the model_class; single operand."

["pipelex/cogt/content_generation/dry_mock.py::dry_extract_page_contents"]
param = "extract_assignment"
rationale = "Consumes the extract_assignment; single operand."

["pipelex/cogt/content_generation/dry_mock.py::dry_img_gen_image_contents"]
param = "img_gen_assignment"
rationale = "Consumes the img_gen_assignment; single operand."

["pipelex/cogt/content_generation/dry_mock.py::dry_judgment_gen_answers"]
param = "judgment_assignment"
rationale = "Worker verb-object: processes the judgment_assignment; single operand."

["pipelex/cogt/content_generation/dry_mock.py::dry_llm_gen_object"]
param = "object_assignment"
rationale = "Consumes the object_assignment; single operand."

["pipelex/cogt/content_generation/dry_mock.py::dry_llm_gen_object_list"]
param = "object_assignment"
rationale = "Consumes the object_assignment; single operand."

["pipelex/cogt/content_generation/dry_mock.py::dry_llm_gen_text"]
param = "llm_assignment"
rationale = "Consumes the llm_assignment; single operand."

["pipelex/cogt/content_generation/dry_mock.py::dry_render_document"]
param = "render_assignment"
rationale = "Dry-run mock of the render leaf: mocks the one render assignment it is handed."

["pipelex/cogt/content_generation/dry_mock.py::dry_search_gen_structured"]
param = "search_object_assignment"
rationale = "Consumes the search_object_assignment; single operand."

["pipelex/cogt/content_generation/dry_mock.py::dry_templating_gen_text"]
param = "templating_assignment"
rationale = "Consumes the templating_assignment; single operand."

["pipelex/cogt/content_generation/dry_mock.py::report_dry_llm_job"]
param = "job_metadata"
rationale = "Positional-Callable reporter protocol (_ReportLLMJobFunc.__call__): job_metadata stays positional to match report_func(job_metadata, ...)."

["pipelex/cogt/content_generation/dry_mock.py::report_mock_usage_llm_job"]
param = "job_metadata"
rationale = "Positional-Callable reporter protocol (_ReportLLMJobFunc.__call__): job_metadata stays positional to match report_func(job_metadata, ...)."

["pipelex/cogt/content_generation/dry_run_factory.py::DryRunFactory._create_nested_factory"]
param = "nested_class"
rationale = "Builds a nested mock factory for the class; single operand."

["pipelex/cogt/content_generation/dry_run_factory.py::DryRunFactory._detect_examples_constraints"]
param = "object_class"
rationale = "Inspects the object class for example constraints; single operand."

["pipelex/cogt/content_generation/dry_run_factory.py::DryRunFactory._detect_format_constraints"]
param = "object_class"
rationale = "Inspects the object class for format constraints; single operand."

["pipelex/cogt/content_generation/dry_run_factory.py::DryRunFactory._detect_literal_fields"]
param = "object_class"
rationale = "Inspects the object class for literal fields; single operand."

["pipelex/cogt/content_generation/dry_run_factory.py::DryRunFactory._extract_types_from_annotation"]
param = "annotation"
rationale = "Extracts from the annotation; single operand."

["pipelex/cogt/content_generation/dry_run_factory.py::DryRunFactory._find_nested_base_model_classes"]
param = "object_class"
rationale = "Inspects the object class for nested models; single operand."

["pipelex/cogt/content_generation/dry_run_factory.py::DryRunFactory._get_examples_from_field"]
param = "field_info"
rationale = "Keyed accessor by the field_info; single operand."

["pipelex/cogt/content_generation/dry_run_factory.py::DryRunFactory._get_literal_values_from_annotation"]
param = "annotation"
rationale = "Keyed accessor by the annotation; single operand."

["pipelex/cogt/content_generation/dry_run_factory.py::DryRunFactory._get_mock_format_from_field"]
param = "field_info"
rationale = "Keyed accessor by the field_info; single operand."

["pipelex/cogt/content_generation/dry_run_factory.py::DryRunFactory._make_example_picker"]
param = "examples"
rationale = "Factory from source: builds the result from the examples; single operand."

["pipelex/cogt/content_generation/dry_run_factory.py::DryRunFactory.make_dry_run_factory"]
param = "object_class"
rationale = "Factory from source: builds the result from the object_class; single operand."

["pipelex/cogt/content_generation/exceptions.py::DryRunMockBuildError.for_object_class"]
param = "object_class_name"
rationale = "Factory from source: builds the result from the object_class_name; single operand."

["pipelex/cogt/content_generation/exceptions.py::DryRunObjectFidelityError.for_object_class"]
param = "object_class_name"
rationale = "Factory from source: builds the result from the object_class_name; single operand."

["pipelex/cogt/content_generation/extract_generate.py::extract_gen_pages"]
param = "extract_assignment"
rationale = "Extracts from the extract_assignment; single operand."

["pipelex/cogt/content_generation/extract_generate.py::extract_gen_pages_and_store"]
param = "extract_assignment"
rationale = "Extracts from the extract_assignment; single operand."

["pipelex/cogt/content_generation/generated_content_factory.py::GeneratedContentFactory._build_storage_key"]
param = "storage_scope"
rationale = "Builds the storage key under the run's storage scope; single operand."

["pipelex/cogt/content_generation/generated_content_factory.py::GeneratedContentFactory._fetch_remote_content"]
param = "url"
rationale = "Fetches the remote content at the URL; single operand."

["pipelex/cogt/content_generation/generated_content_factory.py::GeneratedContentFactory.make_image_content"]
param = "storage_scope"
rationale = "Factory from source: builds the result under the storage scope; single operand."

["pipelex/cogt/content_generation/generated_content_factory.py::GeneratedContentFactory.make_page_contents"]
param = "storage_scope"
rationale = "Factory from source: builds the result under the storage scope; single operand."

["pipelex/cogt/content_generation/img_gen_generate.py::img_gen_image_list"]
param = "img_gen_assignment"
rationale = "Processes the img-gen assignment; single operand."

["pipelex/cogt/content_generation/img_gen_generate.py::img_gen_image_list_and_store"]
param = "img_gen_assignment"
rationale = "Processes the img-gen assignment; single operand."

["pipelex/cogt/content_generation/img_gen_generate.py::img_gen_single_image"]
param = "img_gen_assignment"
rationale = "Processes the img-gen assignment; single operand."

["pipelex/cogt/content_generation/img_gen_generate.py::img_gen_single_image_and_store"]
param = "img_gen_assignment"
rationale = "Processes the img-gen assignment; single operand."

["pipelex/cogt/content_generation/judgment_generate.py::_make_judgment_job"]
param = "judgment_assignment"
rationale = "Factory from source: builds the job from the judgment_assignment; single operand."

["pipelex/cogt/content_generation/judgment_generate.py::_make_judgment_worker"]
param = "judgment_assignment"
rationale = "Factory from source: builds the worker from the judgment_assignment; single operand."

["pipelex/cogt/content_generation/judgment_generate.py::judgment_gen_answers"]
param = "judgment_assignment"
rationale = "Worker verb-object: processes the judgment_assignment; single operand."

["pipelex/cogt/content_generation/llm_generate.py::llm_gen_object"]
param = "object_assignment"
rationale = "Processes the object assignment; single operand."

["pipelex/cogt/content_generation/llm_generate.py::llm_gen_object_list"]
param = "object_assignment"
rationale = "Processes the object assignment; single operand."

["pipelex/cogt/content_generation/llm_generate.py::llm_gen_text"]
param = "llm_assignment"
rationale = "Processes the LLM assignment; single operand."

["pipelex/cogt/content_generation/object_revalidation.py::revalidate_leaf_data"]
param = "raw_data"
rationale = "Consumes the raw_data the leaf returned; single operand."

["pipelex/cogt/content_generation/object_revalidation.py::revalidate_leaf_object"]
param = "raw_obj"
rationale = "Consumes the raw_obj the leaf returned; single operand."

["pipelex/cogt/content_generation/render_generate.py::render_page_views_and_store"]
param = "render_assignment"
rationale = "Transforms/renders the render_assignment; single operand."

["pipelex/cogt/content_generation/schema_to_model_factory.py::SchemaToModelFactory._collect_unsafe_extension_paths"]
param = "node"
rationale = "Walks the schema node; single operand."

["pipelex/cogt/content_generation/schema_to_model_factory.py::SchemaToModelFactory._exec_and_extract_class"]
param = "source_code"
rationale = "Executes the generated source code; single operand."

["pipelex/cogt/content_generation/schema_to_model_factory.py::SchemaToModelFactory._exec_source_to_types"]
param = "source_code"
rationale = "Executes the generated source code; single operand."

["pipelex/cogt/content_generation/schema_to_model_factory.py::SchemaToModelFactory._generate_source_from_schema"]
param = "schema"
rationale = "Worker verb–object: processes the schema; single operand."

["pipelex/cogt/content_generation/schema_to_model_factory.py::SchemaToModelFactory._normalize_class_name"]
param = "title"
rationale = "Transforms/renders the title; single operand."

["pipelex/cogt/content_generation/schema_to_model_factory.py::SchemaToModelFactory._reject_unsafe_schema_extensions"]
param = "schema"
rationale = "Rejects unsafe extensions in the schema; single operand."

["pipelex/cogt/content_generation/schema_to_model_factory.py::SchemaToModelFactory.make_from_json_schema"]
param = "schema"
rationale = "Factory from source: builds the result from the schema; single operand."

["pipelex/cogt/content_generation/schema_to_model_factory.py::SchemaToModelFactory.make_types_from_source"]
param = "source_code"
rationale = "Factory from source: builds the result from the source_code; single operand."

["pipelex/cogt/content_generation/search_generate.py::_make_search_job"]
param = "search_assignment"
rationale = "Factory from source: builds the result from the search_assignment; single operand."

["pipelex/cogt/content_generation/search_generate.py::_make_search_worker"]
param = "search_assignment"
rationale = "Factory from source: builds the result from the search_assignment; single operand."

["pipelex/cogt/content_generation/search_generate.py::_run_structured_search"]
param = "search_assignment"
rationale = "Worker verb–object: processes the search_assignment; single operand."

["pipelex/cogt/content_generation/search_generate.py::search_gen_sourced_answer"]
param = "search_assignment"
rationale = "Worker verb–object: processes the search_assignment; single operand."

["pipelex/cogt/content_generation/search_generate.py::search_gen_structured"]
param = "search_object_assignment"
rationale = "Worker verb–object: processes the search_object_assignment; single operand."

["pipelex/cogt/content_generation/search_generate.py::search_gen_structured_object"]
param = "search_assignment"
rationale = "Worker verb–object: processes the search_assignment; single operand."

["pipelex/cogt/content_generation/templating_generate.py::templating_gen_text"]
param = "templating_assignment"
rationale = "Processes the templating assignment; single operand."

["pipelex/cogt/doc_gen/doc_gen_format.py::parse_doc_gen_choice_key"]
param = "key"
rationale = "Verb–object: parses the key of a doc gen default; single operand."

["pipelex/cogt/doc_gen/input_shape.py::_content_leaf_kind"]
param = "content_class"
rationale = "Classifies one content class as a leaf kind."

["pipelex/cogt/doc_gen/input_shape.py::_leaf"]
param = "kind"
rationale = "Builds the leaf shape of one kind."

["pipelex/cogt/doc_gen/input_shape.py::_scalar_kind"]
param = "annotation"
rationale = "Classifies one field annotation as a scalar kind."

["pipelex/cogt/doc_gen/input_shape.py::shape_of_class"]
param = "content_class"
rationale = "Describes the shape of one content class."

["pipelex/cogt/doc_gen/layout_builder.py::_flat_columns"]
param = "items"
rationale = "Derives table columns from one list of items."

["pipelex/cogt/doc_gen/layout_builder.py::_is_list_of_scalars"]
param = "value"
rationale = "Predicate over one value."

["pipelex/cogt/doc_gen/layout_builder.py::_is_structure_input"]
param = "content"
rationale = "Predicate over one input content."

["pipelex/cogt/doc_gen/layout_builder.py::_joined_scalars"]
param = "items"
rationale = "Joins one list of scalar items into text."

["pipelex/cogt/doc_gen/layout_builder.py::_paragraphs"]
param = "text"
rationale = "Splits one text into paragraphs."

["pipelex/cogt/doc_gen/layout_builder.py::_scalar"]
param = "value"
rationale = "Converts one value into a layout scalar."

["pipelex/cogt/doc_gen/layout_builder.py::html_to_paragraphs"]
param = "html"
rationale = "Converts one HTML string into paragraphs."

["pipelex/cogt/doc_gen/layout_builder.py::humanize"]
param = "name"
rationale = "Turns one field name into a label."

["pipelex/cogt/doc_gen/plain_data.py::plain_data"]
param = "value"
rationale = "Converts one value into plain data."

["pipelex/cogt/document/prompt_document_utils.py::prep_prompt_documents"]
param = "prompt_documents"
rationale = "Prepares the prompt documents; single operand."

["pipelex/cogt/document/prompt_document_utils.py::prepare_prompt_document"]
param = "prompt_document"
rationale = "Prepares the prompt document; single operand."

["pipelex/cogt/document/prompt_document_utils.py::prepare_prompt_document_as_base64"]
param = "prompt_document"
rationale = "Prepares the prompt document as base64; single operand."

["pipelex/cogt/exceptions.py::CogtError.fill_model_and_provider"]
param = "model_handle"
rationale = "Operates on the model_handle; single operand (qualifiers keyword-only)."

["pipelex/cogt/exceptions.py::find_inference_error_category_in_chain"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/extract/extract_job.py::ExtractJob.extract_job_before_start"]
param = "inference_model"
rationale = "Extracts from the inference_model; single operand."

["pipelex/cogt/extract/extract_job_factory.py::ExtractJobFactory.make_extract_job"]
param = "extract_input"
rationale = "Factory from source: builds the result from the extract_input; single operand."

["pipelex/cogt/extract/extract_report.py::ExtractTokenCostReportField.report_field_for_cost_by_category"]
param = "token_category"
rationale = "Derives the report field for the token category; single operand."

["pipelex/cogt/extract/extract_report.py::ExtractTokenCostReportField.report_field_for_nb_tokens_by_category"]
param = "token_category"
rationale = "Derives the report field for the token category; single operand."

["pipelex/cogt/extract/extract_worker_abstract.py::ExtractWorkerAbstract._check_can_perform_job"]
param = "extract_job"
rationale = "Verb–object: validates/checks the extract_job; single operand."

["pipelex/cogt/extract/extract_worker_abstract.py::ExtractWorkerAbstract._extract_pages"]
param = "extract_job"
rationale = "Extracts from the extract_job; single operand."

["pipelex/cogt/extract/extract_worker_abstract.py::ExtractWorkerAbstract.extract_pages"]
param = "extract_job"
rationale = "Extracts from the extract_job; single operand."

["pipelex/cogt/extract/extract_worker_factory.py::ExtractWorkerFactory.make_extract_worker"]
param = "inference_model"
rationale = "Factory from source: builds the result from the inference_model; single operand."

["pipelex/cogt/file/file_preparation_utils.py::prepare_file_from_uri"]
param = "uri"
rationale = "Prepares the file from the URI; single operand."

["pipelex/cogt/image/generated_image.py::GeneratedImageRawDetails.make_from_pil_image"]
param = "pil_image"
rationale = "Factory from source: builds the result from the pil_image; single operand."

["pipelex/cogt/image/prompt_image_utils.py::prep_prompt_images"]
param = "prompt_images"
rationale = "Prepares the prompt images; single operand."

["pipelex/cogt/image/prompt_image_utils.py::prepare_prompt_image"]
param = "prompt_image"
rationale = "Prepares the prompt image; single operand."

["pipelex/cogt/image/prompt_image_utils.py::prepare_prompt_image_as_base64"]
param = "prompt_image"
rationale = "Prepares the prompt image as base64; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_for_model"]
param = "model_rules"
rationale = "Factory from source: builds the result from the model_rules; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_from_aspect_ratio"]
param = "aspect_ratio_taxonomy"
rationale = "Factory from source: builds the result from the aspect_ratio_taxonomy; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_from_background"]
param = "background_taxonomy"
rationale = "Factory from source: builds the result from the background_taxonomy; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_from_inference"]
param = "inference_taxonomy"
rationale = "Factory from source: builds the result from the inference_taxonomy; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_from_input_fidelity"]
param = "input_fidelity_taxonomy"
rationale = "Factory from source: builds the result from the input_fidelity_taxonomy; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_from_input_images"]
param = "input_images_taxonomy"
rationale = "Factory from source: builds the result from the input_images_taxonomy; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_from_model_name"]
param = "model_name_taxonomy"
rationale = "Factory from source: builds the result from the model_name_taxonomy; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_from_num_images"]
param = "num_images_taxonomy"
rationale = "Factory from source: builds the result from the num_images_taxonomy; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_from_output_compression"]
param = "output_compression_taxonomy"
rationale = "Factory from source: builds the result from the output_compression_taxonomy; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_from_output_format"]
param = "output_format_taxonomy"
rationale = "Factory from source: builds the result from the output_format_taxonomy; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_from_prompt"]
param = "prompt_taxonomy"
rationale = "Factory from source: builds the result from the prompt_taxonomy; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_from_safety_checker"]
param = "safety_checker_taxonomy"
rationale = "Factory from source: builds the result from the safety_checker_taxonomy; single operand."

["pipelex/cogt/img_gen/img_gen_args_factory.py::ImgGenArgsFactory.make_args_from_specific"]
param = "specific_taxonomy"
rationale = "Factory from source: builds the result from the specific_taxonomy; single operand."

["pipelex/cogt/img_gen/img_gen_gemini_mapping.py::ImgGenGeminiMapping.aspect_ratio_literal"]
param = "aspect_ratio"
rationale = "Converts the aspect ratio to its provider literal; single operand."

["pipelex/cogt/img_gen/img_gen_gemini_mapping.py::ImgGenGeminiMapping.derive_ratio_and_size_from_exact_size"]
param = "taxonomy"
rationale = "Operates on the aspect-ratio taxonomy; the lookup keys stay keyword-only."

["pipelex/cogt/img_gen/img_gen_gemini_mapping.py::ImgGenGeminiMapping.dimensions_for_aspect_ratio_and_size"]
param = "taxonomy"
rationale = "Operates on the aspect-ratio taxonomy; the lookup keys stay keyword-only."

["pipelex/cogt/img_gen/img_gen_gemini_mapping.py::ImgGenGeminiMapping.grids_for_taxonomy"]
param = "taxonomy"
rationale = "Operates on the aspect-ratio taxonomy; the lookup keys stay keyword-only."

["pipelex/cogt/img_gen/img_gen_gemini_mapping.py::ImgGenGeminiMapping.image_size_for_tier"]
param = "tier"
rationale = "Derives the image size for the size tier; single operand."

["pipelex/cogt/img_gen/img_gen_gemini_mapping.py::ImgGenGeminiMapping.img_gen_taxonomy"]
param = "inference_model"
rationale = "Reads the aspect-ratio taxonomy off the inference model; single operand."

["pipelex/cogt/img_gen/img_gen_gemini_mapping.py::ImgGenGeminiMapping.optional_gemini_taxonomy"]
param = "inference_model"
rationale = "Reads the Gemini aspect-ratio taxonomy off the inference model, None when it declares no Gemini one; single operand."

["pipelex/cogt/img_gen/img_gen_gemini_mapping.py::ImgGenGeminiMapping.optional_img_gen_taxonomy"]
param = "inference_model"
rationale = "Reads the aspect-ratio taxonomy off the inference model, None when it declares none; single operand."

["pipelex/cogt/img_gen/img_gen_gemini_mapping.py::ImgGenGeminiMapping.resolve_image_config"]
param = "taxonomy"
rationale = "Operates on the aspect-ratio taxonomy; the lookup keys stay keyword-only."

["pipelex/cogt/img_gen/img_gen_gpt_mapping.py::ImgGenGptMapping._size_to_string"]
param = "size"
rationale = "Converts the image size to its provider string; single operand."

["pipelex/cogt/img_gen/img_gen_gpt_mapping.py::ImgGenGptMapping.input_fidelity_literal"]
param = "input_fidelity"
rationale = "Derives the GPT Image fidelity literal from the input fidelity; single operand."

["pipelex/cogt/img_gen/img_gen_job.py::ImgGenJob.img_gen_job_before_start"]
param = "inference_model"
rationale = "Prepares the job against the inference_model; single operand."

["pipelex/cogt/img_gen/img_gen_job_components.py::parse_img_gen_size"]
param = "value"
rationale = "Parses the value; single operand."

["pipelex/cogt/img_gen/img_gen_job_factory.py::ImgGenJobFactory.make_img_gen_job_from_prompt"]
param = "img_gen_prompt"
rationale = "Factory from source: builds the result from the img_gen_prompt; single operand."

["pipelex/cogt/img_gen/img_gen_job_factory.py::ImgGenJobFactory.make_img_gen_job_from_prompt_contents"]
param = "positive_text"
rationale = "Factory from source: builds the result from the positive_text; single operand."

["pipelex/cogt/img_gen/img_gen_report.py::ImgGenTokenCostReportField.report_field_for_cost_by_category"]
param = "token_category"
rationale = "Derives the report field for the token category; single operand."

["pipelex/cogt/img_gen/img_gen_report.py::ImgGenTokenCostReportField.report_field_for_nb_tokens_by_category"]
param = "token_category"
rationale = "Derives the report field for the token category; single operand."

["pipelex/cogt/img_gen/img_gen_worker_abstract.py::ImgGenWorkerAbstract._check_can_perform_job"]
param = "img_gen_job"
rationale = "Verb–object: validates/checks the img_gen_job; single operand."

["pipelex/cogt/img_gen/img_gen_worker_abstract.py::ImgGenWorkerAbstract._gen_image"]
param = "img_gen_job"
rationale = "Worker verb–object: processes the img_gen_job; single operand."

["pipelex/cogt/img_gen/img_gen_worker_abstract.py::ImgGenWorkerAbstract._gen_image_list"]
param = "img_gen_job"
rationale = "Worker verb–object: processes the img_gen_job; single operand."

["pipelex/cogt/img_gen/img_gen_worker_abstract.py::ImgGenWorkerAbstract.gen_image"]
param = "img_gen_job"
rationale = "Worker verb–object: processes the img_gen_job; single operand."

["pipelex/cogt/img_gen/img_gen_worker_abstract.py::ImgGenWorkerAbstract.gen_image_list"]
param = "img_gen_job"
rationale = "Worker verb–object: processes the img_gen_job; single operand."

["pipelex/cogt/img_gen/img_gen_worker_factory.py::ImgGenWorkerFactory.make_img_gen_worker"]
param = "inference_model"
rationale = "Factory from source: builds the result from the inference_model; single operand."

["pipelex/cogt/inference/error_classification.py::_build_azure_metadata"]
param = "response"
rationale = "Extracts/derives from the response; single operand."

["pipelex/cogt/inference/error_classification.py::_error_codes_in_body"]
param = "body"
rationale = "Lists the codes and types of one error body, the operand the OpenAI and gateway spent-quota rule reads; single operand."

["pipelex/cogt/inference/error_classification.py::_error_sections"]
param = "body"
rationale = "Lists the sections of one error body, the operand its readers error_code_from_body_code_first and _google_detail_entries pass straight through; single operand."

["pipelex/cogt/inference/error_classification.py::_google_detail_entries"]
param = "body"
rationale = "Lists the entries of one Google error body's details of one type, the operand its readers _google_retry_delay_seconds and _is_quota_exhaustion_google pass straight through; single operand."

["pipelex/cogt/inference/error_classification.py::_google_error_info_metadata"]
param = "entry"
rationale = "Reads the metadata map of one google.rpc.ErrorInfo entry; single operand."

["pipelex/cogt/inference/error_classification.py::_google_provider_error_code_from_details"]
param = "details"
rationale = "Extracts/derives from the details; single operand."

["pipelex/cogt/inference/error_classification.py::_google_retry_delay_seconds"]
param = "details"
rationale = "Extracts the retry delay from a Google error's details, as its sibling _google_provider_error_code_from_details reads the status; single operand."

["pipelex/cogt/inference/error_classification.py::_is_content_policy_violation"]
param = "error_message"
rationale = "Predicate on the error_message; single operand."

["pipelex/cogt/inference/error_classification.py::_parse_response_text_body"]
param = "response"
rationale = "Parses the response; single operand."

["pipelex/cogt/inference/error_classification.py::_provider_error_code_from_body"]
param = "body"
rationale = "Extracts/derives from the body; single operand."

["pipelex/cogt/inference/error_classification.py::_provider_error_code_from_flat_body"]
param = "body"
rationale = "Extracts/derives from the body; single operand."

["pipelex/cogt/inference/error_classification.py::_resolve_sdk_exception_type"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::_stringify_for_scan"]
param = "body"
rationale = "Extracts/derives from the body; single operand."

["pipelex/cogt/inference/error_classification.py::error_code_from_body_code_first"]
param = "body"
rationale = "Reads an error code out of one body dict, exactly as its siblings _provider_error_code_from_body and _provider_error_code_from_flat_body do; the body is the single obvious operand and all three read as one verb-object sentence."

["pipelex/cogt/inference/error_classification.py::extract_anthropic_metadata"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::extract_azure_metadata"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::extract_azure_metadata_from_response"]
param = "response"
rationale = "Extracts from the response; single operand."

["pipelex/cogt/inference/error_classification.py::extract_bedrock_metadata"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::extract_fal_metadata"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::extract_gateway_metadata"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::extract_google_metadata"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::extract_huggingface_metadata"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::extract_linkup_metadata"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::extract_local_extract_metadata"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::extract_mistral_metadata"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::extract_openai_metadata"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::extract_typesafe_metadata"]
param = "exc"
rationale = "Extracts from the exc; single operand."

["pipelex/cogt/inference/error_classification.py::extract_underlying_sdk_exception"]
param = "instructor_exc"
rationale = "Extracts from the instructor_exc; single operand."

["pipelex/cogt/inference/error_classification.py::parse_retry_after_seconds"]
param = "value"
rationale = "Parses the value; single operand."

["pipelex/cogt/inference/error_classify.py::_classify_statusless"]
param = "metadata"
rationale = "Classifies the metadata; single operand."

["pipelex/cogt/inference/error_classify.py::classify_inference_error"]
param = "metadata"
rationale = "Classifies the metadata; single operand."

["pipelex/cogt/inference/error_render.py::_format_message"]
param = "metadata"
rationale = "Transforms/renders the metadata; single operand."

["pipelex/cogt/inference/error_render.py::_render_detail"]
param = "metadata"
rationale = "Transforms/renders the metadata; single operand."

["pipelex/cogt/inference/error_render.py::render_inference_error"]
param = "metadata"
rationale = "Transforms/renders the metadata; single operand."

["pipelex/cogt/inference/inference_constants.py::InferenceOutputType.is_text"]
param = "output_desc"
rationale = "Predicate on the output_desc; single operand."

["pipelex/cogt/inference/inference_manager.py::InferenceManager._setup_one_extract_worker"]
param = "extract_handle"
rationale = "Keyed accessor by the extract_handle; single operand."

["pipelex/cogt/inference/inference_manager.py::InferenceManager._setup_one_img_gen_worker"]
param = "img_gen_handle"
rationale = "Keyed accessor by the img_gen_handle; single operand."

["pipelex/cogt/inference/inference_manager.py::InferenceManager._setup_one_internal_llm_worker"]
param = "llm_handle"
rationale = "Keyed accessor by the llm_handle; single operand."

["pipelex/cogt/inference/inference_manager_protocol.py::InferenceManagerProtocol.get_extract_worker"]
param = "extract_handle"
rationale = "Keyed accessor by the extract_handle; single operand."

["pipelex/cogt/inference/inference_manager_protocol.py::InferenceManagerProtocol.get_img_gen_worker"]
param = "img_gen_handle"
rationale = "Keyed accessor by the img_gen_handle; single operand."

["pipelex/cogt/inference/inference_manager_protocol.py::InferenceManagerProtocol.get_llm_worker"]
param = "llm_handle"
rationale = "Keyed accessor by the llm_handle; single operand."

["pipelex/cogt/inference/transport_retry.py::_make_retry_predicate.should_retry"]
param = "exc"
rationale = "Positional-Callable tenacity retry predicate: exc is the single operand tenacity passes."

["pipelex/cogt/inference/transport_retry.py::_transport_retry_wait"]
param = "retry_state"
rationale = "Positional-Callable tenacity wait strategy: retry_state is the single operand tenacity passes."

["pipelex/cogt/inference/transport_retry.py::request_with_transport_retry"]
param = "send_request"
rationale = "Runs the send_request callable under transport retry; single operand."

["pipelex/cogt/judgment/judgment_report.py::JudgmentTokenCostReportField.report_field_for_cost_by_category"]
param = "token_category"
rationale = "Formatter verb-object: renders the field name for the token_category; single operand."

["pipelex/cogt/judgment/judgment_report.py::JudgmentTokenCostReportField.report_field_for_nb_tokens_by_category"]
param = "token_category"
rationale = "Formatter verb-object: renders the field name for the token_category; single operand."

["pipelex/cogt/judgment/judgment_worker_abstract.py::JudgmentWorkerAbstract._judge"]
param = "judgment_job"
rationale = "Worker verb-object: processes the judgment_job; single operand."

["pipelex/cogt/judgment/judgment_worker_abstract.py::JudgmentWorkerAbstract.judge"]
param = "judgment_job"
rationale = "Worker verb-object: processes the judgment_job; single operand."

["pipelex/cogt/judgment/judgment_worker_factory.py::JudgmentWorkerFactory.make_judgment_worker"]
param = "inference_model"
rationale = "Factory from source: builds the worker from the inference_model; single operand."

["pipelex/cogt/llm/llm_job.py::LLMJob.llm_job_before_start"]
param = "inference_model"
rationale = "Prepares the job against the inference_model; single operand."

["pipelex/cogt/llm/llm_job_factory.py::LLMJobFactory.make_llm_job"]
param = "llm_prompt"
rationale = "Factory from source: builds the result from the llm_prompt; single operand."

["pipelex/cogt/llm/llm_report.py::LLMTokenCostReportField.report_field_for_cost_by_category"]
param = "token_category"
rationale = "Derives the report field for the token category; single operand."

["pipelex/cogt/llm/llm_report.py::LLMTokenCostReportField.report_field_for_nb_tokens_by_category"]
param = "token_category"
rationale = "Derives the report field for the token category; single operand."

["pipelex/cogt/llm/llm_utils.py::dump_error"]
param = "error"
rationale = "Dumps the error for debugging; single operand."

["pipelex/cogt/llm/llm_utils.py::dump_prompt"]
param = "llm_prompt"
rationale = "Dumps the llm_prompt for debugging; single operand."

["pipelex/cogt/llm/llm_utils.py::dump_response_from_structured_gen"]
param = "response"
rationale = "Dumps the response for debugging; single operand."

["pipelex/cogt/llm/llm_utils.py::dump_response_from_text_gen"]
param = "response"
rationale = "Dumps the response for debugging; single operand."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract._apply_constraints"]
param = "llm_job"
rationale = "Verb-object: applies constraints to the job; single operand."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract._before_job"]
param = "llm_job"
rationale = "Worker verb–object: processes the llm_job; single operand."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract._check_can_perform_job"]
param = "llm_job"
rationale = "Verb–object: validates/checks the llm_job; single operand."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract._check_document_support"]
param = "llm_job"
rationale = "Validator: the job is the single operand checked."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract._check_vision_support"]
param = "llm_job"
rationale = "Validator: the job is the single operand checked."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract._end_otel_span_with_completion_object"]
param = "span"
rationale = "Operates on the span; single operand (attached data keyword-only)."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract._end_otel_span_with_completion_text"]
param = "span"
rationale = "Operates on the span; single operand (attached data keyword-only)."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract._end_otel_span_with_error"]
param = "span"
rationale = "Operates on the span; single operand (attached data keyword-only)."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract._gen_object"]
param = "llm_job"
rationale = "Worker verb–object: processes the llm_job; single operand."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract._gen_text"]
param = "llm_job"
rationale = "Worker verb–object: processes the llm_job; single operand."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract._start_otel_span_llm"]
param = "llm_job"
rationale = "Operates on the llm_job; single operand (attached data keyword-only)."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract.gen_object"]
param = "llm_job"
rationale = "Worker verb–object: processes the llm_job; single operand."

["pipelex/cogt/llm/llm_worker_abstract.py::LLMWorkerAbstract.gen_text"]
param = "llm_job"
rationale = "Worker verb–object: processes the llm_job; single operand."

["pipelex/cogt/llm/llm_worker_factory.py::LLMWorkerFactory.make_llm_worker"]
param = "inference_model"
rationale = "Factory from source: builds the result from the inference_model; single operand."

["pipelex/cogt/llm/reasoning_config_base.py::validate_effort_to_level_map"]
param = "effort_to_level_map"
rationale = "Verb–object: validates/checks the effort_to_level_map; single operand."

["pipelex/cogt/model_backends/backend.py::InferenceBackend.get_extra_config"]
param = "key"
rationale = "Keyed accessor by the key; single operand."

["pipelex/cogt/model_backends/backend_credentials.py::BackendCredentialsErrorMsgFactory.make_comprehensive_error_msg"]
param = "backend_credential_reports"
rationale = "Factory from source: builds the result from the backend_credential_reports; single operand."

["pipelex/cogt/model_backends/backend_factory.py::InferenceBackendFactory.make_inference_backend"]
param = "name"
rationale = "Factory from source: builds the result from the name; single operand."

["pipelex/cogt/model_backends/backend_library.py::InferenceBackendLibrary._load_local_model_specs"]
param = "backend_name"
rationale = "Loads model specs for the named backend; single operand."

["pipelex/cogt/model_backends/backend_library.py::InferenceBackendLibrary._record_placeholder_var_names"]
param = "content"
rationale = "A string transform: apply_to_strings_recursive calls transform_func with the string positionally, as it calls substitute_vars on a load that resolves credentials."

["pipelex/cogt/model_backends/backend_library.py::InferenceBackendLibrary.get_inference_backend"]
param = "backend_name"
rationale = "Keyed accessor by the backend_name; single operand."

["pipelex/cogt/model_backends/model_lists.py::ModelLister.list_models"]
param = "backend_name"
rationale = "Operates on the backend_name; single operand (qualifiers keyword-only)."

["pipelex/cogt/model_backends/model_spec_factory.py::InferenceModelSpecFactory.make_inference_model_spec"]
param = "backend_name"
rationale = "Factory from source: builds the result from the backend_name; single operand."

["pipelex/cogt/model_backends/model_spec_index.py::ModelSpecIndex.add"]
param = "model_spec"
rationale = "add(model_spec) reads as a verb-object sentence: the spec is the one obvious operand"

["pipelex/cogt/model_routing/routing_profile_factory.py::RoutingProfileFactory.make_routing_profile"]
param = "name"
rationale = "Factory from source: builds the result from the name; single operand."

["pipelex/cogt/models/deck_manifest.py::DeckSyncReport.files_with_status"]
param = "status"
rationale = "Deck/file op on the status; single operand."

["pipelex/cogt/models/deck_manifest.py::_is_managed_deck_filename"]
param = "filename"
rationale = "Predicate on the filename; single operand."

["pipelex/cogt/models/deck_manifest.py::_is_manifest_older"]
param = "manifest_version"
rationale = "Predicate on the manifest_version; single operand."

["pipelex/cogt/models/deck_manifest.py::_try_parse_version"]
param = "version"
rationale = "Deck/file op on the version; single operand."

["pipelex/cogt/models/deck_manifest.py::compute_file_sha256"]
param = "path"
rationale = "Deck/file op on the path; single operand."

["pipelex/cogt/models/deck_manifest.py::compute_sha256"]
param = "data"
rationale = "Deck/file op on the data; single operand."

["pipelex/cogt/models/deck_manifest.py::compute_sync_report"]
param = "installed_dir"
rationale = "Kit-managed area op on the installed_dir; single operand."

["pipelex/cogt/models/deck_manifest.py::is_deck_stale_fast"]
param = "deck_dir"
rationale = "Predicate on the deck_dir; single operand."

["pipelex/cogt/models/deck_manifest.py::list_managed_installed_files"]
param = "installed_dir"
rationale = "Kit-managed area op on the installed_dir; single operand."

["pipelex/cogt/models/deck_manifest.py::manifest_path"]
param = "installed_dir"
rationale = "Kit-managed area op on the installed_dir; single operand."

["pipelex/cogt/models/deck_manifest.py::read_manifest"]
param = "installed_dir"
rationale = "Kit-managed area op on the installed_dir; single operand."

["pipelex/cogt/models/deck_manifest.py::status_rich_label"]
param = "status"
rationale = "Deck/file op on the status; single operand."

["pipelex/cogt/models/deck_manifest.py::suggest_x_custom_filename"]
param = "numbered_filename"
rationale = "Deck/file op on the numbered_filename; single operand."

["pipelex/cogt/models/deck_manifest.py::write_manifest"]
param = "manifest"
rationale = "Deck/file op on the manifest; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck._get_optional_inference_model"]
param = "model_handle"
rationale = "Keyed accessor by the model_handle; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck._raise_handle_not_found_error"]
param = "ref"
rationale = "Operates on the ref; single operand (qualifiers keyword-only)."

["pipelex/cogt/models/model_deck.py::ModelDeck._resolve_waterfall"]
param = "waterfall_name"
rationale = "Operates on the waterfall_name; single operand (qualifiers keyword-only)."

["pipelex/cogt/models/model_deck.py::ModelDeck._warn_if_ambiguous_doc_gen"]
param = "name"
rationale = "Verb–object: validates/checks the name; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck._warn_if_ambiguous_extract"]
param = "name"
rationale = "Verb–object: validates/checks the name; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck._warn_if_ambiguous_img_gen"]
param = "name"
rationale = "Verb–object: validates/checks the name; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck._warn_if_ambiguous_judgment"]
param = "name"
rationale = "Predicate verb-object: warns about the name; single operand, mirroring the sibling per-family warners."

["pipelex/cogt/models/model_deck.py::ModelDeck._warn_if_ambiguous_llm"]
param = "name"
rationale = "Verb–object: validates/checks the name; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck._warn_if_ambiguous_search"]
param = "name"
rationale = "Verb–object: validates/checks the name; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck.check_llm_choice"]
param = "llm_choice"
rationale = "Verb–object: validates/checks the llm_choice; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck.get_aliases_and_waterfalls_for_type"]
param = "model_type"
rationale = "Keyed accessor by the model_type; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck.get_extract_setting"]
param = "extract_choice"
rationale = "Keyed accessor by the extract_choice; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck.get_img_gen_setting"]
param = "img_gen_choice"
rationale = "Keyed accessor by the img_gen_choice; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck.get_judgment_setting"]
param = "judgment_choice"
rationale = "Keyed accessor by the judgment_choice; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck.get_llm_setting"]
param = "llm_choice"
rationale = "Keyed accessor by the llm_choice; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck.get_optional_inference_model"]
param = "model_handle"
rationale = "Keyed accessor by the model_handle; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck.get_required_inference_model"]
param = "model_handle"
rationale = "Keyed accessor by the model_handle; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck.get_search_setting"]
param = "search_choice"
rationale = "Keyed accessor by the search_choice; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck.is_handle_defined"]
param = "model_handle"
rationale = "Predicate on the model_handle; single operand."

["pipelex/cogt/models/model_deck.py::ModelDeck.is_model_handle_defined"]
param = "model_handle"
rationale = "Predicate on the model_handle; single operand."

["pipelex/cogt/models/model_deck_check.py::_raise_model_choice_not_found"]
param = "msg"
rationale = "Operates on the msg; single operand (qualifiers keyword-only)."

["pipelex/cogt/models/model_deck_check.py::check_extract_choice_with_deck"]
param = "extract_choice"
rationale = "Verb–object: validates/checks the extract_choice; single operand."

["pipelex/cogt/models/model_deck_check.py::check_img_gen_choice_with_deck"]
param = "img_gen_choice"
rationale = "Verb–object: validates/checks the img_gen_choice; single operand."

["pipelex/cogt/models/model_deck_check.py::check_judgment_choice_with_deck"]
param = "judgment_choice"
rationale = "Verb-object: validates the judgment_choice; single operand."

["pipelex/cogt/models/model_deck_check.py::check_llm_choice_with_deck"]
param = "llm_choice"
rationale = "Verb–object: validates/checks the llm_choice; single operand."

["pipelex/cogt/models/model_deck_check.py::check_search_choice_with_deck"]
param = "search_choice"
rationale = "Verb–object: validates/checks the search_choice; single operand."

["pipelex/cogt/models/model_deck_loader.py::load_model_deck_blueprint"]
param = "model_deck_paths"
rationale = "Deck/file op on the model_deck_paths; single operand."

["pipelex/cogt/models/model_listing.py::_filter_aliases_by_backend"]
param = "aliases"
rationale = "Verb-object: the alias mapping being filtered; backend context stays keyword."

["pipelex/cogt/models/model_listing.py::_filter_presets_by_backend"]
param = "presets_list"
rationale = "Verb-object: the preset list being filtered; backend context stays keyword."

["pipelex/cogt/models/model_listing.py::_filter_waterfalls_by_backend"]
param = "waterfalls"
rationale = "Verb-object: the waterfall mapping being filtered; backend context stays keyword."

["pipelex/cogt/models/model_listing.py::_should_include"]
param = "category"
rationale = "Predicate on the candidate category; the filter list stays keyword."

["pipelex/cogt/models/model_listing.py::format_models_markdown"]
param = "result"
rationale = "Verb-object: formats the list_models result dict; single operand."

["pipelex/cogt/models/model_manager.py::ModelManager.build_deck"]
param = "model_deck_blueprint"
rationale = "Factory from source: builds the result from the model_deck_blueprint; single operand."

["pipelex/cogt/models/model_manager.py::ModelManager.get_model_deck_paths"]
param = "deck_dir_path"
rationale = "Keyed accessor by the deck_dir_path; single operand."

["pipelex/cogt/models/model_manager_abstract.py::ModelManagerAbstract.get_inference_model"]
param = "model_handle"
rationale = "Keyed accessor by the model_handle; single operand."

["pipelex/cogt/models/model_manager_abstract.py::ModelManagerAbstract.get_required_inference_backend"]
param = "backend_name"
rationale = "Keyed accessor by the backend_name; single operand."

["pipelex/cogt/models/model_reference.py::ModelReference.parse"]
param = "value"
rationale = "Parses the value into a model reference; single operand."

["pipelex/cogt/models/model_reference.py::ensure_model_reference"]
param = "value"
rationale = "Parses the value; single operand."

["pipelex/cogt/models/model_reference.py::parse_model_reference"]
param = "value"
rationale = "Parses the value; single operand."

["pipelex/cogt/models/model_suggestion.py::get_collection_keys"]
param = "model_deck"
rationale = "Keyed accessor by the model_deck; single operand."

["pipelex/cogt/search/search_job.py::SearchJob.search_job_before_start"]
param = "inference_model"
rationale = "Worker verb–object: processes the inference_model; single operand."

["pipelex/cogt/search/search_job_factory.py::SearchJobFactory.make_search_job"]
param = "query"
rationale = "Factory from source: builds the result from the query; single operand."

["pipelex/cogt/search/search_report.py::SearchTokenCostReportField.report_field_for_cost_by_category"]
param = "token_category"
rationale = "Derives the report field for the token category; single operand."

["pipelex/cogt/search/search_report.py::SearchTokenCostReportField.report_field_for_nb_tokens_by_category"]
param = "token_category"
rationale = "Derives the report field for the token category; single operand."

["pipelex/cogt/search/search_worker_abstract.py::SearchWorkerAbstract._search_sourced_answer"]
param = "search_job"
rationale = "Worker verb–object: processes the search_job; single operand."

["pipelex/cogt/search/search_worker_abstract.py::SearchWorkerAbstract._search_structured"]
param = "search_job"
rationale = "Worker verb–object: processes the search_job; single operand."

["pipelex/cogt/search/search_worker_abstract.py::SearchWorkerAbstract.search_sourced_answer"]
param = "search_job"
rationale = "Worker verb–object: processes the search_job; single operand."

["pipelex/cogt/search/search_worker_abstract.py::SearchWorkerAbstract.search_structured"]
param = "search_job"
rationale = "Worker verb–object: processes the search_job; single operand."

["pipelex/cogt/search/search_worker_factory.py::SearchWorkerFactory.make_search_worker"]
param = "inference_model"
rationale = "Factory from source: builds the result from the inference_model; single operand."

["pipelex/cogt/templating/template_preprocessor.py::_normalize_and_escape"]
param = "template"
rationale = "Transforms/renders the template; single operand."

["pipelex/cogt/templating/template_preprocessor.py::_replace_at_sigil"]
param = "match"
rationale = "Transforms/renders the match; single operand."

["pipelex/cogt/templating/template_preprocessor.py::_replace_dollar_sigil"]
param = "match"
rationale = "Transforms/renders the match; single operand."

["pipelex/cogt/templating/template_preprocessor.py::_validate_at_sigil_alone_on_line"]
param = "template"
rationale = "Verb–object: validates/checks the template; single operand."

["pipelex/cogt/templating/template_preprocessor.py::preprocess_template"]
param = "template"
rationale = "Transforms/renders the template; single operand."

["pipelex/cogt/templating/template_preprocessor.py::rewrite_template_sigils"]
param = "template"
rationale = "Transforms/renders the template; single operand."

["pipelex/cogt/templating/template_preprocessor.py::validate_template_sigils"]
param = "template"
rationale = "Verb–object: validates/checks the template; single operand."

["pipelex/cogt/templating/template_rendering.py::render_template"]
param = "template"
rationale = "Transforms/renders the template; single operand."

["pipelex/cogt/usage/cost_registry.py::CostRegistry.aggregate_costs"]
param = "tokens_usages"
rationale = "Cost report op on the tokens_usages; single operand."

["pipelex/cogt/usage/cost_registry.py::CostRegistry.build_cost_summary"]
param = "tokens_usages"
rationale = "Factory from source: builds the result from the tokens_usages; single operand."

["pipelex/cogt/usage/cost_registry.py::CostRegistry.complete_cost_report"]
param = "tokens_usage"
rationale = "Cost report op on the tokens_usage; single operand."

["pipelex/cogt/usage/cost_registry.py::CostRegistry.compute_cost_report"]
param = "tokens_usage"
rationale = "Deck/file op on the tokens_usage; single operand."

["pipelex/cogt/usage/cost_registry.py::CostRegistry.generate_report"]
param = "pipeline_run_id"
rationale = "Cost report op on the pipeline_run_id; single operand."

["pipelex/cogt/usage/cost_registry.py::CostRegistry.render_report"]
param = "aggregated"
rationale = "Transforms/renders the aggregated; single operand."

["pipelex/cogt/usage/cost_registry.py::CostRegistry.save_to_csv"]
param = "records"
rationale = "Cost report op on the records; single operand."

["pipelex/cogt/usage/usage_cost.py::compute_tokens_usage_cost"]
param = "tokens_usage"
rationale = "Verb-object: compute the cost of one usage record; the single obvious operand is the usage."

["pipelex/core/concepts/concept.py::Concept.is_native_concept"]
param = "concept"
rationale = "Predicate on the concept; single operand."

["pipelex/core/concepts/concept.py::Concept.sentence_from_concept"]
param = "concept"
rationale = "Derivation from the concept; single operand."

["pipelex/core/concepts/concept_factory.py::ConceptFactory._handle_blueprint_with_structure"]
param = "blueprint"
rationale = "Verb-object: handles the blueprint; context stays keyword."

["pipelex/core/concepts/concept_factory.py::ConceptFactory._handle_refines"]
param = "blueprint"
rationale = "Verb-object: handles the blueprint; context stays keyword."

["pipelex/core/concepts/concept_factory.py::ConceptFactory._handle_structure_with_classname"]
param = "blueprint"
rationale = "Verb-object: handles the blueprint; context stays keyword."

["pipelex/core/concepts/concept_factory.py::ConceptFactory.make_domain_and_concept_code_from_concept_ref_or_code"]
param = "concept_ref_or_code"
rationale = "Conversion: splits the ref-or-code; fallback domain stays keyword."

["pipelex/core/concepts/concept_factory.py::ConceptFactory.make_native_concept"]
param = "native_concept_code"
rationale = "Factory keyed by the native concept code; single operand."

["pipelex/core/concepts/concept_factory.py::ConceptFactory.make_refine"]
param = "refine"
rationale = "Verb-object: normalizes the refine string; domain stays keyword."

["pipelex/core/concepts/concept_provider_abstract.py::ConceptProviderAbstract.get_native_concept"]
param = "native_concept"
rationale = "Resolver getter: the native concept being fetched; single operand."

["pipelex/core/concepts/concept_provider_abstract.py::ConceptProviderAbstract.get_required_concept"]
param = "concept_ref"
rationale = "Resolver getter keyed by the concept ref; single operand."

["pipelex/core/concepts/concept_provider_abstract.py::ConceptProviderAbstract.get_required_entry_concept"]
param = "concept_ref_or_code"
rationale = "Entry affordance keyed by the human-supplied concept string; single operand, the concept twin of get_required_entry_pipe."

["pipelex/core/concepts/concept_representation_generator.py::ConceptRepresentationGenerator._format_python_value"]
param = "value"
rationale = "Transforms the value; single operand."

["pipelex/core/concepts/concept_representation_generator.py::ConceptRepresentationGenerator._generate_basemodel_representation"]
param = "model_class"
rationale = "Derivation from the model class; single operand."

["pipelex/core/concepts/concept_representation_generator.py::ConceptRepresentationGenerator._generate_basic_value"]
param = "actual_type"
rationale = "Derivation from the type; single operand."

["pipelex/core/concepts/concept_representation_generator.py::ConceptRepresentationGenerator._generate_dict_value"]
param = "field_name"
rationale = "Derivation keyed by the field name; single operand."

["pipelex/core/concepts/concept_representation_generator.py::ConceptRepresentationGenerator._generate_enum_value"]
param = "enum_type"
rationale = "Derivation from the enum type; single operand."

["pipelex/core/concepts/concept_representation_generator.py::ConceptRepresentationGenerator._generate_fields_dict"]
param = "content_class"
rationale = "Derivation from the content class; single operand."

["pipelex/core/concepts/concept_representation_generator.py::ConceptRepresentationGenerator._generate_list_value"]
param = "args"
rationale = "Derivation from the type args; single operand."

["pipelex/core/concepts/concept_representation_generator.py::ConceptRepresentationGenerator._generate_literal_value"]
param = "literal_args"
rationale = "Derivation from the literal args; single operand."

["pipelex/core/concepts/concept_representation_generator.py::ConceptRepresentationGenerator._unwrap_optional"]
param = "field_type"
rationale = "Transforms the field type; single operand."

["pipelex/core/concepts/concept_representation_generator.py::ConceptRepresentationGenerator.generate_class_representation"]
param = "content_class"
rationale = "Derivation from the content class; single operand."

["pipelex/core/concepts/concept_representation_generator.py::ConceptRepresentationGenerator.generate_field_value"]
param = "field_type"
rationale = "Derivation from the field type; context stays keyword."

["pipelex/core/concepts/concept_representation_generator.py::ConceptRepresentationGenerator.generate_representation"]
param = "concept_ref"
rationale = "Derivation keyed by the concept ref; format stays keyword."

["pipelex/core/concepts/concept_representation_generator.py::generate_json_representation"]
param = "concept_ref"
rationale = "Derivation keyed by the concept ref; single operand."

["pipelex/core/concepts/concept_representation_generator.py::generate_python_representation"]
param = "concept_ref"
rationale = "Derivation keyed by the concept ref; single operand."

["pipelex/core/concepts/helpers.py::extract_concept_code_from_concept_ref_or_code"]
param = "concept_ref_or_code"
rationale = "Conversion: extracts from the ref-or-code; single operand."

["pipelex/core/concepts/helpers.py::get_structure_class_name_from_blueprint"]
param = "blueprint_or_string_description"
rationale = "Derivation from the blueprint-or-description; single operand."

["pipelex/core/concepts/helpers.py::normalize_structure_blueprint"]
param = "structure_dict"
rationale = "Verb-object: normalizes the structure dict; single operand."

["pipelex/core/concepts/helpers.py::strip_markers_from_concept_ref_or_code"]
param = "concept_ref_or_code"
rationale = "Single-operand transformation of the ref-or-code string."

["pipelex/core/concepts/native/concept_native.py::NativeConceptCode.get_native_structure_class"]
param = "class_name"
rationale = "Lookup keyed by the class name it resolves; single operand."

["pipelex/core/concepts/native/concept_native.py::NativeConceptCode.get_validated_native_concept_ref"]
param = "concept_ref_or_code"
rationale = "Verb-object: validates the ref-or-code; single operand."

["pipelex/core/concepts/native/concept_native.py::NativeConceptCode.is_dynamic_concept"]
param = "concept_code"
rationale = "Predicate on the concept code; single operand."

["pipelex/core/concepts/native/concept_native.py::NativeConceptCode.is_native_concept_ref_or_code"]
param = "concept_ref_or_code"
rationale = "Predicate on the ref-or-code; single operand."

["pipelex/core/concepts/native/concept_native.py::NativeConceptCode.is_native_structure_class"]
param = "class_name"
rationale = "Predicate on the class name; single operand."

["pipelex/core/concepts/native/concept_native.py::NativeConceptCode.is_structureless_concept"]
param = "concept_code"
rationale = "Predicate on the concept code; single operand — same shape as its is_dynamic_concept sibling."

["pipelex/core/concepts/native/concept_native.py::NativeConceptCode.is_text_concept"]
param = "concept_code"
rationale = "Predicate on the concept code; single operand."

["pipelex/core/concepts/native/concept_native.py::NativeConceptCode.is_valid_native_concept_ref"]
param = "concept_ref"
rationale = "Predicate on the concept ref; single operand."

["pipelex/core/concepts/native/concept_native.py::NativeConceptCode.validate_native_concept_ref_or_code"]
param = "concept_ref_or_code"
rationale = "Verb-object: validates the ref-or-code; single operand."

["pipelex/core/concepts/native/pinned_blueprints.py::_pinned_description"]
param = "native_code"
rationale = "Noun-named derivation: the pinned description for the native code; single operand."

["pipelex/core/concepts/native/pinned_blueprints.py::_pinned_structure"]
param = "native_code"
rationale = "Noun-named derivation: the pinned structure for the native code; single operand."

["pipelex/core/concepts/native/pinned_blueprints.py::make_pinned_native_blueprint"]
param = "native_code"
rationale = "Factory from source: builds the blueprint for the native code; single operand."

["pipelex/core/concepts/resolved_fields.py::_resolve_concept"]
param = "concept_ref"
rationale = "Verb-object: resolves the concept_ref; local_domain is context."

["pipelex/core/concepts/resolved_fields.py::_resolve_list_item"]
param = "blueprint"
rationale = "Verb-object: resolves the list-item blueprint; local_domain is context."

["pipelex/core/concepts/resolved_fields.py::_resolve_scalar_type_name"]
param = "type_name"
rationale = "Verb-object: resolves the type name; the rest is context."

["pipelex/core/concepts/resolved_fields.py::_resolve_type"]
param = "blueprint"
rationale = "Verb-object: resolves the blueprint's type; local_domain is context."

["pipelex/core/concepts/resolved_fields.py::iter_imprecision_reasons"]
param = "resolved_type"
rationale = "Noun-named derivation: the imprecision reasons of the resolved type; single operand."

["pipelex/core/concepts/resolved_fields.py::resolve_structure_fields"]
param = "structure_blueprint"
rationale = "Verb-object: resolves the structure blueprint's fields; local_domain is context."

["pipelex/core/concepts/structure_generation/exceptions.py::SyntaxErrorData.from_syntax_error"]
param = "syntax_error"
rationale = "Factory from source: builds from the syntax error; single operand."

["pipelex/core/concepts/structure_generation/generator.py::StructureGenerator._escape_string_for_python"]
param = "value"
rationale = "Transforms the value; single operand."

["pipelex/core/concepts/structure_generation/generator.py::StructureGenerator._format_class_docstring"]
param = "docstring"
rationale = "Transforms the docstring; single operand."

["pipelex/core/concepts/structure_generation/generator.py::StructureGenerator._format_default_value"]
param = "value"
rationale = "Transforms the value; context stays keyword."

["pipelex/core/concepts/structure_generation/generator.py::StructureGenerator._format_field_description"]
param = "description"
rationale = "Transforms the description; single operand."

["pipelex/core/concepts/structure_generation/generator.py::StructureGenerator._generate_field_line"]
param = "resolved_field"
rationale = "Noun-named derivation: the source line for the resolved field; single operand."

["pipelex/core/concepts/structure_generation/generator.py::StructureGenerator._python_type_for_concept"]
param = "resolved_type"
rationale = "Noun-named derivation: the Python type for the resolved type; single operand."

["pipelex/core/concepts/structure_generation/generator.py::StructureGenerator._python_type_from_resolved"]
param = "resolved_type"
rationale = "Noun-named derivation: the Python type for the resolved type; single operand."

["pipelex/core/concepts/structure_generation/generator.py::StructureGenerator._validate_execution"]
param = "python_code"
rationale = "Verb-object: validates the python code; single operand."

["pipelex/core/concepts/structure_generation/generator.py::StructureGenerator.validate_generated_code"]
param = "python_code"
rationale = "Verb-object: validates the python code; single operand."

["pipelex/core/concepts/validation.py::is_concept_code_valid"]
param = "concept_code"
rationale = "Predicate on the concept code; single operand."

["pipelex/core/concepts/validation.py::is_concept_ref_or_code_valid"]
param = "concept_ref_or_code"
rationale = "Predicate on the ref-or-code; single operand."

["pipelex/core/concepts/validation.py::is_concept_ref_valid"]
param = "concept_ref"
rationale = "Predicate on the concept ref; single operand."

["pipelex/core/concepts/validation.py::validate_concept_code"]
param = "concept_code"
rationale = "Verb-object: validates the concept code; single operand."

["pipelex/core/concepts/validation.py::validate_concept_ref"]
param = "concept_ref"
rationale = "Verb-object: validates the concept ref; single operand."

["pipelex/core/concepts/validation.py::validate_concept_ref_or_code"]
param = "concept_ref_or_code"
rationale = "Verb-object: validates the ref-or-code; single operand."

["pipelex/core/domains/domain.py::SpecialDomain.is_native"]
param = "domain_code"
rationale = "Predicate on the domain code; single operand."

["pipelex/core/domains/domain_factory.py::DomainFactory.make_from_blueprint"]
param = "blueprint"
rationale = "Factory from source: builds the domain from the blueprint; single operand."

["pipelex/core/domains/validation.py::is_domain_code_valid"]
param = "code"
rationale = "Predicate on the domain code; single operand."

["pipelex/core/domains/validation.py::validate_domain_code"]
param = "code"
rationale = "Verb-object: validates the domain code; single operand."

["pipelex/core/memory/absence_render.py::build_absence_html"]
param = "absence_record"
rationale = "Verb-object: renders the absence record; single operand."

["pipelex/core/memory/absence_render.py::build_absence_json"]
param = "absence_record"
rationale = "Verb-object: renders the absence record; single operand."

["pipelex/core/memory/absence_render.py::build_absence_markdown"]
param = "absence_record"
rationale = "Verb-object: renders the absence record; single operand."

["pipelex/core/memory/absence_render.py::build_absence_payload"]
param = "absence_record"
rationale = "Verb-object: renders the absence record; single operand."

["pipelex/core/memory/input_shaper.py::InputShaper._build_anything_content"]
param = "value"
rationale = "Verb-object: builds the content for the raw value; the rest is context."

["pipelex/core/memory/input_shaper.py::InputShaper._build_item_content"]
param = "value"
rationale = "Verb-object: shapes the raw value into content; the rest is context."

["pipelex/core/memory/input_shaper.py::InputShaper._build_json_object_content"]
param = "json_object"
rationale = "Verb-object: builds the content holding the JSON object; the concept and the rest are context."

["pipelex/core/memory/input_shaper.py::InputShaper._check_input_names"]
param = "pipeline_inputs"
rationale = "Validator: the pipeline inputs are the operand checked against the specs."

["pipelex/core/memory/input_shaper.py::InputShaper._describe_value"]
param = "value"
rationale = "Noun-named derivation: describes the value; single operand."

["pipelex/core/memory/input_shaper.py::InputShaper._is_envelope_dict"]
param = "value"
rationale = "Predicate on the value; single operand."

["pipelex/core/memory/input_shaper.py::InputShaper._is_explicit"]
param = "value"
rationale = "Predicate on the value; single operand."

["pipelex/core/memory/input_shaper.py::InputShaper._make_content"]
param = "concept"
rationale = "Factory keyed by the concept; the value stays keyword."

["pipelex/core/memory/input_shaper.py::InputShaper._peel_multiplicity"]
param = "multiplicity"
rationale = "Single-operand transformation of the multiplicity."

["pipelex/core/memory/input_shaper.py::InputShaper._reconcile_explicit_multiplicity"]
param = "stuff"
rationale = "Verb-object: reconciles the stuff; the rest is context."

["pipelex/core/memory/input_shaper.py::InputShaper._resolve_local_path"]
param = "url"
rationale = "Verb-object: resolves the url; inputs_base_dir is context."

["pipelex/core/memory/input_shaper.py::InputShaper._shape_explicit"]
param = "value"
rationale = "Verb-object: shapes the raw value; the rest is context."

["pipelex/core/memory/input_shaper.py::InputShaper._shape_list"]
param = "value"
rationale = "Verb-object: shapes the raw value; the rest is context."

["pipelex/core/memory/input_shaper.py::InputShaper._shape_one"]
param = "value"
rationale = "Verb-object: shapes the raw value; the rest is context."

["pipelex/core/memory/input_shaper.py::InputShaper._shape_with_multiplicity"]
param = "value"
rationale = "Verb-object: shapes the raw value; the rest is context."

["pipelex/core/memory/input_shaper.py::InputShaper._try_shape_csv"]
param = "value"
rationale = "Verb-object: shapes the raw value; the rest is context."

["pipelex/core/memory/input_shaper.py::InputShaper._try_shape_structureless_envelope"]
param = "value"
rationale = "Verb-object: shapes the raw value when it is a structureless envelope; the rest is context."

["pipelex/core/memory/input_shaper.py::InputShaper.resolve_input_kind"]
param = "concept"
rationale = "Noun-named derivation: the input kind of the concept; single operand."

["pipelex/core/memory/input_shaper.py::InputShaper.shape"]
param = "pipeline_inputs"
rationale = "Verb-object: shapes the pipeline inputs; specs and context stay keyword."

["pipelex/core/memory/working_memory.py::WorkingMemory._get_typed_items_from_list_content"]
param = "list_content"
rationale = "Verb-object: reads the list content; expected type stays keyword."

["pipelex/core/memory/working_memory.py::WorkingMemory.add_alias"]
param = "alias"
rationale = "Verb-object: the alias being added; its target stays keyword."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_aliases_for"]
param = "target"
rationale = "Query keyed by the target name; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_existing_stuffs"]
param = "names"
rationale = "Memory getter keyed by the stuff names; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_list_stuff_first_item_as"]
param = "name"
rationale = "Memory getter keyed by the stuff name; item type stays keyword."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_optional_absence"]
param = "name"
rationale = "Entity-keyed getter on working memory."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_optional_stuff"]
param = "name"
rationale = "Memory getter keyed by the stuff name; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff"]
param = "name"
rationale = "Memory getter keyed by the stuff name; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as"]
param = "name"
rationale = "Memory getter keyed by the stuff name; content type stays keyword."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_choice"]
param = "name"
rationale = "Entity-keyed getter on working memory."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_date"]
param = "name"
rationale = "Entity-keyed getter on working memory."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_document"]
param = "name"
rationale = "Memory getter keyed by the stuff name; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_html"]
param = "name"
rationale = "Memory getter keyed by the stuff name; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_image"]
param = "name"
rationale = "Memory getter keyed by the stuff name; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_list"]
param = "name"
rationale = "Memory getter keyed by the stuff name; item type stays keyword."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_mermaid"]
param = "name"
rationale = "Memory getter keyed by the stuff name; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_number"]
param = "name"
rationale = "Memory getter keyed by the stuff name; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_rating"]
param = "name"
rationale = "Entity-keyed getter on working memory."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_str"]
param = "name"
rationale = "Memory getter keyed by the stuff name; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_text"]
param = "name"
rationale = "Memory getter keyed by the stuff name; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_text_and_image"]
param = "name"
rationale = "Memory getter keyed by the stuff name; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuff_as_yes_no"]
param = "name"
rationale = "Entity-keyed getter on working memory."

["pipelex/core/memory/working_memory.py::WorkingMemory.get_stuffs"]
param = "names"
rationale = "Memory getter keyed by the stuff names; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.is_stuff_code_used"]
param = "stuff_code"
rationale = "Predicate on the stuff code; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.is_stuff_exists"]
param = "name"
rationale = "Predicate on the stuff named; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.list_missing_names"]
param = "names"
rationale = "Verb-object: filters the given names to the missing ones; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.main_list_stuff_first_item_as"]
param = "item_type"
rationale = "Type-directed accessor: the target item type; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.main_stuff_as"]
param = "content_type"
rationale = "Type-directed accessor: the target content type; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.main_stuff_as_list"]
param = "item_type"
rationale = "Type-directed accessor: the target item type; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.record_absence"]
param = "record"
rationale = "Verb-object: records the absence record; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.record_new_main_absence"]
param = "record"
rationale = "Verb-object: records the absence record; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.record_resolved_absence"]
param = "record"
rationale = "Verb-object: records the absence record; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.remove_alias"]
param = "alias"
rationale = "Verb-object: removes the alias; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.remove_stuff"]
param = "name"
rationale = "Verb-object: removes the stuff named; single operand."

["pipelex/core/memory/working_memory.py::WorkingMemory.resolve_stuff"]
param = "name"
rationale = "Entity-keyed getter on working memory."

["pipelex/core/memory/working_memory.py::WorkingMemory.set_alias"]
param = "alias"
rationale = "Verb-object: the alias being set; its target stays keyword."

["pipelex/core/memory/working_memory.py::WorkingMemory.set_new_main_stuff"]
param = "stuff"
rationale = "Verb-object: installs the stuff as main; name stays keyword."

["pipelex/core/memory/working_memory.py::_encode_composite_for_transport"]
param = "composite"
rationale = "Single-operand conversion of the composite content."

["pipelex/core/memory/working_memory.py::_encode_content_with_class_markers"]
param = "content"
rationale = "Single-operand conversion of the content."

["pipelex/core/memory/working_memory_factory.py::WorkingMemoryFactory.convert_stuff_spec_to_typed_named"]
param = "stuff_spec"
rationale = "Conversion: transforms the stuff spec; context stays keyword."

["pipelex/core/memory/working_memory_factory.py::WorkingMemoryFactory.convert_to_working_memory_format"]
param = "needed_inputs_spec"
rationale = "Conversion: transforms the needed-inputs spec; single operand."

["pipelex/core/memory/working_memory_factory.py::WorkingMemoryFactory.make_from_multiple_stuffs"]
param = "stuff_list"
rationale = "Factory from source: builds from the stuff list; options stay keyword."

["pipelex/core/memory/working_memory_factory.py::WorkingMemoryFactory.make_from_pipeline_inputs"]
param = "pipeline_inputs"
rationale = "Factory from source: builds from the pipeline inputs; options stay keyword."

["pipelex/core/memory/working_memory_factory.py::WorkingMemoryFactory.make_from_single_stuff"]
param = "stuff"
rationale = "Factory from source: builds from the stuff; options stay keyword."

["pipelex/core/memory/working_memory_factory.py::WorkingMemoryFactory.make_mock_content"]
param = "typed_named_stuff_spec"
rationale = "Factory from source: builds from the typed-named spec; single operand."

["pipelex/core/memory/working_memory_factory.py::WorkingMemoryFactory.make_mock_inputs"]
param = "needed_inputs"
rationale = "Factory from source: builds from the needed inputs; single operand."

["pipelex/core/memory/working_memory_factory.py::WorkingMemoryFactory.make_mock_stuff"]
param = "typed_named_stuff_spec"
rationale = "Factory from source: builds from the typed-named spec; single operand."

["pipelex/core/pipes/inputs/input_stuff_specs.py::InputStuffSpecs.get_required_stuff_spec"]
param = "variable_name"
rationale = "Specs getter keyed by the variable name; single operand."

["pipelex/core/pipes/inputs/input_stuff_specs.py::InputStuffSpecs.is_variable_existing"]
param = "variable_name"
rationale = "Predicate on the variable named; single operand."

["pipelex/core/pipes/inputs/input_stuff_specs.py::InputStuffSpecs.set_default_domain"]
param = "domain_code"
rationale = "Setter: installs the default domain code; single operand."

["pipelex/core/pipes/inputs/input_stuff_specs.py::TypedNamedStuffSpec.make_from_named"]
param = "named"
rationale = "Factory from source: builds from the named spec; context stays keyword."

["pipelex/core/pipes/pipe_io_artifacts.py::_render_json_text"]
param = "payload"
rationale = "Verb-object: renders the payload as JSON text; single operand."

["pipelex/core/pipes/pipe_io_artifacts.py::render_pipe_io_artifact_files"]
param = "artifacts"
rationale = "Verb-object: renders the artifacts into their files; single operand."

["pipelex/core/pipes/pipe_output.py::PipeOutput.main_stuff_as"]
param = "content_type"
rationale = "Type-directed accessor: the target content type; single operand."

["pipelex/core/pipes/pipe_output.py::PipeOutput.main_stuff_as_items"]
param = "item_type"
rationale = "Type-directed accessor: the target item type; single operand."

["pipelex/core/pipes/pipe_output.py::PipeOutput.main_stuff_as_list"]
param = "item_type"
rationale = "Type-directed accessor: the target item type; single operand."

["pipelex/core/pipes/variable_multiplicity.py::format_concept_with_multiplicity"]
param = "concept_code_or_string"
rationale = "Transforms the concept string; multiplicity stays keyword."

["pipelex/core/pipes/variable_multiplicity.py::parse_concept_with_multiplicity"]
param = "concept_ref_or_code"
rationale = "Verb-object: parses the ref-or-code; single operand."

["pipelex/core/qualified_ref.py::QualifiedRef.has_cross_package_prefix"]
param = "raw"
rationale = "Predicate on the raw ref string; single operand."

["pipelex/core/qualified_ref.py::QualifiedRef.is_address_based_alias"]
param = "alias"
rationale = "Predicate on the alias; single operand."

["pipelex/core/qualified_ref.py::QualifiedRef.is_external_to"]
param = "domain"
rationale = "Predicate against the domain; single operand."

["pipelex/core/qualified_ref.py::QualifiedRef.is_local_to"]
param = "domain"
rationale = "Predicate against the domain; single operand."

["pipelex/core/qualified_ref.py::QualifiedRef.parse"]
param = "raw"
rationale = "Verb-object: parses the raw ref string; options stay keyword."

["pipelex/core/qualified_ref.py::QualifiedRef.parse_concept_ref"]
param = "raw"
rationale = "Verb-object: parses the raw ref string; options stay keyword."

["pipelex/core/qualified_ref.py::QualifiedRef.parse_pipe_ref"]
param = "raw"
rationale = "Verb-object: parses the raw ref string; options stay keyword."

["pipelex/core/qualified_ref.py::QualifiedRef.parse_stripping_cross_package"]
param = "raw"
rationale = "Verb-object: parses the raw ref string; options stay keyword."

["pipelex/core/qualified_ref.py::QualifiedRef.split_cross_package_ref"]
param = "raw"
rationale = "Verb-object: splits the raw ref string; single operand."

["pipelex/core/stuffs/html_rendering.py::render_value_html"]
param = "value"
rationale = "Verb-object: renders the value; single operand."

["pipelex/core/stuffs/image_field_search.py::check_generic_container_for_images"]
param = "container_type"
rationale = "Verb-object: inspects the container type; context stays keyword."

["pipelex/core/stuffs/image_field_search.py::search_for_nested_image_fields"]
param = "content_class"
rationale = "Verb-object: scans the content class; context stays keyword."

["pipelex/core/stuffs/iso_temporal.py::parse_iso_date"]
param = "text"
rationale = "parse_iso_date(text) reads as the verb-object sentence it is: one string to parse, no other operand."

["pipelex/core/stuffs/iso_temporal.py::parse_iso_time"]
param = "text"
rationale = "parse_iso_time(text) reads as the verb-object sentence it is: one string to parse, no other operand."

["pipelex/core/stuffs/list_content.py::ListContent.get_items"]
param = "item_type"
rationale = "Type-directed accessor: the target item type; single operand."

["pipelex/core/stuffs/structured_content.py::StructuredContent._render_value_with_images"]
param = "value"
rationale = "Transforms the value; rendering context stays keyword."

["pipelex/core/stuffs/stuff.py::Stuff.as_list_of_fixed_content_type"]
param = "item_type"
rationale = "Type-directed accessor: the target item type; single operand."

["pipelex/core/stuffs/stuff.py::Stuff.content_as"]
param = "content_type"
rationale = "Type-directed accessor: the target content type; single operand."

["pipelex/core/stuffs/stuff.py::Stuff.make_stuff_name"]
param = "concept"
rationale = "Derivation from the concept; single operand."

["pipelex/core/stuffs/stuff.py::Stuff.verify_content_type"]
param = "content"
rationale = "Verb-object: verifies the content; expected type stays keyword."

["pipelex/core/stuffs/stuff_artefact.py::StuffArtefact.get"]
param = "key"
rationale = "Mapping-protocol getter keyed by the key; single operand."

["pipelex/core/stuffs/stuff_content_factory.py::StuffContentFactory._make_date_content"]
param = "date_subclass"
rationale = "Type-directed factory: the subclass selects the product; the value stays keyword."

["pipelex/core/stuffs/stuff_content_factory.py::StuffContentFactory._make_time_content"]
param = "time_subclass"
rationale = "Type-directed factory: the subclass selects the product; the value stays keyword."

["pipelex/core/stuffs/stuff_content_factory.py::StuffContentFactory._parse_iso_temporal"]
param = "value"
rationale = "Parser: the value string is the single operand."

["pipelex/core/stuffs/stuff_content_factory.py::StuffContentFactory.make_stuff_content_from_concept_required"]
param = "concept"
rationale = "Factory keyed by the concept; the value stays keyword."

["pipelex/core/stuffs/stuff_content_factory.py::StuffContentFactory.make_stuff_content_from_concept_with_fallback"]
param = "concept"
rationale = "Factory keyed by the concept; the value stays keyword."

["pipelex/core/stuffs/stuff_factory.py::StuffFactory._try_make_csv_list_stuff"]
param = "concept"
rationale = "Factory keyed by the concept; the value stays keyword."

["pipelex/core/stuffs/stuff_factory.py::StuffFactory.combine_stuffs"]
param = "stuff_contents"
rationale = "Verb-object: combines the stuff contents; options stay keyword."

["pipelex/core/stuffs/stuff_factory.py::StuffFactory.make_from_blueprint"]
param = "blueprint"
rationale = "Factory from source: builds the stuff from the blueprint; single operand."

["pipelex/core/stuffs/stuff_factory.py::StuffFactory.make_from_concept_ref"]
param = "concept_ref"
rationale = "Factory keyed by the concept ref; the value stays keyword."

["pipelex/core/stuffs/stuff_factory.py::StuffFactory.make_from_str"]
param = "str_value"
rationale = "Factory from source: builds from the string value; options stay keyword."

["pipelex/core/stuffs/stuff_factory.py::StuffFactory.make_stuff"]
param = "concept"
rationale = "Factory keyed by the concept; content and name stay keyword."

["pipelex/core/stuffs/stuff_factory.py::StuffFactory.make_stuff_from_stuff_content_or_data"]
param = "stuff_content_or_data"
rationale = "Factory from source: builds from the content-or-data; options stay keyword."

["pipelex/core/stuffs/stuff_factory.py::StuffFactory.make_stuff_name"]
param = "concept"
rationale = "Derivation from the concept; single operand."

["pipelex/core/stuffs/stuff_factory.py::StuffFactory.try_make_csv_list_content"]
param = "concept"
rationale = "Factory keyed by the concept; the content stays keyword."

["pipelex/core/stuffs/stuff_viewer.py::_get_html_tab_label"]
param = "content_type"
rationale = "Derivation from the content type; single operand."

["pipelex/core/stuffs/stuff_viewer.py::render_stuff_content_viewer"]
param = "stuff_data"
rationale = "Verb-object: renders the stuff data; options stay keyword."

["pipelex/core/stuffs/stuff_viewer.py::render_stuff_viewer"]
param = "stuff"
rationale = "Verb-object: renders the stuff; options stay keyword."

["pipelex/errors/error_class_discovery.py::_is_production_subclass"]
param = "cls"
rationale = "Predicate on the error class; single operand."

["pipelex/errors/error_code_declaration.py::declared_error_codes"]
param = "declaration"
rationale = "Lists the codes of its one operand, a class's declaration: declared_error_codes(cls.error_code)."

["pipelex/errors/error_code_declaration.py::describe_error_code_declaration"]
param = "declaration"
rationale = "Describes its one operand, a class's declaration: describe_error_code_declaration(cls.error_code)."

["pipelex/errors/error_code_sites.py::_chosen_code"]
param = "call"
rationale = "Reads the code its one operand, a with_error_code call node, chooses: _chosen_code(call)."

["pipelex/errors/error_code_sites.py::constructed_class_name"]
param = "node"
rationale = "Names the class its one operand, an AST expression, constructs: constructed_class_name(node)."

["pipelex/errors/error_codes.py::error_code_spec"]
param = "code"
rationale = "Looks up its one operand, a code: error_code_spec(code) reads as the code's spec."

["pipelex/errors/error_codes.py::parse_error_code"]
param = "value"
rationale = "Parses its one operand, a code string: parse_error_code(value) reads as a parse."

["pipelex/errors/foreign_raises.py::_decorator_names"]
param = "function"
rationale = "Lists the decorators of its one operand, a function node: _decorator_names(function)."

["pipelex/errors/foreign_raises.py::_expression_name"]
param = "node"
rationale = "Names its one operand, an AST expression: _expression_name(node), applied recursively."

["pipelex/errors/foreign_raises.py::_raised_class_name"]
param = "node"
rationale = "Names the class its one operand, a raise's expression, constructs: _raised_class_name(node.exc)."

["pipelex/errors/retired_error_pages.py::_code_page_target"]
param = "code"
rationale = "Maps its one operand, a code, to its page: _code_page_target(code)."

["pipelex/errors/retired_error_pages.py::_representative_code"]
param = "cls"
rationale = "Picks the code of its one operand, an error class: _representative_code(cls)."

["pipelex/fix_ops/applier.py::_as_tomlkit_value"]
param = "value"
rationale = "Single-operand conversion of the value."

["pipelex/fix_ops/applier.py::_render_syntax_diagnostic"]
param = "diagnostic"
rationale = "Verb-object: renders the diagnostic; single operand."

["pipelex/fix_ops/applier.py::serialize_and_format"]
param = "toml_doc"
rationale = "Single-operand serialization of the TOML document."

["pipelex/fix_ops/file_transaction.py::_cleanup_staged_updates"]
param = "staged_updates"
rationale = "Verb-object: cleans up the staged updates; single operand."

["pipelex/fix_ops/file_transaction.py::_commit_staged_updates"]
param = "staged_updates"
rationale = "Verb-object: commits the staged updates; single operand."

["pipelex/fix_ops/file_transaction.py::_rollback_committed_updates"]
param = "committed_updates"
rationale = "Verb-object: rolls back the committed updates; single operand."

["pipelex/fix_ops/file_transaction.py::assert_snapshot_unchanged"]
param = "snapshot"
rationale = "Validator: the snapshot is the single operand checked."

["pipelex/fix_ops/file_transaction.py::commit_file_updates"]
param = "updates"
rationale = "Verb-object: commits the updates; single operand."

["pipelex/fix_ops/file_transaction.py::read_file_snapshot"]
param = "path"
rationale = "Factory from source: reads the snapshot of the file at path."

["pipelex/fix_ops/file_transaction.py::stage_file_update"]
param = "update"
rationale = "Verb-object: stages the update; single operand."

["pipelex/graph/graph_analysis.py::GraphAnalysis.from_graphspec"]
param = "graph"
rationale = "Factory from source: builds the analysis from the graph spec; single operand."

["pipelex/graph/graph_analysis.py::GraphAnalysis.get_children"]
param = "node_id"
rationale = "Query accessor keyed by the node it inspects; single operand."

["pipelex/graph/graph_analysis.py::GraphAnalysis.get_consumers"]
param = "digest"
rationale = "Query accessor keyed by the stuff digest it inspects; single operand."

["pipelex/graph/graph_analysis.py::GraphAnalysis.get_producers"]
param = "digest"
rationale = "Query accessor keyed by the stuff digest it inspects; single operand."

["pipelex/graph/graph_analysis.py::GraphAnalysis.get_stuff_info"]
param = "digest"
rationale = "Query accessor keyed by the stuff digest it inspects; single operand."

["pipelex/graph/graph_analysis.py::GraphAnalysis.is_controller"]
param = "node_id"
rationale = "Predicate on the node named by the id; single operand."

["pipelex/graph/graph_analysis.py::GraphAnalysis.is_root"]
param = "node_id"
rationale = "Predicate on the node named by the id; single operand."

["pipelex/graph/graph_factory.py::generate_graph_outputs"]
param = "graph_spec"
rationale = "Verb-object: generates outputs from the graph spec; rendering options stay keyword."

["pipelex/graph/graph_factory.py::save_graph_outputs_to_dir"]
param = "graph_outputs"
rationale = "Verb-object: saves the graph outputs; destination stays keyword."

["pipelex/graph/graph_rendering.py::render_graph_from_spec"]
param = "graph_spec"
rationale = "Verb-object: renders from the graph spec; options stay keyword."

["pipelex/graph/graph_tracer.py::GraphTracer._emit_event"]
param = "event"
rationale = "Verb-object: emits the trace event; single operand."

["pipelex/graph/graph_tracer_manager.py::GraphTracerManager._get_tracer"]
param = "graph_id"
rationale = "Manager getter keyed by the tracer's graph id; single operand."

["pipelex/graph/graph_tracer_manager.py::GraphTracerManager.close_tracer"]
param = "tracer_key"
rationale = "Verb-object: closes the tracer named by the key; single operand."

["pipelex/graph/graph_tracer_manager.py::GraphTracerManager.get_instance_tracer"]
param = "lookup_key"
rationale = "Manager getter keyed by the tracer's lookup key; single operand."

["pipelex/graph/graph_tracer_manager.py::GraphTracerManager.get_tracer"]
param = "graph_id"
rationale = "Manager getter keyed by the tracer's graph id; single operand."

["pipelex/graph/graph_tracer_manager.py::GraphTracerManager.on_pipe_start"]
param = "trace_context"
rationale = "Event handler: the trace context being handled; event fields stay keyword."

["pipelex/graph/graph_tracer_manager.py::GraphTracerManager.open_tracer"]
param = "graph_id"
rationale = "Verb-object: opens the tracer for the graph id; config stays keyword."

["pipelex/graph/graph_tracer_protocol.py::GraphTracerProtocol.on_pipe_end_error"]
param = "node_id"
rationale = "Protocol event handler: the node whose run ended; event fields stay keyword."

["pipelex/graph/graph_tracer_protocol.py::GraphTracerProtocol.on_pipe_end_skipped"]
param = "node_id"
rationale = "Protocol event handler keyed by node_id; details stay keyword."

["pipelex/graph/graph_tracer_protocol.py::GraphTracerProtocol.on_pipe_end_success"]
param = "node_id"
rationale = "Protocol event handler: the node whose run ended; event fields stay keyword."

["pipelex/graph/graph_tracer_protocol.py::GraphTracerProtocol.on_pipe_start"]
param = "trace_context"
rationale = "Protocol event handler: the trace context being handled; event fields stay keyword."

["pipelex/graph/graphspec.py::_truncate_string"]
param = "value"
rationale = "Transforms the value; max_length stays keyword."

["pipelex/graph/mermaidflow/mermaid_html.py::render_mermaid_html"]
param = "mermaid_code"
rationale = "Verb-object: renders the mermaid code; presentation options stay keyword."

["pipelex/graph/mermaidflow/mermaid_html.py::render_mermaid_html_async"]
param = "mermaid_code"
rationale = "Verb-object: renders the mermaid code; presentation options stay keyword."

["pipelex/graph/mermaidflow/mermaid_html.py::render_mermaid_html_with_data_async"]
param = "mermaid_code"
rationale = "Verb-object: renders the mermaid code; data payloads stay keyword."

["pipelex/graph/mermaidflow/mermaidflow_factory.py::MermaidflowFactory._get_node_label"]
param = "node"
rationale = "Derivation from the node spec; single operand."

["pipelex/graph/mermaidflow/mermaidflow_factory.py::MermaidflowFactory._render_dashed_edges"]
param = "edges"
rationale = "Verb-object: renders the edges; accumulators stay keyword."

["pipelex/graph/mermaidflow/mermaidflow_factory.py::MermaidflowFactory._render_node"]
param = "node"
rationale = "Verb-object: renders the node; rendering context stays keyword."

["pipelex/graph/mermaidflow/mermaidflow_factory.py::MermaidflowFactory._render_stuff_node"]
param = "digest"
rationale = "Verb-object: renders the stuff node identified by the digest; display fields stay keyword."

["pipelex/graph/mermaidflow/mermaidflow_factory.py::MermaidflowFactory._render_subgraph_recursive"]
param = "node_id"
rationale = "Verb-object: renders the subgraph rooted at the node id; lookup maps stay keyword."

["pipelex/graph/mermaidflow/mermaidflow_factory.py::MermaidflowFactory.make_from_graphspec"]
param = "graph"
rationale = "Factory from source: builds the diagram from the graph spec; options stay keyword."

["pipelex/graph/mermaidflow/mermaidflow_utils.py::make_stuff_id"]
param = "digest"
rationale = "Derivation: encodes the digest into a node id; single operand."

["pipelex/graph/mermaidflow/stuff_collector.py::_collect_stuff_field"]
param = "graph"
rationale = "Verb-object: collects from the graph; the extractor stays keyword."

["pipelex/graph/mermaidflow/stuff_collector.py::collect_stuff_content_type"]
param = "graph"
rationale = "Verb-object: collects from the graph; single operand."

["pipelex/graph/mermaidflow/stuff_collector.py::collect_stuff_data"]
param = "graph"
rationale = "Verb-object: collects from the graph; single operand."

["pipelex/graph/mermaidflow/stuff_collector.py::collect_stuff_metadata"]
param = "graph"
rationale = "Verb-object: collects from the graph; single operand."

["pipelex/graph/mermaidflow/stuff_collector.py::collect_stuff_metadata.extract_metadata"]
param = "io_spec"
rationale = "Positional Callable protocol: passed as the extractor callback, invoked extractor(io_spec)."

["pipelex/graph/reactflow/reactflow_html.py::_build_templating_context"]
param = "graphspec"
rationale = "Builds the context from the graph spec; config and title stay keyword."

["pipelex/graph/reactflow/reactflow_html.py::_build_viewer_config"]
param = "config"
rationale = "Derives the viewer dict from the rendering config; single operand."

["pipelex/graph/reactflow/reactflow_html.py::generate_reactflow_html"]
param = "graphspec"
rationale = "Verb-object: renders the graph spec to HTML; options stay keyword."

["pipelex/graph/reactflow/reactflow_html.py::generate_reactflow_html_async"]
param = "graphspec"
rationale = "Verb-object: renders the graph spec to HTML; options stay keyword."

["pipelex/graph/validation.py::_validate_edge_references"]
param = "graph"
rationale = "Verb-object: validates the graph; single operand."

["pipelex/graph/validation.py::_validate_failed_nodes_have_errors"]
param = "graph"
rationale = "Verb-object: validates the graph; single operand."

["pipelex/graph/validation.py::_validate_unique_edge_ids"]
param = "graph"
rationale = "Verb-object: validates the graph; single operand."

["pipelex/graph/validation.py::_validate_unique_node_ids"]
param = "graph"
rationale = "Verb-object: validates the graph; single operand."

["pipelex/graph/validation.py::validate_graphspec"]
param = "graph"
rationale = "Verb-object: validates the graph spec; single operand."

["pipelex/interpreter_hub.py::InterpreterHub.set_concept_library"]
param = "concept_library"
rationale = "Hub setter: installs the concept library; single self-labelling operand."

["pipelex/interpreter_hub.py::InterpreterHub.set_default_library_dirs"]
param = "library_dirs"
rationale = "Hub setter: installs the default library dirs; single self-labelling operand."

["pipelex/interpreter_hub.py::InterpreterHub.set_domain_library"]
param = "domain_library"
rationale = "Hub setter: installs the domain library; single self-labelling operand."

["pipelex/interpreter_hub.py::InterpreterHub.set_instance"]
param = "interpreter_hub"
rationale = "Hub setter: installs the InterpreterHub singleton; single self-labelling operand."

["pipelex/interpreter_hub.py::InterpreterHub.set_library_manager"]
param = "library_manager"
rationale = "Hub setter: installs the library manager; single self-labelling operand."

["pipelex/interpreter_hub.py::InterpreterHub.set_pipe_func_executor"]
param = "pipe_func_executor"
rationale = "Hub setter: installs the pipe-func executor; single self-labelling operand."

["pipelex/interpreter_hub.py::InterpreterHub.set_pipe_func_executor_registry"]
param = "pipe_func_executor_registry"
rationale = "Hub setter: installs the pipe-func executor registry; single self-labelling operand."

["pipelex/interpreter_hub.py::InterpreterHub.set_pipe_library"]
param = "pipe_library"
rationale = "Hub setter: installs the pipe library; single self-labelling operand."

["pipelex/interpreter_hub.py::InterpreterHub.set_pipe_router"]
param = "pipe_router"
rationale = "Hub setter: installs the pipe router; single self-labelling operand."

["pipelex/interpreter_hub.py::InterpreterHub.set_pipe_run"]
param = "pipe_run"
rationale = "Hub setter: installs the pipe-run holder; single self-labelling operand."

["pipelex/interpreter_hub.py::InterpreterHub.set_pipeline_manager"]
param = "pipeline_manager"
rationale = "Hub setter: installs the pipeline manager; single self-labelling operand."

["pipelex/interpreter_hub.py::get_native_concept"]
param = "native_concept"
rationale = "Hub getter: the native concept being fetched; single operand."

["pipelex/interpreter_hub.py::get_optional_domain"]
param = "domain_code"
rationale = "Hub getter keyed by the domain code; single operand."

["pipelex/interpreter_hub.py::get_optional_entry_pipe"]
param = "pipe_code"
rationale = "Hub accessor keyed by the human-supplied pipe code; single operand, mirroring get_optional_pipe."

["pipelex/interpreter_hub.py::get_optional_pipe"]
param = "pipe_code"
rationale = "Hub getter keyed by the pipe code; single operand."

["pipelex/interpreter_hub.py::get_pipe_source"]
param = "pipe_code"
rationale = "Hub getter keyed by the pipe code; single operand."

["pipelex/interpreter_hub.py::get_pipeline"]
param = "pipeline_run_id"
rationale = "Hub getter keyed by the pipeline run id; single operand."

["pipelex/interpreter_hub.py::get_required_concept"]
param = "concept_ref"
rationale = "Hub getter keyed by the concept ref; single operand."

["pipelex/interpreter_hub.py::get_required_domain"]
param = "domain_code"
rationale = "Hub getter keyed by the domain code; single operand."

["pipelex/interpreter_hub.py::get_required_entry_pipe"]
param = "pipe_code"
rationale = "Hub accessor keyed by the human-supplied pipe code; single operand, mirroring get_required_pipe."

["pipelex/interpreter_hub.py::get_required_pipe"]
param = "pipe_code"
rationale = "Hub getter keyed by the pipe code; single operand."

["pipelex/interpreter_hub.py::resolve_library_dirs"]
param = "library_dirs"
rationale = "Verb-object: resolves the given library dirs; single operand."

["pipelex/interpreter_hub.py::scoped_current_library"]
param = "library_id"
rationale = "Context manager scoping to the library named by the id; single operand."

["pipelex/interpreter_hub.py::scoped_pipe_func_executor"]
param = "pipe_func_executor"
rationale = "Scoped-binding context manager: binds the pipe-func executor for the block; single self-labelling operand."

["pipelex/interpreter_hub.py::scoped_pipe_router"]
param = "pipe_router"
rationale = "Context manager scoping the given pipe router; single self-labelling operand."

["pipelex/interpreter_hub.py::set_current_library"]
param = "library_id"
rationale = "Module-level setter: selects the library named by the id; single operand."

["pipelex/interpreter_hub.py::set_interpreter_hub"]
param = "interpreter_hub"
rationale = "Module-level setter: installs the InterpreterHub singleton; single self-labelling operand."

["pipelex/interpreter_hub.py::set_pipe_router"]
param = "pipe_router"
rationale = "Module-level setter: installs the pipe router; single self-labelling operand."

["pipelex/interpreter_plugins/direct/direct_plugin.py::DirectOrchestratorPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/interpreter_plugins/pipe_func/pipe_func_plugin.py::PipeFuncPlugin.register"]
param = "registrar"
rationale = "Plugin entrypoint: registers into the registrar; single self-labelling operand, consistent with sibling plugins."

["pipelex/interpreter_plugins/pipe_func/pipe_func_plugin.py::_make_direct_pipe_func_executor"]
param = "config"
rationale = "PipeFuncExecutorFactoryFn implementation: the registry invokes factories positionally via the Callable type."

["pipelex/kernel/llm_ops.py::concrete_llm_model_handle"]
param = "model"
rationale = "Verb-object: resolve one model reference to a concrete handle; the single obvious operand is the model."

["pipelex/kit/cursor_rules.py::_is_pipelex_managed"]
param = "mdc_path"
rationale = "Predicate on the .mdc file path; single operand."

["pipelex/kit/cursor_rules.py::_iter_agent_files"]
param = "agents_dir"
rationale = "Verb-object: iterates the agents dir; single operand."

["pipelex/kit/cursor_rules.py::remove_cursor_rules"]
param = "repo_root"
rationale = "Verb-object: the repo root being cleaned; kit_index stays keyword."

["pipelex/kit/cursor_rules.py::update_cursor_rules"]
param = "repo_root"
rationale = "Verb-object: the repo root being updated; kit context stays keyword."

["pipelex/kit/single_file_agent_rules.py::_demote_headings"]
param = "md_content"
rationale = "Verb-object: transforms the markdown content; levels stays keyword."

["pipelex/kit/single_file_agent_rules.py::_demote_headings.demote_match"]
param = "match"
rationale = "Positional Callable protocol: re.sub replacement callback, invoked repl(match)."

["pipelex/kit/single_file_agent_rules.py::remove_from_targets"]
param = "repo_root"
rationale = "Verb-object: the repo root being cleaned; options stay keyword."

["pipelex/kit/single_file_agent_rules.py::update_single_file_agent_rules"]
param = "repo_root"
rationale = "Verb-object: the repo root being updated; options stay keyword."

["pipelex/language/intent_hints.py::applicable_intent"]
param = "hints"
rationale = "Verb-object read: applicable_intent(hints) judges the hints table, the single obvious operand."

["pipelex/language/intent_hints.py::intent_word_applies"]
param = "word"
rationale = "Predicate on its single operand: intent_word_applies(word), the site kind being a keyword modifier."

["pipelex/language/intent_hints.py::is_intent_word_known"]
param = "word"
rationale = "Predicate on its single operand: is_intent_word_known(word)."

["pipelex/language/intent_hints.py::merge_hints"]
param = "layers"
rationale = "Verb-object read: merge_hints(layers) merges the hint layers, the single obvious operand."

["pipelex/language/mthds_factory.py::MthdsFactory.add_spaces_to_inline_tables"]
param = "toml_string"
rationale = "Verb-object: transforms the TOML string; single operand."

["pipelex/language/mthds_factory.py::MthdsFactory.add_spaces_to_inline_tables.find_and_replace_inline_tables"]
param = "text"
rationale = "Nested helper transforming the text; single operand."

["pipelex/language/mthds_factory.py::MthdsFactory.convert_dicts_to_inline_tables"]
param = "value"
rationale = "Conversion: the value being recursively converted; field_ordering stays keyword."

["pipelex/language/mthds_factory.py::MthdsFactory.convert_mapping_to_table"]
param = "mapping"
rationale = "Conversion: the mapping being converted to a table; field_ordering stays keyword."

["pipelex/language/mthds_factory.py::MthdsFactory.dict_to_mthds_styled_toml"]
param = "data"
rationale = "Conversion: the data dict being rendered to styled TOML; single operand."

["pipelex/language/mthds_factory.py::MthdsFactory.format_tomlkit_string"]
param = "text"
rationale = "Verb-object: formats the text as a tomlkit string node; single operand."

["pipelex/language/mthds_factory.py::MthdsFactory.make_construct_table"]
param = "construct_value"
rationale = "Factory from source: builds the table from the construct mapping; single operand."

["pipelex/language/mthds_factory.py::MthdsFactory.make_mthds_content"]
param = "blueprint"
rationale = "Factory from source: renders the bundle blueprint to .mthds content; single operand."

["pipelex/language/mthds_factory.py::MthdsFactory.make_table_obj_for_concept"]
param = "section_value"
rationale = "Factory from source: builds the table from the concept section mapping; single operand."

["pipelex/language/mthds_factory.py::MthdsFactory.make_table_obj_for_pipe"]
param = "section_value"
rationale = "Factory from source: builds the table from the pipe section mapping; single operand."

["pipelex/language/mthds_factory.py::MthdsFactory.make_template_table"]
param = "template_value"
rationale = "Factory from source: builds the table from the template mapping; single operand."

["pipelex/language/mthds_schema_generator.py::_add_taplo_metadata"]
param = "schema"
rationale = "Schema-pipeline stage transforming the schema dict; single operand."

["pipelex/language/mthds_schema_generator.py::_constrain_batch_over"]
param = "schema"
rationale = "One post-processing pass of the schema pipeline, called as a verb on the schema it rewrites, like its sibling passes."

["pipelex/language/mthds_schema_generator.py::_constrain_input_names"]
param = "schema"
rationale = "Schema-pipeline stage transforming the schema dict; single operand."

["pipelex/language/mthds_schema_generator.py::_constrain_judge_questions"]
param = "schema"
rationale = "One post-processing pass of the schema pipeline, called as a verb on the schema it rewrites, like its sibling passes."

["pipelex/language/mthds_schema_generator.py::_constrain_rating_levels"]
param = "schema"
rationale = "One post-processing pass of the schema pipeline, called as a verb on the schema it rewrites, like its sibling passes."

["pipelex/language/mthds_schema_generator.py::_constrain_stored_names"]
param = "schema"
rationale = "One post-processing pass of the schema pipeline, called as a verb on the schema it rewrites, like its sibling passes."

["pipelex/language/mthds_schema_generator.py::_convert_to_draft4"]
param = "schema"
rationale = "Schema-pipeline stage transforming the schema dict; single operand."

["pipelex/language/mthds_schema_generator.py::_draft4_visitor"]
param = "node"
rationale = "Positional Callable protocol: passed as _walk_schema visitor, invoked visitor(node)."

["pipelex/language/mthds_schema_generator.py::_normalize_type_on_pipe_definitions"]
param = "schema"
rationale = "Single-operand transformation of the schema."

["pipelex/language/mthds_schema_generator.py::_patch_construct_schema"]
param = "schema"
rationale = "Schema-pipeline stage transforming the schema dict; single operand."

["pipelex/language/mthds_schema_generator.py::_promote_schema_required_fields"]
param = "schema"
rationale = "Schema-pipeline stage transforming the schema dict; single operand."

["pipelex/language/mthds_schema_generator.py::_remove_from_required"]
param = "schema_obj"
rationale = "Verb-object: mutates the schema object's required list; field_names stays keyword."

["pipelex/language/mthds_schema_generator.py::_remove_internal_fields"]
param = "schema"
rationale = "Schema-pipeline stage transforming the schema dict; single operand."

["pipelex/language/mthds_schema_generator.py::_walk_schema"]
param = "node"
rationale = "Verb-object: walks the schema node tree; the visitor stays keyword."

["pipelex/language/toml_string_utils.py::format_toml_string"]
param = "text"
rationale = "Verb-object: formats the text; formatting options stay keyword."

["pipelex/libraries/concept/concept_library.py::ConceptLibrary.get_optional_concept"]
param = "concept_ref"
rationale = "Library getter keyed by the concept ref; single operand."

["pipelex/libraries/concept/concept_library.py::ConceptLibrary.get_optional_entry_concept"]
param = "concept_ref_or_code"
rationale = "Entry affordance keyed by the human-supplied concept string; single operand, mirroring get_optional_entry_pipe."

["pipelex/libraries/concept/concept_library.py::ConceptLibrary.is_concept_exists"]
param = "concept_ref"
rationale = "Predicate on the concept named by the ref; single operand."

["pipelex/libraries/concept/concept_library.py::ConceptLibrary.set_concept_resolver"]
param = "resolver"
rationale = "Setter: installs the resolver; single self-labelling operand."

["pipelex/libraries/concept/concept_library_abstract.py::ConceptLibraryAbstract.add_concepts"]
param = "concepts"
rationale = "Verb-object: adds the concepts; single operand."

["pipelex/libraries/concept/concept_library_abstract.py::ConceptLibraryAbstract.add_new_concept"]
param = "concept"
rationale = "Verb-object: adds the concept; single operand."

["pipelex/libraries/concept/concept_library_abstract.py::ConceptLibraryAbstract.list_concepts_by_domain"]
param = "domain_code"
rationale = "Query keyed by the domain code it lists; single operand."

["pipelex/libraries/concept/concept_library_abstract.py::ConceptLibraryAbstract.remove_concepts_by_concept_refs"]
param = "concept_refs"
rationale = "Verb-object: the refs naming the removed concepts; single operand."

["pipelex/libraries/concept_reference_validation.py::_split_concept_ref_context"]
param = "context"
rationale = "Transforms the context string; single operand."

["pipelex/libraries/concept_reference_validation.py::validate_concept_references_in_blueprints"]
param = "blueprints"
rationale = "Verb-object: validates refs within the blueprints; single operand."

["pipelex/libraries/contract_match.py::_canonical_concept_spec"]
param = "spec"
rationale = "Derivation: canonicalizes the spec; single operand."

["pipelex/libraries/crate_normalization.py::_flatten_refinement"]
param = "concepts"
rationale = "Verb-object: flattens the concepts mapping in place; single operand."

["pipelex/libraries/crate_normalization.py::_io_ref_concept"]
param = "io_ref"
rationale = "Noun-named derivation: the concept part of the io ref; single operand."

["pipelex/libraries/crate_normalization.py::_native_effective_structure"]
param = "native_ref"
rationale = "Noun-named derivation: the effective structure for the native ref; single operand."

["pipelex/libraries/crate_normalization.py::_normalize_concept"]
param = "value"
rationale = "Single-operand normalization of the concept entry; the rest is context."

["pipelex/libraries/crate_normalization.py::_resolve_refinement"]
param = "concept_ref"
rationale = "Verb-object: resolves the concept ref; concepts and cache are context."

["pipelex/libraries/crate_normalization.py::normalize_crate"]
param = "crate"
rationale = "Verb-object: normalizes the crate; mthds_version stays keyword."

["pipelex/libraries/crate_qualification.py::_domain_of"]
param = "qualified_ref"
rationale = "Noun-named derivation: parses the domain out of the qualified ref."

["pipelex/libraries/crate_qualification.py::_qualify_concept_entry"]
param = "value"
rationale = "Single-operand qualification of the concept entry; owner_domain is context."

["pipelex/libraries/crate_qualification.py::_qualify_concept_ref"]
param = "concept_ref_or_code"
rationale = "Single-operand transformation of the ref; domain is context."

["pipelex/libraries/crate_qualification.py::_qualify_io_ref"]
param = "io_ref"
rationale = "Single-operand transformation of the ref; domain is context."

["pipelex/libraries/crate_qualification.py::_qualify_pipe_blueprint"]
param = "blueprint"
rationale = "Single-operand qualification of the pipe blueprint; owner_domain is context."

["pipelex/libraries/crate_qualification.py::_qualify_pipe_ref"]
param = "pipe_ref"
rationale = "Single-operand transformation of the ref; domain is context."

["pipelex/libraries/crate_qualification.py::_qualify_slot_value"]
param = "slot_value"
rationale = "Verb-object read, matching sibling _qualify_io_ref: qualifies the one slot value."

["pipelex/libraries/crate_qualification.py::_qualify_structure_field"]
param = "field_blueprint"
rationale = "Single-operand transformation of the field blueprint; domain is context."

["pipelex/libraries/crate_qualification.py::_render_ref_with_markers"]
param = "concept_ref"
rationale = "Verb-object: renders the ref; parsed markers stay keyword."

["pipelex/libraries/crate_qualification.py::qualify_crate"]
param = "crate"
rationale = "Verb-object: qualifies the crate's in-body refs; single operand."

["pipelex/libraries/domain/domain_library.py::DomainLibrary.add_domain"]
param = "domain"
rationale = "Verb-object: adds the domain; single operand."

["pipelex/libraries/domain/domain_library.py::DomainLibrary.add_domains"]
param = "domains"
rationale = "Verb-object: adds the domains; single operand."

["pipelex/libraries/domain/domain_library.py::DomainLibrary.remove_domain_by_code"]
param = "domain_code"
rationale = "Verb-object: the code naming the removed domain; single operand."

["pipelex/libraries/domain/domain_library_abstract.py::DomainLibraryAbstract.get_domain"]
param = "domain_code"
rationale = "Library getter keyed by the domain code; single operand."

["pipelex/libraries/domain/domain_library_abstract.py::DomainLibraryAbstract.get_required_domain"]
param = "domain_code"
rationale = "Library getter keyed by the domain code; single operand."

["pipelex/libraries/library.py::Library._has_unresolved_cross_package_deps"]
param = "pipe"
rationale = "Predicate on the pipe; single operand."

["pipelex/libraries/library.py::Library.get_dependency_library"]
param = "alias"
rationale = "Library getter keyed by the dependency alias; single operand."

["pipelex/libraries/library.py::Library.resolve_concept"]
param = "concept_ref"
rationale = "Verb-object: resolves the concept ref; single operand."

["pipelex/libraries/library.py::Library.set_class_registry"]
param = "class_registry"
rationale = "Setter: installs the class registry; single self-labelling operand."

["pipelex/libraries/library_crate.py::_strip_source"]
param = "dumped"
rationale = "Single-operand transformation of the dumped mapping."

["pipelex/libraries/library_crate_factory.py::LibraryCrateFactory._contract_mismatch_msg"]
param = "pipe_ref"
rationale = "Builds the message for the colliding pipe ref; the declarations stay keyword."

["pipelex/libraries/library_crate_factory.py::LibraryCrateFactory._declaration_sort_key"]
param = "declaration"
rationale = "Sort-key function over the declaration; single operand."

["pipelex/libraries/library_crate_factory.py::LibraryCrateFactory._reconcile_pipe_collision"]
param = "pipe_ref"
rationale = "Verb-object: reconciles the collision at the pipe ref; the colliding declarations stay keyword."

["pipelex/libraries/library_crate_factory.py::LibraryCrateFactory.make_from_blueprints"]
param = "blueprints"
rationale = "Factory from source: builds the crate from the blueprints; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._check_package_visibility"]
param = "blueprints"
rationale = "Verb-object: checks visibility across the blueprints; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._detect_concept_cycles"]
param = "concepts"
rationale = "Verb-object: detects cycles among the concepts; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._detect_concept_cycles.check_for_cycle"]
param = "concept_ref"
rationale = "Nested DFS visitor on the concept ref; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._detect_concept_cycles.get_referenced_concepts"]
param = "concept"
rationale = "Nested helper: reads the concept's references; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._detect_concept_cycles.get_referenced_concepts.extract_type_names"]
param = "annotation"
rationale = "Nested helper: extracts names from the annotation; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._find_package_root"]
param = "mthds_paths"
rationale = "Derivation: finds the root of the given paths; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._load_address_based_dependency"]
param = "library"
rationale = "Verb-object: loads the dependency library object; context stays keyword."

["pipelex/libraries/library_manager.py::LibraryManager._load_concepts_from_blueprints"]
param = "blueprints"
rationale = "Verb-object: loads concepts from the blueprints; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._load_concepts_from_crate"]
param = "concepts"
rationale = "Verb-object: loads the crate concepts; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._load_single_dependency"]
param = "library"
rationale = "Verb-object: loads the dependency library object; context stays keyword."

["pipelex/libraries/library_manager.py::LibraryManager._pop_and_teardown_library"]
param = "library_id"
rationale = "Verb-object: pops and tears down the library named by the id; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._remove_concepts_from_blueprint"]
param = "blueprint"
rationale = "Verb-object: strips concepts from the blueprint; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._remove_pipes_from_blueprint"]
param = "blueprint"
rationale = "Verb-object: strips pipes from the blueprint; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._topological_load_concepts"]
param = "ref_to_entry"
rationale = "Verb-object: loads the ref-to-entry mapping in topological order; single operand."

["pipelex/libraries/library_manager.py::LibraryManager._warn_if_mthds_version_unsatisfied"]
param = "mthds_version_constraint"
rationale = "Predicate-style check on the version constraint; single operand."

["pipelex/libraries/library_manager.py::find_methods_dirs_from_blueprints"]
param = "blueprints"
rationale = "Derivation: finds dirs from the blueprints; single operand."

["pipelex/libraries/library_manager_abstract.py::LibraryManagerAbstract.get_accumulated_blueprints"]
param = "library_id"
rationale = "Manager getter keyed by the library id; single operand."

["pipelex/libraries/library_manager_abstract.py::LibraryManagerAbstract.get_crate"]
param = "library_id"
rationale = "Manager getter keyed by the library id; single operand."

["pipelex/libraries/library_manager_abstract.py::LibraryManagerAbstract.get_library"]
param = "library_id"
rationale = "Manager getter keyed by the library id; single operand."

["pipelex/libraries/library_manager_abstract.py::LibraryManagerAbstract.get_library_class_registry"]
param = "library_id"
rationale = "Manager getter keyed by the library id; single operand."

["pipelex/libraries/library_manager_abstract.py::LibraryManagerAbstract.get_pipe_source"]
param = "pipe_code"
rationale = "Manager getter keyed by the pipe code; single operand."

["pipelex/libraries/library_manager_abstract.py::LibraryManagerAbstract.open_fresh_library"]
param = "library_id"
rationale = "Verb-object: opens the library named by the id; single operand."

["pipelex/libraries/library_manager_abstract.py::LibraryManagerAbstract.open_library"]
param = "library_id"
rationale = "Verb-object: opens the library named by the id; single operand."

["pipelex/libraries/library_manager_abstract.py::LibraryManagerAbstract.teardown"]
param = "library_id"
rationale = "Verb-object: tears down the library named by the id; single operand."

["pipelex/libraries/library_utils.py::get_pipelex_mthds_files_from_dirs"]
param = "dirs"
rationale = "Verb-object: scans the given dirs; single operand."

["pipelex/libraries/library_utils.py::get_pipelex_mthds_files_from_package._find_mthds_in_traversable"]
param = "traversable"
rationale = "Nested helper: scans the traversable; single operand."

["pipelex/libraries/method_load_threads.py::run_method_load"]
param = "func"
rationale = "Verb-object: runs the given load callable in the method-load pool, forwarding its own arguments as asyncio.to_thread does; positional-only, so no keyword of the callable is shadowed."

["pipelex/libraries/pipe/pipe_library.py::PipeLibrary.pretty_list_pipes._format_concept_code"]
param = "concept_code"
rationale = "Nested helper: formats the concept code; single operand."

["pipelex/libraries/pipe/pipe_library_abstract.py::PipeLibraryAbstract.add_new_pipe"]
param = "pipe"
rationale = "Verb-object: adds the pipe; single operand."

["pipelex/libraries/pipe/pipe_library_abstract.py::PipeLibraryAbstract.add_pipes"]
param = "pipes"
rationale = "Verb-object: adds the pipes; single operand."

["pipelex/libraries/pipe/pipe_library_abstract.py::PipeLibraryAbstract.get_optional_entry_pipe"]
param = "pipe_code"
rationale = "Entry-point getter keyed by the human-supplied pipe code; single operand."

["pipelex/libraries/pipe/pipe_library_abstract.py::PipeLibraryAbstract.get_optional_pipe"]
param = "pipe_code"
rationale = "Library getter keyed by the pipe code; single operand."

["pipelex/libraries/pipe/pipe_library_abstract.py::PipeLibraryAbstract.get_required_entry_pipe"]
param = "pipe_code"
rationale = "Entry-point resolver keyed by the human-supplied pipe code; single operand."

["pipelex/libraries/pipe/pipe_library_abstract.py::PipeLibraryAbstract.get_required_pipe"]
param = "pipe_code"
rationale = "Resolver getter keyed by the pipe code; single operand."

["pipelex/libraries/pipe/pipe_library_abstract.py::PipeLibraryAbstract.remove_pipes_by_refs"]
param = "pipe_refs"
rationale = "Verb-object: the refs naming the removed pipes; single operand."

["pipelex/libraries/visibility_utils.py::_blueprint_to_metadata"]
param = "blueprint"
rationale = "Conversion: derives metadata from the blueprint; single operand."

["pipelex/methods/method_ref.py::looks_like_method_ref"]
param = "target"
rationale = "Tests the target string; single operand."

["pipelex/methods/method_ref.py::parse_method_ref"]
param = "ref"
rationale = "Parses the ref; single operand."

["pipelex/mthds_parsing/bundle_elaborator.py::BundleElaborator.elaborate"]
param = "bundle"
rationale = "Verb-object: elaborates the bundle; single operand."

["pipelex/mthds_parsing/bundle_elaborator.py::_is_preliminary_text_pipe"]
param = "pipe_blueprint"
rationale = "Predicate on the pipe blueprint; single operand."

["pipelex/mthds_parsing/handle_pipe_errors.py::_handle_pipe_errors"]
param = "error"
rationale = "Verb-object: handles the error; context stays keyword."

["pipelex/mthds_parsing/handle_pipe_errors.py::categorize_pipe_factory_error"]
param = "factory_error"
rationale = "Verb-object: categorizes the factory error; context stays keyword."

["pipelex/mthds_parsing/handle_pipe_errors.py::categorize_pipe_validation_error"]
param = "validation_error"
rationale = "Verb-object: categorizes the validation error; context stays keyword."

["pipelex/mthds_parsing/handle_pipe_errors.py::categorize_pipe_validation_with_libraries_error"]
param = "pipe_error"
rationale = "Verb-object: categorizes the pipe error; context stays keyword."

["pipelex/mthds_parsing/handle_pipe_errors.py::extract_wrapped_pipe_validation_error"]
param = "error"
rationale = "Verb-object: unwraps the error; single operand."

["pipelex/mthds_parsing/helpers.py::ValidationErrorScope.is_pipe_scope"]
param = "scope"
rationale = "Predicate on the scope; single operand."

["pipelex/mthds_parsing/helpers.py::get_error_scope"]
param = "loc"
rationale = "Derivation from the error loc; single operand."

["pipelex/mthds_parsing/helpers.py::is_pipelex_file"]
param = "file_path"
rationale = "Predicate on the file path; single operand."

["pipelex/mthds_parsing/parser.py::MthdsParser.make_pipelex_bundle_blueprint"]
param = "bundle_path"
rationale = "Factory from source: parses the bundle at the path; options stay keyword."

["pipelex/mthds_parsing/parser.py::_decode_error_position"]
param = "exc"
rationale = "Reads the position out of the one exception it is handed; single operand."

["pipelex/mthds_parsing/pipelex_bundle_blueprint.py::PipelexBundleBlueprint._collect_local_refs_from_concept"]
param = "concept_code"
rationale = "Verb-object: collects refs from the concept named; context stays keyword."

["pipelex/mthds_parsing/pipelex_bundle_blueprint.py::PipelexBundleBlueprint._collect_local_refs_from_pipe"]
param = "pipe_code"
rationale = "Verb-object: collects refs from the pipe named; context stays keyword."

["pipelex/mthds_parsing/pipelex_bundle_blueprint.py::PipelexBundleBlueprint.get_elaboration_for"]
param = "pipe_code"
rationale = "Query accessor keyed by the pipe code; single operand."

["pipelex/mthds_parsing/pipelex_bundle_blueprint.py::_strippable_same_domain_pipe_code"]
param = "code"
rationale = "Single-operand transformation of the code; the rest is context."

["pipelex/mthds_parsing/validation_error_categorizer.py::_categorize_concept_validation_error"]
param = "loc"
rationale = "Verb-object: categorizes the error at the loc; context stays keyword."

["pipelex/mthds_parsing/validation_error_categorizer.py::_categorize_typeless_pipe_error"]
param = "message"
rationale = "Verb-object: categorizes the message; the rest is context."

["pipelex/mthds_parsing/validation_error_categorizer.py::_extract_wrapped_invalid_pipe_code_syntax_error"]
param = "error"
rationale = "Extraction from the single error operand."

["pipelex/mthds_parsing/validation_error_categorizer.py::_extract_wrapped_native_concept_redeclaration_error"]
param = "error"
rationale = "Extraction from the single error operand."

["pipelex/mthds_parsing/validation_error_categorizer.py::_is_pydantic_internal_loc_element"]
param = "element"
rationale = "Predicate on the loc element; single operand."

["pipelex/mthds_parsing/validation_error_categorizer.py::categorize_blueprint_validation_error"]
param = "error"
rationale = "Verb-object: categorizes the error; context stays keyword."

["pipelex/observer/observer_protocol.py::ObserverProtocol.observe_after_failing_run"]
param = "payload"
rationale = "Protocol method: observes the run payload; single operand across implementations."

["pipelex/observer/observer_protocol.py::ObserverProtocol.observe_after_successful_run"]
param = "payload"
rationale = "Protocol method: observes the run payload; single operand across implementations."

["pipelex/observer/observer_protocol.py::ObserverProtocol.observe_before_run"]
param = "payload"
rationale = "Protocol method: observes the run payload; single operand across implementations."

["pipelex/pipe_controllers/absence_taint.py::is_plural_step_result"]
param = "pipe"
rationale = "Predicate on the pipe's step result; modifiers stay keyword."

["pipelex/pipe_controllers/absence_taint.py::scan_taint_triggers"]
param = "pipe"
rationale = "Verb-object: scans the pipe for taint triggers; slot_taints is context."

["pipelex/pipe_controllers/condition/special_outcome.py::SpecialOutcome.is_continue"]
param = "outcome"
rationale = "Predicate on the outcome string; single operand."

["pipelex/pipe_controllers/condition/special_outcome.py::SpecialOutcome.is_fail"]
param = "outcome"
rationale = "Predicate on the outcome string; single operand."

["pipelex/pipe_controllers/sub_pipe_factory.py::SubPipeFactory.make_from_blueprint"]
param = "blueprint"
rationale = "Factory from source: the name names the operand; single obvious operand."

["pipelex/pipe_machinery/pipe_abstract.py::PipeAbstract._end_pipe_span_error"]
param = "span"
rationale = "Verb-object: ends the span; error fields stay keyword."

["pipelex/pipe_machinery/pipe_abstract.py::PipeAbstract._end_pipe_span_success"]
param = "span"
rationale = "Verb-object: ends the span; result fields stay keyword."

["pipelex/pipe_machinery/pipe_abstract.py::PipeAbstract._expected_inputs_for_fix"]
param = "needed_inputs"
rationale = "Noun-named derivation from the needed inputs; single operand."

["pipelex/pipe_machinery/pipe_abstract.py::PipeAbstract._make_single_concept_data_for_registry"]
param = "concept"
rationale = "Derivation from the concept; single operand."

["pipelex/pipe_machinery/pipe_blueprint.py::PipeCategory.is_controller_by_str"]
param = "category_str"
rationale = "Predicate on the category string; single operand."

["pipelex/pipe_machinery/pipe_blueprint.py::explicit_signature_tag_migration_message"]
param = "pipe_code"
rationale = "Noun-named derivation: the migration message for the given pipe code; single operand."

["pipelex/pipe_machinery/pipe_blueprint.py::slot_concept_spec"]
param = "slot_value"
rationale = "Verb-object read: slot_concept_spec(slot_value) projects the one slot value to its concept spec string."

["pipelex/pipe_machinery/rendering/input_renderer.py::_delighten_entry"]
param = "entry"
rationale = "Single-operand transformation of the entry; kind is a mode and stays keyword."

["pipelex/pipe_machinery/rendering/input_renderer.py::_delighten_template"]
param = "envelope_template"
rationale = "Single-operand transformation of the template; specs stay keyword."

["pipelex/pipe_machinery/rendering/input_renderer.py::_substitute_none_values"]
param = "value"
rationale = "Single-operand transformation of the value."

["pipelex/pipe_machinery/rendering/input_renderer.py::_to_toml_value"]
param = "value"
rationale = "Single-operand conversion of the value."

["pipelex/pipe_machinery/rendering/input_renderer.py::_unwrap_scalar_content"]
param = "content"
rationale = "Single-operand unwrap of the content; envelope is context."

["pipelex/pipe_machinery/rendering/input_renderer.py::build_concept_comments"]
param = "input_specs"
rationale = "Noun-named derivation: the comments mapping for the input specs; single operand."

["pipelex/pipe_machinery/rendering/input_renderer.py::build_inputs_template"]
param = "the_pipe"
rationale = "Noun-named derivation: the inputs template for the pipe; explicit is a mode."

["pipelex/pipe_machinery/rendering/input_renderer.py::render_inputs"]
param = "the_pipe"
rationale = "Verb-object: renders the pipe's inputs; format stays keyword."

["pipelex/pipe_machinery/rendering/input_renderer.py::render_inputs_toml"]
param = "the_pipe"
rationale = "Verb-object: renders the pipe's inputs; explicit is a mode."

["pipelex/pipe_machinery/rendering/input_renderer.py::serialize_inputs_template_to_toml"]
param = "template"
rationale = "Single-operand serialization of the template; options stay keyword."

["pipelex/pipe_machinery/rendering/output_renderer.py::_collect_possible_outputs"]
param = "the_pipe"
rationale = "Verb-object: collects from the pipe; single operand."

["pipelex/pipe_machinery/rendering/output_renderer.py::_render_json_output"]
param = "the_pipe"
rationale = "Verb-object: renders the pipe's output; single operand."

["pipelex/pipe_machinery/rendering/output_renderer.py::_render_python_output"]
param = "the_pipe"
rationale = "Verb-object: renders the pipe's output; single operand."

["pipelex/pipe_machinery/rendering/output_renderer.py::_render_schema_output"]
param = "the_pipe"
rationale = "Verb-object: renders the pipe's output; single operand."

["pipelex/pipe_machinery/rendering/output_renderer.py::render_output"]
param = "the_pipe"
rationale = "Verb-object: renders the pipe's output; format stays keyword."

["pipelex/pipe_machinery/validation.py::is_input_used_by_variables"]
param = "input_name"
rationale = "Predicate on the input named; the variables stay keyword."

["pipelex/pipe_machinery/validation.py::is_pipe_code_valid"]
param = "pipe_code"
rationale = "Predicate on the pipe code; single operand."

["pipelex/pipe_machinery/validation.py::is_valid_input_name"]
param = "input_name"
rationale = "Predicate on the input name; single operand."

["pipelex/pipe_operators/compose/construct_blueprint.py::ConstructBlueprint.make_from_raw"]
param = "raw"
rationale = "Factory from source: builds the blueprint from the raw value; single operand."

["pipelex/pipe_operators/compose/construct_blueprint.py::ConstructFieldBlueprint.make_from_raw"]
param = "raw"
rationale = "Factory from source: builds the field blueprint from the raw value; single operand."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._build_field_type_summary"]
param = "field_values"
rationale = "Derivation from the field values; single operand."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._convert_content_for_field"]
param = "stuff_content"
rationale = "Verb-object: converts the stuff content; target context stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._convert_for_target_type"]
param = "stuff_content"
rationale = "Verb-object: converts the stuff content; target type stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._convert_list_content"]
param = "list_content"
rationale = "Verb-object: converts the list content; target context stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._convert_list_items_as_dicts"]
param = "items"
rationale = "Verb-object: converts the items; target context stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._convert_list_items_as_objects"]
param = "items"
rationale = "Verb-object: converts the items; target context stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._convert_list_to_dict_keyed_by"]
param = "value"
rationale = "Verb-object: converts the value; key field stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._convert_single_item_as_object"]
param = "item"
rationale = "Verb-object: converts the item; target context stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._convert_text_content"]
param = "text_content"
rationale = "Verb-object: converts the text content; target context stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._expects_list_content_type"]
param = "expected_type"
rationale = "Predicate on the expected type; single operand."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._expects_list_type"]
param = "expected_type"
rationale = "Predicate on the expected type; single operand."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._get_field_expected_type"]
param = "field_name"
rationale = "Query accessor keyed by the field it inspects; single operand."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._get_list_item_type"]
param = "expected_type"
rationale = "Derivation from the expected type; single operand."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._get_nested_field_class"]
param = "field_name"
rationale = "Query accessor keyed by the field it inspects; single operand."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._resolve_dotted_path"]
param = "path"
rationale = "Verb-object: resolves the dotted path; single operand."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._resolve_field"]
param = "field_blueprint"
rationale = "Verb-object: resolves the field blueprint; context stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._resolve_from_stuff_name"]
param = "name"
rationale = "Verb-object: resolves the stuff named; context stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._resolve_from_var"]
param = "field_blueprint"
rationale = "Verb-object: resolves the field blueprint; context stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._resolve_nested"]
param = "field_blueprint"
rationale = "Verb-object: resolves the field blueprint; context stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._resolve_template"]
param = "field_blueprint"
rationale = "Verb-object: resolves the field blueprint; context stays keyword."

["pipelex/pipe_operators/compose/structured_content_composer.py::StructuredContentComposer._validate_item_compatibility"]
param = "item"
rationale = "Verb-object: validates the item; expectations stay keyword."

["pipelex/pipe_operators/doc_gen/pipe_doc_gen.py::PipeDocGen._named_contents"]
param = "working_memory"
rationale = "Reads the step's inputs out of one working memory."

["pipelex/pipe_operators/doc_gen/pipe_doc_gen.py::PipeDocGen._title"]
param = "named_contents"
rationale = "Derives the document's title from its one mapping of named contents."

["pipelex/pipe_operators/doc_gen/template_field_check.py::_describe_fields"]
param = "model_class"
rationale = "Lists the fields of one model class."

["pipelex/pipe_operators/doc_gen/template_field_check.py::_list_item_type"]
param = "annotation"
rationale = "Reads the item type of one list annotation."

["pipelex/pipe_operators/doc_gen/template_field_check.py::_unwrap"]
param = "annotation"
rationale = "Unwraps one annotation from Optional and Annotated."

["pipelex/pipe_operators/func/pipe_func_execution_transport.py::pipe_func_execution_result_from_response"]
param = "response"
rationale = "Converter: rebinds a transported response into a result; single self-labelling operand."

["pipelex/pipe_operators/llm/pipe_llm.py::PipeLLM._format_error_location"]
param = "pipe_run_params"
rationale = "Derivation from the run params; single operand."

["pipelex/pipe_operators/llm/pipe_llm.py::PipeLLM._format_llm_error"]
param = "exc"
rationale = "Verb-object: formats the exception; context stays keyword."

["pipelex/pipe_operators/llm/pipe_llm.py::PipeLLM.resolve_dynamic_output_stuff_spec"]
param = "pipe_run_params"
rationale = "Derivation from the run params; context stays keyword."

["pipelex/pipe_operators/shared/template_document_analyzer.py::TemplateDocumentAnalyzer._resolve_concept"]
param = "concept_ref_or_code"
rationale = "Verb-object: resolves the ref-or-code; single operand."

["pipelex/pipe_operators/shared/template_document_analyzer.py::TemplateDocumentAnalyzer._resolve_variable_type"]
param = "var_path"
rationale = "Query accessor keyed by the variable path; context stays keyword."

["pipelex/pipe_operators/shared/template_document_analyzer.py::TemplateDocumentAnalyzer.analyze_template_for_documents"]
param = "template_source"
rationale = "Verb-object: analyzes the template source; context stays keyword."

["pipelex/pipe_operators/shared/template_image_analyzer.py::TemplateImageAnalyzer._resolve_concept"]
param = "concept_ref_or_code"
rationale = "Verb-object: resolves the ref-or-code; single operand."

["pipelex/pipe_operators/shared/template_image_analyzer.py::TemplateImageAnalyzer._resolve_variable_type"]
param = "var_path"
rationale = "Query accessor keyed by the variable path; context stays keyword."

["pipelex/pipe_operators/shared/template_image_analyzer.py::TemplateImageAnalyzer.analyze_template_for_images"]
param = "template_source"
rationale = "Verb-object: analyzes the template source; context stays keyword."

["pipelex/pipe_operators/structure/pipe_structure.py::PipeStructure._format_error_location"]
param = "pipe_run_params"
rationale = "Derivation from the run params; single operand."

["pipelex/pipe_run/delivery_executor.py::DeliveryExecutor._generate_absence_files"]
param = "absence_record"
rationale = "Verb-object: renders the absence record into files; files is an out-param."

["pipelex/pipe_run/delivery_executor.py::DeliveryExecutor._generate_graph_files"]
param = "graph_spec"
rationale = "Verb-object: renders files from the graph spec; options stay keyword."

["pipelex/pipe_run/delivery_executor.py::DeliveryExecutor._generate_main_stuff_files"]
param = "main_stuff"
rationale = "Verb-object: renders files from the main stuff; options stay keyword."

["pipelex/pipe_run/delivery_executor.py::DeliveryExecutor._generate_main_stuff_files_from_raw"]
param = "raw_main_stuff"
rationale = "Verb-object: renders files from the raw main stuff; options stay keyword."

["pipelex/pipe_run/delivery_executor.py::DeliveryExecutor._generate_usage_file"]
param = "pipe_output"
rationale = "Verb-object helper mirroring its sibling generators: serialize this pipe_output's usage into the tokens_usages.json artifact."

["pipelex/pipe_run/delivery_executor.py::DeliveryExecutor._store_results"]
param = "pipe_output"
rationale = "Verb-object: stores the pipe output; options stay keyword."

["pipelex/pipe_run/delivery_executor.py::DeliveryExecutor.execute"]
param = "pipe_output"
rationale = "Verb-object: executes delivery for the pipe output; options stay keyword."

["pipelex/pipe_run/delivery_executor.py::DeliveryExecutor.generate_result_files"]
param = "pipe_output"
rationale = "Verb-object: renders result files from the pipe output; options stay keyword."

["pipelex/pipe_run/delivery_executor.py::DeliveryExecutor.try_local_hydrate_stuff"]
param = "stuff_raw"
rationale = "Verb-object: hydrates the raw stuff; single operand."

["pipelex/pipe_run/dry_run_in_process.py::dry_run_pipe_in_process"]
param = "pipe"
rationale = "Verb-object: dry-runs the pipe; options stay keyword."

["pipelex/pipe_run/pipe_job_factory.py::PipeJobFactory.make_pipe_job"]
param = "pipe"
rationale = "Factory from source: builds the job for the pipe; job fields stay keyword."

["pipelex/pipe_run/pipe_router_protocol.py::PipeRouterProtocol._after_failing_run"]
param = "pipe_job"
rationale = "Protocol hook: the pipe job being handled; single operand."

["pipelex/pipe_run/pipe_router_protocol.py::PipeRouterProtocol._after_successful_run"]
param = "pipe_job"
rationale = "Protocol hook: the pipe job being handled; single operand."

["pipelex/pipe_run/pipe_router_protocol.py::PipeRouterProtocol._before_run"]
param = "pipe_job"
rationale = "Protocol hook: the pipe job being handled; single operand."

["pipelex/pipe_run/pipe_router_protocol.py::PipeRouterProtocol._run_pipe_job"]
param = "pipe_job"
rationale = "Protocol hook: runs the pipe job; single operand."

["pipelex/pipe_run/pipe_router_protocol.py::PipeRouterProtocol.run"]
param = "pipe_job"
rationale = "Protocol method: runs the pipe job; single operand across implementations."

["pipelex/pipe_run/pipe_router_protocol.py::PipeRouterProtocol.run_batch_branch"]
param = "pipe_job"
rationale = "Protocol hook: the pipe job being dispatched as a fan-out branch; single operand."

["pipelex/pipe_run/pipe_run_params.py::PipeRunParams.copy_by_injecting_multiplicity"]
param = "pipe_run_params"
rationale = "Verb-object: copies the given run params; multiplicity stays keyword."

["pipelex/pipe_run/pipe_run_params.py::PipeRunParams.pop_pipe_from_stack"]
param = "pipe_code"
rationale = "Verb-object: pops the pipe named by the code; single operand."

["pipelex/pipe_run/pipe_run_params.py::PipeRunParams.push_pipe_layer"]
param = "pipe_code"
rationale = "Verb-object: pushes the pipe named by the code; single operand."

["pipelex/pipe_run/pipe_run_params.py::PipeRunParams.push_pipe_to_stack"]
param = "pipe_code"
rationale = "Verb-object: pushes the pipe named by the code; single operand."

["pipelex/pipe_run/pipe_run_params_factory.py::resolve_batch_max_concurrency"]
param = "max_concurrency_setting"
rationale = "Verb-object: resolves the config setting value; single operand, callers pass a labelled config read."

["pipelex/pipe_run/pipe_run_protocol.py::PipeRunProtocol.run"]
param = "pipe_job"
rationale = "Protocol method: runs the pipe job; single operand across implementations."

["pipelex/pipe_run/tracing_assembly.py::assemble_tracing"]
param = "pipeline_run_id"
rationale = "Verb-object: assembles the trace of the run named by the id; options stay keyword."

["pipelex/pipe_run/tracing_assembly.py::assemble_tracing_on_output"]
param = "pipe_output"
rationale = "Verb-object: assembles tracing onto the pipe output; options stay keyword."

["pipelex/pipe_signature/signature_walk.py::collect_signature_paths"]
param = "pipe"
rationale = "Verb-object: walks from the root pipe; accumulators stay keyword."

["pipelex/pipe_signature/signature_walk.py::collect_signature_refs"]
param = "pipe"
rationale = "Verb-object: walks from the root pipe; visited set stays keyword."

["pipelex/pipeline/blueprint_selection.py::collect_entry_pipe_refs"]
param = "blueprints"
rationale = "Derivation: collects the entry refs from the batch's blueprints; single operand."

["pipelex/pipeline/blueprint_selection.py::select_primary_blueprint"]
param = "blueprints"
rationale = "Verb-object: selects among the blueprints; single operand."

["pipelex/pipeline/build_pipe_io_artifacts.py::build_pipe_io_artifacts"]
param = "pipes"
rationale = "Reads as a verb-object sentence over the loaded pipes, like the three builders it wraps."

["pipelex/pipeline/bundle_graph_rendering.py::_dry_run_bundle"]
param = "bundle_path"
rationale = "Verb-object: dry-runs the bundle at the path; options stay keyword."

["pipelex/pipeline/bundle_graph_rendering.py::_sanitize_graph_name"]
param = "graph_name"
rationale = "Transforms the graph name; single operand."

["pipelex/pipeline/bundle_graph_rendering.py::generate_graph_for_bundle"]
param = "bundle_path"
rationale = "Verb-object: generates the graph for the bundle at the path; options stay keyword."

["pipelex/pipeline/bundle_graph_rendering.py::generate_view_for_bundle"]
param = "bundle_path"
rationale = "Verb-object: generates the view for the bundle at the path; options stay keyword."

["pipelex/pipeline/bundle_validator.py::BundleValidator.validate_pipes"]
param = "pipes"
rationale = "Verb-object: validates the pipes; single operand."

["pipelex/pipeline/controller_taint.py::collect_controller_taint_analyses"]
param = "pipes"
rationale = "Single-operand analysis over the pipes collection."

["pipelex/pipeline/dry_run_pipeline.py::dry_run_pipeline"]
param = "mthds_contents"
rationale = "Verb-object: dry-runs the given .mthds contents; options stay keyword."

["pipelex/pipeline/dry_run_warnings.py::build_dry_run_warnings"]
param = "dry_run_result"
rationale = "Projects the sweep's per-pipe status map into warning items; reads as 'build dry-run warnings from the dry-run result', the one operand, as its sibling family builders take theirs."

["pipelex/pipeline/execution_seams.py::acquire_library"]
param = "library_id"
rationale = "Verb-object: acquires the library named by the id; single operand."

["pipelex/pipeline/execution_seams.py::acquire_library_async"]
param = "library_id"
rationale = "Verb-object: acquires the library named by the id; single operand, the same call shape as acquire_library."

["pipelex/pipeline/execution_seams.py::load_libraries_and_activate"]
param = "library_dirs"
rationale = "Verb-object: loads the given library dirs; options stay keyword."

["pipelex/pipeline/execution_seams.py::prepare_pipe_job"]
param = "pipe"
rationale = "Verb-object: prepares the job for the pipe; job fields stay keyword."

["pipelex/pipeline/file_input_consumers.py::collect_file_input_consumers"]
param = "entry_pipe"
rationale = "Collects the file input consumers of the entry pipe, its single operand."

["pipelex/pipeline/fixes/applicability.py::is_safe_fix_for_load_scope"]
param = "fix"
rationale = "Predicate on the fix; is_single_file is context."

["pipelex/pipeline/fixes/applicability.py::is_target_in_write_scope"]
param = "target_path"
rationale = "Predicate on the target path; scope params stay keyword."

["pipelex/pipeline/fixes/fix_loop.py::_absolute_source_path"]
param = "path"
rationale = "Single-operand conversion of the path."

["pipelex/pipeline/fixes/fix_loop.py::_bind_fixes_to_snapshots"]
param = "fixes"
rationale = "Verb-object: binds the fixes; the rest is context."

["pipelex/pipeline/fixes/fix_loop.py::_colliding_op_name"]
param = "fix_op"
rationale = "Noun-named derivation from the fix op; scopes stay keyword."

["pipelex/pipeline/fixes/fix_loop.py::_fix_fingerprint"]
param = "fix"
rationale = "Noun-named derivation: the fingerprint of the fix; single operand."

["pipelex/pipeline/fixes/fix_loop.py::_is_signature_pipe_section"]
param = "pipe_section"
rationale = "Predicate on the pipe section; single operand."

["pipelex/pipeline/fixes/fix_loop.py::_partition_by_write_scope"]
param = "fixes"
rationale = "Verb-object: partitions the fixes; scope params stay keyword."

["pipelex/pipeline/fixes/fix_loop.py::_pending_signatures_from_validation_result"]
param = "validation_result"
rationale = "Noun-named derivation from the validation result; single operand."

["pipelex/pipeline/fixes/fix_loop.py::_safe_fixes"]
param = "items"
rationale = "Noun-named derivation: filters the error items down to safe fixes; the rest is context."

["pipelex/pipeline/fixes/fix_loop.py::_split_cross_file_collisions"]
param = "fixes"
rationale = "Verb-object: splits the fixes; codes_by_file is context."

["pipelex/pipeline/fixes/fix_loop.py::_validation_error_items"]
param = "exc"
rationale = "Noun-named derivation from the single error operand."

["pipelex/pipeline/fixes/fix_loop.py::fix_bundle_file"]
param = "mthds_file_path"
rationale = "Verb-object: fixes the bundle file at path; options stay keyword."

["pipelex/pipeline/fixes/fix_render.py::_format_fix_file"]
param = "fix_payload"
rationale = "Verb-object: formats the fix payload; bundle_path is context."

["pipelex/pipeline/fixes/fix_render.py::format_fix_markdown"]
param = "result"
rationale = "Positional-Callable protocol shape: markdown renderer over the result dict."

["pipelex/pipeline/fixes/fix_render.py::format_fix_progress_markdown"]
param = "result"
rationale = "Verb-object: formats the fix result's progress; bundle_path is context."

["pipelex/pipeline/fixes/planner.py::_plan_match_sequence_output"]
param = "error_data"
rationale = "Verb-object: plans the fix for the error data; single operand."

["pipelex/pipeline/fixes/planner.py::_plan_strip_namespace"]
param = "error_data"
rationale = "Verb-object: plans the fix for the error data; single operand."

["pipelex/pipeline/fixes/planner.py::_plan_strip_native_concept_redecl"]
param = "error_data"
rationale = "Verb-object: plans the fix for the error data; single operand."

["pipelex/pipeline/fixes/planner.py::_plan_sync_controller_inputs"]
param = "error_data"
rationale = "Verb-object: plans the fix for the error data; single operand."

["pipelex/pipeline/fixes/planner.py::plan_fix_for_blueprint_validation_error"]
param = "error_data"
rationale = "Verb-object: plans the fix for the error data; single operand."

["pipelex/pipeline/fixes/planner.py::plan_fix_for_pipe_validation_error"]
param = "error_data"
rationale = "Verb-object: plans the fix for the error data; single operand."

["pipelex/pipeline/hint_warnings.py::_HintLinter._concept_site_kind"]
param = "concept_ref"
rationale = "Verb-object read with a single obvious operand: the site or ref being classified/linted."

["pipelex/pipeline/hint_warnings.py::_HintLinter._field_site_kind"]
param = "field"
rationale = "Verb-object read with a single obvious operand: the site or ref being classified/linted."

["pipelex/pipeline/hint_warnings.py::_HintLinter._resolve_concept_kind"]
param = "concept_ref"
rationale = "Verb-object read with a single obvious operand: the site or ref being classified/linted."

["pipelex/pipeline/hint_warnings.py::_HintLinter._slot_site_kind"]
param = "concept_spec"
rationale = "Verb-object read with a single obvious operand: the site or ref being classified/linted."

["pipelex/pipeline/hint_warnings.py::_HintLinter._split_ref"]
param = "qualified_ref"
rationale = "Verb-object read with a single obvious operand: the site or ref being classified/linted."

["pipelex/pipeline/hint_warnings.py::build_hint_warnings"]
param = "qualified"
rationale = "Verb-object read with one obvious operand: the qualified crate content being swept."

["pipelex/pipeline/input_form.py::_node_site_kind"]
param = "node"
rationale = "Verb-object read: the node whose site value-kind is judged."

["pipelex/pipeline/input_form.py::_slot_hints_of"]
param = "slot_value"
rationale = "Verb-object read: the slot value whose hints are extracted."

["pipelex/pipeline/input_form.py::build_input_form"]
param = "pipes"
rationale = "Reads as a verb-object sentence over the loaded pipes, mirroring build_pipe_io_contracts."

["pipelex/pipeline/input_form.py::build_output_form"]
param = "pipes"
rationale = "The output twin of build_input_form; the two are called side by side and must read alike."

["pipelex/pipeline/input_normalizer.py::_load_local_head"]
param = "local_path"
rationale = "Reads the head of the local file, its single operand."

["pipelex/pipeline/input_normalizer.py::collect_file_inputs"]
param = "working_memory"
rationale = "Reads the file inputs out of the working memory, its single operand."

["pipelex/pipeline/input_normalizer.py::format_file_input_path"]
param = "path"
rationale = "Renders the file input path, its single operand."

["pipelex/pipeline/input_normalizer.py::prepare_file_inputs"]
param = "working_memory"
rationale = "Verb-object: prepares the file inputs within the working memory; single operand."

["pipelex/pipeline/liftable_pipes.py::build_liftable_pipes"]
param = "taint_analyses"
rationale = "Single-operand derivation over the taint analyses."

["pipelex/pipeline/optionality_warnings.py::build_optionality_warnings"]
param = "taint_analyses"
rationale = "Single-operand derivation over the taint analyses."

["pipelex/pipeline/pipe_io_contracts.py::build_pipe_io_contracts"]
param = "pipes"
rationale = "Verb-object: builds contracts from the pipes; single operand."

["pipelex/pipeline/pipeline_manager_abstract.py::PipelineManagerAbstract.get_optional_pipeline"]
param = "pipeline_run_id"
rationale = "Manager getter keyed by the run id; single operand."

["pipelex/pipeline/pipeline_manager_abstract.py::PipelineManagerAbstract.get_pipeline"]
param = "pipeline_run_id"
rationale = "Manager getter keyed by the run id; single operand."

["pipelex/pipeline/pipeline_manager_abstract.py::PipelineManagerAbstract.remove_pipeline"]
param = "pipeline_run_id"
rationale = "Verb-object: forgets the run named by the id; single operand."

["pipelex/pipeline/pipeline_response.py::PipelexRunResultExecute.from_pipe_output"]
param = "pipe_output"
rationale = "Factory from source: builds the result from the pipe output; single operand."

["pipelex/pipeline/runner.py::_extract_validate_graph_pipe_code"]
param = "extra"
rationale = "Derivation: extracts from the extra mapping; single operand."

["pipelex/pipeline/validate_bundle.py::_pipes_to_dry_run"]
param = "loaded_pipes"
rationale = "Verb-object: selects among the loaded pipes; the requested codes stay keyword."

["pipelex/pipeline/validate_bundle.py::build_pending_signatures"]
param = "pipes_by_ref"
rationale = "Verb-object: builds signatures from the pipes-by-ref mapping; single operand."

["pipelex/pipeline/validate_bundle.py::build_validated_pipes"]
param = "dry_run_result"
rationale = "Verb-object: builds the pipe list from the dry-run result; single operand."

["pipelex/pipeline/validate_bundle.py::validate_bundle"]
param = "mthds_file_path"
rationale = "Verb-object: validates the bundle file at the path; options stay keyword."

["pipelex/pipeline/validate_bundle.py::validate_bundles_from_directory"]
param = "directory"
rationale = "Verb-object: validates bundles from the directory; options stay keyword."

["pipelex/pipeline/validate_bundle_translation.py::_backfill_pipe_error_source"]
param = "pipe_error"
rationale = "Verb-object: backfills the pipe error in place; single operand."

["pipelex/pipeline/validation_render.py::count_applicable_fixes"]
param = "items"
rationale = "Single-operand count over the error items; scope stays keyword."

["pipelex/pipeline/validation_render.py::format_validate_markdown"]
param = "result"
rationale = "Verb-object: formats the validate result; single operand."

["pipelex/plugins/backend_extras_factory.py::BackendExtrasFactory.make_extras"]
param = "inference_model"
rationale = "Factory from source: builds the result from the inference_model; single operand."

["pipelex/plugins/contract.py::PipelexPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/plugins/discovery.py::_load_external_plugin"]
param = "entry_point"
rationale = "Loads the plugin from the entry point; single operand."

["pipelex/plugins/model_handle.py::ModelHandle.make_for_inference_model"]
param = "inference_model"
rationale = "Factory from source: builds the result from the inference_model; single operand."

["pipelex/plugins/registrar.py::PluginRegistrar.add_teardown"]
param = "callback"
rationale = "Registers the callback callable as the sole operand."

["pipelex/plugins/registrar.py::PluginRegistrar.claim_content_generator"]
param = "factory"
rationale = "Registers the factory callable as the sole operand."

["pipelex/plugins/registrar.py::PluginRegistrar.claim_isolated_execution_probe"]
param = "factory"
rationale = "Registers the factory callable as the sole operand."

["pipelex/plugins/registrar.py::PluginRegistrar.claim_method_file_store"]
param = "factory"
rationale = "Registers the factory callable as the sole operand, as every other hub slot claim does."

["pipelex/plugins/registrar.py::PluginRegistrar.claim_pipe_func_executor"]
param = "factory"
rationale = "Registrar claim: claims the pipe-func executor hub slot with a factory; single self-labelling operand, consistent with sibling claims."

["pipelex/plugins/registrar.py::PluginRegistrar.claim_pipe_router"]
param = "factory"
rationale = "Registers the factory callable as the sole operand."

["pipelex/plugins/registrar.py::PluginRegistrar.claim_pipe_run"]
param = "factory"
rationale = "Registers the factory callable as the sole operand."

["pipelex/plugins/registrar.py::PluginRegistrar.claim_task_manager"]
param = "factory"
rationale = "Registers the factory callable as the sole operand."

["pipelex/plugins/sdk_client_registry.py::SdkClientRegistry.get"]
param = "model_handle"
rationale = "Registry getter keyed by the model handle."

["pipelex/providers/anthropic/anthropic_config.py::AnthropicConfig.get_reasoning_level"]
param = "effort"
rationale = "Maps the reasoning effort to a provider reasoning level; single operand."

["pipelex/providers/anthropic/anthropic_factory.py::AnthropicFactory._make_document_block_param"]
param = "prepped_document"
rationale = "Factory from source: builds the result from the prepped_document; single operand."

["pipelex/providers/anthropic/anthropic_factory.py::AnthropicFactory._make_image_block_param"]
param = "prepped_image"
rationale = "Factory from source: builds the result from the prepped_image; single operand."

["pipelex/providers/anthropic/anthropic_factory.py::AnthropicFactory.make_anthropic_client"]
param = "model_handle"
rationale = "Factory from source: builds the result from the model_handle; single operand."

["pipelex/providers/anthropic/anthropic_factory.py::AnthropicFactory.make_nb_tokens_by_category"]
param = "usage"
rationale = "Factory from source: builds the result from the usage; single operand."

["pipelex/providers/anthropic/anthropic_factory.py::AnthropicFactory.make_simple_messages"]
param = "llm_job"
rationale = "Factory from source: builds the result from the llm_job; single operand."

["pipelex/providers/anthropic/anthropic_factory.py::AnthropicFactory.make_user_message"]
param = "llm_job"
rationale = "Factory from source: builds the result from the llm_job; single operand."

["pipelex/providers/anthropic/anthropic_factory.py::AnthropicFactory.openai_typed_user_message"]
param = "user_content_txt"
rationale = "Factory from source: builds the result from the user_content_txt; single operand."

["pipelex/providers/anthropic/anthropic_list.py::_display_anthropic_models_flat"]
param = "models"
rationale = "Verb–object: renders the model list; single operand."

["pipelex/providers/anthropic/anthropic_list.py::_display_anthropic_models_table"]
param = "models"
rationale = "Verb–object: renders the model list; single operand."

["pipelex/providers/anthropic/anthropic_llms.py::anthropic_list_available_models"]
param = "model_handle"
rationale = "Lists the available models for the model handle; single operand."

["pipelex/providers/anthropic/anthropic_plugin.py::AnthropicPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/azure_rest/azure_img_gen_worker.py::AzureImgGenWorker._raise_categorized_azure_status_error"]
param = "exc"
rationale = "Categorizes and re-raises the Azure HTTP status error; single operand."

["pipelex/providers/azure_rest/azure_rest_plugin.py::AzureRestPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/bedrock/bedrock_client_protocol.py::BedrockClientProtocol.chat"]
param = "messages"
rationale = "Protocol chat: the messages list is the payload operand; provider params keyword-only."

["pipelex/providers/bedrock/bedrock_factory.py::BedrockFactory.make_bedrock_client"]
param = "model_handle"
rationale = "Factory from source: builds the result from the model_handle; single operand."

["pipelex/providers/bedrock/bedrock_factory.py::BedrockFactory.make_simple_message"]
param = "llm_job"
rationale = "Factory from source: builds the result from the llm_job; single operand."

["pipelex/providers/bedrock/bedrock_list.py::_display_bedrock_models_flat"]
param = "models"
rationale = "Verb–object: renders the model list; single operand."

["pipelex/providers/bedrock/bedrock_list.py::_display_bedrock_models_table"]
param = "models"
rationale = "Verb–object: renders the model list; single operand."

["pipelex/providers/bedrock/bedrock_llms.py::bedrock_list_available_models"]
param = "model_handle"
rationale = "Lists the available models for the model handle; single operand."

["pipelex/providers/bedrock/bedrock_plugin.py::BedrockPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/blackboxai/blackboxai_plugin.py::BlackboxaiPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/docling/docling_extract_worker.py::DoclingExtractWorker._extract_from_source"]
param = "source_uri"
rationale = "Extracts from the source_uri; single operand (qualifiers keyword-only)."

["pipelex/providers/docling/docling_factory.py::DoclingFactory.make_extract_output_from_docling_document"]
param = "doc"
rationale = "Factory from source: builds the result from the doc; single operand."

["pipelex/providers/docling/docling_plugin.py::DoclingPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/fal/fal_factory.py::FalFactory.make_generated_image"]
param = "fal_result"
rationale = "Factory from source: builds the result from the fal_result; single operand."

["pipelex/providers/fal/fal_factory.py::FalFactory.make_generated_image_list"]
param = "fal_result"
rationale = "Factory from source: builds the result from the fal_result; single operand."

["pipelex/providers/fal/fal_img_gen_worker.py::FalImgGenWorker._submit_and_get_result"]
param = "img_gen_job"
rationale = "Submits the img-gen job and returns its result; single operand."

["pipelex/providers/fal/fal_plugin.py::FalPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/google/google_config.py::GoogleConfig.get_reasoning_level"]
param = "effort"
rationale = "Maps the reasoning effort to a provider reasoning level; single operand."

["pipelex/providers/google/google_factory.py::GoogleFactory.extract_text_from_response"]
param = "response"
rationale = "Extracts from the response; single operand (qualifiers keyword-only)."

["pipelex/providers/google/google_factory.py::GoogleFactory.extract_token_usage"]
param = "usage_metadata"
rationale = "Extracts from the usage_metadata; single operand (qualifiers keyword-only)."

["pipelex/providers/google/google_factory.py::GoogleFactory.make_google_client"]
param = "backend"
rationale = "Factory from source: builds the result from the backend; single operand."

["pipelex/providers/google/google_factory.py::GoogleFactory.prepare_document_part"]
param = "prompt_document"
rationale = "Transforms the prompt_document into provider parts; single operand."

["pipelex/providers/google/google_factory.py::GoogleFactory.prepare_image_part"]
param = "prompt_image"
rationale = "Transforms the prompt_image into provider parts; single operand."

["pipelex/providers/google/google_factory.py::GoogleFactory.prepare_user_contents"]
param = "llm_prompt"
rationale = "Transforms the llm_prompt into provider parts; single operand."

["pipelex/providers/google/google_list.py::_display_google_models_flat"]
param = "models"
rationale = "Verb–object: renders the model list; single operand."

["pipelex/providers/google/google_list.py::_display_google_models_table"]
param = "models"
rationale = "Verb–object: renders the model list; single operand."

["pipelex/providers/google/google_plugin.py::GooglePlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/huggingface/huggingface_factory.py::HuggingFaceFactory.make_huggingface_inference_provider"]
param = "provider_str"
rationale = "Factory from source: builds the result from the provider_str; single operand."

["pipelex/providers/huggingface/huggingface_img_gen_worker.py::HuggingFaceImgGenWorker._generate_single_image"]
param = "img_gen_job"
rationale = "Generates one image from the img-gen job; single operand."

["pipelex/providers/huggingface/huggingface_plugin.py::HuggingFacePlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/linkup/linkup_plugin.py::LinkupPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/linkup/linkup_search_worker.py::LinkupSearchWorker._parse_date"]
param = "date_str"
rationale = "Parses/consumes the date_str; single operand."

["pipelex/providers/log_sinks/log_sink_plugin.py::LogSinkPlugin.register"]
param = "registrar"
rationale = "Plugin protocol: registers into the registrar; single operand, consistent with sibling plugins."

["pipelex/providers/log_sinks/log_sink_plugin.py::_make_console_log_sink"]
param = "config"
rationale = "Factory from source: builds the sink from the config; single operand, the LogSinkFactoryFn shape."

["pipelex/providers/log_sinks/log_sink_plugin.py::_make_gcp_log_sink"]
param = "config"
rationale = "Factory from source: builds the sink from the config; single operand, the LogSinkFactoryFn shape."

["pipelex/providers/log_sinks/log_sink_plugin.py::_make_json_log_sink"]
param = "config"
rationale = "Factory from source: builds the sink from the config; single operand, the LogSinkFactoryFn shape."

["pipelex/providers/log_sinks/log_sink_plugin.py::_make_otlp_log_sink"]
param = "config"
rationale = "Factory from source: builds the sink from the config; single operand, the LogSinkFactoryFn shape."

["pipelex/providers/mistral/mistral_config.py::MistralConfig.get_reasoning_level"]
param = "effort"
rationale = "Maps the reasoning effort to a provider reasoning level; single operand."

["pipelex/providers/mistral/mistral_extract_worker.py::MistralExtractWorker._extract_pages_from_document"]
param = "document_uri"
rationale = "Extracts from the document_uri; single operand (qualifiers keyword-only)."

["pipelex/providers/mistral/mistral_factory.py::MistralFactory._clean_mistral_image_base64"]
param = "base64_str"
rationale = "Normalizes the base64 image string; single operand."

["pipelex/providers/mistral/mistral_factory.py::MistralFactory.make_extract_output_from_mistral_response"]
param = "mistral_extract_response"
rationale = "Factory from source: builds the result from the mistral_extract_response; single operand."

["pipelex/providers/mistral/mistral_factory.py::MistralFactory.make_extracted_image_from_page_from_mistral_ocr_image_obj"]
param = "mistral_ocr_image_obj"
rationale = "Factory from source: builds the result from the mistral_ocr_image_obj; single operand."

["pipelex/providers/mistral/mistral_factory.py::MistralFactory.make_mistral_client"]
param = "backend"
rationale = "Factory from source: builds the result from the backend; single operand."

["pipelex/providers/mistral/mistral_factory.py::MistralFactory.make_mistral_document_url"]
param = "prompt_document"
rationale = "Factory from source: builds the result from the prompt_document; single operand."

["pipelex/providers/mistral/mistral_factory.py::MistralFactory.make_mistral_image_url"]
param = "prompt_image"
rationale = "Factory from source: builds the result from the prompt_image; single operand."

["pipelex/providers/mistral/mistral_factory.py::MistralFactory.make_mistral_image_url_chunk_from_uri"]
param = "uri"
rationale = "Factory from source: builds the result from the uri; single operand."

["pipelex/providers/mistral/mistral_factory.py::MistralFactory.make_nb_tokens_by_category"]
param = "usage"
rationale = "Factory from source: builds the result from the usage; single operand."

["pipelex/providers/mistral/mistral_factory.py::MistralFactory.make_simple_messages"]
param = "llm_job"
rationale = "Factory from source: builds the result from the llm_job; single operand."

["pipelex/providers/mistral/mistral_factory.py::MistralFactory.make_simple_messages_openai_typed"]
param = "llm_job"
rationale = "Factory from source: builds the result from the llm_job; single operand."

["pipelex/providers/mistral/mistral_list.py::_display_mistral_models_flat"]
param = "models"
rationale = "Verb–object: renders the model list; single operand."

["pipelex/providers/mistral/mistral_list.py::_display_mistral_models_table"]
param = "models"
rationale = "Verb–object: renders the model list; single operand."

["pipelex/providers/mistral/mistral_plugin.py::MistralPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/openai/openai_client_factory.py::OpenAIClientFactory.make_openai_client"]
param = "model_handle"
rationale = "Factory from source: builds the result from the model_handle; single operand."

["pipelex/providers/openai/openai_completions_factory.py::OpenAICompletionsFactory._get_document_filename"]
param = "prompt_document"
rationale = "Derives the upload filename from the prompt document; single operand."

["pipelex/providers/openai/openai_completions_factory.py::OpenAICompletionsFactory.make_nb_tokens_by_category"]
param = "usage"
rationale = "Factory from source: builds the result from the usage; single operand."

["pipelex/providers/openai/openai_completions_factory.py::OpenAICompletionsFactory.make_simple_messages"]
param = "llm_job"
rationale = "Factory from source: builds the result from the llm_job; single operand."

["pipelex/providers/openai/openai_completions_img_gen_worker.py::OpenAICompletionsImgGenWorker._build_messages_with_images"]
param = "img_gen_job"
rationale = "Builds the messages payload from the img-gen job; single operand."

["pipelex/providers/openai/openai_config.py::OpenAIConfig.get_reasoning_level"]
param = "effort"
rationale = "Maps the reasoning effort to a provider reasoning level; single operand."

["pipelex/providers/openai/openai_img_gen_worker.py::OpenAIImgGenWorker._get_requested_size"]
param = "args_dict"
rationale = "Extracts the requested size from the args dict; single operand."

["pipelex/providers/openai/openai_list.py::_display_openai_models_flat"]
param = "models"
rationale = "Verb–object: renders the model list; single operand."

["pipelex/providers/openai/openai_list.py::_display_openai_models_table"]
param = "models"
rationale = "Verb–object: renders the model list; single operand."

["pipelex/providers/openai/openai_llms.py::openai_list_available_models"]
param = "model_handle"
rationale = "Lists the available models for the model handle; single operand."

["pipelex/providers/openai/openai_plugin.py::OpenAIPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/openai/openai_responses_factory.py::OpenAIResponsesFactory._get_document_filename"]
param = "prompt_document"
rationale = "Derives the upload filename from the prompt document; single operand."

["pipelex/providers/openai/openai_responses_factory.py::OpenAIResponsesFactory.make_input_items"]
param = "llm_job"
rationale = "Factory from source: builds the result from the llm_job; single operand."

["pipelex/providers/openai/openai_responses_factory.py::OpenAIResponsesFactory.make_nb_tokens_by_category"]
param = "usage"
rationale = "Factory from source: builds the result from the usage; single operand."

["pipelex/providers/openai/vertexai_factory.py::VertexAIFactory._make_api_key"]
param = "gcp_credentials_file_path"
rationale = "Factory from source: builds the result from the gcp_credentials_file_path; single operand."

["pipelex/providers/openai/vertexai_factory.py::VertexAIFactory._make_endpoint"]
param = "gcp_project_id"
rationale = "Factory from source: builds the result from the gcp_project_id; single operand."

["pipelex/providers/openai/vertexai_factory.py::VertexAIFactory.make_endpoint_and_api_key"]
param = "extra_config"
rationale = "Factory from source: builds the result from the extra_config; single operand."

["pipelex/providers/openrouter/openrouter_plugin.py::OpenRouterPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/portkey/portkey_completions_factory.py::PortkeyCompletionsFactory.make_portkey_openai_client_for_completions"]
param = "model_handle"
rationale = "Factory from source: builds the result from the model_handle; single operand."

["pipelex/providers/portkey/portkey_constants.py::PortkeyOpenAISdkVariant.is_completions"]
param = "sdk"
rationale = "Predicate on the sdk; single operand."

["pipelex/providers/portkey/portkey_constants.py::PortkeyOpenAISdkVariant.is_responses"]
param = "sdk"
rationale = "Predicate on the sdk; single operand."

["pipelex/providers/portkey/portkey_factory.py::PortkeyFactory.get_api_key"]
param = "backend"
rationale = "Derives the value from the backend config; single operand."

["pipelex/providers/portkey/portkey_factory.py::PortkeyFactory.get_endpoint"]
param = "backend"
rationale = "Derives the value from the backend config; single operand."

["pipelex/providers/portkey/portkey_factory.py::PortkeyFactory.is_debug_enabled"]
param = "backend"
rationale = "Predicate: reports whether debug logging is enabled for the backend; single operand."

["pipelex/providers/portkey/portkey_factory.py::PortkeyFactory.make_extras"]
param = "inference_model"
rationale = "Factory from source: builds the result from the inference_model; single operand."

["pipelex/providers/portkey/portkey_plugin.py::PortkeyPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/portkey/portkey_responses_factory.py::PortkeyResponsesFactory.make_portkey_openai_client_for_responses"]
param = "model_handle"
rationale = "Factory from source: builds the result from the model_handle; single operand."

["pipelex/providers/pypdfium2/pypdfium2_plugin.py::Pypdfium2Plugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/providers/pypdfium2/pypdfium2_worker.py::Pypdfium2Worker._resolve_pdf_uri"]
param = "pdf_uri"
rationale = "Resolves the PDF URI to a readable local source; single operand."

["pipelex/providers/reportlab/reportlab_plugin.py::ReportlabDocGenPlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates, as for every built-in plugin."

["pipelex/providers/secrets/secrets_plugin.py::SecretsPlugin.register"]
param = "registrar"
rationale = "Duck-typed plugin protocol: discovery invokes plugin.register(registrar) positionally."

["pipelex/providers/secrets/secrets_plugin.py::_make_env_secrets_provider"]
param = "config"
rationale = "Positional-Callable protocol: registered as a SecretsProviderFactoryFn."

["pipelex/providers/storage/storage_plugin.py::StoragePlugin.register"]
param = "registrar"
rationale = "Duck-typed plugin protocol: discovery invokes plugin.register(registrar) positionally."

["pipelex/providers/storage/storage_plugin.py::_make_gcp_storage_provider"]
param = "config"
rationale = "Positional-Callable protocol: registered as a StorageProviderFactoryFn."

["pipelex/providers/storage/storage_plugin.py::_make_in_memory_storage_provider"]
param = "config"
rationale = "Positional-Callable protocol: registered as a StorageProviderFactoryFn."

["pipelex/providers/storage/storage_plugin.py::_make_local_storage_provider"]
param = "config"
rationale = "Positional-Callable protocol: registered as a StorageProviderFactoryFn."

["pipelex/providers/storage/storage_plugin.py::_make_s3_storage_provider"]
param = "config"
rationale = "Positional-Callable protocol: registered as a StorageProviderFactoryFn."

["pipelex/providers/typesafe/typesafe_error_classification.py::classify_typesafe_error"]
param = "metadata"
rationale = "Classifies the metadata; single operand, mirroring classify_inference_error."

["pipelex/providers/typesafe/typesafe_plugin.py::TypesafePlugin.register"]
param = "registrar"
rationale = "Plugin protocol register: the registrar is the sole sink the plugin populates."

["pipelex/reporting/cost_report_renderer.py::render_cost_report_for_output"]
param = "pipe_output"
rationale = "Verb-object: renders the report for the pipe output; single operand."

["pipelex/reporting/reporting_manager.py::ReportingManager._emit_usage_event"]
param = "inference_job"
rationale = "Verb-object: emits usage for the inference job; tokens_usage stays keyword."

["pipelex/reporting/reporting_manager.py::ReportingManager._emit_usage_event_runner_fallback"]
param = "inference_job"
rationale = "Verb-object: emits usage for the inference job via fallback; context stays keyword."

["pipelex/reporting/reporting_manager.py::ReportingManager._report_extract_job"]
param = "extract_job"
rationale = "Verb-object: reports the extract job; single operand."

["pipelex/reporting/reporting_manager.py::ReportingManager._report_img_gen_job"]
param = "img_gen_job"
rationale = "Verb-object: reports the img-gen job; single operand."

["pipelex/reporting/reporting_manager.py::ReportingManager._report_llm_job"]
param = "llm_job"
rationale = "Verb-object: reports the LLM job; single operand."

["pipelex/reporting/reporting_manager.py::ReportingManager._report_search_job"]
param = "search_job"
rationale = "Verb-object: reports the search job; single operand."

["pipelex/reporting/reporting_protocol.py::ReportingProtocol.report_inference_job"]
param = "inference_job"
rationale = "Protocol method: reports the inference job; single operand across implementations."

["pipelex/reporting/usage_records.py::apply_tokens_usage_wire_shape"]
param = "response_dump"
rationale = "Verb-object: apply the wire shape to an execute-response dump; the dump being reshaped is the subject."

["pipelex/reporting/usage_records.py::dump_tokens_usage_records"]
param = "tokens_usages"
rationale = "Verb-object: dump the run's usage list to wire records; the single obvious operand is the usage list."

["pipelex/reporting/usage_records.py::make_tokens_usage_record"]
param = "tokens_usage"
rationale = "Factory verb-object: make the wire record for one usage; the single obvious operand is the usage."

["pipelex/runtime_bridge/primitives/hydration.py::_hydrate_composite_component"]
param = "raw_value"
rationale = "Single-operand hydration of the raw value."

["pipelex/runtime_bridge/primitives/hydration.py::_hydrate_list_item"]
param = "raw_item"
rationale = "Verb-object: hydrates the raw item; single operand."

["pipelex/runtime_bridge/primitives/hydration.py::hydrate_content"]
param = "raw_content"
rationale = "Verb-object: hydrates the raw content; concept stays keyword."

["pipelex/runtime_bridge/primitives/hydration.py::hydrate_working_memory"]
param = "working_memory_raw"
rationale = "Verb-object: hydrates the raw working-memory dict; single operand."

["pipelex/runtime_bridge/serialization.py::resolve_main_stuff_root_key"]
param = "pipe_output"
rationale = "Derivation from the pipe output; single operand."

["pipelex/runtime_bridge/serialization.py::serialize_completed_output"]
param = "pipe_output"
rationale = "Verb-object: serializes the pipe output; workflow_id stays keyword."

["pipelex/runtime_bridge/serialization.py::serialize_pipe_output"]
param = "pipe_output"
rationale = "Verb-object: serializes the pipe output; single operand."

["pipelex/runtime_hub.py::RuntimeHub.set_bundle_validator_registry"]
param = "bundle_validator_registry"
rationale = "Hub setter: installs the bundle validator registry; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_config"]
param = "config"
rationale = "Hub setter: installs the config; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_console"]
param = "console"
rationale = "Hub setter: installs the console; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_console_print_target"]
param = "target"
rationale = "Hub setter: installs the print target; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_content_generator"]
param = "content_generator"
rationale = "Hub setter: installs the content generator; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_inference_backend_registry"]
param = "inference_backend_registry"
rationale = "Hub setter: installs the inference backend registry; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_inference_manager"]
param = "inference_manager"
rationale = "Hub setter: installs the inference manager; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_instance"]
param = "runtime_hub"
rationale = "Hub setter: installs the RuntimeHub singleton; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_isolated_execution_probe"]
param = "probe"
rationale = "Hub setter: installs the execution probe; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_model_lister_registry"]
param = "model_lister_registry"
rationale = "Hub setter: installs the model lister registry; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_models_manager"]
param = "models_manager"
rationale = "Hub setter: installs the models manager; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_orchestrator_registry"]
param = "orchestrator_registry"
rationale = "Hub setter: installs the orchestrator registry; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_report_delegate"]
param = "reporting_delegate"
rationale = "Hub setter: installs the reporting delegate; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_sdk_client_manager"]
param = "sdk_client_manager"
rationale = "Hub setter: installs the SDK client manager; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_secrets_provider"]
param = "secrets_provider"
rationale = "Hub setter: installs the secrets provider; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_secrets_provider_registry"]
param = "secrets_provider_registry"
rationale = "Hub setter: the registry is the operand being installed."

["pipelex/runtime_hub.py::RuntimeHub.set_storage_provider"]
param = "storage_provider"
rationale = "Hub setter: installs the storage provider; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.set_storage_provider_registry"]
param = "storage_provider_registry"
rationale = "Hub setter: the registry is the operand being installed."

["pipelex/runtime_hub.py::RuntimeHub.set_telemetry_manager"]
param = "telemetry_manager"
rationale = "Hub setter: installs the telemetry manager; single self-labelling operand."

["pipelex/runtime_hub.py::RuntimeHub.setup_config"]
param = "config_cls"
rationale = "Sets up config from the given config class; single operand."

["pipelex/runtime_hub.py::get_extract_worker"]
param = "extract_handle"
rationale = "Hub getter keyed by the worker's handle; single operand."

["pipelex/runtime_hub.py::get_img_gen_worker"]
param = "img_gen_handle"
rationale = "Hub getter keyed by the worker's handle; single operand."

["pipelex/runtime_hub.py::get_llm_worker"]
param = "llm_handle"
rationale = "Hub getter keyed by the worker's handle; single operand."

["pipelex/runtime_hub.py::get_secret"]
param = "secret_id"
rationale = "Hub getter keyed by the secret id; single operand."

["pipelex/runtime_hub.py::scoped_content_generator"]
param = "content_generator"
rationale = "Context manager scoping the given content generator; single self-labelling operand."

["pipelex/runtime_hub.py::scoped_event_log"]
param = "event_log"
rationale = "Context manager scoping the given event log; single self-labelling operand."

["pipelex/runtime_hub.py::set_runtime_hub"]
param = "runtime_hub"
rationale = "Module-level setter: installs the RuntimeHub singleton; single self-labelling operand."

["pipelex/system/configuration/config_loader.py::ConfigLoader._override_files_for_dir"]
param = "config_dir"
rationale = "Derivation from the config dir; single operand."

["pipelex/system/configuration/config_loader.py::ConfigLoader._plugin_override_files_for_dir"]
param = "config_dir"
rationale = "Derivation from the config dir; single operand."

["pipelex/system/configuration/config_loader.py::ConfigLoader.find_project_root"]
param = "start_dir"
rationale = "Verb-object: searches upward from the start dir; single operand."

["pipelex/system/configuration/config_loader.py::ConfigLoader.resolve_config_file"]
param = "relative_path"
rationale = "Verb-object: resolves the relative path; single operand."

["pipelex/system/environment.py::all_env_vars_are_set"]
param = "keys"
rationale = "Predicate on the given env-var keys; single operand."

["pipelex/system/environment.py::any_env_var_is_placeholder"]
param = "keys"
rationale = "Predicate on the given env-var keys; single operand."

["pipelex/system/environment.py::get_optional_env"]
param = "key"
rationale = "Env getter keyed by the var name; single operand."

["pipelex/system/environment.py::get_required_env"]
param = "key"
rationale = "Env getter keyed by the var name; single operand."

["pipelex/system/environment.py::is_env_var_set"]
param = "key"
rationale = "Predicate on the var named by the key; single operand."

["pipelex/system/environment.py::is_env_var_truthy"]
param = "key"
rationale = "Predicate on the var named by the key; single operand."

["pipelex/system/registries/class_registry_utils.py::ClassRegistryUtils.auto_register_all_subclasses"]
param = "base_class"
rationale = "Verb-object: registers subclasses of the base class; options stay keyword."

["pipelex/system/registries/class_registry_utils.py::ClassRegistryUtils.import_modules_in_folder"]
param = "folder_path"
rationale = "Verb-object: imports modules under the folder path; options stay keyword."

["pipelex/system/registries/class_registry_utils.py::ClassRegistryUtils.register_classes_in_file"]
param = "file_path"
rationale = "Verb-object: registers classes in the file; options stay keyword."

["pipelex/system/registries/class_registry_utils.py::ClassRegistryUtils.register_classes_in_folder"]
param = "folder_path"
rationale = "Verb-object: registers classes under the folder path; options stay keyword."

["pipelex/system/registries/func_registry.py::pipe_func.decorator"]
param = "func"
rationale = "Positional Callable protocol: decorator applied to the function by @ syntax."

["pipelex/system/registries/singleton.py::MetaSingleton.clear_subclass_instances"]
param = "base_cls"
rationale = "Verb-object: clears instances of the base class; single operand."

["pipelex/system/registries/singleton.py::MetaSingleton.get_subclass_instance"]
param = "base_cls"
rationale = "Registry getter keyed by the base class; single operand."

["pipelex/system/runtime.py::RuntimeManager.set_run_mode"]
param = "run_mode"
rationale = "Setter: installs the run mode; single self-labelling operand."

["pipelex/system/runtime.py::RuntimeManager.set_worker_mode"]
param = "worker_mode"
rationale = "Setter: installs the worker mode; single self-labelling operand."

["pipelex/system/telemetry/exception_capture.py::ExceptionCapture._capture_exception"]
param = "exc_info"
rationale = "Verb-object: captures the exc info; single operand."

["pipelex/system/telemetry/exception_capture.py::ExceptionCapture._thread_exception_handler"]
param = "args"
rationale = "Positional Callable protocol: threading.excepthook handler, invoked hook(args)."

["pipelex/system/telemetry/otel_constants.py::make_otel_gen_ai_output_type"]
param = "output_type"
rationale = "Conversion: maps the output type; single operand."

["pipelex/system/telemetry/otel_factory.py::OtelFactory._is_unresolved_placeholder"]
param = "value"
rationale = "Predicate on the value; single operand."

["pipelex/system/telemetry/otel_factory.py::OtelFactory.make_inputs_json"]
param = "working_memory"
rationale = "Conversion: serializes the working memory; options stay keyword."

["pipelex/system/telemetry/otel_factory.py::OtelFactory.make_langfuse_exporter"]
param = "langfuse_config"
rationale = "Factory from source: builds the exporter from the config; single operand."

["pipelex/system/telemetry/otel_factory.py::OtelFactory.make_output_json"]
param = "pipe_output"
rationale = "Conversion: serializes the pipe output; options stay keyword."

["pipelex/system/telemetry/otel_factory.py::OtelFactory.make_trace_id"]
param = "pipeline_run_id"
rationale = "Derivation: encodes the run id into a trace id; single operand."

["pipelex/system/telemetry/otel_factory.py::OtelFactory.make_trace_names"]
param = "pipeline_run_id"
rationale = "Derivation from the run id; context stays keyword."

["pipelex/system/telemetry/otel_factory.py::OtelFactory.make_truncated_content"]
param = "content"
rationale = "Verb-object: truncates the content; limits stay keyword."

["pipelex/system/telemetry/otel_factory.py::OtelFactory.stringify_json"]
param = "json_conent"
rationale = "Conversion: stringifies the JSON content; single operand."

["pipelex/system/telemetry/posthog_span_exporter.py::PostHogSpanExporter._apply_content_redaction"]
param = "properties"
rationale = "Verb-object: redacts the properties in place; single operand."

["pipelex/system/telemetry/posthog_span_exporter.py::PostHogSpanExporter._build_redacted_generation_span_name"]
param = "original_span_name"
rationale = "Transforms the span name; single operand."

["pipelex/system/telemetry/posthog_span_exporter.py::PostHogSpanExporter._build_redacted_pipe_span_name"]
param = "original_span_name"
rationale = "Transforms the span name; single operand."

["pipelex/system/telemetry/posthog_span_exporter.py::PostHogSpanExporter._capture_event"]
param = "event"
rationale = "Verb-object: captures the event; single operand."

["pipelex/system/telemetry/posthog_span_exporter.py::PostHogSpanExporter._do_export"]
param = "spans"
rationale = "Verb-object: exports the spans; single operand."

["pipelex/system/telemetry/posthog_span_exporter.py::PostHogSpanExporter._export_generation_span"]
param = "span"
rationale = "Verb-object: exports the span; single operand."

["pipelex/system/telemetry/posthog_span_exporter.py::PostHogSpanExporter._export_pipe_span"]
param = "span"
rationale = "Verb-object: exports the span; single operand."

["pipelex/system/telemetry/posthog_span_exporter.py::PostHogSpanExporter._get_base_properties"]
param = "span"
rationale = "Derivation from the span; single operand."

["pipelex/system/telemetry/posthog_span_exporter.py::PostHogSpanExporter._get_redacted_output_class_name"]
param = "output_class_name"
rationale = "Transforms the class name; single operand."

["pipelex/system/telemetry/posthog_span_exporter.py::PostHogSpanExporter._get_redacted_pipe_code"]
param = "pipe_code"
rationale = "Transforms the pipe code; single operand."

["pipelex/system/telemetry/posthog_span_exporter.py::PostHogSpanExporter._truncate_content"]
param = "content"
rationale = "Verb-object: truncates the content; limits stay keyword."

["pipelex/system/telemetry/telemetry_config.py::TelemetryConfig.is_custom_telemetry_allowed_for_mode"]
param = "mode"
rationale = "Predicate on the integration mode; single operand."

["pipelex/system/telemetry/telemetry_config.py::TelemetryRedactionConfig.make_from_posthog_config"]
param = "posthog_config"
rationale = "Factory from source: builds from the posthog config; single operand."

["pipelex/system/telemetry/telemetry_manager.py::TelemetryManager._capture_custom_event"]
param = "event_name"
rationale = "Verb-object: captures the event named; properties and identity stay keyword."

["pipelex/system/telemetry/telemetry_manager.py::TelemetryManager._wrap_capture_exception"]
param = "client"
rationale = "Verb-object: wraps the client's capture; single operand."

["pipelex/system/telemetry/telemetry_manager.py::TelemetryManager._wrap_capture_exception.sanitized_capture_exception"]
param = "exception"
rationale = "Positional Callable protocol: replaces client.capture_exception, invoked capture(exception)."

["pipelex/system/telemetry/telemetry_manager_abstract.py::TelemetryManagerAbstract.track_event"]
param = "event_name"
rationale = "Verb-object: tracks the event named; properties stay keyword."

["pipelex/system/trace_context.py::TraceContext.copy_for_child"]
param = "child_node_id"
rationale = "Verb-object: copies the context for the child node; sequence stays keyword."

["pipelex/test_extras/shared_pytest_plugins.py::_cleanup_placeholder_env_vars"]
param = "env_var_keys"
rationale = "Verb-object: the env-var keys being cleaned up; single operand."

["pipelex/test_extras/shared_pytest_plugins.py::_setup_env_var_placeholders"]
param = "env_var_keys"
rationale = "Verb-object: the env-var keys being set up; single operand."

["pipelex/test_extras/shared_pytest_plugins.py::is_inference_disabled_in_pipelex"]
param = "request"
rationale = "Predicate inspecting the pytest request; single operand."

["pipelex/test_extras/shared_pytest_plugins.py::needs_inference_in_pipelex"]
param = "request"
rationale = "Predicate inspecting the pytest request; single operand."

["pipelex/test_extras/shared_pytest_plugins.py::pytest_addoption"]
param = "parser"
rationale = "Framework-owned pytest hook signature; pluggy binds by parameter name."

["pipelex/tools/jinja2/image_registry.py::ImageRegistry.get_image_placeholder"]
param = "image"
rationale = "Extracts/derives from the image; single operand."

["pipelex/tools/jinja2/image_registry.py::ImageRegistry.make_finalize.finalize"]
param = "value"
rationale = "Positional-Callable jinja2 finalize hook: value is the single operand jinja passes."

["pipelex/tools/jinja2/image_registry.py::ImageRegistry.register_image"]
param = "image"
rationale = "Registers the image; single operand."

["pipelex/tools/jinja2/jinja2_environment.py::_register_filters"]
param = "jinja2_env"
rationale = "Jinja op on the jinja2_env; single operand (context keyword-only)."

["pipelex/tools/jinja2/jinja2_environment.py::make_jinja2_env_from_registry"]
param = "template_category"
rationale = "Factory from source: builds the result from the template_category; single operand."

["pipelex/tools/jinja2/jinja2_environment.py::make_jinja2_env_without_loader"]
param = "template_category"
rationale = "Factory from source: builds the result from the template_category; single operand."

["pipelex/tools/jinja2/jinja2_filters.py::escape_script_tag"]
param = "value"
rationale = "Transforms the value; single operand."

["pipelex/tools/jinja2/jinja2_filters.py::markdown_to_formatted"]
param = "value"
rationale = "Jinja filter: Jinja passes the filtered value positionally."

["pipelex/tools/jinja2/jinja2_filters.py::markdown_to_html"]
param = "value"
rationale = "Jinja filter: Jinja passes the filtered value positionally."

["pipelex/tools/jinja2/jinja2_optional_guards.py::_GuardWalker._guard_vars"]
param = "test_node"
rationale = "Noun-named derivation: the guarded vars of the test node; single operand."

["pipelex/tools/jinja2/jinja2_optional_guards.py::_GuardWalker._is_unguarded_optional"]
param = "full_path"
rationale = "Predicate on the path; guard sets stay keyword."

["pipelex/tools/jinja2/jinja2_optional_guards.py::_GuardWalker._record"]
param = "full_path"
rationale = "Verb-object: records the path; single operand."

["pipelex/tools/jinja2/jinja2_optional_guards.py::_GuardWalker._walk_body"]
param = "body_nodes"
rationale = "Visitor: walks the body nodes; guard sets stay keyword."

["pipelex/tools/jinja2/jinja2_optional_guards.py::_GuardWalker._walk_if"]
param = "node"
rationale = "Verb-object walk over one if node, like the walker's other walk methods; single operand."

["pipelex/tools/jinja2/jinja2_optional_guards.py::_GuardWalker._walk_test"]
param = "test_node"
rationale = "Visitor: walks the test node; guard sets stay keyword."

["pipelex/tools/jinja2/jinja2_optional_guards.py::_GuardWalker.walk"]
param = "node"
rationale = "Visitor: walks the node; guard sets stay keyword."

["pipelex/tools/jinja2/jinja2_parsing.py::check_jinja2_parsing"]
param = "template_source"
rationale = "Jinja op on the template_source; single operand (context keyword-only)."

["pipelex/tools/jinja2/jinja2_render_budget.py::_compare_container_units"]
param = "value"
rationale = "Positional-Callable walk callback: the walk passes each container positionally."

["pipelex/tools/jinja2/jinja2_render_budget.py::_compare_leaf_units"]
param = "value"
rationale = "Positional-Callable walk callback: the walk passes each element positionally."

["pipelex/tools/jinja2/jinja2_render_budget.py::_repr_container_size"]
param = "value"
rationale = "Positional-Callable walk callback: the walk passes each container positionally."

["pipelex/tools/jinja2/jinja2_render_budget.py::_repr_leaf_size"]
param = "value"
rationale = "Positional-Callable walk callback: the walk passes each element positionally."

["pipelex/tools/jinja2/jinja2_render_budget.py::compare_weight"]
param = "value"
rationale = "Estimates what comparing the value costs; the limit stays keyword."

["pipelex/tools/jinja2/jinja2_render_budget.py::escaped_length"]
param = "text"
rationale = "Measures the text it is given."

["pipelex/tools/jinja2/jinja2_render_budget.py::is_lazy"]
param = "value"
rationale = "Predicate on the value it is given."

["pipelex/tools/jinja2/jinja2_render_budget.py::json_string_length"]
param = "text"
rationale = "Measures the text it is given."

["pipelex/tools/jinja2/jinja2_render_budget.py::produced_size"]
param = "value"
rationale = "Measures the value an operation produced."

["pipelex/tools/jinja2/jinja2_render_budget.py::size_of"]
param = "value"
rationale = "Measures the value it is given; a hot path of every render."

["pipelex/tools/jinja2/jinja2_render_budget.py::text_size"]
param = "value"
rationale = "Estimates the printed length of the value; the limit stays keyword."

["pipelex/tools/jinja2/jinja2_render_charging.py::render_budget_of"]
param = "context"
rationale = "Reads the budget off the render context it is given."

["pipelex/tools/jinja2/jinja2_render_costs.py::escaped_text_size"]
param = "value"
rationale = "Estimates the escaped length of the value, also passed as a positional measure; the limit stays keyword."

["pipelex/tools/jinja2/jinja2_render_rewrite.py::_RenderBudgetRewriter._rewrite_comparison"]
param = "node"
rationale = "Jinja NodeVisitor dispatch: visit() calls the visitor get_visitor returns with the node positionally."

["pipelex/tools/jinja2/jinja2_render_rewrite.py::_RenderBudgetRewriter._rewrite_concat"]
param = "node"
rationale = "Jinja NodeVisitor dispatch: visit() calls the visitor get_visitor returns with the node positionally."

["pipelex/tools/jinja2/jinja2_render_rewrite.py::_RenderBudgetRewriter._rewrite_filter"]
param = "node"
rationale = "Jinja NodeVisitor dispatch: visit() calls the visitor get_visitor returns with the node positionally."

["pipelex/tools/jinja2/jinja2_render_rewrite.py::_RenderBudgetRewriter._rewrite_filter_block"]
param = "node"
rationale = "Jinja NodeVisitor dispatch: visit() calls the visitor get_visitor returns with the node positionally."

["pipelex/tools/jinja2/jinja2_render_rewrite.py::_RenderBudgetRewriter._rewrite_item"]
param = "node"
rationale = "Jinja NodeVisitor dispatch: visit() calls the visitor get_visitor returns with the node positionally."

["pipelex/tools/jinja2/jinja2_render_rewrite.py::_RenderBudgetRewriter._rewrite_literal"]
param = "node"
rationale = "Jinja NodeVisitor dispatch: visit() calls the visitor get_visitor returns with the node positionally."

["pipelex/tools/jinja2/jinja2_render_rewrite.py::_RenderBudgetRewriter._rewrite_loop"]
param = "node"
rationale = "Jinja NodeVisitor dispatch: visit() calls the visitor get_visitor returns with the node positionally."

["pipelex/tools/jinja2/jinja2_render_rewrite.py::_RenderBudgetRewriter._rewrite_output"]
param = "node"
rationale = "Jinja NodeVisitor dispatch: visit() calls the visitor get_visitor returns with the node positionally."

["pipelex/tools/jinja2/jinja2_render_rewrite.py::rewrite_for_render_budget"]
param = "template"
rationale = "Rewrites the parsed template it is given."

["pipelex/tools/jinja2/jinja2_rendering.py::_add_to_templating_context"]
param = "templating_context"
rationale = "Transforms the templating_context; single operand."

["pipelex/tools/jinja2/jinja2_rendering.py::_compile_jinja2_template"]
param = "template_source"
rationale = "Jinja op on the template_source; single operand (context keyword-only)."

["pipelex/tools/jinja2/jinja2_rendering.py::_prepare_templating_context"]
param = "templating_context"
rationale = "Jinja op on the templating_context; single operand (context keyword-only)."

["pipelex/tools/jinja2/jinja2_rendering.py::render_jinja2_async"]
param = "template_source"
rationale = "Jinja op on the template_source; single operand (context keyword-only)."

["pipelex/tools/jinja2/jinja2_rendering.py::render_jinja2_sync"]
param = "template_source"
rationale = "Jinja op on the template_source; single operand (context keyword-only)."

["pipelex/tools/jinja2/jinja2_required_variables.py::_extract_filters_and_variable"]
param = "node"
rationale = "Extracts/derives from the node; single operand."

["pipelex/tools/jinja2/jinja2_scopes.py::_frame_level_parts"]
param = "statement"
rationale = "Noun-named derivation over one Jinja AST operand; single operand."

["pipelex/tools/jinja2/jinja2_scopes.py::_loaded_names"]
param = "expression"
rationale = "Noun-named derivation over one Jinja AST operand; single operand."

["pipelex/tools/jinja2/jinja2_scopes.py::assigned_target_names"]
param = "target"
rationale = "Lists the names one assignment target binds."

["pipelex/tools/jinja2/jinja2_scopes.py::attribute_chain"]
param = "node"
rationale = "Reads the attribute chain of one Jinja node."

["pipelex/tools/jinja2/jinja2_scopes.py::definitely_assigned_names"]
param = "statement"
rationale = "Noun-named derivation: the names one statement binds for certain; single operand."

["pipelex/tools/jinja2/jinja2_scopes.py::dotted_attribute_path"]
param = "node"
rationale = "Noun-named derivation: the dotted path of the node; single operand."

["pipelex/tools/jinja2/jinja2_scopes.py::frame_bound_names"]
param = "statement"
rationale = "Noun-named derivation: the names one statement binds in the frame it opens; single operand."

["pipelex/tools/jinja2/jinja2_scopes.py::names_assigned_by_statements"]
param = "statements"
rationale = "Noun-named derivation: the names a statement list binds for certain; single operand."

["pipelex/tools/jinja2/jinja2_scopes.py::names_read_before_bound"]
param = "statements"
rationale = "Noun-named derivation over one Jinja AST operand; single operand."

["pipelex/tools/jinja2/jinja2_template_loader.py::TemplateLoader.is_loaded"]
param = "name"
rationale = "Predicate on the name; single operand."

["pipelex/tools/jinja2/jinja2_template_loader.py::TemplateLoader.load"]
param = "name"
rationale = "Keyed accessor by the name; single operand."

["pipelex/tools/jinja2/jinja2_template_loader.py::TemplateLoader.reload"]
param = "name"
rationale = "Keyed accessor by the name; single operand."

["pipelex/tools/jinja2/jinja2_template_registry.py::TemplateRegistry.get"]
param = "key"
rationale = "Keyed accessor by the key; single operand."

["pipelex/tools/jinja2/jinja2_template_registry.py::TemplateRegistry.is_registered"]
param = "key"
rationale = "Predicate on the key; single operand."

["pipelex/tools/jinja2/jinja2_with_images_filter.py::_render_sequence_with_images"]
param = "sequence"
rationale = "Jinja op on the sequence; single operand (context keyword-only)."

["pipelex/tools/jinja2/template_surface.py::get_template_surface"]
param = "obj"
rationale = "Reads as get the template surface of this value; the value is the single obvious operand."

["pipelex/tools/log/log.py::Log._should_ignore"]
param = "problem_id"
rationale = "Predicate on the problem id; single operand."

["pipelex/tools/log/log.py::Log.configure"]
param = "log_config"
rationale = "Setter: installs the log_config; single operand."

["pipelex/tools/log/log.py::Log.configure_if_unset"]
param = "log_config"
rationale = "Setter: installs the log_config; single operand."

["pipelex/tools/log/log.py::Log.critical"]
param = "content"
rationale = "Logs the content; single operand (formatting keyword-only)."

["pipelex/tools/log/log.py::Log.debug"]
param = "content"
rationale = "Logs the content; single operand (formatting keyword-only)."

["pipelex/tools/log/log.py::Log.error"]
param = "content"
rationale = "Logs the content; single operand (formatting keyword-only)."

["pipelex/tools/log/log.py::Log.info"]
param = "content"
rationale = "Logs the content; single operand (formatting keyword-only)."

["pipelex/tools/log/log.py::Log.install_sink"]
param = "sink"
rationale = "Setter: installs the sink; single operand."

["pipelex/tools/log/log.py::Log.set_level"]
param = "level"
rationale = "Setter: installs the level; single operand."

["pipelex/tools/log/log.py::Log.set_level_by_name"]
param = "level_name"
rationale = "Setter: installs the level_name; single operand."

["pipelex/tools/log/log.py::Log.set_level_for_package"]
param = "package_name"
rationale = "Setter: installs the package_name; single operand."

["pipelex/tools/log/log.py::Log.set_levels_for_packages"]
param = "package_log_levels"
rationale = "Setter: installs the package_log_levels; single operand."

["pipelex/tools/log/log.py::Log.verbose"]
param = "content"
rationale = "Logs the content; single operand (formatting keyword-only)."

["pipelex/tools/log/log.py::Log.warning"]
param = "content"
rationale = "Logs the content; single operand (formatting keyword-only)."

["pipelex/tools/log/log_config.py::CallerInfoTemplate.for_template_key"]
param = "key"
rationale = "Factory from source: builds the result from the key; single operand."

["pipelex/tools/log/log_dispatch.py::LogDispatch.configure"]
param = "log_config"
rationale = "Setter: installs the log_config; single operand."

["pipelex/tools/log/log_dispatch.py::LogDispatch.dispatch"]
param = "content"
rationale = "Logs the content; single operand (formatting keyword-only)."

["pipelex/tools/markdown/markdown_parser.py::_join_text_fragments"]
param = "state"
rationale = "markdown-it rule callback: the inline ruler calls each rule with its state positionally."

["pipelex/tools/markdown/markdown_parser.py::render_markdown_as_html"]
param = "markdown_text"
rationale = "Renders one Markdown text as HTML."

["pipelex/tools/mermaid/mermaid_utils.py::clean_str_for_mermaid_node_title"]
param = "text"
rationale = "Transforms the text; single operand."

["pipelex/tools/mermaid/mermaid_utils.py::encode_pako_from_bytes"]
param = "state_bytes"
rationale = "Transforms the state_bytes; single operand."

["pipelex/tools/mermaid/mermaid_utils.py::encode_pako_from_string"]
param = "state"
rationale = "Transforms the state; single operand."

["pipelex/tools/mermaid/mermaid_utils.py::escape_mermaid_label"]
param = "label"
rationale = "Transforms the label; single operand."

["pipelex/tools/mermaid/mermaid_utils.py::make_mermaid_url"]
param = "mermaid_code"
rationale = "Factory from source: builds the result from the mermaid_code; single operand."

["pipelex/tools/mermaid/mermaid_utils.py::print_mermaid_url"]
param = "url"
rationale = "Renders the url; single operand."

["pipelex/tools/mermaid/mermaid_utils.py::render_mermaid_html_generic"]
param = "mermaid_code"
rationale = "Jinja op on the mermaid_code; single operand (context keyword-only)."

["pipelex/tools/mermaid/mermaid_utils.py::render_mermaid_html_generic_async"]
param = "mermaid_code"
rationale = "Jinja op on the mermaid_code; single operand (context keyword-only)."

["pipelex/tools/mermaid/mermaid_utils.py::sanitize_mermaid_id"]
param = "node_id"
rationale = "Transforms the node_id; single operand."

["pipelex/tools/misc/async_utils.py::WorkerThreads.run"]
param = "func"
rationale = "Verb-object: runs the given callable in one of the pool's threads, forwarding its own arguments as asyncio.to_thread does; positional-only, so no keyword of the callable is shadowed."

["pipelex/tools/misc/async_utils.py::_invoke"]
param = "factory"
rationale = "Operates on the factory; single operand (qualifiers keyword-only)."

["pipelex/tools/misc/async_utils.py::gather_bounded"]
param = "task_factories"
rationale = "Operates on the task_factories; single operand (qualifiers keyword-only)."

["pipelex/tools/misc/attribute_utils.py::AttributePolisher._looks_like_base64"]
param = "value"
rationale = "Predicate on the value; single operand."

["pipelex/tools/misc/attribute_utils.py::AttributePolisher._truncate_bytes"]
param = "value"
rationale = "Transforms the value; single operand."

["pipelex/tools/misc/attribute_utils.py::AttributePolisher._truncate_string"]
param = "value"
rationale = "Transforms the value; single operand."

["pipelex/tools/misc/attribute_utils.py::AttributePolisher.apply_truncation_recursive"]
param = "obj"
rationale = "Operates on the obj; single operand (qualifiers keyword-only)."

["pipelex/tools/misc/attribute_utils.py::AttributePolisher.get_truncated_value"]
param = "value"
rationale = "Keyed accessor by the value; single operand."

["pipelex/tools/misc/attribute_utils.py::AttributePolisher.should_truncate"]
param = "value"
rationale = "Predicate on the value; single operand."

["pipelex/tools/misc/base64_utils.py::extract_base64_str_from_base64_url_if_possible"]
param = "possibly_base64_url"
rationale = "Extracts/derives from the possibly_base64_url; single operand."

["pipelex/tools/misc/base64_utils.py::is_prefixed_base64_url"]
param = "possibly_base64_url"
rationale = "Predicate on the possibly_base64_url; single operand."

["pipelex/tools/misc/base64_utils.py::load_binary_as_base64"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/misc/base64_utils.py::make_base64_url"]
param = "base64_data"
rationale = "Factory from source: builds the result from the base64_data; single operand."

["pipelex/tools/misc/base64_utils.py::make_base64_url_from_bytes"]
param = "raw_bytes"
rationale = "Factory from source: builds the result from the raw_bytes; single operand."

["pipelex/tools/misc/base64_utils.py::make_base64_url_from_path"]
param = "path"
rationale = "Factory from source: builds the result from the path; single operand."

["pipelex/tools/misc/base64_utils.py::strip_base64_str_if_needed"]
param = "base64_str"
rationale = "Transforms the base64_str; single operand."

["pipelex/tools/misc/context_provider_abstract.py::ContextProviderAbstract.get_typed_object_or_attribute"]
param = "name"
rationale = "Keyed accessor by the name; single operand."

["pipelex/tools/misc/dict_utils.py::apply_to_strings_in_list"]
param = "data"
rationale = "Transforms the data; single operand."

["pipelex/tools/misc/dict_utils.py::apply_to_strings_recursive"]
param = "data"
rationale = "Transforms the data; single operand."

["pipelex/tools/misc/dict_utils.py::extract_vars_from_strings_recursive"]
param = "data"
rationale = "Extracts/derives from the data; single operand."

["pipelex/tools/misc/dict_utils.py::extract_vars_from_strings_recursive.extract_from_string"]
param = "text"
rationale = "Inner recursion helper: extracts vars from the text; single operand."

["pipelex/tools/misc/dict_utils.py::extract_vars_from_strings_recursive.traverse"]
param = "value"
rationale = "Inner recursion helper: traverses the value; single operand."

["pipelex/tools/misc/dict_utils.py::insert_before"]
param = "dictionary"
rationale = "Transforms the dictionary; single operand."

["pipelex/tools/misc/dict_utils.py::substitute_nested_in_context"]
param = "context"
rationale = "Transforms the context; single operand."

["pipelex/tools/misc/diff.py::_generate_diff_summary"]
param = "diff_content"
rationale = "Operates on the diff_content; single operand (qualifiers keyword-only)."

["pipelex/tools/misc/diff.py::has_diff_dirs._filter_excluded_files"]
param = "file_list"
rationale = "Inner helper: filters the file list; single operand."

["pipelex/tools/misc/diff.py::has_diff_dirs._has_diff"]
param = "dir_comparison"
rationale = "Inner helper: tests the dir comparison; single operand."

["pipelex/tools/misc/diff.py::make_diff_dirs_pretty._collect_diffs"]
param = "dir_comparison"
rationale = "Inner helper: collects diffs from the dir comparison; single operand."

["pipelex/tools/misc/diff.py::make_diff_dirs_pretty._filter_excluded_files"]
param = "file_list"
rationale = "Inner helper: filters the file list; single operand."

["pipelex/tools/misc/exceptions.py::TomlError.from_tomli_error"]
param = "exc"
rationale = "Factory from source: builds the result from the exc; single operand."

["pipelex/tools/misc/file_fetch_utils.py::fetch_file_and_content_type_from_url_httpx"]
param = "url"
rationale = "Fetches the file at the URL; single operand."

["pipelex/tools/misc/file_fetch_utils.py::fetch_file_from_url_httpx"]
param = "url"
rationale = "Fetches the file at the URL; single operand."

["pipelex/tools/misc/file_utils.py::_reraise_walk_error"]
param = "walk_error"
rationale = "File/path op on the walk_error; single operand."

["pipelex/tools/misc/file_utils.py::copy_file_from_package"]
param = "package_name"
rationale = "File/path op on the package_name; single operand."

["pipelex/tools/misc/file_utils.py::copy_folder_from_package"]
param = "package_name"
rationale = "File/path op on the package_name; single operand."

["pipelex/tools/misc/file_utils.py::ensure_directory_exists"]
param = "directory_path"
rationale = "File/path op on the directory_path; single operand."

["pipelex/tools/misc/file_utils.py::ensure_directory_for_file_path"]
param = "file_path"
rationale = "File/path op on the file_path; single operand."

["pipelex/tools/misc/file_utils.py::ensure_path"]
param = "path"
rationale = "File/path op on the path; single operand."

["pipelex/tools/misc/file_utils.py::failable_load_text_from_path"]
param = "path"
rationale = "Loads text from the path (failable); single operand."

["pipelex/tools/misc/file_utils.py::find_files_in_dir"]
param = "dir_path"
rationale = "Extracts/derives from the dir_path; single operand."

["pipelex/tools/misc/file_utils.py::get_incremental_directory_path"]
param = "base_path"
rationale = "File/path op on the base_path; single operand."

["pipelex/tools/misc/file_utils.py::get_incremental_file_path"]
param = "base_path"
rationale = "File/path op on the base_path; single operand."

["pipelex/tools/misc/file_utils.py::load_binary"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/misc/file_utils.py::load_binary_async"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/misc/file_utils.py::load_text_from_path"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/misc/file_utils.py::path_exists"]
param = "path_str"
rationale = "File/path op on the path_str; single operand."

["pipelex/tools/misc/file_utils.py::reject_bare_str_or_path"]
param = "value"
rationale = "Validates/checks the value; single operand."

["pipelex/tools/misc/file_utils.py::remove_file"]
param = "file_path"
rationale = "File/path op on the file_path; single operand."

["pipelex/tools/misc/file_utils.py::remove_folder"]
param = "folder_path"
rationale = "File/path op on the folder_path; single operand."

["pipelex/tools/misc/file_utils.py::save_bytes_to_binary_file"]
param = "byte_data"
rationale = "Transforms the byte_data; single operand."

["pipelex/tools/misc/file_utils.py::save_text_to_path"]
param = "text"
rationale = "Transforms the text; single operand."

["pipelex/tools/misc/filetype_utils.py::detect_file_type_from_base64"]
param = "base64_data"
rationale = "Parses/reads the base64_data; single operand."

["pipelex/tools/misc/filetype_utils.py::detect_file_type_from_bytes"]
param = "raw_bytes"
rationale = "Parses/reads the raw_bytes; single operand."

["pipelex/tools/misc/filetype_utils.py::detect_file_type_from_path"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/misc/filetype_utils.py::mime_type_to_extension"]
param = "mime_type"
rationale = "Transforms the mime_type; single operand."

["pipelex/tools/misc/hash_utils.py::hash_md5_to_int"]
param = "string"
rationale = "Transforms the string; single operand."

["pipelex/tools/misc/hash_utils.py::hash_sha256"]
param = "data"
rationale = "Transforms the data; single operand."

["pipelex/tools/misc/http_utils.py::_validate_local_path"]
param = "url"
rationale = "Validates/checks the url; single operand."

["pipelex/tools/misc/http_utils.py::validate_url_resource_exists"]
param = "url"
rationale = "Validates/checks the url; single operand."

["pipelex/tools/misc/image_utils.py::ImageFormat.from_mime_type"]
param = "mime_type"
rationale = "Factory from source: builds the result from the mime_type; single operand."

["pipelex/tools/misc/image_utils.py::ImageFormat.is_supported_mime_type"]
param = "mime_type"
rationale = "Predicate on the mime_type; single operand."

["pipelex/tools/misc/image_utils.py::ImageFormat.raise_if_unsupported_mime_type"]
param = "mime_type"
rationale = "Validates/checks the mime_type; single operand."

["pipelex/tools/misc/image_utils.py::pil_image_to_bytes"]
param = "pil_image"
rationale = "Transforms the pil_image; single operand."

["pipelex/tools/misc/json_utils.py::clean_json_content"]
param = "content"
rationale = "Transforms the content; single operand."

["pipelex/tools/misc/json_utils.py::clean_json_dumps"]
param = "data"
rationale = "Transforms the data; single operand."

["pipelex/tools/misc/json_utils.py::deep_update"]
param = "target_dict"
rationale = "Transforms the target_dict; single operand."

["pipelex/tools/misc/json_utils.py::json_str"]
param = "some_object"
rationale = "Transforms the some_object; single operand."

["pipelex/tools/misc/json_utils.py::load_json_dict_from_path"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/misc/json_utils.py::load_json_from_path"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/misc/json_utils.py::load_json_list_from_path"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/misc/json_utils.py::pure_json_str"]
param = "data"
rationale = "Transforms the data; single operand."

["pipelex/tools/misc/json_utils.py::purify_json"]
param = "data"
rationale = "Transforms the data; single operand."

["pipelex/tools/misc/json_utils.py::purify_json_dict"]
param = "data"
rationale = "Transforms the data; single operand."

["pipelex/tools/misc/json_utils.py::purify_json_list"]
param = "data"
rationale = "Transforms the data; single operand."

["pipelex/tools/misc/json_utils.py::remove_none_values"]
param = "json_content"
rationale = "Transforms the json_content; single operand."

["pipelex/tools/misc/json_utils.py::remove_none_values_from_dict"]
param = "data"
rationale = "Transforms the data; single operand."

["pipelex/tools/misc/json_utils.py::save_as_json_to_path"]
param = "object_to_save"
rationale = "Transforms the object_to_save; single operand."

["pipelex/tools/misc/markdown_utils.py::convert_to_markdown"]
param = "data"
rationale = "Transforms the data; single operand."

["pipelex/tools/misc/placeholder.py::make_placeholder_value"]
param = "key"
rationale = "Factory from source: builds the result from the key; single operand."

["pipelex/tools/misc/placeholder.py::value_is_placeholder"]
param = "value"
rationale = "Predicate on the value; single operand."

["pipelex/tools/misc/pretty.py::PrettyPrinter.make_pretty"]
param = "value"
rationale = "Factory from source: builds the result from the value; single operand."

["pipelex/tools/misc/pretty.py::PrettyPrinter.make_pretty_panel"]
param = "content"
rationale = "Factory from source: builds the result from the content; single operand."

["pipelex/tools/misc/pretty.py::PrettyPrinter.pretty_print"]
param = "content"
rationale = "Renders the content; single operand."

["pipelex/tools/misc/pretty.py::PrettyPrinter.pretty_print_url_without_rich"]
param = "content"
rationale = "Renders the content; single operand."

["pipelex/tools/misc/pretty.py::PrettyPrinter.pretty_print_using_rich"]
param = "content"
rationale = "Renders the content; single operand."

["pipelex/tools/misc/pretty.py::PrettyPrinter.pretty_print_without_rich"]
param = "content"
rationale = "Renders the content; single operand."

["pipelex/tools/misc/pretty.py::PrettyPrinter.pretty_svg"]
param = "pretty"
rationale = "Renders the pretty; single operand."

["pipelex/tools/misc/pretty.py::PrettyPrinter.pretty_text"]
param = "pretty"
rationale = "Renders the pretty; single operand."

["pipelex/tools/misc/pretty.py::PrettyPrinter.wrap_in_panel"]
param = "pretty"
rationale = "Renders the pretty; single operand."

["pipelex/tools/misc/pretty.py::pretty_print"]
param = "content"
rationale = "Renders the content; single operand."

["pipelex/tools/misc/pretty.py::pretty_print_md"]
param = "content"
rationale = "Renders the content; single operand."

["pipelex/tools/misc/pretty.py::pretty_print_url"]
param = "url"
rationale = "Renders the url; single operand."

["pipelex/tools/misc/semver.py::parse_constraint"]
param = "constraint_str"
rationale = "Parses/reads the constraint_str; single operand."

["pipelex/tools/misc/semver.py::parse_version"]
param = "version_str"
rationale = "Parses/reads the version_str; single operand."

["pipelex/tools/misc/semver.py::parse_version_tag"]
param = "tag"
rationale = "Parses/reads the tag; single operand."

["pipelex/tools/misc/semver.py::select_minimum_version"]
param = "available_versions"
rationale = "Parses/reads the available_versions; single operand."

["pipelex/tools/misc/semver.py::select_minimum_version_for_multiple_constraints"]
param = "available_versions"
rationale = "Parses/reads the available_versions; single operand."

["pipelex/tools/misc/semver.py::version_satisfies"]
param = "version"
rationale = "Predicate on the version; single operand."

["pipelex/tools/misc/string_utils.py::camel_to_snake_case"]
param = "name"
rationale = "Transforms the name; single operand."

["pipelex/tools/misc/string_utils.py::can_inject_text"]
param = "value"
rationale = "Predicate on the value; single operand."

["pipelex/tools/misc/string_utils.py::get_root_from_dotted_path"]
param = "dotted_path"
rationale = "Extracts/derives from the dotted_path; single operand."

["pipelex/tools/misc/string_utils.py::has_text"]
param = "text"
rationale = "Predicate on the text; single operand."

["pipelex/tools/misc/string_utils.py::is_none_or_has_text"]
param = "text"
rationale = "Predicate on the text; single operand."

["pipelex/tools/misc/string_utils.py::is_not_none_and_has_text"]
param = "text"
rationale = "Predicate on the text; single operand."

["pipelex/tools/misc/string_utils.py::is_numeric_string"]
param = "text"
rationale = "A one-operand string predicate: is_numeric_string(text) reads as the question it answers, like its has_text/is_snake_case neighbours."

["pipelex/tools/misc/string_utils.py::is_pascal_case"]
param = "word"
rationale = "Predicate on the word; single operand."

["pipelex/tools/misc/string_utils.py::is_snake_case"]
param = "word"
rationale = "Predicate on the word; single operand."

["pipelex/tools/misc/string_utils.py::matches_wildcard_pattern"]
param = "text"
rationale = "Predicate on the text; single operand."

["pipelex/tools/misc/string_utils.py::normalize_to_ascii"]
param = "text"
rationale = "Transforms the text; single operand."

["pipelex/tools/misc/string_utils.py::pascal_case_to_kebab"]
param = "name"
rationale = "Transforms the name; single operand."

["pipelex/tools/misc/string_utils.py::pascal_case_to_sentence"]
param = "name"
rationale = "Transforms the name; single operand."

["pipelex/tools/misc/string_utils.py::pascal_case_to_snake_case"]
param = "name"
rationale = "Transforms the name; single operand."

["pipelex/tools/misc/string_utils.py::snake_to_capitalize_first_letter"]
param = "snake_str"
rationale = "Transforms the snake_str; single operand."

["pipelex/tools/misc/string_utils.py::snake_to_pascal_case"]
param = "snake_str"
rationale = "Transforms the snake_str; single operand."

["pipelex/tools/misc/string_utils.py::snake_to_title_case"]
param = "snake_str"
rationale = "Transforms the snake_str; single operand."

["pipelex/tools/misc/tenacity_utils.py::log_retry"]
param = "retry_state"
rationale = "Operates on the retry_state; single operand (qualifiers keyword-only)."

["pipelex/tools/misc/toml_sync.py::collect_leaf_key_paths"]
param = "doc"
rationale = "Parses/reads the doc; single operand."

["pipelex/tools/misc/toml_sync.py::get_nested_value"]
param = "doc"
rationale = "Parses/reads the doc; single operand."

["pipelex/tools/misc/toml_sync.py::set_nested_value"]
param = "doc"
rationale = "Setter: installs the doc; single operand."

["pipelex/tools/misc/toml_utils.py::load_toml_from_base_and_overrides"]
param = "paths"
rationale = "Loads and merges the paths; single operand, same shape as its sibling load_toml_from_path_and_merge_with_overrides."

["pipelex/tools/misc/toml_utils.py::load_toml_from_content"]
param = "content"
rationale = "Parses/reads the content; single operand."

["pipelex/tools/misc/toml_utils.py::load_toml_from_path"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/misc/toml_utils.py::load_toml_from_path_and_merge_with_overrides"]
param = "paths"
rationale = "Parses/reads the paths; single operand."

["pipelex/tools/misc/toml_utils.py::load_toml_from_path_if_exists"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/misc/toml_utils.py::load_toml_with_tomlkit"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/misc/toml_utils.py::save_toml_to_path"]
param = "data"
rationale = "Transforms the data; single operand."

["pipelex/tools/network/host_rules.py::classify_disallowed_host"]
param = "host"
rationale = "Reads as classify(host): its one operand is the host the SSRF guard refused, as is_disallowed_host takes it."

["pipelex/tools/network/host_rules.py::is_disallowed_host"]
param = "host"
rationale = "Predicate on the host; single operand."

["pipelex/tools/network/host_rules.py::is_disallowed_ip"]
param = "host"
rationale = "Predicate on the host; single operand."

["pipelex/tools/network/ssrf_guard.py::resolve_to_allowed_ips"]
param = "host"
rationale = "Parses/reads the host; single operand."

["pipelex/tools/pdf/pypdfium2_renderer.py::PyPdfium2Renderer._extract_embedded_images_from_page_sync"]
param = "pdf_input"
rationale = "Extracts/derives from the pdf_input; single operand."

["pipelex/tools/pdf/pypdfium2_renderer.py::PyPdfium2Renderer._extract_embedded_images_from_pdf_sync"]
param = "pdf_input"
rationale = "Extracts/derives from the pdf_input; single operand."

["pipelex/tools/pdf/pypdfium2_renderer.py::PyPdfium2Renderer._extract_text_from_pdf_pages_sync"]
param = "pdf_input"
rationale = "Extracts/derives from the pdf_input; single operand."

["pipelex/tools/pdf/pypdfium2_renderer.py::PyPdfium2Renderer._render_pdf_pages_sync"]
param = "pdf_input"
rationale = "Jinja op on the pdf_input; single operand (context keyword-only)."

["pipelex/tools/pdf/pypdfium2_renderer.py::PyPdfium2Renderer.extract_embedded_images_from_page"]
param = "pdf_input"
rationale = "Extracts/derives from the pdf_input; single operand."

["pipelex/tools/pdf/pypdfium2_renderer.py::PyPdfium2Renderer.extract_embedded_images_from_pdf"]
param = "pdf_input"
rationale = "Extracts/derives from the pdf_input; single operand."

["pipelex/tools/pdf/pypdfium2_renderer.py::PyPdfium2Renderer.extract_embedded_images_from_pdf_uri"]
param = "pdf_uri"
rationale = "Extracts/derives from the pdf_uri; single operand."

["pipelex/tools/pdf/pypdfium2_renderer.py::PyPdfium2Renderer.extract_text_from_pdf_pages"]
param = "pdf_input"
rationale = "Extracts/derives from the pdf_input; single operand."

["pipelex/tools/pdf/pypdfium2_renderer.py::PyPdfium2Renderer.extract_text_from_pdf_pages_from_uri"]
param = "pdf_uri"
rationale = "Extracts/derives from the pdf_uri; single operand."

["pipelex/tools/pdf/pypdfium2_renderer.py::PyPdfium2Renderer.render_pdf_pages"]
param = "pdf_input"
rationale = "Jinja op on the pdf_input; single operand (context keyword-only)."

["pipelex/tools/pdf/pypdfium2_renderer.py::PyPdfium2Renderer.render_pdf_pages_from_uri"]
param = "pdf_uri"
rationale = "Jinja op on the pdf_uri; single operand (context keyword-only)."

["pipelex/tools/pdf/pypdfium2_renderer.py::_extract_image_from_pdf_object"]
param = "image_obj"
rationale = "Extracts/derives from the image_obj; single operand."

["pipelex/tools/pdf/pypdfium2_renderer.py::_resolve_pdf_uri_to_input"]
param = "pdf_uri"
rationale = "Parses/reads the pdf_uri; single operand."

["pipelex/tools/secrets/secrets_provider_abstract.py::SecretsProviderAbstract.get_optional_secret"]
param = "secret_id"
rationale = "Keyed accessor by the secret_id; single operand."

["pipelex/tools/secrets/secrets_provider_abstract.py::SecretsProviderAbstract.get_optional_secret_specific_version"]
param = "secret_id"
rationale = "Keyed accessor by the secret_id; single operand."

["pipelex/tools/secrets/secrets_provider_abstract.py::SecretsProviderAbstract.get_required_secret"]
param = "secret_id"
rationale = "Keyed accessor by the secret_id; single operand."

["pipelex/tools/secrets/secrets_provider_abstract.py::SecretsProviderAbstract.get_required_secret_specific_version"]
param = "secret_id"
rationale = "Keyed accessor by the secret_id; single operand."

["pipelex/tools/secrets/secrets_provider_abstract.py::SecretsProviderAbstract.get_secret"]
param = "secret_id"
rationale = "Keyed accessor by the secret_id; single operand."

["pipelex/tools/secrets/secrets_provider_abstract.py::SecretsProviderAbstract.set_secret_as_env_var"]
param = "secret_id"
rationale = "Setter: installs the secret_id; single operand."

["pipelex/tools/secrets/secrets_utils.py::_get_env_var"]
param = "var_name"
rationale = "Keyed accessor by the var_name; single operand."

["pipelex/tools/secrets/secrets_utils.py::_get_secret"]
param = "secret_name"
rationale = "Keyed accessor by the secret_name; single operand."

["pipelex/tools/secrets/secrets_utils.py::_handle_fallback_pattern"]
param = "var_spec"
rationale = "Operates on the var_spec; single operand (qualifiers keyword-only)."

["pipelex/tools/secrets/secrets_utils.py::substitute_vars"]
param = "content"
rationale = "Operates on the content; single operand (qualifiers keyword-only)."

["pipelex/tools/secrets/secrets_utils.py::substitute_vars.replace_var"]
param = "match"
rationale = "Positional-Callable re.sub repl: match is the single operand re passes."

["pipelex/tools/storage/gcp_storage_provider.py::GcpStorageProvider._generate_signed_url_sync"]
param = "key"
rationale = "Keyed accessor by the key; single operand."

["pipelex/tools/storage/gcp_storage_provider.py::GcpStorageProvider._load_head_sync"]
param = "key"
rationale = "Keyed accessor by the storage key, called positionally through asyncio.to_thread."

["pipelex/tools/storage/gcp_storage_provider.py::GcpStorageProvider._load_size_sync"]
param = "key"
rationale = "Keyed accessor by the storage key, called positionally through asyncio.to_thread."

["pipelex/tools/storage/gcp_storage_provider.py::GcpStorageProvider._load_with_metadata_sync"]
param = "key"
rationale = "Parses/reads the key; single operand."

["pipelex/tools/storage/gcp_storage_provider.py::GcpStorageProvider._make_public_url"]
param = "key"
rationale = "Factory from source: builds the result from the key; single operand."

["pipelex/tools/storage/gcp_storage_provider.py::GcpStorageProvider._store_sync"]
param = "data"
rationale = "Stores the data; single operand (key keyword-only)."

["pipelex/tools/storage/local_storage_provider.py::LocalStorageProvider._validate_key"]
param = "key"
rationale = "Keyed accessor by the key; single operand."

["pipelex/tools/storage/s3_storage_provider.py::S3StorageProvider._make_public_url"]
param = "key"
rationale = "Factory from source: builds the result from the key; single operand."

["pipelex/tools/storage/storage_provider_abstract.py::StorageProviderAbstract._add_scheme"]
param = "key"
rationale = "Keyed accessor by the key; single operand."

["pipelex/tools/storage/storage_provider_abstract.py::StorageProviderAbstract._load_head"]
param = "key"
rationale = "Keyed accessor by the storage key; single operand."

["pipelex/tools/storage/storage_provider_abstract.py::StorageProviderAbstract._load_size"]
param = "key"
rationale = "Keyed accessor by the storage key; single operand, as _load_head."

["pipelex/tools/storage/storage_provider_abstract.py::StorageProviderAbstract._load_with_metadata"]
param = "key"
rationale = "Parses/reads the key; single operand."

["pipelex/tools/storage/storage_provider_abstract.py::StorageProviderAbstract._store"]
param = "data"
rationale = "Keyed accessor by the data; single operand."

["pipelex/tools/storage/storage_provider_abstract.py::StorageProviderAbstract._strip_scheme"]
param = "uri"
rationale = "Keyed accessor by the uri; single operand."

["pipelex/tools/storage/storage_provider_abstract.py::StorageProviderAbstract.load"]
param = "uri"
rationale = "Keyed accessor by the uri; single operand."

["pipelex/tools/storage/storage_provider_abstract.py::StorageProviderAbstract.load_head"]
param = "uri"
rationale = "Keyed accessor by the uri; single operand."

["pipelex/tools/storage/storage_provider_abstract.py::StorageProviderAbstract.load_size"]
param = "uri"
rationale = "Keyed accessor by the uri; single operand, as load_head."

["pipelex/tools/storage/storage_provider_abstract.py::StorageProviderAbstract.load_with_metadata"]
param = "uri"
rationale = "Parses/reads the uri; single operand."

["pipelex/tools/storage/storage_provider_abstract.py::StorageProviderAbstract.public_url"]
param = "uri"
rationale = "Keyed accessor by the uri; single operand."

["pipelex/tools/storage/storage_provider_abstract.py::StorageProviderAbstract.store"]
param = "data"
rationale = "Keyed accessor by the data; single operand."

["pipelex/tools/tabular/csv_codec.py::_assert_single_char_delimiter"]
param = "delimiter"
rationale = "Validates/checks the delimiter; single operand."

["pipelex/tools/tabular/csv_codec.py::_is_flat_annotation"]
param = "annotation"
rationale = "Predicate on the annotation; single operand."

["pipelex/tools/tabular/csv_codec.py::_read_table"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/tabular/csv_codec.py::_row_to_dict"]
param = "data_row"
rationale = "Transforms the data_row; single operand."

["pipelex/tools/tabular/csv_codec.py::_to_cell"]
param = "value"
rationale = "Transforms the value; single operand."

["pipelex/tools/tabular/csv_codec.py::_validate_header"]
param = "header"
rationale = "Validates/checks the header; single operand."

["pipelex/tools/tabular/csv_codec.py::assert_supported_table_suffix"]
param = "path"
rationale = "File/path op on the path; single operand."

["pipelex/tools/tabular/csv_codec.py::csv_from_list_content"]
param = "list_content"
rationale = "Transforms the list_content; single operand."

["pipelex/tools/tabular/csv_codec.py::flat_field_names"]
param = "row_model"
rationale = "Transforms the row_model; single operand."

["pipelex/tools/tabular/csv_codec.py::is_tabular_path"]
param = "path"
rationale = "Predicate on the path; single operand."

["pipelex/tools/tabular/csv_codec.py::list_content_from_csv"]
param = "path"
rationale = "Transforms the path; single operand."

["pipelex/tools/tabular/csv_codec.py::read_rows"]
param = "path"
rationale = "Parses/reads the path; single operand."

["pipelex/tools/typing/annotation_utils.py::unwrap_optional"]
param = "annotation"
rationale = "Reads as verb-object: unwrap_optional(annotation) takes the one obvious operand, the annotation to unwrap, and call sites pass self-labelling annotation expressions."

["pipelex/tools/typing/class_utils.py::has_compatible_field"]
param = "model_cls"
rationale = "Predicate on the model_cls; single operand."

["pipelex/tools/typing/class_utils.py::has_compatible_field._is_compatible"]
param = "type_param"
rationale = "Inner predicate: tests the type param; single operand."

["pipelex/tools/typing/class_utils.py::normalize_properties_for_comparison"]
param = "properties"
rationale = "Transforms the properties; single operand."

["pipelex/tools/typing/class_utils.py::normalize_property_for_comparison"]
param = "prop"
rationale = "Transforms the prop; single operand."

["pipelex/tools/typing/module_inspector.py::convert_file_path_to_module_path"]
param = "file_path"
rationale = "Extracts/derives from the file_path; single operand."

["pipelex/tools/typing/module_inspector.py::find_class_names_in_file"]
param = "file_path"
rationale = "Extracts/derives from the file_path; single operand."

["pipelex/tools/typing/module_inspector.py::find_classes_in_module"]
param = "module"
rationale = "Extracts/derives from the module; single operand."

["pipelex/tools/typing/module_inspector.py::import_module_from_file"]
param = "file_path"
rationale = "Inspects the file_path; single operand."

["pipelex/tools/typing/module_inspector.py::import_module_from_file_if_has_classes"]
param = "file_path"
rationale = "Inspects the file_path; single operand."

["pipelex/tools/typing/pydantic_utils.py::_truncated_rich_repr_from_items"]
param = "rich_repr_items"
rationale = "Transforms the rich_repr_items; single operand."

["pipelex/tools/typing/pydantic_utils.py::analyze_pydantic_validation_error"]
param = "exc"
rationale = "Validates/checks the exc; single operand."

["pipelex/tools/typing/pydantic_utils.py::clean_model_to_dict"]
param = "obj"
rationale = "Transforms the obj; single operand."

["pipelex/tools/typing/pydantic_utils.py::convert_strenum_to_str"]
param = "obj"
rationale = "Transforms the obj; single operand."

["pipelex/tools/typing/pydantic_utils.py::empty_dict_factory_of"]
param = "_key"
rationale = "Factory from source: builds the result from the _key; single operand."

["pipelex/tools/typing/pydantic_utils.py::empty_list_factory_of"]
param = "_"
rationale = "Factory from source: builds the result from the _; single operand."

["pipelex/tools/typing/pydantic_utils.py::format_pydantic_validation_error"]
param = "exc"
rationale = "Validates/checks the exc; single operand."

["pipelex/tools/typing/pydantic_utils.py::make_truncated_wrapper"]
param = "model"
rationale = "Factory from source: builds the result from the model; single operand."

["pipelex/tools/typing/pydantic_utils.py::make_truncated_wrapper.rich_repr_method"]
param = "_self"
rationale = "Positional-Callable __rich_repr__: the bound instance is passed positionally by Rich."

["pipelex/tools/typing/pydantic_utils.py::serialize_model"]
param = "obj"
rationale = "Transforms the obj; single operand."

["pipelex/tools/typing/structure_printer.py::StructurePrinter.get_type_structure"]
param = "tp"
rationale = "Keyed accessor by the tp; single operand."

["pipelex/tools/typing/structure_printer.py::StructurePrinter.get_type_structure.collect_types"]
param = "tp"
rationale = "Inner recursion helper: collects types from tp; single operand."

["pipelex/tools/typing/structure_printer.py::StructurePrinter.get_type_structure.format_type"]
param = "tp"
rationale = "Inner recursion helper: formats tp; single operand."

["pipelex/tools/typing/structure_printer.py::StructurePrinter.pretty_type"]
param = "tp"
rationale = "Renders the tp; single operand."

["pipelex/tools/typing/validation_utils.py::has_exactly_one_among_attributes_from_list"]
param = "obj"
rationale = "Predicate on the obj; single operand."

["pipelex/tools/typing/validation_utils.py::has_more_than_one_among_attributes_from_list"]
param = "obj"
rationale = "Predicate on the obj; single operand."

["pipelex/tools/typing/validation_utils.py::has_more_than_one_among_attributes_from_lists"]
param = "obj"
rationale = "Predicate on the obj; single operand."

["pipelex/tools/uri/uri_base64.py::make_base64_url_from_any_uri"]
param = "uri"
rationale = "Factory from source: builds the result from the uri; single operand."

["pipelex/tools/uri/uri_base64.py::make_base64_url_from_http_url"]
param = "url"
rationale = "Factory from source: builds the result from the url; single operand."

["pipelex/tools/uri/uri_bytes.py::load_bytes_and_mime_type_from_any_uri"]
param = "uri"
rationale = "Loads the bytes and media type one URI names."

["pipelex/tools/uri/uri_bytes.py::load_bytes_from_any_uri"]
param = "uri"
rationale = "Loads the bytes one URI names."

["pipelex/tools/uri/uri_resolver.py::_resolve_base64_data_url"]
param = "uri"
rationale = "Parses/reads the uri; single operand."

["pipelex/tools/uri/uri_resolver.py::_resolve_file_uri"]
param = "uri"
rationale = "Parses/reads the uri; single operand."

["pipelex/tools/uri/uri_resolver.py::describe_uri"]
param = "uri"
rationale = "Parses/reads the uri; single operand."

["pipelex/tools/uri/uri_resolver.py::extract_filename_from_uri"]
param = "uri"
rationale = "Extracts/derives from the uri; single operand."

["pipelex/tools/uri/uri_resolver.py::is_relative_local_path"]
param = "uri"
rationale = "Predicate on the uri; single operand."

["pipelex/tools/uri/uri_resolver.py::resolve_local_path_reference"]
param = "uri"
rationale = "Verb-object: resolves the uri; base_dir is context."

["pipelex/tools/uri/uri_resolver.py::resolve_uri"]
param = "uri"
rationale = "Parses/reads the uri; single operand."

["pipelex/tracing/activity_event_log.py::ActivityEventLogCache.get_or_create"]
param = "tracing_config"
rationale = "Factory from source: builds the event log from the tracing config; single operand."

["pipelex/tracing/dynamodb_event_log.py::DynamoDBEventLog._key_condition"]
param = "pipeline_run_id"
rationale = "Derivation: encodes the run id into a key condition; single operand."

["pipelex/tracing/dynamodb_event_log.py::DynamoDBEventLog._make_pk"]
param = "pipeline_run_id"
rationale = "Derivation: encodes the run id into the partition key; single operand."

["pipelex/tracing/event_log_factory.py::make_event_log"]
param = "tracing_config"
rationale = "Factory from source: builds the event log from the tracing config; writer_id stays keyword."

["pipelex/tracing/event_log_protocol.py::EventLogProtocol.cleanup"]
param = "pipeline_run_id"
rationale = "Protocol method: purges the run identified by the id; single operand across implementations."

["pipelex/tracing/event_log_protocol.py::EventLogProtocol.emit"]
param = "event"
rationale = "Protocol method: emits the trace event; single operand across implementations."

["pipelex/tracing/event_log_protocol.py::EventLogProtocol.read_events"]
param = "pipeline_run_id"
rationale = "Protocol method: reads the run identified by the id; single operand across implementations."

["pipelex/tracing/graphspec_assembler.py::GraphSpecAssembler.assemble"]
param = "events"
rationale = "Verb-object: assembles the graph from the events; graph metadata stays keyword."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_batch_aggregate"]
param = "event"
rationale = "Dispatch handler: handles the event; single operand."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_batch_item"]
param = "event"
rationale = "Dispatch handler: handles the event; single operand."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_condition_output_merge"]
param = "event"
rationale = "An event handler of the assembler's pass one, called with the one event it folds in, like its sibling handlers."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_condition_resolved"]
param = "event"
rationale = "An event handler of the assembler's pass one, called with the one event it folds in, like its sibling handlers."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_controller_output"]
param = "event"
rationale = "Dispatch handler: handles the event; single operand."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_edge_event"]
param = "event"
rationale = "Dispatch handler: handles the event; single operand."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_execution_data"]
param = "event"
rationale = "Dispatch handler: handles the event; single operand."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_parallel_combine"]
param = "event"
rationale = "Dispatch handler: handles the event; single operand."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_pipe_end_error"]
param = "event"
rationale = "Dispatch handler: handles the event; single operand."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_pipe_end_skipped"]
param = "event"
rationale = "Protocol event handler: the event is the single operand."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_pipe_end_success"]
param = "event"
rationale = "Dispatch handler: handles the event; single operand."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_pipe_start"]
param = "event"
rationale = "Dispatch handler: handles the event; single operand."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._handle_usage_report"]
param = "event"
rationale = "Dispatch handler: handles the event; single operand."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState._track_earliest_timestamp"]
param = "event"
rationale = "Verb-object: reads the event to track its timestamp; single operand."

["pipelex/tracing/graphspec_assembler.py::_AssemblerState.pass_one"]
param = "events"
rationale = "First pass over the event sequence; single operand."

["pipelex/tracing/usage_aggregator.py::UsageAggregator.aggregate"]
param = "events"
rationale = "Verb-object: aggregates the events; single operand."

["pipelex/tracing/usage_attribution.py::_merge_token_categories"]
param = "usages"
rationale = "Verb-object: operates on one list of usage records; the single obvious operand is the usages."

["pipelex/tracing/usage_attribution.py::_rated_count"]
param = "usages"
rationale = "Verb-object: operates on one list of usage records; the single obvious operand is the usages."

["pipelex/tracing/usage_attribution.py::make_self_contained_spec"]
param = "usages"
rationale = "Verb-object: operates on one list of usage records; the single obvious operand is the usages."