Start work internals
How the Start work box reads a request, and which model calls it makes. The user’s guide is Start work.
Where it lives
| Piece | File |
|---|---|
| The parse, the overrides and what’s still missing | apps/board/src/lib/start-work.ts |
The button and W |
apps/board/src/components/start-work/StartWorkButton.tsx |
| Dictation | apps/board/src/lib/start-work-voice.ts |
| The box (its own chunk, fetched a few seconds after the page loads so the first W opens it at once) | apps/board/src/components/start-work/StartWorkDialog.tsx |
| The breakdown prompt, its schema, the conversation’s rounds and checks | apps/server/src/functions/shared/start-work-core.ts |
| A study (Study it first, the Study intent) | onMachine('study') in StartWorkDialog.tsx; the recipe in db/migrations/20261110075452_study_recipe.sql |
A machine plan run’s ask tool and rule |
apps/agent/src/plan-clarify.ts |
| The plan function | start-work-plan in apps/server/src/functions/http-fns.ts |
| The team and project guess | apps/server/src/functions/shared/start-work-route-core.ts, start-work-route in http-fns.ts |
| The suggested title | apps/server/src/functions/shared/start-work-title-core.ts, start-work-title in http-fns.ts |
| The tour | apps/board/src/lib/ui-tour.ts, apps/board/src/components/tour/ |
| The mascot’s clips | apps/desktop/scripts/mascot-clip.mjs |
Two per-person preferences are kept in board_prefs: startWorkVoice (Listen as soon as it opens) and
startWorkPlanner (the Planner pill).
The parse
The parse runs in the browser on every keystroke, so the pills are instant and nothing leaves the page until Enter.
- Team and project: a name is taken only when the sentence points at it: after to, in, into, for, on, under,
written as
@winnable, or followed by team or project. “Add a winnable state to the game” stays a title. A one-letter typo in a name of five letters or more still matches, and so does the start of a name of four letters or more. A project named in several teams shows the teams to pick from. - Import: a request that starts with import, pull in or bring in; ticket keys or my issues next to a
tracker (from Linear), a later import or a leading sync or fetch; or ticket keys alone (
DRO-454). Otherwise those are words: “Add CSV import to winnable” is a card. Keys areABC-123; lower-case keys count only while importing. - Plan: plan, break it down, split it into, as an epic, or 30 words or more. A long request keeps its whole text as the card’s notes.
- Study: study at the start, or study it first or as a study anywhere. “Add a study mode” and “Case study page” stay cards. A brief whose first line asks for a study is a study.
- A request that mixes intents does one; the intent pill says which.
- Brief: 500 characters or more, or three or more lines of 30+ words. Only the first line is parsed for a team and project. A first line that only names the team leaves no title, so the title comes from the next line with words on it, up to three lines down.
- Project: only words that point at a project count (“this project” and “the project” don’t). Only planned, active and paused projects are offered, plus the team’s General.
- Agent and model (
wordAttrs): an agent or model the org offers, right after using, use, with or via, and only where its name ends the phrase (the end, punctuation, or a word like and, to, on, in): “using Codex”, “with Fable 5.2”, “using Codex and gpt-6”, but not “Add chat with Codex sessions”. A model is matched by label, id, Claude + label, or family alone (the org’s first of that family). They win over the guess’s agent and model, show without the guess tag, and their words come out of the title. A sentence is read whole; a brief only its first line. An import takes neither. - Template:
bug: …,[Bug] …, or… with the Bug template(also using, from, as a). The longest name wins. The card is made first, thencard_apply_templatefills it.
The model calls
Each call goes through the LLM client (apps/server/src/functions/shared/llm.ts) on the org’s AI backend: the org’s own key,
else the server’s, or a machine that serves model calls (AI backends). None of them writes
anything.
| Call | When | Sends | Model |
|---|---|---|---|
start-work-route |
the words name no team (and the board is filtered to none), or no project; or the text has a word that could name an agent, model, machine, recipe or priority | the first 2000 characters, the teams with their repositories, the projects with descriptions and five newest card titles | gemini-3.6-flash unless GEMINI_ROUTE_MODEL says otherwise |
start-work-title |
the box’s own title left out six or more of the request’s words | the first 6000 characters and the box’s own title | the same as the guess |
start-work-plan |
Plan it or Break it down with the Gemini planner | the text, the team’s and project’s names, and up to the last eight rounds | GEMINI_MODEL (apps/server/src/functions/shared/finish-classify-core.ts) unless GEMINI_PLAN_MODEL says otherwise |
The guess fills only empty pills, never a pill a person set or took off, never an ambiguous name, a new project or an import. A guess under 0.5 confidence isn’t shown. Without a key the box stops asking until it opens again.
The title call is told to keep keys, product, screen and file names, versions and error codes as written. The
function refuses a title that drops a ticket key, issue number, version or code the box’s own title has.
The plan call keeps no state: each round sends the last answer (the plan as the person left it), the answers and the changes. After Skip, plan it now, or once it has asked twice, the next answer must be a plan. A plan has up to 20 steps; the steps are created in one insert, and a write that fails part-way archives what was made.
A machine plan
The Agent on a machine planner adds a card with the org’s Plan recipe and starts its run. The ask tool and the
rule to ask at most twice come from the agent for a plan run (apps/agent/src/plan-clarify.ts), so the recipe, and
each machine’s approval of it, don’t change. Proposed steps are a step_proposals row until the person approves them.
A workstream from a plan
Accepting makes a parent card (the request) and children (parent_card_id, step_index), each blocked by the one
before through a card_relations row of kind blocks. Start it moves the first step into Working; the parent
never runs itself, and its move into Working starts the steps that wait for nothing (private.start_workstream).
