TabTree

Lists every mind map, kanban, note and board in the TabTree library — the user's own and those of the team spaces they belong to (name, type, space, folder, size, last modified).

无需输入参数。

Reads one TabTree map. A mind map comes back as a markdown outline; a board as a list of elements and connections. `file` is a file name (or a map name) returned by list_maps. A 🗂 PROJECT (format projet) opens with a “🗂 Project” block before its outline: description, vision, mission; the objectives with their key results done/total; each epic with its Verdict (untested · testing · validated · invalidated), its cards done/total and its ICE; the live sprint — its number and name, its day (“day 9 of 14”) and last day if the root carries “Sprint length:” (and “Sprints start:” for the first one), its goal (the running sprint's goal, kept in the board's season — the 🎯 chip), committed / done / backlog counts, and the last closed sprint with its bets; then the Backlog ranked by ICE = Impact × Confidence × (6 − Effort) (a card without its own scores takes its epic's). Read this block before steering a project: to plan the next sprint, take the top of the ICE ranking up to about 6 committed cards, `move` them from Backlog to “To do”, set the goal with { op: "season", goal: … }, and settle a bet with { op: "attr", target: <epic>, name: "Verdict", value: "validated" } — all safe changes, applied by TabTree itself.

Searches text across the whole TabTree library — map names, nodes, notes, shapes, sticky notes. Case-insensitive.

Creates a NEW TabTree mind map from a markdown outline (#/## headings, bullet lists indented by 2 spaces, [x]/[ ] checkboxes, [title](url) links, and " @a:<id>" / " @e:<emoji>" at the end of a line for an illustration). The first top-level line becomes the centre. SCREENSHOTS: pass `images` — a list of { target, file } where `file` is the path of a PNG/JPEG on this machine (a screenshot you saved) and `target` the exact text of the node it goes on; the picture is re-encoded to fit and drawn as the node's cover. PROJECT — when the user wants to run a project, a product, a launch or a plan of bets (not a one-off mind map), create it with `format: "projet"`: one tree that holds the vision, the objectives, the epics as bets you settle, their cards and the sprints. TabTree recognises the first-level branches by their leading emoji. Write it like this (an attribute is its own line "Name: value"): # 🗂 <Project name> - Description: one sentence — what ships, for whom, why now - Vision: the world once it has worked, no numbers - Mission: what ships by when, with the one number that proves it - Sprint length: 2 weeks (optional — the planned rhythm) - Sprints start: 2026-11-02 (optional — the first sprint's first day) - 🎯 Objectives - O1 — the outcome, by a date - [ ] KR1 — a number with its target - 🧱 Epics - F · Foundations - Hypothesis: what we believe is true and justifies the epic - Goal: the number that settles it - Signal: the indicator, and where it is read - Verdict: untested (untested | testing | validated | invalidated) - Impact: 4 (optional, 1–5; with Confidence and Effort → ICE = Impact × Confidence × (6 − Effort)) - Confidence: 3 - Effort: 2 - [ ] F01 · a card, a deliverable in a few days @todo - 📚 Knowledge - [Company knowledge](map:<file>) - 📝 Decisions - 2026-10-26 — the decision, who took it, and the gate that reopens it Pass `columns` to put the cards on the project's

“Claude, plant me the project”: turns a project brief into a TabTree TREE in one call — the map drawn as a real tree, root planted at the bottom. Use it when the user wants to start, frame or visualise a project (not for a plain mind map). Extract from the brief: WHY it exists (it grows as roots under the ground), its RISKS (roots too — the higher the priority, the thicker the root), and its BRANCHES (the work streams), each with its TASKS. In the tree: an owner is a bird on the branch, a due date within 3 days makes it sway (overdue: a storm), a done task is a ripe fruit, a task in progress a green one. TabTree then diagnoses the project's shape and picks its SPECIES (a baobab when three branches carry most of the work, a fir for a long flat backlog, a cedar for a deep strategy, a palm for a small project already well along, a willow when it bends under overdue work, an olive for a slow patient yield, otherwise an oak) — tell the user which tree their project is, and why, using the sentence the answer gives you. Dates are YYYY-MM-DD; only set the ones the brief gives. Owners: a first name or an email.

Creates a NEW TabTree board (whiteboard): shapes (rect, ellipse, diamond, text, sticky), TABLES (kind "table" with `cells` — a comparison, a pricing grid, a RACI), IMAGES (kind "image" with a `file` path or an https `url` — your logos, photos, posters, placed where you say) and arrow connections that stay anchored to the shapes in the app. With no x/y coordinates, layout is automatic by level (the connections define the hierarchy, left to right). Good for a diagram, a flow, a brainstorm. In a flowchart use ellipse for start/end, rect for a step, and diamond for a decision — its text should read as a closed question with exactly two ways out. FIT THE TEXT TO THE BOX. A box shows roughly (w−24)/7 characters per line and (h−10)/20 lines, and every blank line costs a full line. Write captions, not paragraphs: when filling a canvas template (Business Model Canvas, Lean Canvas, SWOT…), the shipped templates use 70–110 characters per block, and that is what looks composed. Longer text is shrunk to fit — nothing ever spills out — but past ~11px it stops being readable and the response will warn you.

Creates a NEW TabTree kanban board in one call — columns and cards, each card with what TabTree shows on it: owner, start/due days, priority, colour labels, time estimate, Ai4X lever, note (links in it become clickable — a Google Meet link, a doc), a link, and sub-tasks. It opens directly as a kanban in TabTree, on every device signed in to the account, and in a TEAM space every member sees it. To add or move cards on an EXISTING kanban, use propose_changes instead.

Plans a whole PROJECT in TabTree from a brief, in one call, and lets the user build it with one click in the app. You write a blueprint: the work (each item human, agent or pair — an agent or pair item needs a deliverable and acceptance criteria), Build (project work) and Run (recurring) sides, epics, roles, milestones, and the systems the project needs (crm, launch, hiring, ops — each becomes a sheet + pipeline tab). TabTree creates an empty board named after the project and shows the plan on the user's library screen; the user adjusts the horizon, how much Claude takes, the systems and who holds each role, then clicks Build it. Nothing appears until TabTree is open on one of the user's devices. Never invent people, e-mail addresses, clients or figures: only names written in the brief. Work-item ids: a-z, 0-9 and _ only. Dates: "w1"… within the horizon, or a real day YYYY-MM-DD.

Changes an EXISTING mind map, kanban or BOARD (also one in a team space). ON A BOARD, target elements by the ids read_map shows (sh:2, im:7, st:0), or an image by its exact name: add_image { file | url | data, name, alt, x, y, w, h } or { ..., inside: "sh:2" } — placed below what that shape already holds, in centred rows, never overlapping, on top of the shape; with both w and h the image is FITTED into that cell with its proportions kept; add_shape { type, x, y, w, h, text, color }, add_text { x, y, text }, move { target, x, y } or { target, dx, dy }, resize { target, w, h }, label { target, name, alt } to name an existing image, arrange { target: "sh:2", images: [ids or names], w, h } to line images up inside a shape (omit images to tidy all it holds), and delete { target }. All but delete are applied by TabTree itself; delete waits for review. Sending the same add twice never makes a duplicate: images are matched by name, which defaults to the file's name. On a mind map or kanban, HYBRID, by design: SAFE changes — add cards or branches, move a card to a column, tick it, set its owner, dates, priority, labels, estimate, Ai4X lever, an attribute, a link, a comment, a picture, a ⭐ star for the user, the map's format, the running sprint's goal when none is typed yet (op season), and set up the columns of a board that has none — are APPLIED BY TABTREE ITSELF within seconds when TabTree is open on one of the user's devices (otherwise the next time it opens), and Cmd+Z undoes them. Changes that rewrite or remove what someone wrote — rename, note, delete, replacing existing columns, replacing a sprint goal someone typed, a persona re-cast — appear as a banner for the user to review and approve. In one call, the safe changes BEFORE the first review-only change apply by themselves and the rest goes to review, in order. Name each target node by its exact text, or by a path "Ancestor > Node" when the same wording appears twice; a later change may target a node added earlier

Keeps what matters from THIS conversation in the user's TabTree second brain: facts, decisions and lessons. Call it ONLY after you listed the items to the user in the conversation and they agreed — then once. Nothing is filed until the user accepts it in TabTree (a banner, on any of their devices). Use it when the user ends a conversation (thanks, "that's all", "ok bye") or right after a decision was made. Facts and decisions go to the "Company knowledge" map of ONE space (created if the space has none); lessons always go to the user's "🌱 Lessons" map in Personal. Never for tasks (use propose_changes or create_kanban). Never a password, key or token. If nothing is worth keeping, call it with nothing: true and tell the user so.

Fills the user's TabTree KNOWLEDGE BASE — the "Company knowledge" map of a space — with its objects: projects, products, topics, clients, people, the company and its brands, partners. Each entry gets a short DEFINITION (what TabTree's card prompts read as context), its other names and a few facts. Use it when the user asks to fill or update their knowledge base, for example from their second brain. An entry that already exists (same name or alias, any section) is UPDATED, never duplicated. Nothing is written until the user accepts it in TabTree: one banner per call, one click applies it all. 30 entries per call at most — send several calls for more. Never a password, key or token.

Reads ONE card of a TabTree kanban or mind map and returns the prompt TabTree's 🪄 builds for it — Role, Context (board, column, owner, dates, labels, the knowledge-base entries the card is about, relevant passages from the user's other maps in the same space), Task (the card, its spec, its acceptance criteria — and, when the reviewer sent the card back, their last request, first in the Context), Guardrails and Format (picked from the deliverable: spreadsheet, slides, email, code, research, document, plan). Use it when the user asks you to work on, do or prepare a card ("work on the card X"). Then do the work following that prompt, and send the result back with deliver_card. Read-only.

Reads the numbers of ONE TabTree kanban board, computed by the same code as the app's 📊 Dashboard and 🏁 Sprint panel: cards per column; the running sprint (day, goal) and its burnup — done / scope, scope change since day 1, the pace and whether it will finish on time, day by day; what is blocking (cards marked Blocked, waiting on an open card, overdue, or still for 3 days; columns over their limit; work per person); the flow over 30 days (cycle time, ageing work in progress, a forecast range, cards at risk of missing their due date, labels); and what agents carry. Use it when the user asks how a board, a sprint or a project is going, what is blocking, or when it will be done — then act on it with propose_changes. Read-only.

Sends your finished work on a card back to TabTree, ON that card, for the user's approval: the deliverable becomes a 📄 entry under the card (its note holds your result, in Markdown), with optional next-step sub-tasks, and the card moves to the board's review column when it has one (e.g. "🛂 To validate") — or to the column you name, never Done on such a board, never Won or Lost on a sales pipeline (a human moves it there). Nothing is written until the user approves it in TabTree — one banner, one click, Cmd+Z undoes it. Use it after card_prompt, once the deliverable is ready. Never put a password, key or token in it.