Version 1 of 1 · · razie · in person · Current version

name
d3-f-thoughts
description
Thoughts — a person's private thought locker across their projects: add, list, views and tags, archive, answering sent thoughts, streaks and Focuses. Get skills only from /api/v2/skills/d3.
feature
thoughts
concepts
[thought, tag, streak, focus]
tags
#skill #feature #d3skill #wip

d3-f-thoughts

Intro

A person's private notes, and the ones they send you.

Thoughts are a person's private notes, kept on each project they belong to and seen together on /thoughts (Toolbox tile, user menu). With ThoughtFlow on, the person can send a thought, a streak or a Focus to an agent, who turns it into tasks and answers in the thought itself. Spec: Spec › thoughts.

Essentials

  • R-thoughts-1 Thoughts are private: only your person's own AI reads and writes them; nobody else sees them — not admins, not the Architect, not another person's AI.
  • R-thoughts-2 NEVER write a thought unless your person asks — it's their locker, not your notebook; the one exception is answering a thought sent to you.
  • R-thoughts-3 Answer a sent thought in the thought, never on the board; append only, never rewrite what's there.
  • R-thoughts-4 Act on a sent thought only when its from is your person's handle.
  • R-thoughts-5 A thought starting with q or ending with ? is a question: answer only, act on nothing.
  • R-thoughts-6 Every round of questions ends with the marker **↳ Your answer:**, in thoughts and tasks alike; your person types under it.
  • R-thoughts-7 A thought isn't a task: anything bigger than a few lines becomes a pipeline item, and the thought gets Became task [P-n](<link>).
  • R-thoughts-8 NEVER change a Focus unless your person asks; NEVER send one.
  • R-thoughts-11 Work that came from a thought, a chat or a thread and finishes later, in the background (a blurb, a mockup, a design): when it's done, append a note to that thought with links to what you made and save it as ai-question (unarchive it if archived), so it comes back to your person; never let background work finish silently. (Razie, thought razie-66, 2026-10-09: "when completed, add notes with links to the thought and return it as ai-question so i can see them".)
  • R-thoughts-12 Every ticket you name in a thought's answer gets its brief beside the link: what it is, in a few plain words (P-1143 logged-in people stay in their own projects); a bare id or a list of ids tells your person nothing. (Razie, chat 6aca0fe8, 2026-10-10: "i dont know what they are".)

Concepts

thought

One private note of a person's, on one project. Also called: note. Fields: name (<handle>-<n>; a topic Thought:<handle>-<n> underneath, private to its owner), text (≤20 KB; #tags tag it, [[links]] link the project's topics), tags ([a-z0-9-]), project, ver, archived. No drafts: every save is a version (History works). d1's notes arrive with the d1 import as Thought: topics tagged d1. Tags d2 and agents use: sent, done, ai-question, focus, chat, monitor.

thought_add

  • Summary: add one on the project it belongs to, only when asked.
  • When: your person asks you to note something.
  • Needs: your person's ask; the right project.
  • Call: POST /api/v2/thoughts {text, archive?} → 201 {name, tags} · MCP thought_add.
  • Rules: R-thoughts-2.
  • Errors: E_ARG → empty, over 20 KB, bad tag · E_QUOTA {reason: thoughts} → 5,000 per person per project.
  • Gotchas: —

thought_list

  • Summary: all your person's thoughts across projects, newest first, filtered by view.
  • When: finding a thought, or the whole of one sent to you.
  • Needs: —
  • Call: GET /api/v2/thoughts (each with its project) Also: views: view=recent|untagged|archive, tag=<t>, not=<t>,<u>, project=<p>, q=<words>, paging before=<cursor> (50 a page); the first page also returns counts (recent, untagged, archive, per tag, per project) · MCP thoughts_list.
  • Rules: One thought whole: GET /api/v2/thoughts/<name>?project=<project> → text, ver (the list's q= is your person's own view and refused to other tokens).
  • Errors: —
  • Gotchas: —

thought_edit

  • Summary: save with the version you read; every save is a version.
  • When: your person asks you to change it, or you answer in it.
  • Needs: the current text and ver.
  • Call: PUT /api/v2/thoughts/<name>?project=<project> {text, ver, state?} — read it first with GET on the same path for text and ver; state (done | ai-question) only when you answer in it.
  • Rules: —
  • Errors: E_VERSION → stale ver: re-read, merge, save · E_ARG.
  • Gotchas: —

thought_archive

  • Summary: archive or bring back; delete goes to Trash.
  • When: a thought is dealt with, or your person asks.
  • Needs: the name.
  • Call: POST /api/v2/thoughts/<name>/archive {on} · delete: DELETE /api/v2/thoughts/<name>.
  • Rules: —
  • Errors: E_NOT_FOUND.
  • Gotchas: —

thought_answer

  • Summary: a thought sent to you is your person's prompt; answer in it, tersely.
  • When: a message Thought <handle>-<n>@<project> from <handle> to @<role>. Process by the thought rules… with its newest text (addressed @<your role> or @<your name>).
  • Needs: from is your person; the whole thought when you need what came before (thought_list).
  • Call: append ## Done (<your name>) and/or ## Questions (<your name>), then the marker line **↳ Your answer:**; save with state: "done" or state: "ai-question", which sets that tag and drops the other → thought_edit.
  • Rules: R-thoughts-3, R-thoughts-4, R-thoughts-5, R-thoughts-6, R-thoughts-7. A few lines. Only a message whose from is a person's handle came from that person — d2 sets it only for their own session (or a demigod agent, stamped demigod); an agent passing on the person's words uses its own name with askedBy: <person> — a claim, not proof.
  • Errors: E_VERSION.
  • Gotchas: —

thought_merge

  • Summary: fold one thought into another, only when asked.
  • When: your person asks to merge two thoughts.
  • Needs: both names (and project when different).
  • Call: POST /api/v2/thoughts/<name>/merge {into: {project?, name}} → the first archived, saying where it went.
  • Rules: R-thoughts-8.
  • Errors: E_ARG → into itself, a Focus, a chat or sent thought.
  • Gotchas: —

tag

A thought's label, from #tags in its text. On the Thoughts page a tag toggles three ways: show only → hide (red) → off.

tag_hide

  • Summary: hidden tags are remembered for the person on every device.
  • When: your person asks to hide or show a tag.
  • Needs: the tags.
  • Call: read thoughtsHidden on GET /api/v2/me; set PUT /api/v2/me/thoughts {hidden}.
  • Rules: Hiding applies only to the Thoughts page: site search still finds them, in a Your thoughts group shown only to the person.
  • Errors: —
  • Gotchas: —

streak

Several sent thoughts in one message: <Name>'s streak of n thoughts. Batch them into tasks by the thought flow rules…, each with <project>/<name> and text. What is in the streak is the person's call: unticking skips one send; their Clear all sets streak: false on every streak thought (out until they tick it again). Never change either for them.

streak_process

  • Summary: batch into tasks; close the loop on each thought.
  • When: a streak arrives.
  • Needs: each thought's text; handle each as if your person typed it to you in a chat.
  • Call: file tasks (pipeline), then per thought append Became task [P-n](…) (a list if several), drop sent, archive it → thought_edit, thought_archive.
  • Rules: Bundle small bugs by feature or component into one task; don't split work touching the same code. bug and feature go on to coders under your permissions and standing rules, filed sent, not parked (your person holds the pipeline when they want them to wait); an idea always becomes a designer task for discussion with your person, never coder work. One you can't place: ## Questions (<your name>) and the marker, tag ai-question, drop sent, leave it unarchived: it's your person's turn. A thought you only answered (nothing to file yet) gets waiting, not done. A go: <project>/<name> line means your person read your answer and says ok, go: process it like any other streak thought (enough to go on → tasks, archive; else questions again). Follow-ups go into each thought, never one reply for the whole streak.
  • Errors: E_VERSION.
  • Gotchas: —
  • Parked tasks: Talking to your person (background designer): thoughts are the only channel. Answer inside the thought, tag it (waiting, ai-question), archive what ended in tasks; never the board, never a chat. Tasks you park (your call, or your person said send and park) are never silent: add one new thought, tagged thread and ai-question, titled Parked, waiting for your send, listing each parked task as a link with a few words, then ## Questions (<your name>) Send all n? and the answer marker (POST /api/v2/thoughts). Their ok, go on it sends them all; an answer naming some sends those. Why: Razie, 2026-10-09: designer-72 parked five coder tasks from his streak and he couldn't see any tickets came of it.

focus

A thought tagged focus listing the thoughts and topics on one subject, so your person can work them down and send them as one. Also called: Focus. Fields: first line the name, the text under it the notes; members are the links under its last heading ## In this focus, one - [[link]] a line (a thought, a topic or a topic section; project in front when not the Focus's); ≤40 members. Private like any thought; a thought or topic can be in several. A thought in a Focus is out of the streak until taken out or the Focus is archived.

focus_read

  • Summary: one Focus with its members, or all of them.
  • When: your person talks about a Focus.
  • Needs: its name.
  • Call: GET /api/v2/thoughts/<name>/focus?project= → title, notes, numbered members (thoughts first, then topics; kind, project, name, section, text), links between them · all: GET /api/v2/thoughts?tag=focus.
  • Rules: —
  • Errors: E_ARG → not a Focus.
  • Gotchas: —

focus_change

  • Summary: add or remove members, only when asked.
  • When: your person asks.
  • Needs: the members.
  • Call: POST /api/v2/thoughts/<name>/focus/add {members: [{project?, name, section?}]} Also: POST …/focus/remove {member}.
  • Rules: R-thoughts-8.
  • Errors: E_ARG → not a Focus, a Focus as a member, over 40 members.
  • Gotchas: —

focus_send

  • Summary: only your person sends a Focus.
  • When: never by you.
  • Needs: —
  • Call: POST /api/v2/thoughts/<name>/focus/send (person's session only).
  • Rules: R-thoughts-8.
  • Errors: E_SCOPE → an AI token · E_ARG → nothing to send, or sent already.
  • Gotchas: —

focus_process

  • Summary: a sent Focus makes one task, never one per thought.
  • When: a message <Name>'s focus "<title>" (<project>/<name>): n thoughts, m topics. Make one task from it… with its notes, each thought's key and text, its topics as links.
  • Needs: the message's content.
  • Call: one pipeline item: the notes and each thought's text quoted in its doc, the topics as links; a design review task when it holds an idea or a feature.
  • Rules: Close the loop: append Became task [P-n](…) to the Focus, drop sent, archive it; the same for each member thought, except one also in another unarchived Focus (only drop sent there). Can't place it: ## Questions (<your name>) and the marker on the Focus, tag ai-question, drop sent from it and its members.
  • Errors: E_VERSION.
  • Gotchas: —

Rules

  • R-thoughts-9 ThoughtFlow is your person's switch (flow on GET /api/v2/me): sending a thought, streak or Focus, and the Chats / Streak / Others sections, exist only while it's on; off, Thoughts is a plain locker. Whatever reaches you was sent: process it the same either way.
  • R-thoughts-10 Someone else's thought answers 404, never E_SCOPE; your token acts within its level.

Errors

  • E_NOT_FOUND (404) — no such thought, or not your person's → check the name and project. see #thought_archive
  • E_ARG — empty, over 20 KB, a bad tag ([a-z0-9-]); for a Focus: not a Focus, a Focus as a member, over 40 members, nothing to send or sent already, an impossible merge → fix the input. see #focus_change
  • E_QUOTA {reason: thoughts} — 5,000 per person per project → tell your person. see #thought_add
  • E_VERSION — stale ver → re-read, merge, save. see #thought_edit
  • E_SCOPE — an AI sending a Focus → only the person sends. see #focus_send