For nerds

How it works, inside.

The workinonit spec sheet: data model, scope resolution, event log, sync across Macs, consolidation and pipelines. With the real commands and files.

Python stdlib onlySQLite local per Mac0 servers≈ 100 tokens at startup2 Claude Code hooks
01

Scope: from agent to master

The model and its tools stay generic. Instructions and memory are tied to the place you work in, and the place comes from the folder.

session=model+tools+context(scope)
scope=master→project→placeresolved from the working directory
model and tools
Generic: Claude Code as it ships. No custom agent to write or maintain.
instructions and memory
Tied to the scope, not the agent. Opening a session inside a master is the same as instantiating that master's agent.

Data model masters.json

# catalog in iCloud, shared by every Mac
MASTER    Rossi Studio        client · agency · product line · personal
 ├─ PROJECT Site           site · app · tool · bot · assets · brand · video · docs
 │   ├─ place  ~/Clients/Rossi/site
 │   ├─ place  github.com/rossi/site
 │   └─ place  rossistudio.com
 └─ PROJECT Brand
     └─ place  ~/Clients/Rossi/brand
catalog
masters.json: names, kinds, master homes, sites, repos, groups. One project can have many places.
notes on nodes
todo · fact · decision · handoff, attached to a project, a master, or global.
inheritance
A master's notes apply to all of its projects; a project's notes to all of its places.
moves
A project that changes master keeps its id, notes and sessions. Moved folders are found again by name and relinked.

Longest path prefix resolution

working directoryrulescope
~/Clients/Rossi/site/src/componentslongest prefix in the catalogRossi Studio › Site
~/Clients/Rossi/quotesinside the master's homeRossi Studio › automatic project
~/Downloads/testno matchInbox
~ · iCloud · /Userscontainer foldernever a project
injection
SessionStart hook → workinonit brief --hook. No embeddings, no ranking: the folder is the query.
isolation
The hierarchy narrows the retrieval space before any question is asked. One master never leaks into another.
unknown folder
Claude asks once where it goes, then workinonit attach . <master>[/<project>].

Consequences

zero setup
A new master is empty and usable right away: context grows from the work.
no prompt drift
The brief is regenerated at every start from the real state: recent sessions, git, open notes.
model independence
Memory lives outside the model and the vendor. Switch either and you lose nothing.
02

Inputs, event log, delivery

Four input channels, one append-only log. Writing a piece of information and using it are two separate moments: the channel doesn't matter.

inputs
Claude in a sessionthe skill tells it when to write
CLIworkinonit note "…" --kind …
Voice notes from your phonetranscribed, imported hourly
Obsidian inbox- [ ] → todo · #tag → scope
sync/<mac>/events.jsonl
{"op": "add", "kind": "decision", "project": "rossi-site", …}
{"op": "add", "kind": "todo", "urgent": 1, …}
{"op": "assign", "id": "a3f9c1…", "project": "alpi-shop", …}
{"op": "done", "id": "7be210…", …}
{"op": "move", …}
tree nodes
Rossi Studio › Site
Alpi Shop › Shop
Brand Nova master note
Inbox no scope, waiting for assign

One event

{
  "ts": 1794838780.95, "dev": "MacBook", "op": "add", "id": "9ef11e5b21f4",
  "master": "rossi", "project": "rossi-site", "kind": "decision",
  "text": "Hosting stays on Lightsail", "tags": [], "author": "claude",
  "created_at": "2026-11-16T19:00:39+00:00"
}
kind and scope
The kind decides meaning and lifecycle; the scope decides where the information resurfaces.
no scope
It lands in the Inbox. workinonit assign <id> <master>/<project> attaches it to a node.
assignment
Is itself an event (assign), so it propagates to every Mac like everything else.

Sync across Macs, without a server

# iCloud / WORKINONIT / sync
sync/
├── macbook/   events.jsonl  sessions.json  state.json
├── mac-mini/  events.jsonl  sessions.json  state.json
└── imac/      events.jsonl  sessions.json  state.json

# per Mac, outside iCloud
~/.workinonit/   SQLite  # inside iCloud it would get corrupted
writes
Each Mac writes only to its own folder: notes (events.jsonl), sessions and operations (sessions.json), git state and presence (state.json).
reads
Each Mac reads every folder and rebuilds the state in its own SQLite. Last-write-wins: no locks, no conflicts.
code
The code lives in iCloud too, so every Mac runs the same version.

Lifecycle by kind

kindmeaninglifecycle
todosomething to do, can be urgentopen → workinonit done <id> → leaves the active context
facta stable truth about a client or projectpersistent
decisiona choice already made, not to be reopenedpersistent
handoffState · Done · Next · Waiting onreplaced by the next one
03

Cost moves from read time to write time

The same idea as indexes and materialized views: do the expensive work once, when the data comes in, not on every read.

L0 · brief

Always, at startup

Injected by the hook: project, handoff, urgent items, todos, decisions, facts, warnings from other Macs.

≈ 100 tokens · push
L1 · on demand

When needed

workinonit brief <project>, workinonit find "…": queries on the local database.

near-zero cost
L2 · verbatim

Rarely

Full transcripts, diary, git history. Targeted reads, with the scope already known.

only what's needed
write
One call to a small model per session, in the background.
read
About 100 tokens, flat, ready at every start. The expensive model never acts as a search engine: zero vault searches, zero notes opened.
second brain
Every question is an exploration inside the expensive model's context window: the cost grows with the archive.
04

Memory derived from the traces of your work

Most of the memory is written by nobody. It comes from Claude Code transcripts, git and GitHub, and it attaches to the tree by path prefix.

Sources

sourcewhat it extracts
~/.claude/projects/*/*.jsonldirectory, branch, title, first and last prompt, cost, lines changed
tool callstyped operations: files written, installs, commits, pushes, deploys, deletions, ssh
local gitbranch, uncommitted changes, unpushed commits, recent commits
gh repo listhourly: repositories with no local folder stay visible
timestampsactive minutes: breaks over 10 minutes don't count

Automatic handoff

session idle for 20 min→transcript excerpt→claude -p --model haiku→State · Done · Next · Waiting on
isolation
The call loads no hooks and doesn't record its own session: no recursion, no ghost sessions.
replacement
Each handoff replaces the previous one. On first run it rebuilds the history of every project.
rescan
SessionEnd hook → workinonit scan in the background. The server rescans every 10 minutes too.

The L0 brief, line by line

WORKINONIT · Rossi Studio › Site [active]← path prefix resolution
⚠ on Mac mini: 2 unpushed commits← the other Mac's state.json
State: mobile menu on branch menu, not in main← automatic handoff
Next: merge and deploy← automatic handoff
Waiting on: photos from the client, Friday← automatic handoff
- [URGENT] renew the domain by Nov 30← todo note --urgent
- [decision] hosting stays on Lightsail← decision note
- [fact] only replies on WhatsApp← master note, inherited
diary
Sessions, operations and commits in order, filterable by master and by Mac. Dashboard at 127.0.0.1:7337, or /api/diary?days=7.
across Macs
Unpushed commits or uncommitted changes elsewhere show up in the brief before you touch the project, not after the conflict.
05

Learn: corrections become rules coming soon

The transcripts already hold every correction you've made to Claude. Today they only count in the chat where you made them; learn will consolidate them into rules.

scope transcripts→correction points→mistake → rule→lesson in the brief
signals
Counter-instruction ("no, like this") · rejected request · reverted edit · operation redone after a mistake.
consolidation
Equivalent corrections from different sessions become a single lesson note, with the number of corrections behind it.
placement
On the project if it's specific, on the master if it's general. It carries over to projects of the same kind, but never leaves the master.
application
Lessons enter the SessionStart brief like any other note. Prompts rewritten: zero.
06

Pipelines: portable procedural memory

A pipeline is a proven method (steps, agent prompts, scripts, quality criteria) kept apart from the client's data. Record it once, use it in any master.

# 1 · gather everything a project knows about how the work was done (read-only)
$ workinonit pipe harvest rossi-video
# 2 · create the pipeline from that project
$ workinonit pipe new video-social --from rossi-video
# 3 · use it in another master, from inside the destination project's folder
$ cd ~/Clients/Alpi/video && workinonit pipe start video-social
$ workinonit pipe step video-social edit done
$ workinonit pipe status
# 4 · what the run taught goes back into the procedure: new version
$ workinonit pipe promote video-social "subtitles always outside the safe zone"

PIPELINE.md pipelines/<id>/

---
name: Social video
version: 3
origin: rossi-video
description: From raw footage to vertical reels, with subtitles and covers.
---
## Steps
1. [agent]  select      → prompts/select.md
2. [you]    choose      → keep, drop, reorder
3. [script] edit        → scripts/render.py
4. [agent]  review      → look at the frames, not just the file

## Changelog
- v3 subtitles always outside the safe zone (from alpi-video)
- v1 born from rossi-video

The run _pipeline/ in the project folder

{ "pipeline": "video-social", "version": "3", "project": "alpi-video",
  "steps": { "select": "done", "choose": "done", "edit": "todo", … },
  "inputs": {}, "outputs": {}, "choices": {}, "deviations": [] }
in the pipeline
Steps, prompts, scripts, parameters, quality criteria, general rules.
in the master
The client's assets, brand, facts, decisions and rules. The origin master's data never enters another master.
versions
promote bumps the version and logs in the changelog what changed and where it came from. New runs start from the latest.
tracking
Starting a run is an event in the destination project's log, so every Mac can see it.
↳

Commands and files

Install ~/.claude/settings.json

{ "hooks": {
    "SessionStart": [{ "hooks": [{ "type": "command", "command": "workinonit brief --hook" }] }],
    "SessionEnd":   [{ "hooks": [{ "type": "command", "command": "(workinonit scan -q >/dev/null 2>&1 &)" }] }]
} }

Plus a LaunchAgent that keeps the dashboard and scanner running, and a skill that tells Claude when to write a note.

brief [path]
The project's brief (default: current folder)
note "…" --kind
todo · fact · decision, on a project, --master or --global
done · urgent
Closes a todo · pins it on top
handoff "…"
Writes where you left off, by hand
find "…"
Searches notes, facts and sessions everywhere
new · newmaster
Creates a project in the master's home · creates a master
attach · assign
Links a folder · sends a note where it belongs
scan · serve
Rescans · dashboard on :7337
notup
Imports work voice notes from your phone
pipe …
list · show · harvest · new · start · status · step · promote

What lives where

masters.jsonthe master → project → place catalog, in iCloud
sync/<mac>/each Mac's event log, sessions and state, in iCloud
~/.workinonit/local SQLite database, one per Mac
~/.claude/projects/Claude Code transcripts, read and never modified
pipelines/<id>/PIPELINE.md, prompts/, scripts/
127.0.0.1:7337local dashboard and API (/api/diary, /api/health)
↑ back to top