Reference

Glossary

In short

Wanigan, Drupal and WordPress each have their own words for things, and these docs use all three. Here each one is said plainly, with a link to the page that explains it.

On this page

A to C

Words from Wanigan itself, and from Drupal and WordPress, in alphabetical order. A word with two meanings gives both.

Acceptance criteria: What done means for a card, as a list of lines you can check. Only you tick or remove one; an agent may only add one (Cards).
Account: A folder your agent keeps its sign-in in. Each project chooses which Claude Code and Codex account its new sessions use; Gemini CLI has one sign-in (Accounts and models).
Action bar: The bar that floats above a part chosen on the page: Style, Move, Take out and Ask an agent (The action bar).
Activity: A project’s record of what happened and who did it: every claim, move and session, per project and per card (G then A).
Adapter: A small part of the site helper that saves words a plugin keeps where core cannot reach, through that plugin’s own public code, checking first that everything it calls is there (Plugin and builder adapters).
AI review: Claude Code checking a card against each criterion with read-only tools, backing each answer with a file and an exact quote that Wanigan then finds in the real file. Advice only (AI review).
Archive: Taking a card off the board for good. Only you do it; nothing is deleted, and the List still shows it (Send back, reopen, archive).
Attachment: An image or file pasted, dropped or picked into a session, a reply in Needs you or Talk to Wanigan. It is kept in Wanigan’s data folder, never in the project (Inside a session).
Base field: On Drupal, a field that a kind of content defines in code, such as its title, rather than one added in the admin. Its label is code, so Make real does not change it (What a refusal means).
Block (Drupal): A piece of a Drupal page placed in a theme’s region, or in a Layout Builder layout, such as a menu or a piece of text. The block library lists those the site can place (Drupal).
Block (WordPress): One unit of content in WordPress’s block editor, such as a paragraph, a heading or a navigation menu, stored as markup in a post, template or template part. WordPress keeps no id for a block, so Wanigan knows one by its place in that markup (WordPress).
Block binding: On WordPress, a block whose words come from somewhere else, such as a field of the post. Wanigan saves words shown that way into that field (What it saves).
Block style: On WordPress, a named look a block type offers, added to a block as an is-style- class. The component library lists them (The component library).
Brief: What Make it real hands an agent for a style or a token: the change, its element and why Wanigan did not make it itself, so the agent makes it in the theme’s own styles (Style edits as a brief).
Breadcrumbs: Above the code editor’s text, the file’s folders and where the cursor is, such as a PHP class or a Twig block, each with a menu of what is beside it. In the Inspector, the row of parts around the chosen one (An editor, not a text box).
Cache tags and contexts: Drupal’s record of what a cached part depends on: its tags say which data clears it when that data changes, and its contexts which variations, such as each user or each query, it keeps a copy for. The Inspector’s Cache shows both (Made by).
Can act: A paired phone’s switch in Settings › Phone. On, the phone can answer what needs you, start and type into sessions and move cards; off, it can only read (Phone).
Card: One piece of work on a project’s board: a task, bug, feature or idea, with a key such as NS-6, a description, acceptance criteria and a priority from P0 to P3 (Cards).
Checkpoint: A snapshot of the project folder Wanigan takes with git when a session starts and each time a turn ends, without touching your index, branch or stash, so each turn’s changes can be read alone (Turns, checkpoints and undo).
Claim and lease: A claim is a session holding the card it works on. It is a lease of 30 minutes, renewed while the session is alive; when the session is gone it lapses and the card goes back to Ready (The board’s rules).
Classic and block themes: The two kinds of WordPress theme. A classic theme builds pages from PHP template files; a block theme builds them from block templates and template parts that the Site Editor can change (Classic themes, text domains and child themes).
Command palette: On a Mac, ⌘K; on Windows and Linux, Ctrl+K: every view, project, card, session and command, found by a few letters of its name, each with its key (The command palette).
Compare: Lays a page of your local site over the same page on a hosted environment, at one width, and boxes and names every difference (On a Mac, ⇧C; on Windows and Linux, Shift+C) (Compare Local with Live).
Component library: Everything a site’s core says it can place, each pictured alone in the site’s own theme, with where the site uses it (On a Mac, ⇧B; on Windows and Linux, Shift+B) (The component library).
Configuration and configuration import: On Drupal, configuration is what the site keeps as settings rather than content, such as a block’s title, the site’s name or a view’s text. A configuration import puts back what was exported to files, so Wanigan says when a word it saves there would be undone by the next one (Configuration).
Connectors and abilities: WordPress core’s AI Client reaches AI providers through connectors, each set up with a key or not; abilities are what plugins have registered with core, each with a name, a category and hints such as read-only. The Inspector lists both, never a key (The site’s AI).
Core: Wanigan’s core is the background process that keeps the database and runs every session, so sessions outlive the window (The core that keeps running). Drupal core and WordPress core are the platforms themselves, as opposed to the modules, plugins and themes added to them.

D to H

Decision: A rule for a project, such as “Use pnpm, never npm”, told to every session that starts there (Pause and Decisions).
Demo: A second Wanigan with sample projects, Northstar Storefront and Fieldnotes among them, stand-in agents and its own data folder; nothing real is touched and no model is called (Try the demo first).
Design layer: Where Wanigan keeps what you type or style on the page before the site has it. The page goes on showing it, reload after reload, while the site stays exactly as it was (The design layer and Edits).
Dock: The panel beneath the work, closed until you open it: Code, Notes, Problems, Request and DevTools in the live view, and the code editor in any project (The dock).
Draft: An edit in the design layer that the site does not have yet (What each state means). On Drupal, a draft is also a newer version of content that visitors do not see yet; Make real never saves over one.
Draft with Claude: In New card, Claude Code turns a rough note into a card with a clear title, a description naming real files and checkable criteria, reading the project read-only. Nothing exists until you create it (Draft with Claude).
Edit anyway: The code editor’s button for changing a file it opened read-only, such as Drupal core or a vendor folder, once you mean it (Someone else’s code).
Edit target: Something the site helper says can be changed where it shows, such as a field of one item, a block’s settings or a menu link, with how: the site’s own form, or a small form the helper checks and saves. Edit ▾ › In the site lists them (Design).
Entity: Drupal’s word for a stored thing with fields, such as a piece of content, a term, a user or a media item. Wanigan names the part showing one by its type, UUID and language (How an edit names its element).
Evidence: What shows a card’s work is done: a file, a link or a note. A card reaches Review only with evidence, from the agent or from you (Done means checked).
Field: One piece of stored data on a Drupal entity or a WordPress post, such as its body, a price or a custom field. Make real saves words into the one field that holds them (Make real).
Fragile: Said of a design-layer edit whose element no part of the site names, so it is kept only by where it sits in the page. Wanigan says so before you make it (Fragile elements).
Go to: The live view’s address field: any page of the site from a few letters of its title, an admin page, a path or an id (On a Mac, ⇧Space; on Windows and Linux, Shift+Space in the live view, On a Mac, ⌘⇧Space; on Windows and Linux, Ctrl+Shift+Space anywhere in a project) (Go to a page).
Hidden or lookalike characters: Characters that make a command read differently from what runs: control characters, invisible ones, ones that reorder text, unusual spaces and lookalike letters. A permission row in Needs you spells each out, such as ⟨U+202E⟩, with a warning (Hidden and lookalike characters).
Hook: An agent’s hooks are the events it reports, such as a turn starting or a permission asked, which tell Wanigan a session’s state (How a session reports). A Drupal or WordPress hook is a point where modules, plugins and themes run their code as a page is made; the trace times each one.
Hosted environment: A copy of your site on a host, such as Dev, Test or Live, found in the project’s files or added by you. Wanigan shows its pages read-only and never sends it the helper’s token (Local and hosted environments).
How this works: A button on many views that draws the view’s rules as lanes of boxes, with this project’s live numbers (How this works).

I to M

In the site: Saved by the site itself, through its own core, as you. In Edit ▾ it groups the changes saved that way; in Edits, “In the site, not verified” is an edit made real that Verify has not checked yet (What each state means).
Inbox, Ready, Working, Review, Done: The board’s five columns: what agents filed, waiting for you to accept; accepted work; cards a session holds; work submitted with evidence; and what you approved (The columns and their rules).
Inspector: The panel on the right of the live editor for the part chosen on the page: Design (what to do with it), Made by (what made it, and whose code that is) and Data (what it holds) (The Inspector).
Jev: TypeSafe’s decision model, which reads each new card once you give it a key: what to do with it, how much it matters, whether it repeats another. Advice, unless a project lets it accept confident cards (Jev).
Key frame: A still picture from a recording, at a click, a new page or an error, up to eight of them. An agent gets the key frames, never the video (How key frames are chosen).
Kind: What sort of thing a part is, as the site says: a component, a template, a field, a block. A style for every one of its kind reaches every part made the same way, such as every Card component (One element, or every one).
Layers: The tree of a page’s parts in the live editor’s left panel, named the way the site names them (Layers).
Layout Builder and inline blocks: Layout Builder is Drupal core’s way of laying a page out in sections and regions. An inline block is a block made for one layout and not reusable elsewhere, so Make real saves its words through that layout (What each platform saves).
Lens: A way to colour the page by owner, cache, cost, what can be edited or what just changed (On a Mac, ⇧L; on Windows and Linux, Shift+L) (The layout).
Live view: Your local site inside Wanigan, in each project’s Live tab, following the agents as they work. Off until you switch it on (The live editor).
Local model: A model that runs on your Mac, through LM Studio or a running Ollama or NVIDIA PAIR, so prompts and code go to it rather than to a model provider (Models on this computer).
Make it real: Saving an edit from the design layer through the site’s own core, as you, into the one thing that holds those words. A style or a token goes to an agent as a brief instead (Make real).
MCP and wanigan mcp: MCP, the Model Context Protocol, is how a coding agent is given extra tools. wanigan mcp is Wanigan’s own MCP server, handed to every agent session: eight read-only tools for looking at the project’s local site (wanigan mcp).
Module: An extension that adds features to Drupal. On Drupal the site helper is a development-only module, wanigan_live (The helper module).
Must-use plugin: A plugin file in wp-content/mu-plugins that WordPress loads by itself on every request, without activating it. On WordPress the site helper is one, wanigan-live.php (The must-use plugin).

N to R

Narration: What you say while the live view records, put into the recording’s step log at the moment you said it, so an agent gets your words with the key frames (Narrate as you record).
Needs you: Wanigan’s home: one ranked list of everything waiting on you, from every project, such as a permission prompt, a card ready for review or an agent’s question (G then N) (Needs you).
Noise floor: How much a page differs from itself between two renders, as two numbers: the largest colour difference and how many pixels differ. Verify passes an area only within it (The noise floor).
Note: Words for an agent about a part of the page, with a picture of it; notes wait in the dock’s Notes tab and go as one message (Notes across pages). On a card, a note (wanigan note) is a comment that renews its claim.
Notification tray: The bell in the rail: everything the status line said, newest first with its time, and news about updates (The window’s parts).
Orphaned: Said of a design-layer edit whose element is gone or now shows other words. It is set aside, never put on whatever is there now, and becomes a draft again once its element is found (When an edit loses its element).
Override: A copy of someone else’s template, core’s or a contributed project’s, in your own theme, which the site then uses instead, so an update cannot lose your change (Made by). For a pattern override, see pattern.
Paragraphs and Layout Paragraphs: Paragraphs is a Drupal module whose items, paragraphs, belong to the page that holds them and are kept as versions of it; Layout Paragraphs is a builder for arranging them. Make real saves a paragraph through its page, and not while that builder is open (Paragraphs).
Part and part identity: A part is one piece of a page as the site made it: a template’s output, a component, a field, a block. Its identity is what the site stores it as, such as an entity’s UUID and field, so it is found again after a reload or a reorder (How an edit names its element).
Pattern, synced pattern and pattern override: On WordPress, a pattern is a ready-made group of blocks. A synced pattern is saved once and shown on many pages, so its own words change everywhere; a pattern override is words one placement of it keeps for itself (Words shown beyond this page).
Pathauto: A Drupal module that makes a page’s address from values such as its title, so a save that changes the title can move the page; the live view follows it (Make an edit real).
Pause: A project’s switch for no new sessions or claims; live agents can be asked to wrap up, and nothing running is stopped (Pause and Decisions).
Pin: In Running, marks a session to keep on Watch, up to twelve (Running and Watch).
Placement: Where something is put on a site: a Drupal block in a region, a component in a layout, a WordPress widget in its area, a synced pattern on a page. Take out removes only the placement, never what it showed (Take one out).
Preprocess: On Drupal, a function a module or theme runs to prepare a template’s variables before it renders. The trace shows each one, timed, with what it changed (The trace).
Project and project key: A project is a folder you open, usually a repository, with its own board, sessions and history; Wanigan writes nothing into it. Its key, such as NS, comes from its name and prefixes its cards: NS-6 (Projects and keys).
Project bar: The bar across the top of a project: its name (a menu with Project settings…), its views, what is running, and Pause (The window’s parts).
Prop and slot: What a component takes: a prop is a value, such as an address or a choice of look, and a slot is a place for other content, such as a picture (Props, slots and files).
Proven and not yet proven: Whether a local model and an agent have been seen working together: a real turn with a tool call, read back from Wanigan’s own record. A model not yet proven may not use tools reliably (Proven or not yet proven).
Rail: The narrow column down the window’s left edge: Needs you, Sessions, your projects as tiles, search, notifications and Settings (The window’s parts).
Reach: How far a change goes: one element, one item shown twice on the page, every one of a kind, every page that uses a template, or the whole site. Wanigan says it before saving anything shown beyond this page (Reading an edit).
Read-only file: A file the code editor opens without letting you type, such as Drupal core, a contributed module, a vendor folder or WordPress itself, because an update would lose the change (Someone else’s code).
Recording and step log: A recording is up to two minutes of the live view, from its own frames. Its step log lists each click, key, scroll, page, console error and failed or slow request, and never what was typed in a password field (Record the page).
REST API: The web interface WordPress and its block editor use to read and save content. Wanigan saves WordPress words through it, as you (What it saves).
Revision: An earlier version of content that Drupal or WordPress keeps. Make real saves with a new revision where the site keeps them, so the old words can be got back in the site’s own editor (Make real).
Running: Every live session in every project, grouped by project, as a List or on Watch (G then R) (Running and Watch).

S to T

Saved view: A board’s filter, card types, priority, agent and order, saved under a name; 1 to 9 on the board apply them (Board and List).
Session and one-off session: A session is a real terminal running Claude Code, Codex, Gemini CLI or a shell in the project’s folder, inside Wanigan’s core. A one-off session has no card, for quick work, and can be made a card later (Sessions).
Single-directory component: A Drupal component kept in one folder: its Twig template, and a .component.yml that names it and declares its props and slots (The component library).
Site helper: An optional add-on, a Drupal module or a WordPress must-use plugin, that Wanigan writes into your local site on your click. It tells Wanigan what made every part and lets it save through the site’s own core (The site helper).
Site Editor: WordPress’s editor for a block theme’s templates, template parts and styles. A change to a theme’s template makes a copy of it in the database, as the Site Editor does (What it saves).
Skill: A folder of instructions an agent can use, described by its SKILL.md. Settings › Skills lists every skill your agents can see (Skills).
Snap: A picture of the live view or the whole page that you mark up with boxes, arrows, highlights, labels and blurs, and send to an agent (On a Mac, ⇧S; on Windows and Linux, Shift+S) (Take a snap).
Stand-in: A made-up program or site that behaves like the real one, for the demo and the tests: stand-in agents, a stand-in ddev, a stand-in WordPress. The docs say so wherever a stand-in is all something has been tested with (Honest status).
Status line: One line at the bottom of every view: the latest outcome, the tour compass, the keys and Talk to Wanigan; in the live view, what just happened and the mode you are in (The window’s parts).
Stored-words search: When nothing on the page offers to edit some words, Wanigan looks where the content keeps them, such as a post’s stored content or a custom field, and saves them there through core, only if they are found exactly once (How the stored-words search works).
Talk to Wanigan: The round button at the end of the status line: ask what needs you or what the agents did, and Claude Code answers from Wanigan’s records, using a turn of your plan (Talk to Wanigan).
Template part: On WordPress, a reusable piece of a block theme’s templates, such as its header, kept in the theme’s files or, once changed, in the database (What it saves).
Template suggestion: On Drupal, a more specific template name core looks for before the general one, such as node--product.html.twig before node.html.twig. Made by lists the ones a part could have used, most specific first (Made by).
Text domain: On WordPress, the name a theme or plugin gives its translatable strings; a translation file can change a string in it without touching code (Classic themes, text domains and child themes).
Theme hook: On Drupal, the name a template is registered under, which Twig debug prints beside it. Made by shows it for a template (Made by).
Token: A value a theme names once and uses everywhere, written as a CSS custom property such as --color-accent; changing one in the design layer changes it for the whole site (A token for the whole site). A session’s tokens are something else: what its conversation used (Tokens).
Tour: A short walk through a view that points at each part and says what it is for; each view offers its own the first time you open it (Tours and How this works).
Trace: What the site helper records as a page renders, through core itself: the template, suggestions and hooks behind every part, timed, with its variables, cache and queries (The trace).
Turn: One exchange with an agent, from your message to the end of its answer. Wanigan checkpoints the folder at the end of each turn (Turns, checkpoints and undo).
Twig and Twig debug: Twig is the template language of Drupal themes. Twig debug makes Drupal write comments into the page naming the template behind each part, which is how the live view names parts without the helper (Without the helper: Twig debug).

U to Z

Verify and verdict: Verify renders the page with and without the design layer at 390 and 1440 px and compares them, every edit on one element together. Its verdict says in sentences whether the site now shows what you designed, and where not (Verify, and reading a verdict).
Verified: The state of a design-layer edit whose verification passed: the site renders it as designed (Reading a verdict).
Watch: Running’s second layout: up to twelve live terminals at once, those that need you most first. A tile never resizes its session (Running and Watch).
Webform: A Drupal module for forms. Where it is installed, Make real saves a form’s own words through Webform’s own code (Webform).
Widget and Inactive widgets: On WordPress, a widget is an item in a theme’s widget area, such as a sidebar. Inactive widgets is where WordPress keeps widgets taken out of every area, settings and all, and where Take out puts one (Moves, inserts and Take out).
Workflow: On Drupal, the states content moves through under content moderation, such as a draft before it is published. A save through Make real checks the workflow’s rules before and after (The rules every save follows).
Worktree: A separate checkout of the same git repository, on its own branch. A card can work in its own, kept in Wanigan’s data folder, so agents on different cards never share files (A branch for each card).
wl: comments and data-wl-* attributes: The marks the site helper writes into the page’s HTML while the live view is on, so Wanigan can find each part:  comments and attributes such as data-wl-field (How it answers only the live view).
X-Wanigan-Live: The header every request from the live view carries, with the helper’s key. The helper acts only for requests that carry it, so the site looks the same in any other browser (How it answers only the live view).