knav_app
ChatGPTApp-level metadata: id, slugs, region, counts, home scene, live URL, API header hint, integration flags, design/layout settings (theme, full width vs max width, sticky header, menu format), and the platform user-security settings (password expiry/reuse, account lockout incl. the configured-vs-ENFORCED distinction, inactivity timeout, IP allow-list, support access, Data Access Control presence/enforcement + any override that bypasses it). NOT knav_apps, which lists the apps registered on the account and supplies the app_id values.
knav_apps
ChatGPTList the Knack apps registered on this Knavigator MCP account (app id, name, status, verification freshness), the account's credit balance, and where to register more apps. Supplies the app_id every other tool takes; one call per session is enough. NOT knav_app, which describes ONE app's metadata and security settings.
knav_census
ChatGPTValue census of ONE key path across the app: every distinct value the key takes, with a count and example owners per value; for example, scenes[].views[].action with type form gives create / insert / update counts. Path segments: name, name[] (every array element), name[key=value] (only elements whose key equals value), * (every property). Target tables is a TABLE CENSUS in one call: every table view with its page, rows per page, whether users can change it (allow_limit), and its KTL _dr / _sth values (raw and parsed). Walks one path, so it is never capped by unrelated matches the way knav_grep is. To find WHERE a known value occurs use knav_grep.
knav_code
ChatGPTThe app's live custom JavaScript and CSS: whether each is stored and switched on, its size and SHA-256. Set lines ("5640-5790") or module (by banner comment) to read that code (CSS with css), numbered, exactly as written, nothing masked: 400 lines / 40 KB a call. Set calls to list every view-based Knack API call (view-based PUT, POST, GET, DELETE) with the facts needed to judge it against Knack's view-based API rules, such as the 7 Oct 2026 (week 41) change: line, method, how the call is made, the scene and view and whether the view is on that scene, the view's type and editing / adding settings, each field sent and whether it is editable on that view (with the reason), and whether it is a records or a connection-picker request; plus the app's "Restrict POST for View-based API" setting. A view chosen at run time is stated, with candidates only when traced. Commented-out calls are listed apart. It shows whether custom code is present and switched on; comparing hashes detects a change. For "check my apps for Knack's API changes", "will my custom code break on 7 Oct" or a Knack forum post about the change, calls lists the facts, once per app (knav_apps lists the apps), to compare with Knack's rules. knav_grep finds text only.
knav_conditional_rules
ChatGPTA field's own conditional (auto-set) rules: each rule's set-to value + trigger criteria, in builder order. Given an OBJECT, lists every rule-bearing field on it with rule counts, for "what gets auto-set on every save of X?". NOT knav_display_rules (which show/hide OTHER things based on it). For every setter of the field beyond its own rules (form inputs, inline edits, record rules, tasks) use knav_writes.
knav_display_rules
ChatGPTDisplay rules referencing a field: form/view display rules plus column conditional-format rules, with conditions. Rules that SHOW / HIDE / restyle OTHER things based on this field's value. NOT knav_conditional_rules (which auto-SETS this field's own value). Page-level rules are not included; knav_scene with rules:true returns them.
knav_editable
ChatGPTViews where a field is editable: the [Editable] form inputs and [Inline Edit] table columns. User-driven edits only. For every reference (not just editable ones) use knav_uses; for every mechanism that sets the field, including record rules and tasks, use knav_writes.
knav_emails
ChatGPTPer-object email count (== the Knavigator Emails tab), split by source. Set views to enumerate the senders (views and tasks, with subject, recipients and trigger); set app-wide to sweep EVERY object for an app-wide inventory. For the emails referencing a specific FIELD use knav_emails_using.
knav_emails_using
ChatGPTEmails that reference a field, with the roles the field plays (subject/body/recipient/criteria). One field in, its emails out: each email named with where it is sent from and the role the field plays in it. For an object's email count or its full sender list use knav_emails; for the field's non-email references use knav_uses.
knav_field
ChatGPTWhat a field is: type, object, connection, equation, settings, usage count. One field's definition and its usage total. For the itemized list of WHERE it is used call knav_uses; to compare usage across many fields call knav_rank; for what recalculates downstream of it call knav_ripple.
knav_formulas
ChatGPTEvery CALCULATED field on an object in one call: equations with their formula text, and count/sum/average/min/max aggregates (what they aggregate, over which connection, under which filters), plus the source fields each one reads. Answers "what recalculates on X, and from what?". Per-object catalogue. For the downstream chain from ONE field across objects use knav_ripple; for a field's own definition use knav_field.
knav_graph
ChatGPTConnection adjacency (no args), one object's graph + reachable set (from), or shortest path (from + to). No args = every object's outbound edges; from = one object's neighbours + everything reachable downstream; from + to = the shortest connection path. For a SINGLE object's own inbound/outbound list use knav_object with connections:true.
knav_grep
ChatGPTFull-text search of the RAW snapshot (recipients, criteria values, URLs…) with owning entity + JSON path per hit, plus the live custom JavaScript/CSS searched line by line (decoded). Case-sensitive unless i is set; capped at 50 locations unless all is set. Matches VALUES (recipients, criteria, URLs, choice text, messages); for resolving a NAME to an entity key use knav_search; for a URL census grouped by host use knav_hosts; for the distinct values ONE key takes across the app, with counts (e.g. every form action), use knav_census; to list custom-code API calls with their editability facts, use knav_code with calls.
knav_hosts
ChatGPTApp-wide external-host inventory: every http(s) URL in the raw snapshot grouped by host, with occurrence counts and the entities referencing it. Set urls to list each distinct URL instead. Capped at 50 rows unless all is set. For one known URL or host string with its exact locations use knav_grep.
knav_ktl
ChatGPTKTL keyword index. KTL (Knack Toolkit Library) keywords are underscore-prefixed directives such as "_hv" written into field and view descriptions to switch on custom behaviour. Lists all keywords in use (no target), the keywords on or targeting one entity, or every use of one keyword. Each hit names the keyword and the entity carrying it. An empty index means the app carries no KTL keywords.
knav_names
ChatGPTBulk id → name resolution: one tab-separated "key<TAB>name<TAB>context" line per id; unknown ids report per-line. Ids only, never names; to go from a name to a key use knav_search.
knav_object
ChatGPTObject summary (or every field / connection graph / views sourced on it, via flags). Summary by default; set fields, connections or views to get the full field list, this object's own inbound+outbound connections, or the views sourced on it (the same list knav_views returns for an object target). For the app-wide object-to-object graph or a path between two objects use knav_graph; for the app-wide object list use knav_objects.
knav_objects
ChatGPTApp-wide object inventory: one row per object (key, name, role flag, field & task counts) plus app totals. Set roles to list only the role (profile) objects. For one object in depth use knav_object. This inventory only flags WHICH objects are roles; for whether each role can actually log in use knav_roles.
knav_orphans
ChatGPTApp-wide ORPHAN census of what exists in the schema but nothing reaches: views listed on a page yet not placed in its layout (never render, still answer the view API), pages nothing links to (unreachable · detached), objects no view sources, fields whose connection or formula names something deleted, ids the live custom JavaScript/CSS names that the app does not have. Scope with views/scenes/objects/fields/code; set unused to add the slow every-unused-field sweep (the rank least census). For ONE view or page use knav_view / knav_scene, which report the same orphan facts. Each listed section is capped at 1000 rows here (counts stay exact; the cut is stated). unused is time-budgeted: on a large app it can be refused, and the refusal names the per-object alternative (knav_rank with least and object).
knav_rank
ChatGPTFields ranked by total usage: view/rule usage PLUS schema roles (object identifier, connection display field). Most-used by default; least flips the order, object scopes to one object, limit caps the rows. By far the slowest tool: cost grows with the app's field count and results are NOT cached, so every call pays the full sweep. On a large app (~2,500+ fields) the whole-app sweep does not fit in one request and is refused; object ranks one object's fields instead. limit does NOT reduce the work (it only trims the output). For one field's own count use knav_field.
knav_ripple
ChatGPTWhat recalculates, at ANY depth, when a field changes: the transitive recalc chain over equation/concatenation tokens and aggregate membership (aggregated field AND filter field), with cross-object hops labelled. knav_uses answers depth 1 (direct references); this walks every hop. knav_formulas is the per-object catalogue of calculated fields; this is the chain from ONE field, across objects.
knav_roles
ChatGPTPer-role access rollup: every user role, how many login pages name it (admittedByName, and which), how many open login pages there are (openLogins: limit off, they admit every signed-in role), reachable (= a named login or any open login), how often its profile key is referenced elsewhere (references), and where its NAME is used (nameReferences / byName: KTL [ktlRoles, ...] keyword options, quoted names in the custom JavaScript, roles the KTL config switches on such as bulkOps and userFilters). Set unreachable to list only the roles with no named login and no open login. Reachable = at least one login view admits the role. NOT knav_objects with roles:true, which is the plain list of role objects with no access analysis.
knav_scene
ChatGPTA page's path, live URL, builder link, login requirement, views, child pages, and page rules. Scope it with rules/views/children/entered-from when you only want one section; set diff to a second page to compare the two page subtrees view by view. For the whole page tree use knav_scenes; for one VIEW on the page use knav_view; for a data OBJECT use knav_object; for the app-wide census of orphaned views and unreachable or detached pages use knav_orphans.
knav_scenes
ChatGPTApp-wide page (scene) tree: root pages with recursive subtree page counts (portal sizing), page-level role restrictions annotated, + orphaned-parent-slug warnings. Set tree to expand the nested descendants under each root; set root to show one page's subtree and depth to limit how many levels are shown. For ONE page's details (views, rules, entry points) use knav_scene.
knav_search
ChatGPTResolve a name/slug fragment to field/object/view/scene keys (40-row cap; all lifts it, type narrows to one entity kind). Matches entity NAMES and slugs only. For searching raw VALUES (email recipients, URLs, criteria text) use knav_grep; to turn ids back into names use knav_names.
knav_task
ChatGPTA scheduled task's full config: schedule, when-conditions, field updates, email settings, field references. For the LIST of tasks on an object, or every task in the app, use knav_tasks.
knav_tasks
ChatGPTTasks on an object (== the builder's Tasks tab): name, action, run status, cadence. With no target: every task in the app, grouped by object, with run-status counts. For one task's full config use knav_task.
knav_uses
ChatGPTWhere a field is used (Used In / Depended On By / Depends On), grouped as the Knavigator screen groups it, entities named. Direct (depth-1) references only; for the transitive recalc chain use knav_ripple. Narrower neighbours: knav_editable = only where a user can CHANGE it; knav_display_rules = rules that show/hide things based on it; knav_conditional_rules = rules that auto-set its value; knav_emails_using = emails that reference it; knav_writes = every mechanism that SETS it.
knav_view
ChatGPTA view's source object, rule blocks (record/inline-edit/display/submit/action-link/column-styling), field references, emails it sends, each connection input's source filters and option limits in words (or none), and every place the custom code names the view (Code References, with each CSS rule block - full selector list, declarations, enclosing @media/@supports - and each JS line with 2 lines of context; facts only; it does not say whether the view is hidden). Form Fields show each connection input's source filters and option limits in words; "none" means every record is offered. Set rules-summary for rule counts only; pass diff=<view> for a clone-drift audit against a second view. For the OBJECT behind it use knav_object; for the PAGE it sits on use knav_scene; for the app-wide view census use knav_views; for every orphaned view or unreachable page app-wide use knav_orphans.
knav_views
ChatGPTApp-wide view inventory by TYPE: per-type counts (incl. explicit 0 for absent native types like report) + total; set type to list every view of one type (each row carries how many custom-code lines name the view). Given an OBJECT target, lists the views SOURCED on that object (type, page, connected-or-not), for the "which views expose object_N, and which can I read via the view-based API?" question. Set editable for the write-capability census of table views. For ONE view use knav_view.
knav_writes
ChatGPTWhat writes records INTO an object (form submits, record rules, action links, inline editing, DELETE links, tasks), or, given a FIELD, every mechanism that SETS that field (form inputs, inline-edit columns, record rules, tasks, its own conditional rules, custom-code API calls). Answers "where do records of X come from?" / "what writes this field?". Field mode is a superset of knav_editable (user inputs only): it also counts record rules, tasks and conditional rules. For READ references use knav_uses.