Beeline Workspace

Fetch and attach a public web source. Local/private addresses are blocked.

add_build_url_source

Analyze competency gaps: required levels vs actual levels in your workspace. Can scope by role (show all learners in that role) or by user (show all role requirements for that user). Returns gap size and whether each competency requirement is met. Args: role_id: Optional job role UUID to analyze. Shows all learners assigned to this role. user_id: Optional user ID to analyze. Shows all role requirements for this user. At least one of role_id or user_id must be provided.

get_role_competency_gaps

Who needs attention right now — the groups (or learners) furthest behind, worst first, each with a one-line reason. A ranking over the same warehouse figures `get_group_dashboard` and `list_learners` return; no new or invented score. Groups are ranked by `users_fully_complete_pct` ascending, tie-broken on `avg_user_progress_pct`; groups with no users are excluded (they read as 0% while representing nobody) and counted in `excluded_empty_groups`. ⚠️ This ranking is about GROUPS, not a verdict on the people in them. `users_fully_complete_pct` counts users who are 100% done on ALL content assigned TO THAT GROUP, so a group whose members are trained through their store/role groups appears at "0%" while those same users are fully complete on their own totals. Each row carries `assignment_scope` saying which denominator it used, and `avg_user_progress_pct` distinguishes "nobody has finished yet" (real progression, mid-flight) from "nothing is happening" (progression also ~0). Check both before calling a group the worst in the org. In `learners` mode rows are USER-level: `user_fully_complete` is the all-or-nothing flag and `user_content_completed_pct` is that person's partially-credited %, over ALL content assigned to them. Learners are ranked by `user_content_completed_pct` ascending, tie-broken on `user_avg_progress_pct` ascending; people with nothing assigned rank last (their 0% is "0 of 0", not falling behind). Args: mode: 'groups' (default — which stores/regions are behind) or 'learners' (which individuals are behind). top_n: How many rows to return (max 25).

get_at_risk

Ingest an already-uploaded file (by its storage key) as a ContentSource — embedded, queryable, competency-attachable AI fuel — scoped to this org. The bytes are NOT copied; only the extracted text + embeddings are derived. Returns the content_source_id, which you can then pass as a source_reference_ids entry to generate_block / rewrite_block to ground generation in this material. Idempotent: re-ingesting the same file in the same org returns the existing source. Non-text files (video/audio/image) are skipped (no extractable text). Args: file_key: Storage key of an already-uploaded file (from the normal presigned-upload flow). Bytes-over-MCP is intentionally not supported. name: Optional display name (defaults to the file name).

attach_source

Where are the capability gaps across your org (or a group)? — the exec/CEO view. Aggregates assessment performance up to COMPETENCIES (via the gap-analysis engine) so you see "the org is weak on Regulatory Compliance" rather than "question 123 fails a lot", with an AI thematic narrative and strategic recommendations. Returns summary counts (competencies analysed, critical/high gaps, mapping coverage), the top competency gaps (name, failure rate, learners affected, severity, knowledge-vs-performance split), the thematic `insights` narrative, and `recommendations`. Scoped to a group (its whole subtree) when given, else the whole org. Admin, or a manager of the group. PR-FAQ (CAPABILITY surface, per CLAUDE.md): a Tuesday-morning ops director / CEO can ask "what are our biggest capability gaps and what should we do about them?" and get a ranked, competency-level answer with a narrative and next steps — something no existing report or dashboard surfaced; it turns raw assessment failures into a strategic capability readout that targets where to invest training next. Args: group_id: Optional group to scope to (otherwise your groups / whole org). include_descendants: If true (default), a group_id includes its subtree. top_n: How many top competency gaps to return in the curated view. include_insights: Generate the AI thematic narrative (default true). Set false for a faster numbers-only read. full: Return the complete gap report instead of the curated summary.

get_capability_gaps

Poll the status of a background group-member move started by move_group_members (returned when a move affects more than 25 people). Admin, or a manager of both groups involved in that move. Args: job_id: The job_id returned by move_group_members.

get_group_move_status

Side-by-side comparison of 2–10 groups — the exec "which of our regions/stores/franchises is winning, and which is dragging" view. Returns per-group completion, assessment score, overdue, active-7d/30d, and role mix, PLUS cross-group ranks/percentiles and best/worst performer per metric, and `metric_definitions` describing each field it returns. `completion_pct` here is the SHARE OF PEOPLE fully complete, not average progress — a group where everyone is 90% done scores 0. This payload carries no average-progress figure at all; for completion and progression side by side use `get_group_dashboard`. Each group's numbers already include its descendant-group members (automatic rollup). ⚠️ So if one compared group CONTAINS another, their shared members are counted on both rows: the response then carries `overlapping_groups` and an `overlap_warning`, and those rows should be reported as nested views rather than separate populations. Pairs with the visualize skill for a ranked comparison chart. Admin, or a manager of every group in the list. Args: group_ids: 2–10 group ids to compare (from get_group_dashboard).

compare_groups

Per-course completion across the workspace library — which courses are landing and which are dead stock. One row per beeline with `assigned`, `completed`, `completion_pct`, `avg_progress` and `completed_last_30d` over the active member set, plus provenance and content type. This is the reporting view of the library; the Build tool `list_beelines` returns metadata only (no numbers), and `get_program_report` drills ONE course down by group. `completed_last_30d` is the freshness signal: a course with a big `completed` total but zero recent completions is dead stock, not a success. Use it to separate "actively landing" from "finished long ago". Args: group_id: Optional group to scope the population to (its subtree). search: Filter by course name. content_type: 'Practical' (has a practical cell) or 'Theory'. sort: Service sort key; defaults to name.

get_content_report

Completion & progression for one program (beeline) — overall and broken down by group — from the Insights warehouse. With `include_learners`, also WHO: one row per learner, by name. `overall` gives the whole scoped cohort's `learners_assigned`, `learners_completed`, `completion_pct`, and `avg_progress` (progression, 0-100). `by_group` lists per-group completion. When scoped to a group, descendant-group members are included (default). `learners` (only when `include_learners` or `learner_status` is given) answers "who has / hasn't completed X" — e.g. who has acknowledged a policy. It is `{total, page, page_size, status_counts, results}`; each row is `learner_id`, `learner_name`, `status` ('completed' / 'in_progress' / 'not_started'), `progress_pct` (0-100), `completed_at` (ISO, completed rows only) and `assigned`. Rows are the learners assigned this beeline plus anyone in scope who completed it without a current assignment (`assigned: false`) — the same people `overall` counts. `status_counts` covers the whole scoped population, before `learner_status` filtering and paging. Managers see only learners in their managed groups. No emails or phone numbers are returned. Note: this reports at the beeline (program) level. Per-cell reporting is not exposed yet. Args: beeline_id: The beeline (program) to report on. Must be in your workspace. group_id: Optional group to scope to (otherwise your groups / whole org). include_descendants: If true (default), a group_id also includes learners in its descendant groups. include_learners: If true, add the per-learner `learners` block. learner_status: Only list learners in this state — 'completed', 'in_progress' or 'not_started' (implies include_learners). Unknown values are rejected. page / page_size: Pagination for `learners.results` (page_size max 100).

get_program_report

Completions over time — the momentum question. "Are we speeding up or slowing down?" Returns `buckets` (oldest first, one entry per period that had at least one completion) plus `total_completions` over the window. A period with no completions is omitted rather than zero-filled — treat a missing period as zero when charting, and don't read the gap as missing data. Distinct from the activity timeline, which counts platform events (logins, cell views) rather than finished courses. Args: bucket: 'day', 'week' (default) or 'month'. days: Window length ending now (default 90, max 730). group_id: Optional group to scope the population to (its subtree). beeline_id: Optional single course to trend.

get_completion_trends

Configure an assessment cell — pass mark, attempts, timing, shuffling. Provide only the settings to change. Read the current values back from `list_questions` (its `settings` key) or from this tool's response. To make a pass mark an actual REQUIREMENT you need both halves: `pass_mark_percent` sets the bar, `required_to_pass=True` makes clearing it mandatory to progress. On its own a pass mark is advisory — the default is that attempting the assessment is enough. Args: cell_id: The assessment (ASSES) cell. Its assessment is created if it doesn't have one yet. pass_mark_percent: Pass mark as a PERCENT, 0-100. Pass 80 for 80% (not 0.8 — a fraction is rejected rather than read as 0.8%). required_to_pass: True = the learner must reach the pass mark to progress. False = attempting is enough (the platform default). max_attempts: Maximum attempts allowed (>= 1). Omit for unlimited. duration_seconds: Time limit in seconds (>= 1). Omit for untimed. shuffle_questions: Randomise question order per attempt. show_learner_results_report: Show the learner their results report. expected_version: Optional optimistic-concurrency guard.

update_assessment_settings

Confirm a reviewed proposal and apply it. role_pack: admin-only; enqueues apply_role_pack_proposal. zeno_action (a change Zeno prepared, e.g. a "Fix it" from conductor_preview): an admin, or a manager whose places cover it, may confirm. It runs as YOU, now — status comes back applied, or failed with the reason. Other kinds (e.g. quest_pack) are not supported via MCP yet. Args: proposal_id: UUID of the proposal in proposed/edited status.

confirm_proposal

Create a Role Pack proposal from JDs or a hand-authored plan. Admin-only. Provide at least one of pasted_text, file_keys, or plan. Without ``plan``, creates status=generating, ingests sources, and enqueues async generation — poll get_proposal until status is proposed. With ``plan``, skips generation and stores a validated RolePackPlan as status=edited (recovery when generation fails). Args: pasted_text: Free-text job descriptions / role notes. file_keys: Storage keys of already-uploaded JD files in this workspace (from the normal upload flow). Bytes-over-MCP is not supported. framework_name: Optional suggested competency framework name. plan: Optional full RolePackPlan (see patch_proposal_plan). When provided, generation is skipped.

create_role_pack_proposal

Create a brand-new, empty beeline (one empty section) in your workspace. This is the starting point when there's no existing beeline to edit — the agent's first move when building something from nothing. Use the returned beeline_id / section (the one entry in `structure`) with add_cell to start filling it in. Args: name: Beeline title (defaults to "New Beeline"). description: Optional beeline description.

create_beeline

Create one learner group in your workspace. Admin-only. Call once WITHOUT confirm to preview what would be created (no changes made), then again with confirm=True to actually create it. Args: name: The group's name. classification: The classification NAME (e.g. 'Location', 'Role', or a custom one). Must already exist in your workspace. parent_group_id: Optional parent group to nest this under (max 9 levels). Omitted for a Location group, it goes under the whole-company group. location_kind: Optional — 'CONTAINER' (region/division folder) or 'SITE' (operational store/branch). latitude / longitude: Optional GPS coordinates for a site. start_date / end_date: Optional cohort dates (YYYY-MM-DD). confirm: False (default) returns a preview; True performs the creation.

create_group

Create a sign-up / log-in link that moves this guest build into a real Beeline workspace. Call it when the user wants to keep the course; the outline must be saved first. Args: guest_handle: from start_guest_build. Returns the preview plus claim_url and expires_in_seconds (3600): the link expires after an hour and works once, so create a fresh one if the user comes back later. Errors: preview_not_ready, claim_unavailable, invalid_guest_handle, build_not_found, build_expired (a preview lasts 7 days by default), build_already_claimed.

create_build_claim_link

Create several learner groups at once. Admin-only. Each item is an object with the same fields as create_group: {name, classification, parent_group_id?, location_kind?, latitude?, longitude?, start_date?, end_date?}. parent_group_id must be an ALREADY- EXISTING group (you cannot reference a sibling being created in the same call by id) — to build a nested hierarchy, create the parent groups in one call, then their children in a follow-up call using the returned ids. Invalid rows (unknown classification, cross-org parent, too-deep) do NOT fail the whole batch — they come back as warnings; the valid rows still preview/create. Call without confirm to preview; confirm=True to create. Args: groups: List of group objects (see above). confirm: False (default) previews; True creates the valid rows.

bulk_create_groups

Delete a content block by id. Args: cell_id: The cell to edit. block_id: Id of the block to delete. expected_version: Optional optimistic-concurrency guard.

delete_cell_block

Permanently delete a group; its sub-groups move up to the deleted group's parent (never orphaned). The whole-company group cannot be deleted. Admin-only. This is DESTRUCTIVE and cannot be undone — to temporarily hide a group instead, use edit_group with active=false. Call without confirm to preview (how many sub-groups and members are affected); confirm=True to delete. Args: group_id: The group to delete. confirm: False (default) previews; True permanently deletes.

delete_group

Remove a field from a survey cell by id. Args: cell_id: The survey cell. field_id: Id of the field to remove. expected_version: Optional optimistic-concurrency guard.

delete_survey_field

Remove a question from an assessment cell. This detaches it (and preserves any learner response history), it does not hard-delete the question. Args: cell_id: The assessment cell. question_id: Id of the question to remove. expected_version: Optional optimistic-concurrency guard.

delete_question

WHY is this person or team behind? Fused multi-signal gap diagnosis. Runs the platform's gap-detection engine across up to five evidence signals — role requirements (required vs actual level), assessment failures (the EXACT questions they get wrong, with common wrong answers), knowledge decay (overdue spaced-repetition reviews), Capability Studio targets, and the latest completed performance review (learner subjects) — then fuses them per competency. A gap flagged by multiple signals ranks above any single-signal gap. Subjects: pass user_id for one learner, group_id for a group (its descendant groups roll up automatically), role_id for the people who currently hold a job role, or none for org-wide (admin) / across your managed groups (manager). A role's population is its live holders (active or primary assignment, active membership; holders still in onboarding count), scored on THAT role's requirements only — a holder's other roles do not bleed in. A manager sees only holders inside their managed groups. Pass at most one of user_id, group_id, role_id. The `signals` block reports each detector's status (found_gaps / no_gaps / no_data / not_configured / unsupported_for_subject) so silence is never mistaken for a clean bill. Args: user_id: Diagnose one learner (admin, or their manager). group_id: Diagnose a group's cohort (admin, or its manager). role_id: Diagnose the holders of one job role (UUID; admin, or a manager for the holders in their managed groups). include_descendants: Include descendant groups' members (default true). top_n: How many top-ranked gaps to return in the curated view. full: Return every raw fused gap instead of the curated summary.

diagnose_gaps

Dismiss one signal so it leaves the list. It comes back on its own if the number of people missing it grows by half or more, or if it is still there after 30 days. Args: signal_id: The signal's id, from list_signals. confirm: True (the default) dismisses. False only previews which signal would be dismissed, and changes nothing.

dismiss_signal

Clone an existing beeline into a new, independent copy in the same content library — a fast way to start from a known-good template instead of building from scratch. This only clones content. It does NOT reassign the copy to a different group/branch — assignment is a separate workflow this connector doesn't expose yet. Args: beeline_id: The beeline to duplicate.

duplicate_beeline

Update the text and/or marks of a block's text leaf. Args: cell_id: The cell to edit. block_id: Id of the block whose text to update. text: New text for the leaf. marks: Formatting to apply, e.g. {"bold": true}. child_path: Optional integer path to a nested leaf (e.g. list item). expected_version: Optional optimistic-concurrency guard.

update_cell_block_text

Edit one learner group's fields. Admin-only. Only fields you pass (non-null) are considered; unchanged ones are left alone. To MOVE a group to a different parent use move_group, not this — reparenting has its own preview (subtree size). Call without confirm to preview the exact field changes; confirm=True to apply. Args: group_id: The group to edit. name: New name. classification: New classification NAME (must exist in your workspace). active: Set active/inactive. location_kind: 'CONTAINER' or 'SITE'. latitude / longitude: GPS coordinates. start_date / end_date: Cohort dates (YYYY-MM-DD). confirm: False (default) previews; True applies.

edit_group

Apply the same change to many groups at once. Admin-only. Set one classification on all the given groups and/or add/remove tags (all by NAME). At least one of classification / add_tags / remove_tags is required. All group_ids must be in your workspace — a foreign id fails the whole call (nothing is changed). Call without confirm to preview; confirm= True to apply. Args: group_ids: The groups to edit (must all be in your workspace). classification: Classification NAME to set on every group. add_tags: Tag NAMES to add to every group. remove_tags: Tag NAMES to remove from every group. confirm: False (default) previews; True applies.

bulk_edit_groups

Resolve a group NAME to its id, org-scoped. Read-only. Every group tool here takes `group_id`, but people refer to groups by name — this is the missing step between the two. Returns EVERY match rather than picking one: an exact match and a same-named group in another part of the tree are indistinguishable from a name alone, and choosing between them is the caller's job, not this tool's. Exact (case-insensitive) matches are returned alone when any exist; only when there are none does this fall back to a contains search, so a group called "Sales" is never buried under "Sales - North" and "Sales - South". Args: name: The group name, or part of it. include_inactive: Also return deactivated groups. Default False.

find_group_by_name

Find beelines/cells grounded in a given content source. The response keeps the contract-tier vs best-effort split from the impact query, but filters beelines to the ones the caller can actually access. Args: content_source_id: Source to inspect.

find_content_using_source

Generate new Slate content block(s) from a plain-language instruction and insert them into a cell — the AI writes the content, the engine validates, versions, and persists it. Gated on the org's AI token budget. Anchor where the new blocks land with exactly one of after_id, before_id, or position ('prepend' | 'append', the default). Args: cell_id: The cell to add generated content to. instruction: What to write, e.g. "a 3-paragraph intro to food hygiene". source_reference_ids: Optional ContentSource ids to ground the generation in (retrieval-augmented); the content is written from those sources. after_id: Insert directly after this block id. before_id: Insert directly before this block id. position: 'prepend' or 'append' (used when no after_id/before_id). title: Optional title/topic hint for the generator. expected_version: Optional optimistic-concurrency guard (vs content_version).

generate_block

Group completion & progression dashboard for your workspace, from the Insights warehouse. Group metrics roll up descendant-group members automatically. Returns org `summary`, `classification_counts`, and a per-group list. Every group carries FOUR distinct, separately-named measures — do not conflate them: - `users_fully_complete_pct` / `users_fully_complete_count` — % and count of USERS in scope who are fully complete. Fully complete = 100% of ALL their assigned content, all-or-nothing, no partial credit. - `group_fully_complete` (bool) — true only when EVERY user in the group is fully complete; null when the group has no users in scope. - `avg_user_progress_pct` — average PROGRESSION, not completion. A group at 0% `users_fully_complete_pct` with a healthy `avg_user_progress_pct` is mid-flight, not failing. - plus user counts, overdue, and practical-review backlog. `summary.new_learners_30d` (+ `_pct`) = users in scope who joined the WORKSPACE in the last 30 days. Joining or moving group is not new. Org-wide it equals `get_activity_report`'s `new_users['30d']`. `summary.groups_fully_complete_count` rolls the group flag up. Every field's meaning is restated in the response's `metric_definitions`. ⚠️ Read `users_fully_complete_pct` as a statement about the GROUPING, not the people: it counts only content assigned to that group, so a group whose members are trained via their store/role groups reads 0% while those same people are 100% complete on their own totals. Say which you are quoting. Managers see only their managed groups. Args: classification_system_type: Optional filter — 'LOC' (locations), 'ROL' (roles), or 'GEN' (general/custom). Omit for all. group_by_tag_category: Optional tag-category slug (from `list_group_tags`) to ALSO return a `by_tag` rollup — one bucket per tag value in that category, aggregating every group carrying the tag. This is how you answer "break completion down by area manager / store format / region" when that cut is a tag rather than a group classification. A group carrying two tags in the category counts in both buckets; groups with no tag in the category land in an "Untagged" bucket.

get_group_dashboard

Detailed completion & progression for one group (INCLUDING its descendant-group members — rollup is automatic), from the warehouse. `summary` is GROUP-level: `users_fully_complete_pct` / `users_fully_complete_count` (users who are 100% done on ALL their assigned content — all-or-nothing, no partial credit), `group_fully_complete` (true only when EVERY user in scope is fully complete; null for an empty group), `avg_user_progress_pct` (progression, NOT completion), active_7d/30d, overdue, avg assessment. `learners` rows are USER-level and use a different vocabulary on purpose: `user_fully_complete` (the all-or-nothing flag for that ONE person — this is the field that used to be misnamed `is_group_complete`) and `user_content_completed_pct` (their partially-credited %). `assignment_scope` says which denominator this group's numbers count — `assigned_to_this_group_only`, or `all_content_assigned_to_user` when the group resolves to "all content" access — and the assigned/completed field names follow it (`beelines_assigned_to_group` vs `beelines_assigned_to_user`). Read it before quoting a percentage: a group-scoped 0% means nothing was assigned THROUGH THIS GROUP, not that the people are behind. `metric_definitions` restates every field. For the full paginated learner list use `list_learners`. Args: group_id: The group to drill into (its whole subtree rolls up). learner_sample_size: Max learner rows to include (default 50). include_contact: If true, keep emails/phones. Default omits them (names and user ids stay — enough to say who is behind).

get_group_detail

Ingest source material into the workspace's canonical fidelity stack. Provide exactly one input: pasted ``text``, a safe public ``url``, an existing workspace Asset ``file_key`` (discoverable with search_workspace_content), or an MCP attachment ``file_reference``. The attachment shape is ``{download_url, file_name, mime_type?}``; it is downloaded with redirect-by-redirect SSRF checks and a 25 MB cap, stored once as a private org Asset, then extracted. Documents use the existing structured extractor, embeddings, and feature-gated embedded-image Asset pipeline. Returns stable source/asset ids and provenance, never private URLs. Args: name: Optional display name (maximum 255 characters). text: Pasted source text (maximum 100,000 characters). url: Public HTTP(S) web page or text URL; private/local hosts are blocked. file_key: Existing file key from an Asset in this workspace. file_reference: MCP attachment with download_url, file_name, mime_type?. purpose: beeline, cell, enrich, ref (default), or general. generate_embeddings: Generate retrieval embeddings now (default true). extract_source_assets: Extract embedded PDF/PPT images when the workspace feature is enabled (default true; file inputs only).

ingest_content_source

Insert new block(s) into a cell. Give AT MOST ONE anchor — after_id, before_id, or position ('prepend' | 'append'). Omit them all to append to the end of the cell, which is the common case. Passing two is rejected as ambiguous. Args: cell_id: The cell to edit. new_blocks: Slate block objects to insert (each {"type": ..., "children": [...]}). A callout's "variant" must be one of note|tip|warning|danger|mistake|think|didyouknow (info/success are rejected) or set an "icon". Common types: p, h2, h3, quote, callout, ul, ol, code, divider, image, flip_boxes, tabs, accordion, timeline, comparison, table, learner_checklist, todo_turbo. Lists nest list-item children; read an existing block with get_cell_blocks and copy its shape for anything beyond plain text. after_id: Insert directly after this block id. before_id: Insert directly before this block id. position: 'prepend' (start) or 'append' (end). expected_version: Optional optimistic-concurrency guard.

insert_cell_block

Headcount movement and dormancy — who joined recently, who has gone quiet. The questions a completion dashboard can't answer. Returns `new_users` (joined the WORKSPACE in the last 7/30/90 days — joining or moving group is not being new) and `inactive` (last active longer than 30/60/90 days ago, INCLUDING people who have never been active at all), over the active member population. Both sets are cumulative thresholds, not disjoint buckets: someone inactive for 90 days is also counted in the 60d and 30d figures. Args: group_id: Optional group to scope to. Omit for org-wide (admin) or your managed groups (manager).

get_activity_report

Learner feedback on content — star ratings AND free-text comments, enriched with AI sentiment and category analysis. Returns the paginated `feedback` rows plus a dataset-level `analysis` block (sentiment and category breakdowns computed over the whole filtered set, not just the page) and top-performing content. A group scope rolls up descendant groups automatically. Use this for "what are people actually saying about our training" — the sentiment/category split answers it faster than reading every comment. Args: group_id: Optional group to scope to (its whole subtree). Omit for org-wide (admin) or your managed groups (manager). page / page_size: Pagination (page_size max 100). rating: Filter to one star rating, 1-5. sentiment: Filter by AI sentiment label. category: Filter by AI category label. beeline_id: Only feedback on this beeline's cells.

get_feedback

A rich single-learner summary, drawn from the profile service — job role & KPIs, performance-review scores, learning completion, streak, recognition/rank, certifications, assessment history, and a rule-based coaching insight. Admin, or a manager of a group the learner is in. The `learning` block is USER-level and counts ALL content assigned to this person across every group membership and direct assignment — NOT one group's slice, which is why a person can be `user_fully_complete: true` here while a group they belong to reports 0% (see `get_group_detail`): `beelines_assigned_to_user` / `beelines_completed_by_user`, `user_content_completed_pct` (partial credit) and `user_fully_complete` (all-or-nothing: 100% of ALL their assigned content; null when they have nothing assigned). `metric_definitions` restates each field. For the 2D competency picture (Knowledge×Performance, quadrant, XP), use get_learner_competency_snapshot(user_id) — this summary intentionally doesn't duplicate it. Args: user_id: The learner's user id (e.g. from list_learners). full: If true, return the complete profile payload instead of the curated summary. include_contact: If true, include the learner's email. Default omits contact identifiers — name and user_id are enough to identify them.

get_learner_summary

List and SEGMENT learners with completion & progression, from the warehouse. The workhorse for people-and-place questions — "how many baristas per store", "who's dormant in the Kiosk sites", "everyone scoring under 50". Returns `{total, limit, offset, results, kpis}`. Each row is USER-level, over ALL content assigned to that person across every group membership (never one group's slice — the field names say so): `user_fully_complete` (the all-or-nothing flag: 100% of ALL their assigned content, no partial credit), `user_content_completed_pct` (their partially-credited % — 90 here means user_fully_complete is false), `beelines_assigned_to_user` / `beelines_completed_by_user`, `user_avg_progress_pct` (progression), overdue count, practical/assessment metrics, and group memberships. `kpis` is COHORT-level over the SAME filtered population, so a headline number and the rows underneath always agree: `users_fully_complete_count` / `users_fully_complete_pct` (people at 100%), `avg_user_progress_pct`, `beelines_assigned_to_users_total` (0 means nothing is assigned, so a 0% completion rate there is "0 of 0", not a failure to finish work), and `group_fully_complete` for the cohort. `metric_definitions` in the response restates each field. Managers see only their managed groups. Args: group_id: Optional group to scope to (otherwise all your groups / whole org). include_descendants: If true (default), a group_id also includes learners in its descendant groups. page / page_size: Pagination (page_size max 100). search: Text search on name / email / phone. sort: 'name' (A-Z), 'completion' (highest `user_content_completed_pct` first), 'completion_asc' (lowest first, then lowest progression; people with nothing assigned last — the "who is furthest behind" order), 'progress' / 'assessment' / 'overdue' (highest first), or 'recent_active' (most recent first). Unknown values are rejected. overdue_only: Only learners with overdue items. tags: Group-tag NAMES to filter by, e.g. ['Kiosk'] — matches learners in any group carrying any of these tags. Get the vocabulary from `list_group_tags`. An unrecognised name is rejected (never silently ignored, which would return the whole org as if filtered). roles: Org roles to include, e.g. ['LEARN'] — multi-select. activity_window: '7d' / '30d' / '90d' for learners active within that window, or 'inactive' for those who have NEVER been active. progress_min / progress_max: Progression band, 0-100. assessment_min / assessment_max: Blended assessment-score band, 0-100. pa_status: Practical-assessment state — 'pending', 'failed', or 'complete'. exclude_managers: Drop managers from the population. membership_status: 'active' (default — current members only), 'revoked' (deactivated/expired only), or 'all'. Use 'all' or 'revoked' only for historical/audit questions; current-state reporting should stay on 'active'. include_contact: If true, keep emails/phones on each row. Default omits them — names and user ids are enough to identify people.

list_learners

List the questions of an assessment cell, in order. Each item has question_id, question_type, json_content, required, gradable, points. Use this first when editing an assessment — the question_id values are how you address questions in update/delete/reorder, and content_version is what you pass as expected_version. Returns an empty list for an assessment cell that has no questions yet. Args: cell_id: The assessment (ASSES) cell to read.

list_questions

List beelines in your workspace library. Use this to discover beeline IDs before using get_beeline_structure, get_beeline_metadata, or any editing tool. Args: search: Optional name substring to filter by (case-insensitive). status: Optional status filter — BACKLOG, DRAFT, REVIEW, PUBLISHED, ARCHIVED. page: Page number (1-indexed, default 1). page_size: Results per page (max 50, default 20).

list_beelines