# Tasks & Projects

Route: /projects · Status: changing · Checked against code: 2026-10-22 67bcbaca

Tasks is where your work lives. It is not a flat to-do list: a project is a part of your
life (a job, a product, a move), and it holds branches, sections, tasks and steps. Focus is
the short list of what you are working on now, and each project remembers what was decided,
what is still open and where you stopped.

## What you see

Three views at the top:

- **Focus** — one calm column at /focus. At the top, one chip picks the project Focus shows
  (*All*, or a project with how many of its tasks are in Focus); the choice is remembered.
  Then the task you are on, as a single card — its branch and step, its result, the steps,
  up to three saved materials *For this task*, **Start session** and **Done**, and a field
  to drop a thought. Under it *Next* (the rest of Focus) and *Could take* (up to three tasks,
  each with its reason). No side panels and no daily limit.
- **Projects** — «Проекты N» and **+ New**, then the cards three to a row (mockup 2-1).
  A card is the project's dot and name, what it is for («ради …», or «без конца · сфера»)
  and one line of where it stands: OnePuls's summary, else the last thing done, else what
  the project is about. When something in the project (with its branches) waits for you,
  that line becomes one **waits for you** line instead, the most important thing first, then
  «ещё N»: an agent's question (*Codex ждёт ответа* — amber dot, bold, the agent's logo; a
  click opens the project on its **Inbox**), work handed in by an agent or an AI over MCP
  (*Claude Code сдал · проверь*), your own passed deadline (*Срок был вчера · эссе*, grey with
  a calendar, never red), a task someone gave you in a team project lately (seven days — there
  is no «when given» field). Ordinary Inbox items stay in the Inbox; nothing else is coloured.
  *No project* is one more card while it has open tasks; the
  **Inbox** chip shows thoughts that fit no project; the **On hold** box keeps the projects
  you packed away. The project tree panel shows only inside a project. «All tasks» opens
  from Focus («все задачи»).
- **All tasks** — every task in one list with search, filters, project chips and bulk
  selection, grouped into Overdue / In progress / To do / Done.

Inside a project:

- The header: the project's colour and name (a branch shows its parent first), *your AIs
  that write here* (their logos — those you allowed to write over MCP), a lock when the
  project is closed to AI, and **+ Task**. Under the name, one line: *About the project ·
  for: its goal* — click the words to edit them right there. There is no **⋯** menu: what
  it held lives in **Settings**.
- Tabs: **Overview** (where it stands), **Tasks** (*List* or *Month*, mockups 3-04 / 3-06),
  **Ideas** (*Path* — the project's steps with ideas on them — or *List*; see
  [Ideas](ideas.md)), **Notes** (with a **Materials** filter — the links saved in the
  project), **Atlas** (a map of the project), **History** (everything that happened),
  **Inbox** — only while the archivist has left something for you to decide — and, on the
  right, **Settings** (also linked at the bottom of the Overview).
- **Settings** has five cards. *Project*: name and colour, *About*, the goal (from Goals),
  where it sits with **Move…**, and **Open-ended** — an area of life (Health, Home) with no
  *What next* on its Overview. *AI*: who of your own AIs (Claude, ChatGPT, Cursor over MCP)
  may see the project — *Closed*, *Read only*, *Read and write* — and one switch per connected
  AI (*Can't see / Reads / Writes*, never above the project's level); the project's AI
  helper, if you have one; **Instructions for AI**, which your AIs get with the project; and
  **Brief for an AI without access** (copy it, or download the whole project as .md).
  *Team*: «for now the project is yours alone» (making it a team comes later). *Move*: the
  apps it came from, with **Undo the move…** — only for a project a move brought. *Put away*:
  **For later** and **Delete** (the window says what goes: tasks, branches, History; notes,
  ideas and Atlas boards stay without the project).
- **Sort later** in the projects panel: links saved with no place yet. The row shows only
  while something lies there.
- **Notes** is a slice of the project's notes, not an editor: cards with pinned notes first,
  then the latest. A journal (a note kept as dated entries, «13.10 — …») shows its newest
  entries; every card says who wrote or last changed it and how many History records mention
  it. A card opens the note in Notes; **All notes** opens Notes on this project. The **Materials**
  chip shows the project's saved links instead of the cards.
- **The path** (stage A, mockups `projectUI.pen` § 8). A project may have a path — its stages in
  order, each *ahead*, *here*, *done* or *dropped*, a stage with up to one level of smaller
  steps. The path is a draft that changes as you go, not a plan to follow: the plan and the path
  are one thing. The **Overview** opens with it — the stages as a line («2 из 5»), *you are
  here* on the stage with the freshest work, and the card of that stage: its tasks, decisions,
  dead ends, tools, result and time, only what is not empty, «done when» if you wrote it.
  **Tasks** shows the stages as its sections, with their state and progress. A project without
  a path looks as before.
- **History** is everything that happened, newest first: search (by words, and by meaning —
  a Russian question finds an English record), kinds on a row (*All · Done · Decisions · Dead
  ends · Tools · Results*, more under *more ▾*), and *Stage · Topic · Who · Period*. *Main* by
  default, *All* adds the service steps (a stage added, renamed, finished — every path change
  is a record). A record is shown in your language; *translated from EN* shows the original.
  **Correct** changes a record's kind, stage or topics — never its words.
- **Pour it out** (*Выгрузить*, on **Tasks**): one box for everything about the project, in as
  many messages as you like, over hours, typed or dictated; nothing goes to work until **Sort
  it out**. Then *Laid out like this*: tasks by stage, each with its package — why, your words
  verbatim, done when, depends on, where in the code — checked against the tasks already there
  (*add to it*), and who does it: you, a person in the project, an agent, an AI. **Yes, lay it
  out** writes them; **Undo** takes them back.
- **Atlas** is a preview: a live mini-map of the project's main board (the one changed last),
  who drew it — you, OnePuls, or your own AI by its logo — its other boards, and a phrase to
  give your own AI («Draw in PulsOne Atlas …») with **Copy**. **Open** goes to the canvas. With
  no board yet: **Create a board** starts one from the project's sections, tasks and ideas.

With no projects yet, the page offers two ways in: **Tell OnePuls** (talk the project through)
and **Move from…** — the move from other apps at `/projects/move`. On *What we take*, **Path and
ideas** — **Draft the path** lays the ideas the move brings (and the old tasks going to Ideas) on
the steps OnePuls drafts, or aside; an empty step is said plainly; the path comes with the move
and goes with **Undo the move**.

## How to use it

1. **+ New** → **Tell OnePuls** (the default): say or type what is on your mind — one thing
   or several. OnePuls checks it against the projects you have and answers *Here's what I
   got*: a card per thing — a **new** project (goal, branches, first *Do* / *Find out* tasks,
   open questions), **add to** a project you already have (goal *was → now*, new tasks),
   **already there**, or **not sure** (an idea by default, or a branch, or a project of its
   own). When the story has an order of work, a new project comes with a **path draft** —
   3–5 stages, *from your story*; drop it or change it, it is yours. Untick, edit, press
   **Create**; **Undo** in the toast takes all of it back. While it
   works you can **Minimise** — *Ready* comes to the Island. The other choices: **Move
   from…** (another app), **Empty project** and **From a template**.
2. **New task** → pick *Project › Section*, write the name, add steps (Enter for the next
   one), mark it important, give it a deadline or put it in Focus. Quick syntax works:
   `call the bank tomorrow #finance !important`.
3. Open **Focus**, pick the project, take a task, press **Start session**. The card turns
   into the session: a big timer, the steps with *now*, and a field for stray thoughts with
   the ones you already dropped. **Pause**, **Finish**, and *then a 5 min break ▾*. Lengths
   of the session and both breaks are behind **⋯**. **Session without a task** runs the same
   timer with nothing attached.
4. After the session, look at the review: what got done, where your thoughts went, and what
   OnePuls suggests. Apply what you agree with. Closed the tab, or ran the session from the
   island or the phone? The summary comes by itself — **Last session's summary** in Focus and
   a row in *Waiting for you* on My Day; **Continue** or **Got it**.
5. Coming back after a while? Open the project's **Overview**, or **Full project history**
   from it.
6. A lot in your head about one project? **Tasks → Выгрузить**, pour it all out, **Sort it
   out**, check the cards, **Yes, lay it out**.

## How it works

**Structure.** Project → branches (sub-projects, one level deep) → sections → tasks → steps.
A branch is part of its project and moves with it. A project may hold only notes and still
be a real project. Steps are counted on their task, never as tasks of their own.

**Focus is not a date.** Putting a task into Focus or taking it out never touches its
deadline. A task set to *in progress* anywhere is in Focus automatically. It stays there
until you finish it or remove it.

**Sessions.** The timer lives inside Focus (the old Pomodoro page opens Focus, and a session
that was running keeps running). A focus session records its real minutes; a task shows how
many sessions and minutes went into it. While a session runs, the head shows *today* and
*this week*. Every fourth session of the day is followed by the long break unless you choose
otherwise. When a task has not had a session for a few days, its card opens with
*Where you stopped* — a line OnePuls writes and you can correct.

**The session summary** (stage B). Every session gets one, a session without a task too: its
minutes and what got done in its time — steps and tasks closed, materials saved, what your own
AIs did over MCP — read from what PulsOne recorded, never asked for; and *Where you stopped*.
Another session on the same task (without a task — the same project) within two hours adds to
the same summary: «50 min · 2 sessions». When something got done, one progress record goes into
the project's History. Nothing to fill in.

**The session feed** (stage B, desktop app on Windows only). With **Feed** switched on next to
*Done*, the app notes which programs and windows you worked in while a session runs — *Feed is
recording · steps stay on this computer*, with *Pause feed*. The steps never leave the computer
(encrypted, erased after 7/30/90 days). After the session its feed waits in Focus: remove any
row, then **Send** — or it goes by itself in ~10 minutes; **Leave the feed out** drops it.
OnePuls then writes a short **Summary** and **Details** (the work told by its parts) into the
session's summary; you can **Edit** them or ask OnePuls to add to them. The team never sees it.

**What to take next.** One rule for the project's *What next* and for Focus: in Focus,
deadline within a week, the task you touched last, in a starred branch, in progress. Focus
also names quieter reasons — *quick*, a later deadline, an open question. When nothing of
the chosen project is in Focus, Focus offers one task with its reason and **Take and start**.

**Materials.** *For this task* shows up to three saved links: those saved on the task first,
then the project's ones that match it by words. **Not it** hides one under this task for good.
Links the Telegram bot is still asking about are never shown.

**Thoughts find their place.** There is no Backlog to tend. Anything you capture — in the
Island, in Focus, during a session, in its summary, or from OnePuls and your own AI — goes to
the archivist, and it files the thought by itself: decisions, questions and thoughts become
History, ideas go to the project's **Ideas**, and something to find out becomes a *Find out*
task. It first decides where the thought belongs across *all* your projects. Thoughts from a
session wait about ten minutes before they are filed, so you can change where they go;
everything else is filed every 15 minutes. Each thought shows a label like *idea · PulsOne ›
Marketing*; click it to move the thought. Ideas go further — a piece of an idea you already have,
or a new idea on its step; the session summary's **To ideas** shows where each went, with **not
that** (see Ideas).

**Inbox — only what the archivist could not settle.** A project's **Inbox** tab appears with a
count when something waits, and disappears when it is empty. Three kinds of rows, each with
where it came from (a session, you, OnePuls, Claude, ChatGPT…) and when:
*not sure where* (pick one of 2–3 places, then *Accept · Not needed · Later*), *decisions
disagree* (a new decision contradicts the one in force — *Keep … · Replace with the new one ·
Later*; an AI never overturns your decision on its own) and *looks like a duplicate* (two open
tasks — *Merge* makes the newer one a step of the older, nothing is deleted; *Keep both*).
*Later* hides a row until tomorrow. Every settled row leaves a service step in History
(visible under *All*); the tab shows *Sorted today: N → to History*. There is no input field.

**Suggestions, never silent changes.** From what you said, OnePuls may suggest a step, a task
or an idea — with the reason — in the session review and on the Overview. Nothing changes
until you press *Apply*, and *Undo* is right there. Tasks untouched for 60 days, with no
deadline and no open steps, are listed as *Not touched in a while* — a rule, not the AI.

**The project's memory.** The **Overview** is the snapshot (mockup 3-01), in white cards:
*Where you are* — OnePuls's summary in large type, the line that changed since your last look
marked, «you were away 3 days», «updated by OnePuls · 09:12 · versions» — with the project's
History under it (*Main / All*, «2 new since last time», five steps that open into why, was →
became and how it was done, *All history*); *What next* — up to three tasks with their reason,
the first one starts a session right away; *Open questions*, answered right there or taken into
work as a *Find out* task; OnePuls's suggestions to the plan; *Branches* with ★ and «2 in Focus
· yesterday». Your last look is remembered on this device (`src/lib/projectSeen.ts`).
**Team day** (stage B, B6; mockup `DtInb`) opens the Overview of a shared project: *Today ·
Yesterday · Week*; links between people one line each, only when there is one — two in the same
stage, an agent waiting for an answer (**Answer** opens the task), someone's open question; then
a card per person or AI with only the lines that are not empty — *Did* (closed tasks and steps by
stage, credited to whoever closed them — `tasks.completed_by`, set by the database — else the
assignee, else nobody), *Decision* (from History, with the reason and time), *Result*, *Asked* (an agent's
question and the answer), *Stuck*, *Next* (the next open step of the task worked on last) — and
the time from focus sessions on this project. Built by rules from rows the team already shares;
the minutes come from `project_team_day`. Admin and manager see everyone; a member sees only their
own card, and your card says «how the team sees you». **More detail** on a card asks OnePuls to
connect the same lines into a few sentences — from those lines only, shown in the card, not saved.
The session feed and private thoughts are never shown.
**History** is the one feed of what happened. All of it is selected from what was actually
recorded — your words, closed tasks, settled hypotheses — the screen never invents a sentence.
What your own AI wrote into the project over MCP is there too, under its name and logo: a note
it made (*Main*), a note it changed and a task it added (*All*), its questions and the answers
they got — read from the write receipts (`aiWritesIn` in `src/lib/projectSpine.ts`).
Find what you need with the search (by words for now — by meaning comes with stage A's backend)
and the filters: kind (*Done · Decisions · Dead ends · Tools · Results*, the rest under *more*;
a kind with nothing in it is not offered), *Who* and *Period*; picking a kind shows all of it,
not only *Main*. When the project has stages (stage A, `docs/stage-a-data.md`) there is also
*Stage* (with its smaller steps) and *Topic*, each row says its stage and topics, a record written
in another language shows in yours with *translated from EN* (click — the original), and
*correct* fixes its kind, stage or topics — never the text (`src/lib/historyFilters.ts`,
`src/lib/historyEditApi.ts`; the correction is bench-only until the migration).
**Build a report** in History's header opens a wide window (mockup 3-03): on the left the
brief — period (week / month / your own dates), for whom (myself / client / manager / team),
what to include (done, decisions and why, what's next, open questions, time and sessions, how it
went), tone and length, and your own request with *+ deadlines*, *+ risks*, *+ no numbers*; on
the right a white A4 sheet. Nothing is written until you press *Build*: OnePuls then writes the
sheet live from the History's records for the period. Change the brief and *Update* takes the
lead («brief changed»); the sheet as it is can still be downloaded. *Download* saves a PDF or a
.md. *Save the
brief as the «Client» template* keeps the brief for that audience — picking it next time fills
the brief in. The report is not stored; nothing is written into History.

**Materials.** A saved link — a video, an article, a reel, a post, a file — lies where you
saved it: on a task, on a project, or on the shelf *Sort later*. In an open task, **+ material**
→ paste a link → **Save**: the type and the app show at once, the page's own title comes back
with the saved link. A project's Notes tab has a **Materials** filter: the project's links, its
tasks' and its branches', grouped by type, each with the place it lies on; **⋯** moves a link
(to the task in Focus, a project, *Sort later*) or removes it. In the Island, a bare link — or a
link with a few words and no question — goes to *Sort later*; a question about a link goes to
OnePuls. With PulsOne installed on an Android phone, **Share → PulsOne** opens a sheet with three
places — the task in Focus, the project touched last, *Sort later* — and one tap saves. Search
through an aggregator (Recall, Remly, Glean…) is listed, but cannot be connected yet.

**On hold.** **Put on hold** folds a project, with its branches, into the *On hold* box. Its
tasks leave Today and the counters, and OnePuls remembers it but does not bring it up. Its page
stays readable under a veil with **Back to work**.

**Moving in.** `/projects/move` brings work over from Todoist, Notion, Evernote, ChatGPT or Claude
and plain files, in three steps. *From*: pick several apps at once; each gets its simplest way in —
an export file, a phrase for your own AI connected to that app over MCP, or a prompt for your AI
chat whose answer you paste back. Nothing is read while you add files or paste: *Next* reads them
all at once (a row says «added — read on Next» until then), and stays on *From* when nothing could be
read. *What to take*: everything found, by app. One project kept in
two apps arrives as one (*merged: Notion · Todoist*), duplicate tasks fold, and a project with the
name of one you already have goes into it. One project is ticked by default; *All at once* is a box
you tick yourself. Open tasks untouched for 90+ days are *Put off in the move* and go to the
project's ideas unless you take them. *Where to start*: done tasks keep their dates, so they sit in
History on the day they were done; stated decisions and questions become History entries dated as
in the source; notes become project notes. OnePuls writes a first summary, you put 1–3 tasks into
Focus, and **Undo the move** deletes exactly what the move made.

**Moving in from code.** Picked **GitHub** and **Claude Code**: connect PulsOne to Claude Code
once (one line in the terminal; Cursor and Codex take the same link) and say *Move this project
to PulsOne* in the project folder. Claude Code reads the code, git, pull requests, issues and its
own sessions on your computer — they never leave it — and sends a draft; the screen waits for
it (*Claude Code is reading…*) and goes on by itself. *What to take* shows the project by
**stages** (how it was built): each record with its kind (*Result · Decision · Dead end · Tool ·
Question*), its receipt (a PR, an issue, a commit, a session) and its date; a decision in your own
words; *replaced → yt-dlp* where you changed your mind. *Not sure* comes unticked. The
CLAUDE.md note can become the project's *Instructions for AI* by a tick. *Foundation and ideas*
puts each idea in its pillar › branch; an idea *off the foundation* comes only when ticked; empty
pillars are named. A line says how much was taken from how much («41 records out of 1 214
commits, 312 PRs and 180 sessions»). *Where to start* shows *Ideas found their place in the
foundation* (the pillars with their ideas, the empty ones with **Come up**) and **Keep
recording**: Claude Code shows three lines for CLAUDE.md and, after your yes, saves each
session's decisions, dead ends and results. Moving again from the same repo brings only what is
new. A claude.ai export (ZIP) brings its projects — instructions as a note for AI — and its chats
as topics.

**Team.** A project can be shared with a small circle: *Settings → Team → Make it a team*.
**Invite** copies a one-use link for 7 days (nothing is emailed); whoever opens it signs in and is
in. Roles: **Admin** (everything, access included — the owner always is one), **Manager** (tasks,
assignees, decisions), **Member** (own tasks, thoughts, answers). The project, its branches,
sections, tasks, History and notes are shared; ideas, materials, Atlas and Inbox are not yet, and
Focus stays personal. Tasks get an assignee — a person, or one of the owner's AIs set to
**Executor** with the person who answers for it; a task for an AI needs *What should come out*.
The Tasks tab filters *Mine · All · Unassigned*. **Make it yours only** takes everyone out at
once; what they wrote stays. Others' changes arrive when you come back to the tab and every 90
seconds. Details: `docs/team.md`.

**AI Agents.** A project's own agents on the person's own server — Claude Code, Codex, Gemini
CLI, Cursor or a script. The tab sits between Tasks and Ideas, in solo and Team projects alike,
and lists the agents, their server, and whether it is online. **+ Agent** connects a server
once (`npx -y https://pulsone.app/runner-<version>.tgz connect <code>`, the code lives 10 minutes), then picks one of the
agents that server's runner allows and the folder on the server it works in for this project.
Branches share their project's agents. The agents, the model keys and the compute stay on the
person's server; PulsOne can start only what the runner's `config.json` lists. Servers are
renamed or disconnected in *Settings → Account → AI agent servers*.
Giving a task to an agent is picking it in **Who does it** — in solo projects too; the task needs
*What should come out*. It starts within seconds: the drawer shows the agent working, short lines
of **Progress** and the **full log**, and **Stop**. When the agent hands it in, the drawer and the
task row say *handed in · check it*: **Accept** closes the task, **Return** (with an optional
note) sends it back for another go. The tab shows what each agent is doing now — working on a
task, queued, busy in another project, online or offline — and *Handed in · check*.
An agent that cannot go on without a decision **asks**: the task shows *{agent} asks* with the
question, one-tap choices and a field for one's own answer; the same question waits at the top
of the project's **Inbox** and on the phone. The agent goes on with the answer, and the question
and the answer stay in History as a decision. Questions come only from agents — people talk
in their own messenger (`docs/ai-agents.md`).

**Elsewhere.** A task's deadline puts it on that day in the Calendar; a calendar block gives
it an hour. Projects can carry goals (see Goals), and a project can have its own AI in
OnePuls. On a phone, /projects shows a phone layout of the same data.
Focus (the task now and «Дальше», across projects) has its own address, /focus;
on a phone it lands on «Сегодня», where the current task lives.

## What OnePuls can do here

- tasks (task.create, task.update, task.delete)
- projects, sub-projects and a project's own AI (project.create, project.about, project.update, project.park, project.star, project.open_ended, project.ai_instructions, project.report_settings, project.unpark, project.delete, project.from_template, project.ai.create, project.ai.attach, project.ai.detach, project.ai.update, project.ai.delete)
- sections inside a project (section.create, section.update, section.delete)
- a thought for the archivist to file into a project (backlog.capture, backlog.material.save, backlog.material.move)
- a project's «Входящие» — what the archivist left for them to settle (inbox.resolve)
- assumptions to check (hypothesis.create, hypothesis.resolve, hypothesis.update, hypothesis.withdraw)
- topics put off for later (shelf.add, shelf.close)
- the session feed's summary — rewritten when you correct it (session.feed_correct)