@marver-design/marver 0.27.2 → 0.29.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +160 -0
- package/README.md +6 -4
- package/dist/{anchor-check-gkxkPAIv.mjs → anchor-check-DhlpKl2K.mjs} +1 -1
- package/dist/{audio-Dw1lfMdb.mjs → audio-DX4POHAj.mjs} +39 -4
- package/dist/{boards-BqUqKNW8.mjs → boards-BeWtjGUM.mjs} +49 -4
- package/dist/boards-EH2onUXM.mjs +995 -0
- package/dist/{build-VgNg4rr8.mjs → build-CWbrb2bl.mjs} +9 -5
- package/dist/{capture-vadKjuCo.mjs → capture-DEtM4qm5.mjs} +259 -34
- package/dist/cli.mjs +40 -19
- package/dist/{comments-YEU1Zhv9.mjs → comments-XNhMmSSu.mjs} +4 -4
- package/dist/config-BezZTiov.mjs +182 -0
- package/dist/conn-BMiHS42T.mjs +222 -0
- package/dist/connectors-DekQvKt9.mjs +292 -0
- package/dist/{context-Ccjrhr1J.mjs → context-BUnFiyA3.mjs} +2 -2
- package/dist/{daemon-Dc9AH0M3.mjs → daemon-Sc_z8gT6.mjs} +2209 -205
- package/dist/{dev-ri6nAlRp.mjs → dev-DWBKQhxf.mjs} +31 -15
- package/dist/{init-W0nxR1OY.mjs → init-CYlFaRzG.mjs} +7 -2
- package/dist/jam-Cj5gBvwD.mjs +373 -0
- package/dist/{link-CdTgn94Y.mjs → link-BFFRgrMt.mjs} +3 -3
- package/dist/listener-DdLEM79A.mjs +80 -0
- package/dist/logo-CXY-1yrn.mjs +305 -0
- package/dist/{ls-BZ5TAtd5.mjs → ls-NqmePKOf.mjs} +1 -1
- package/dist/{manifest-aFyDmL8C.mjs → manifest-DPZ3WNg_.mjs} +1 -1
- package/dist/{marks-CnCCfAbD.mjs → marks-BnNANic9.mjs} +22 -3
- package/dist/{marks-BF9pNEgH.mjs → marks-DBp3h1Mc.mjs} +3 -6
- package/dist/{marver-id-gate-D-R0hSt_.mjs → marver-id-gate-vBLb_Icb.mjs} +1 -1
- package/dist/{perf-DkAUFT6W.mjs → perf-Denssrko.mjs} +45 -27
- package/dist/{perf-jam-BaH3Lg0m.mjs → perf-jam-CLkERSHo.mjs} +9 -2
- package/dist/permit-DDa6wqOs.mjs +187 -0
- package/dist/{plugin-B8UghYuF.mjs → plugin-DqoZB-D6.mjs} +849 -789
- package/dist/{poster-BNgafWMK.mjs → poster-CrsjqhY4.mjs} +1 -1
- package/dist/{profile-jIS6BcAs.mjs → profile-B1FKOM1e.mjs} +1 -1
- package/dist/{publish-bakes-38Nja78p.mjs → publish-bakes-DW-NDgU2.mjs} +3 -3
- package/dist/{queue-CAM_vNmX.mjs → queue-DeSQm24g.mjs} +189 -35
- package/dist/{recover-B8AiI29B.mjs → recover-GtJ9UDAB.mjs} +2 -2
- package/dist/{serve-Dp3nHstu.mjs → serve-DQv3Ti6X.mjs} +8 -4
- package/dist/{session-BAaJsK5c.mjs → session-VDJfXEEm.mjs} +1 -1
- package/dist/{share-Ce4tP7ji.mjs → share-Bu_kuOKL.mjs} +1 -1
- package/dist/{shot-CMQgMVZm.mjs → shot-DBWN8hPP.mjs} +1 -1
- package/dist/{shot-Ch24tiMO.mjs → shot-T04Ixrvq.mjs} +7 -6
- package/dist/sizes-wjXDev3b.mjs +139 -0
- package/dist/{slots-CFNnegCc.mjs → slots-Dn4Onb0V.mjs} +101 -3
- package/dist/speech-worker.mjs +23 -3
- package/dist/{sync-CQdGARJ9.mjs → sync-CMozOwZ0.mjs} +1 -1
- package/dist/transport-C5FnY9ni.mjs +203 -0
- package/dist/{work-Bxz-ObF3.mjs → work-BYWD_1Zf.mjs} +3 -3
- package/dist/{work-CNhFF9pU.mjs → work-DJxH7cCX.mjs} +1 -1
- package/docs/boards-and-folders.md +11 -0
- package/docs/jam-session.md +52 -18
- package/docs/live-jam.md +95 -10
- package/docs/performance.md +1 -1
- package/docs/publish.md +7 -0
- package/package.json +1 -1
- package/src/client/shell/Comments.tsx +5 -4
- package/src/client/shell/ContextMenu.tsx +5 -4
- package/src/client/shell/JamSurface.tsx +135 -29
- package/src/client/shell/Play.tsx +16 -4
- package/src/client/shell/api.ts +7 -3
- package/src/client/shell/app-bridge.ts +11 -3
- package/src/client/shell/comments-store.ts +14 -0
- package/src/client/shell/goto.ts +4 -3
- package/src/client/shell/icons.tsx +1 -0
- package/src/client/shell/jam-capture.ts +136 -37
- package/src/client/shell/jam-keys.ts +170 -18
- package/src/client/shell/jam-lane.tsx +14 -5
- package/src/client/shell/jam-lines.ts +76 -10
- package/src/client/shell/jam-panel.tsx +58 -4
- package/src/client/shell/jam-queue.ts +55 -8
- package/src/client/shell/jam-session.tsx +55 -6
- package/src/client/shell/jam-state.ts +19 -4
- package/src/client/shell/jam-surface-parts.tsx +6 -3
- package/src/client/shell/jam-ui.tsx +10 -1
- package/src/client/shell/jam-voice-wait.ts +21 -0
- package/src/client/shell/jam-voice.ts +14 -5
- package/src/client/shell/live-picture.ts +134 -0
- package/src/client/shell/open-item.ts +83 -0
- package/src/client/shell/open-resolve.ts +50 -0
- package/src/client/shell/store.ts +6 -2
- package/src/client/shell/styles.css +29 -11
- package/src/client/shell/tidy.ts +3 -2
- package/src/client/stage/main.tsx +30 -8
- package/src/shared/app-api.ts +173 -3
- package/src/shared/app-perf.ts +4 -2
- package/src/shared/approval.ts +20 -0
- package/src/shared/events.ts +1 -1
- package/templates/AGENTS-embedded.md +28 -1
- package/templates/AGENTS-studio.md +28 -1
- package/templates/instructions/boards.md +7 -1
- package/templates/instructions/jam.md +94 -0
- package/dist/boards-BHKP5yhI.mjs +0 -342
- package/dist/live-Cgzsicwi.mjs +0 -4
package/docs/jam-session.md
CHANGED
|
@@ -24,14 +24,31 @@ dot. While it records, everything you do is part of it:
|
|
|
24
24
|
- **pictures**: `I` takes one of the frame under the pointer, and the frames you touched are
|
|
25
25
|
pictured as the capture ends - three at most - at the size you were looking at them (a
|
|
26
26
|
device, a width you dragged, the play stage). A capture holds twelve pictures in all.
|
|
27
|
-
|
|
28
|
-
|
|
27
|
+
In the Mac app (0.3, with Marver 0.29), a picture in play is **live**: the stage as you saw
|
|
28
|
+
it - a menu you opened, text you typed - captioned "as you saw it". It is taken when the
|
|
29
|
+
whole stage is in view with nothing over it and has shown its screen for a second (a device
|
|
30
|
+
preset, a slide fitted to the window); otherwise, in a browser, and whenever the app cannot
|
|
31
|
+
take it, the picture is a fresh render of the frame. A live picture is not filtered: it shows
|
|
32
|
+
whatever was on the stage, comment pins and anyone's words in them included.
|
|
33
|
+
|
|
34
|
+
Two ways to end it (0.28): `E` **stops and queues it** - the agent starts on it, nothing to confirm - and `⇧E`
|
|
35
|
+
**stops to review**: its read-back opens so you can check it and add to it first. Both are on the capture bar. `Esc`
|
|
36
|
+
throws it away. One capture records at a time.
|
|
37
|
+
|
|
38
|
+
After `E` the tile reads **Sending** while its last words and pictures come in, then Queued or the agent's state;
|
|
39
|
+
nothing opens and the canvas stays where it is. If the queue cannot take it (rare: another comment already sits
|
|
40
|
+
under its id), it stays on the lane as a draft reading **Not queued** and one line says why - open it to add it to
|
|
41
|
+
the queue. After `⇧E` the tile reads **Finishing**, then **To confirm** as its read-back opens. Either way the capture
|
|
42
|
+
waits for the words you said last: 15 s, longer while the speech engine is still working through them (a minute at
|
|
43
|
+
most). With the microphone on and nothing heard (the speech engine not available, the microphone still opening),
|
|
44
|
+
its record says the words may be incomplete.
|
|
29
45
|
|
|
30
46
|
Closing or reloading the tab asks first while a capture is recording, finishing or not yet taken by the canvas (as it
|
|
31
47
|
does for any unsaved work). If you leave anyway, the capture
|
|
32
48
|
is kept as it stood - its words and notes so far, and a line saying the page closed before it finished - and comes
|
|
33
|
-
back as a draft to read, resume or drop; it never goes to your agent on its own.
|
|
34
|
-
no chance to
|
|
49
|
+
back as a draft to read, resume or drop; it never goes to your agent on its own. One you had already stopped with `E`
|
|
50
|
+
(its tile reading Sending) is queued as `E` does, with that line. (Best effort: a crash gives the page no chance to
|
|
51
|
+
keep it.)
|
|
35
52
|
|
|
36
53
|
A capture the page could not send waits in this browser, for this address, and sends itself the next time the canvas
|
|
37
54
|
opens there - see [A capture left on an old address](#a-capture-left-on-an-old-address).
|
|
@@ -42,7 +59,7 @@ are the frames its run may edit, and the frames pictured before and after it.
|
|
|
42
59
|
|
|
43
60
|
## The read-back
|
|
44
61
|
|
|
45
|
-
When a capture ends, its **read-back** opens: the timeline of what you said and did, with its
|
|
62
|
+
When a capture ends with `⇧E` (and when `J` ends one to wrap the session up), its **read-back** opens: the timeline of what you said and did, with its
|
|
46
63
|
pictures, under a short name a small model gave it (see [Names](#names)). Read it, fix a
|
|
47
64
|
mistranscribed word in place, and decide:
|
|
48
65
|
|
|
@@ -56,7 +73,6 @@ mistranscribed word in place, and decide:
|
|
|
56
73
|
A draft's read-back also takes notes after the fact: type in **Add a note** and they are
|
|
57
74
|
logged under "Added after", in the timeline's style, and go to the agent with the rest.
|
|
58
75
|
|
|
59
|
-
`jam: { capture: "at-once" }` skips the read-back: a capture queues as soon as it ends.
|
|
60
76
|
|
|
61
77
|
## The lane
|
|
62
78
|
|
|
@@ -70,13 +86,18 @@ captures · 6 frames changed" - so the lane keeps its room for what still needs
|
|
|
70
86
|
(or `⏎` on it) to open them in place, behind a narrow collapse tile that folds them back.
|
|
71
87
|
|
|
72
88
|
Your agent works on up to `jam.concurrency` captures at once (6 by default), each in its own
|
|
73
|
-
run
|
|
74
|
-
|
|
89
|
+
run - your Claude Code session up to 8 more, each in a background subagent of its own - but
|
|
90
|
+
never two runners on the same frame: a capture about a frame another runner holds waits for it,
|
|
91
|
+
and its tile says so ("Waits for 01-slide", the run holding it in its tooltip). One on a frame
|
|
92
|
+
your own session's run is working goes to that session at once, which decides how the two meet
|
|
93
|
+
- after, folded in, or a variant beside it ([Live Jam](live-jam.md#your-own-session-takes-the-work-028)).
|
|
75
94
|
|
|
76
95
|
## Review
|
|
77
96
|
|
|
78
97
|
When a run finishes, its tile turns to **Ready to review**, with a soft chime (`jam: { chime:
|
|
79
|
-
false }` silences it).
|
|
98
|
+
false }` silences it). In the Mac app, with notices on, a canvas you are not looking at sends a
|
|
99
|
+
notice too, and clicking it opens the review ([what needs you](boards-and-folders.md#what-is-new-what-needs-you)).
|
|
100
|
+
`V` opens the next one to review:
|
|
80
101
|
|
|
81
102
|
- **Review** shows the agent's reply beside each frame it changed, **before and after at
|
|
82
103
|
once**: side by side for a tall frame (a phone), one above the other for a wide one (a
|
|
@@ -92,13 +113,25 @@ run - "and this too".
|
|
|
92
113
|
When a capture asked for something new beside a frame - "a laptop version of this, next to
|
|
93
114
|
it" - the frame it pointed at was only where the new one goes. If the run made a new frame
|
|
94
115
|
and left the one you pointed at unchanged, the capture's thread moves onto the new frame
|
|
95
|
-
(when that capture ran alone, so the new frame is surely its own).
|
|
116
|
+
(when that capture ran alone, or its run put the frame on the board with `--run`, so the new frame is surely its own).
|
|
96
117
|
|
|
97
118
|
## A session: `J`
|
|
98
119
|
|
|
99
|
-
`J` (or the Jam button in the toolbar) opens the start sheet: what Marver listens to,
|
|
100
|
-
|
|
101
|
-
|
|
120
|
+
`J` (or the Jam button in the toolbar) opens the start sheet: what Marver listens to, who
|
|
121
|
+
works, three switches, and the keyboard shortcuts. **Start** (`⏎`) begins the session and its
|
|
122
|
+
first capture at once.
|
|
123
|
+
|
|
124
|
+
**Who works** (0.28): while the session runs, your tags and captures go to the coding-agent
|
|
125
|
+
session you already have open in the repo - "Your Claude Code session", with everything it
|
|
126
|
+
has. With several open, the newest takes the work; click the row for the next one. With none
|
|
127
|
+
open, a copy of your last session does the run. Claude Code hands each run to a background
|
|
128
|
+
subagent and is free again in seconds, so your captures run side by side; Marver gives Codex
|
|
129
|
+
and Cursor their runs one at a time. Starting the session connects every Claude
|
|
130
|
+
Code, Codex and Cursor session in the repo - nothing else to set up ([Live Jam](live-jam.md#your-own-session-takes-the-work-028)).
|
|
131
|
+
The three switches cover the runs Marver spawns: **MCP servers and skills** (on), **your
|
|
132
|
+
session's context** (on - off means no session and no copy take work, only fresh agents), and
|
|
133
|
+
**collaborators' comments** (off - only your own words reach the agent). They are kept for this
|
|
134
|
+
machine in `design/.local/jam/prefs.json`.
|
|
102
135
|
|
|
103
136
|
While a session runs, the canvas keeps its glowing edge and the Jam button its dot and
|
|
104
137
|
clock - seconds the first minute, then minutes - and the lane shows **Jam on**, listening
|
|
@@ -142,8 +175,9 @@ words. Other agents do not name captures.
|
|
|
142
175
|
## What your agent receives
|
|
143
176
|
|
|
144
177
|
Each capture reaches your agent as one job: its words with their times, your notes, every UI
|
|
145
|
-
step, the pictures, and the element under each
|
|
146
|
-
(`data-mv-loc`, the file and line it was written at, so the agent
|
|
178
|
+
step, the pictures (files it opens, since 0.29 - a live one marked), and the element under each
|
|
179
|
+
point with its source location (`data-mv-loc`, the file and line it was written at, so the agent
|
|
180
|
+
goes straight there). It
|
|
147
181
|
reads each distinct ask, acts on the reserved frames only, and replies per ask; the reply
|
|
148
182
|
shows in the review, beside the before and after pictures. The managed instructions
|
|
149
183
|
(`design/instructions/jam.md`, refreshed by `npx marver init`) spell this out for the agent.
|
|
@@ -152,12 +186,12 @@ shows in the review, beside the before and after pictures. The managed instructi
|
|
|
152
186
|
|
|
153
187
|
```ts
|
|
154
188
|
// design/config.ts
|
|
155
|
-
jam: { agent: "claude", concurrency: 6,
|
|
189
|
+
jam: { agent: "claude", concurrency: 6, chime: true, names: true, loc: true },
|
|
156
190
|
```
|
|
157
191
|
|
|
158
192
|
| Key | Default | What it does |
|
|
159
193
|
|---|---|---|
|
|
160
|
-
| `capture` | `"confirm"` |
|
|
194
|
+
| `capture` | `"confirm"` | No longer used (0.28): `E` queues a capture, `⇧E` stops to review it |
|
|
161
195
|
| `chime` | `true` | A soft chime when a capture is ready to review |
|
|
162
196
|
| `names` | `true` | Name each capture with Claude Haiku (Claude Code only) |
|
|
163
197
|
| `loc` | `true` | Stamp each element of your design files with `data-mv-loc` (dev only, never published) |
|
|
@@ -170,7 +204,7 @@ A bad value says so at boot and takes the default; nothing here turns Jam off.
|
|
|
170
204
|
| Where | Keys |
|
|
171
205
|
|---|---|
|
|
172
206
|
| Anywhere on the canvas | `S` capture · `J` session · `Q` the lane · `V` next to review |
|
|
173
|
-
| A capture recording | `E`
|
|
207
|
+
| A capture recording | `E` stop and queue · `⇧E` stop to review · `N` note · `I` picture · `L` laser · `⌥L` inspect · `Esc` drop |
|
|
174
208
|
| A read-back | `⏎` add to queue · `K` keep · `R` resume · `Esc` drop |
|
|
175
209
|
| A review | `⏎` looks good · `⇧⏎` more work · `→` later · `←` back · `B` both/before/after · `⌥←` `⌥→` frames · `Esc` leave |
|
|
176
210
|
| The lane (`Q`) | `←` `→` move · `⏎` open (or open/fold the Done tile) · `⌘⏎` do next · `K` keep · `⌫` drop · `Esc` leave |
|
package/docs/live-jam.md
CHANGED
|
@@ -42,6 +42,85 @@ With no agent CLI installed, jam stays off and both `init` and `marver dev` say
|
|
|
42
42
|
of going quiet. Workspaces created before 0.9.0 need no re-init; they resolve the same way
|
|
43
43
|
at every dev boot.
|
|
44
44
|
|
|
45
|
+
## Your own session takes the work (0.28)
|
|
46
|
+
|
|
47
|
+
Start a Jam session on the canvas (`J`, or the Jam button) - that is the one switch. While it runs, your tags and
|
|
48
|
+
captures go to the coding-agent session you already have open in the repo, with its conversation, its tools, your MCP
|
|
49
|
+
servers and skills. When it cannot take a run, a copy of it does; with nothing to copy, a fresh agent with the same
|
|
50
|
+
power. Outside a Jam session, tags go to a background run (a copy of your last session, by default).
|
|
51
|
+
|
|
52
|
+
Nothing to set up. `marver init`, `marver dev` and starting a Jam session write each tool's hooks once, locally -
|
|
53
|
+
`.claude/settings.local.json`, `.codex/hooks.json`, `.cursor/hooks.json` - and keep them out of git (a committed file is
|
|
54
|
+
never changed; one you removed by hand is not written back until you turn that tool on again in the start sheet).
|
|
55
|
+
|
|
56
|
+
| Tool | An idle session | A session at work | A copy of it |
|
|
57
|
+
|---|---|---|---|
|
|
58
|
+
| **Claude Code** | woken through its inbox; it takes the run | reads it between tool calls | `claude -p --resume <id> --fork-session` |
|
|
59
|
+
| **Codex** | a copy of it does the run | its `Stop` hook turns the end of the turn into "run `marver jam next`" | `codex exec fork <id>` |
|
|
60
|
+
| **Cursor** | a full-power Cursor agent does the run | its `stop` hook auto-submits the follow-up | none (Cursor has no fork) |
|
|
61
|
+
| opencode, Grok, droid, pi | background agents | - | - |
|
|
62
|
+
|
|
63
|
+
- **Codex asks you to trust new hooks once** - type `/hooks` in Codex. The start sheet says so while no session is
|
|
64
|
+
connected.
|
|
65
|
+
- **What the session is told**: one line naming the request - "Live Jam: new request from your Marver canvas -
|
|
66
|
+
"Intro frame redesign" (1a2b3c4d) - run `npx marver jam next`" (the same line sent again ends "(again)": Claude
|
|
67
|
+
Code drops a message identical to the one before it). Claude Code shows it in the inbox as a message from another
|
|
68
|
+
session, with a caution that it did not come from you; `design/AGENTS.md` ("Live Jam") tells the agent to expect it and take it as your request.
|
|
69
|
+
- **What the session does** (design/instructions/jam.md, "Runs from the canvas"): `npx marver jam next` takes the run
|
|
70
|
+
and prints a short brief - your request in your words, the frames, how to answer; `jam say <handle> "On it - ..."` posts one line at once; the
|
|
71
|
+
work, with subagents for a capture across frames; `jam progress <handle>` on a long run; `jam done <handle> --file
|
|
72
|
+
<f>` hands back the replies, and the canvas posts them and frees the frames. `jam release` gives a run back,
|
|
73
|
+
`jam status` and `jam mute` are there too. The commands travel through files under `design/.local/jam/`, signed
|
|
74
|
+
with the session's own key, so a sandbox that blocks localhost cannot stop them.
|
|
75
|
+
- **A capture's pictures are files** (0.29). Each request lists its pictures - the frame each shows and the file to
|
|
76
|
+
open, `design/.local/jam/pictures/<id>.png` - for whoever runs it: your session, a copy, a fresh agent. A `live` one,
|
|
77
|
+
from the Mac app, is your screen in play as you saw it; the others are fresh renders ([Jam sessions](jam-session.md)).
|
|
78
|
+
- **Claude Code dispatches, so it multitasks.** Its brief opens with a few lines for the session - start ONE
|
|
79
|
+
background subagent (the Agent tool, `run_in_background: true`) with the part of the brief below its `----` line and
|
|
80
|
+
what the conversation knows that matters, then `jam next` until nothing waits, and end the turn; every run, however
|
|
81
|
+
small, so the next request never waits behind one - and below the line
|
|
82
|
+
the subagent's own prompt: it owns that run, never takes another, says "On it", works and hands it back itself. A
|
|
83
|
+
subagent's commands carry the session's id, so they speak for its connection; one that cannot reach it adds the
|
|
84
|
+
`--as <id>` its prompt names. Your session is free again in seconds, so several runs go at once: a Claude Code
|
|
85
|
+
session holds up to 8 (Codex and Cursor 3 - Marver gives them their runs one at a time; `jam.sessionMax` caps every
|
|
86
|
+
session), and runs a session holds do not count against `jam.concurrency`, which caps only the runs Marver starts. A
|
|
87
|
+
background subagent's built-in tools can be fewer than the session's, and a permission it needs is asked in the
|
|
88
|
+
session. When you move a run elsewhere, the session is told to stop the subagent on it first, so nothing edits its
|
|
89
|
+
frames once it is released.
|
|
90
|
+
- **Two requests on one frame.** One frame never has two runners - except two runs of your own session: a request on a
|
|
91
|
+
frame your session's run is working is offered to it at once, its ping naming the run it overlaps ("overlaps your
|
|
92
|
+
run r-1a2b3c4d.1"). The session decides: send it to the subagent on that frame, to do after or fold in now, or make it
|
|
93
|
+
a variant in a new frame placed beside it (`boards place --run`). A run your session lets go of while another of its
|
|
94
|
+
runs holds the frame goes back to the queue and waits for the frame; a frame any other runner holds - a copy, a fresh
|
|
95
|
+
agent, your agent in chat - makes the request wait, and its tile says "Waits for <frame>".
|
|
96
|
+
- **A request with no frame** - a capture made on an empty board, a comment on the board itself, the session record -
|
|
97
|
+
goes to your session beside your other runs, in a slot of your session's: with your session full, its tile says
|
|
98
|
+
"Waits · your session is full" until it has room or you choose another session. A capture or a comment reserves no
|
|
99
|
+
frame: it makes what it asks for as new frames, each put on the board with `--run <handle>` (`boards pin <board>
|
|
100
|
+
<scene/frame> --run <handle>` on an empty board). The session record writes its one file and nothing else. With no
|
|
101
|
+
session taking the work it runs alone, as before - a run Marver starts finds the frames it made only when nothing runs
|
|
102
|
+
beside it - and so does one your session does not take or lets go of. Its tile says "Waits to run alone", and the
|
|
103
|
+
requests behind it "Waits · a run goes alone first". Once its run has put a frame on the board it holds that frame, and
|
|
104
|
+
from then on - let go of by your session, retried or tagged again - it is a request on that frame like any other.
|
|
105
|
+
- **Frames placed through Marver.** A run puts a frame next to another with `npx marver boards place <board>
|
|
106
|
+
<scene/frame> --after|--before <scene/frame>` (`--run <handle>`: the new frame is that run's, and its review pictures
|
|
107
|
+
it) - never by editing the board file. A request that still needs a file no run is given (a board file, the comment
|
|
108
|
+
logs, local state, a frame outside its run) comes back to you as a question saying which and why, never as "the
|
|
109
|
+
agent did not answer".
|
|
110
|
+
- **Who works** shows in the start sheet - with several sessions open, the newest takes the work and one click picks
|
|
111
|
+
another - and on every run's tile: "Dispatching" until your session takes it, then "Claude Code is working" (or
|
|
112
|
+
"Codex is working", "Agent is working"). Hover the tile for whose run it is - your session, a copy of it and why a
|
|
113
|
+
copy took it, or a background run; the run's status in its thread says the same.
|
|
114
|
+
- **An offer not taken** - Claude Code not pulling it in 2 minutes, a Codex or Cursor turn ending without taking it -
|
|
115
|
+
goes to a copy or a fresh agent. **A run your session took and went quiet on** for 15 minutes is stalled: give it
|
|
116
|
+
back, run it in the background, or drop it (the tag's status, or the tile's menu). The last two wait for your session
|
|
117
|
+
to let go - it is told to stop, its late `done` is refused, and the frames stay reserved until it releases the run or
|
|
118
|
+
its process is gone.
|
|
119
|
+
|
|
120
|
+
The start sheet's switches: **MCP servers and skills** (on) and **your session's context** (on) for the runs Marver
|
|
121
|
+
spawns, and **collaborators' comments** (off: only your own words reach any runner). Your own session keeps the tools
|
|
122
|
+
you gave it; with context off, no session and no copy take work - fresh agents only.
|
|
123
|
+
|
|
45
124
|
## The config block
|
|
46
125
|
|
|
47
126
|
```ts
|
|
@@ -54,10 +133,17 @@ jam: { agent: "claude", concurrency: 6 },
|
|
|
54
133
|
| `agent` | detected | The CLI the daemon spawns: `"claude"`, `"codex"`, `"cursor"`, `"droid"`, `"opencode"`, `"grok"`, or `"pi"` |
|
|
55
134
|
| `concurrency` | `6` | Frames worked on at once (1-16). The same frame never gets two agents |
|
|
56
135
|
| `subagents` | `true` | Inside one job, fan out one subagent per frame |
|
|
57
|
-
| `capture` | `"confirm"` |
|
|
136
|
+
| `capture` | `"confirm"` | No longer used (0.28): `E` queues a capture, `⇧E` stops to review it ([captures](jam-session.md#configuration)) |
|
|
58
137
|
| `chime` | `true` | A soft chime when a capture is ready to review |
|
|
59
138
|
| `names` | `true` | Name each capture with Claude Haiku through Claude Code - its words go to Anthropic (Claude Code only) |
|
|
60
139
|
| `loc` | `true` | Stamp design elements with `data-mv-loc` (file and line, dev only) so the agent goes straight to the source |
|
|
140
|
+
| `runner` | `"auto"` | Who runs a batch: `"auto"` - your session during a Jam session, else a copy of it, else a fresh agent; `"session"` - wait for a session, never fall back; `"background"` - never a session |
|
|
141
|
+
| `session` | `true` | Connect this repo's Claude Code, Codex and Cursor sessions (their hooks). `false`: none are written, and existing ones go quiet |
|
|
142
|
+
| `context` | `"fork"` | Background runs copy your session; `"fresh"` starts them fresh (and no session takes work) |
|
|
143
|
+
| `mcp` | `true` | Background runs use your MCP servers |
|
|
144
|
+
| `skills` | `true` | Background runs use your skills |
|
|
145
|
+
| `others` | `false` | Other people's words reach the agent, labelled; off: only yours |
|
|
146
|
+
| `sessionMax` | unset | Runs one session holds at once - unset: 8 for Claude Code (it dispatches each to a background subagent), 3 for Codex and Cursor; set, it caps every session |
|
|
61
147
|
|
|
62
148
|
Shorthands: `jam: "codex"` names the agent and takes the rest of the defaults, `jam: true`
|
|
63
149
|
is the default block, and **`jam: false` is the off switch**.
|
|
@@ -71,18 +157,17 @@ that fails to parse also leaves jam off, since it may have been the file that sa
|
|
|
71
157
|
## What the agent may do
|
|
72
158
|
|
|
73
159
|
Be clear-eyed about what this is. The real protection is not a sandbox - it is that the
|
|
74
|
-
agent doing the work is **your own**, running on **your machine**,
|
|
75
|
-
makes is a diff you review** before anything
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
network):
|
|
160
|
+
agent doing the work is **your own**, running on **your machine**, that **only your own words
|
|
161
|
+
reach it** by default, and that **every change it makes is a diff you review** before anything
|
|
162
|
+
is resolved. Since 0.28 a run Marver spawns for Claude Code, Codex or Cursor has full power -
|
|
163
|
+
the shell inside the tool's own sandbox, your MCP servers and skills, a copy of your session -
|
|
164
|
+
because a lesser agent was the wrong trade; the other CLIs keep their jails:
|
|
80
165
|
|
|
81
166
|
| | How it is spawned |
|
|
82
167
|
|---|---|
|
|
83
|
-
| **Claude Code** | `claude -p --permission-mode acceptEdits
|
|
84
|
-
| **Codex** | `codex exec -s workspace-write`,
|
|
85
|
-
| **Cursor** | `cursor-agent -p --sandbox enabled --trust
|
|
168
|
+
| **Claude Code** | `claude -p --permission-mode acceptEdits`; Bash runs in Claude Code's sandbox (writes in the repo, no network, `~/.ssh`, `~/.aws`, `~/.gnupg` and keychains unreadable - for the Read tool too - and no way out of the sandbox); every other permission question goes to `marver jam permit`, Marver's small MCP server named with `--permission-prompt-tool`: MCP tools and skills when on, the web, subagents and edits inside the repo are allowed, the rest refused, nobody is asked. A copy adds `--resume <id> --fork-session`; MCP off adds `--strict-mcp-config`, skills off `--disable-slash-commands` |
|
|
169
|
+
| **Codex** | `codex exec --approve-for-me` (Codex's own automatic reviewer answers approvals - MCP calls included - inside `workspace-write`, no network for the shell); a copy is `codex exec fork <id>` with the same settings; MCP off turns each server `codex mcp list` names off. Codex's sandbox does not limit reads: the shell has no network, and the reviewer judges what leaves |
|
|
170
|
+
| **Cursor** | `cursor-agent -p --sandbox enabled --trust`, plus `--approve-mcps` with MCP on - the shell runs inside the OS sandbox (network egress blocked); `--trust` only answers the workspace-trust prompt for the repo you already run `marver dev` in, and `--force` is never passed. Cursor's skills and already-approved MCP servers follow your own Cursor setup |
|
|
86
171
|
| **droid** | `droid exec --auto low` for file edits, with `--disabled-tools` removing the shell (`Execute`), the delegation tools (`Task`, missions), and the Slack/connector tools |
|
|
87
172
|
| **opencode** | `opencode run --pure` (no external plugins) with a per-run DEFAULT-DENY `OPENCODE_PERMISSION` grant - read/edit/search/web/task allowed by name, everything else (bash included) denied - never its all-approving `--auto` flag |
|
|
88
173
|
| **grok** | `grok -p --tools read_file,search_replace,list_dir,grep,todo_write` - an ALLOWLIST of read/edit tools only, so the shell, web, and subagents are simply absent (a deny-list is a footgun: it can miss a tool's real name); `--permission-mode acceptEdits` auto-applies the edits |
|
package/docs/performance.md
CHANGED
|
@@ -357,7 +357,7 @@ their reason. `--days <n>` (14 by default) and `--json` as elsewhere.
|
|
|
357
357
|
| Option | |
|
|
358
358
|
|---|---|
|
|
359
359
|
| `--loads` | each board load in full |
|
|
360
|
-
| `--jam` | Jam's timings |
|
|
360
|
+
| `--jam` | Jam's timings; with the Mac app, its live pictures kept, failed and rendered instead |
|
|
361
361
|
| `run <board>` | a headless run of the board ([Headless runs](#headless-runs)); with `--slow` and `--repeat <n>` (1-5) |
|
|
362
362
|
| `--runs` | the headless runs, compared inside their cohorts; with `--against <run>` and `--days <n>` (14) |
|
|
363
363
|
| `--crashes` | the Mac app's crashes and hangs of this repo's canvases (below) |
|
package/docs/publish.md
CHANGED
|
@@ -258,6 +258,13 @@ falls back to your `package.json` name and the canvas shell to the root
|
|
|
258
258
|
directory name - which inside a container is usually `app`, so every unnamed
|
|
259
259
|
containerised canvas reports as one campaign.
|
|
260
260
|
|
|
261
|
+
Your logo - `share.logo`, else the first of `design/logo.svg|png`, `public/logo.svg|png`
|
|
262
|
+
and `public/favicon.svg|png|ico` - ships with the build. The gate shows it, and since
|
|
263
|
+
0.29 it is the only tab icon of the canvas and the gate, so a browser tab (and the Mac
|
|
264
|
+
app's tab for a shared canvas) wears it rather than Marver's mark. With no logo, the tab
|
|
265
|
+
wears Marver's mark. A canvas built before 0.29 keeps Marver's mark until you build and
|
|
266
|
+
deploy it again.
|
|
267
|
+
|
|
261
268
|
## Railway (the one-pager)
|
|
262
269
|
|
|
263
270
|
1. Push your repo to GitHub with the Dockerfile below at its root, and create a Railway
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@marver-design/marver",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.29.0",
|
|
4
4
|
"description": "The agent-native design canvas. A design/ folder, one command, a canvas of live frames built from your repo's real components - comment @marver and your own coding agent does the work. The tool ships no AI.",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"private": false,
|
|
@@ -779,7 +779,7 @@ export function ThreadCard({ thread, at, bounds, nodeKey, side = 'r', flank, sta
|
|
|
779
779
|
if (sent.trim() && await useComments.getState().replyOk(thread.id, sent)) setText((cur) => (cur === sent ? '' : cur))
|
|
780
780
|
}
|
|
781
781
|
const card = (
|
|
782
|
-
<div ref={cardRef} data-sh-wheel-local className={`cm-card sh-no-pan${flip ? ' flip' : ''}${float ? ` parked dock-${side}` : ''}${float && flank ? ` flank-${flank}` : ''}${stage ? ' stage-dock' : ''}`} style={{ ...pos, ...hueVars(anchorHue(thread.anchor)) }}
|
|
782
|
+
<div ref={cardRef} data-sh-wheel-local data-thread={thread.id} className={`cm-card sh-no-pan${flip ? ' flip' : ''}${float ? ` parked dock-${side}` : ''}${float && flank ? ` flank-${flank}` : ''}${stage ? ' stage-dock' : ''}`} style={{ ...pos, ...hueVars(anchorHue(thread.anchor)) }}
|
|
783
783
|
onPointerDown={(e) => e.stopPropagation()} onClick={(e) => e.stopPropagation()} onWheel={(e) => e.stopPropagation()}>
|
|
784
784
|
{/* thread-level actions pin to the card corner, out of the header's flow -
|
|
785
785
|
the name row never has to share its line with them */}
|
|
@@ -986,8 +986,9 @@ export function IdentityDialog() {
|
|
|
986
986
|
)
|
|
987
987
|
}
|
|
988
988
|
|
|
989
|
-
/** Open a thread by id: activate, select its node, fit the camera. True on success.
|
|
990
|
-
|
|
989
|
+
/** Open a thread by id: activate, select its node, fit the camera. True on success. `alive` (a notice's request, A4.6
|
|
990
|
+
* #30) is read again when the camera moves: a request that ended meanwhile moves nothing. */
|
|
991
|
+
export function revealThread(c: string, alive: () => boolean = () => true): boolean {
|
|
991
992
|
const t = useComments.getState().threads.find((t) => t.id === c)
|
|
992
993
|
if (!t) return false
|
|
993
994
|
// resolve the host BEFORE activating: a thread whose frame is not on this board
|
|
@@ -996,7 +997,7 @@ export function revealThread(c: string): boolean {
|
|
|
996
997
|
if (!key) return false
|
|
997
998
|
useComments.getState().setActive(c)
|
|
998
999
|
useStore.getState().select(key)
|
|
999
|
-
setTimeout(() => canvasCtl.fitNode(key), 80)
|
|
1000
|
+
setTimeout(() => { if (alive()) canvasCtl.fitNode(key) }, 80)
|
|
1000
1001
|
return true
|
|
1001
1002
|
}
|
|
1002
1003
|
|
|
@@ -23,7 +23,8 @@ export const framePath = (board: string, f: { id: string; file: string }) => {
|
|
|
23
23
|
/** A menu row. `panel` makes it open a panel IN PLACE of the menu (a picker - the board's status),
|
|
24
24
|
* drawn by the caller and handed `close`; `onClick` then is not called. */
|
|
25
25
|
export type MenuItem = { label: string; icon: ReactNode; onClick?: () => void; panel?: (close: () => void) => ReactNode }
|
|
26
|
-
|
|
26
|
+
/** `id`: what the menu is for, on its element (`data-menu`) - a tile's menu opened by a notice's click is waited for by it */
|
|
27
|
+
export type MenuState = { x: number; y: number; items: MenuItem[]; id?: string }
|
|
27
28
|
export type MenuOpener = (e: { preventDefault(): void; clientX: number; clientY: number }, items: MenuItem[]) => void
|
|
28
29
|
|
|
29
30
|
/** A right-click menu for the sidebar. One instance lives in App; `open(e, items)` positions
|
|
@@ -32,13 +33,13 @@ export type MenuOpener = (e: { preventDefault(): void; clientX: number; clientY:
|
|
|
32
33
|
* keydown (which would clear the selection/laser underneath the menu). */
|
|
33
34
|
export function useContextMenu() {
|
|
34
35
|
const [menu, setMenu] = useState<MenuState | null>(null)
|
|
35
|
-
const open
|
|
36
|
+
const open = (e: Parameters<MenuOpener>[0], items: MenuItem[], id?: string) => {
|
|
36
37
|
e.preventDefault()
|
|
37
38
|
const MENU_W = 240 // the CSS max-width; labels ellipsize inside it
|
|
38
39
|
// a menu taller than the window (many "Move to …" folders) pins to the top edge and scrolls
|
|
39
40
|
// ...and never under the Mac app's strip (TOP 44 when the shell took the inset)
|
|
40
41
|
const h = Math.min(items.length * 32 + 12, window.innerHeight - 16 - TOP)
|
|
41
|
-
setMenu({ x: Math.max(8, Math.min(e.clientX, window.innerWidth - MENU_W - 8)), y: Math.max(TOP + 8, Math.min(e.clientY, window.innerHeight - h - 8)), items })
|
|
42
|
+
setMenu({ x: Math.max(8, Math.min(e.clientX, window.innerWidth - MENU_W - 8)), y: Math.max(TOP + 8, Math.min(e.clientY, window.innerHeight - h - 8)), items, ...(id ? { id } : {}) })
|
|
42
43
|
}
|
|
43
44
|
return { menu, open, close: () => setMenu(null) }
|
|
44
45
|
}
|
|
@@ -65,7 +66,7 @@ export function ContextMenu({ menu, close }: { menu: MenuState | null; close: ()
|
|
|
65
66
|
const app = document.querySelector('.sh-app')
|
|
66
67
|
if (!menu || !app) return null
|
|
67
68
|
return createPortal(
|
|
68
|
-
<div className={`sh-menu sh-ctxmenu${panel ? ' sh-ctxpanel' : ''}`} ref={ref} style={{ left: menu.x, top: top ?? menu.y }}>
|
|
69
|
+
<div className={`sh-menu sh-ctxmenu${panel ? ' sh-ctxpanel' : ''}`} ref={ref} data-menu={menu.id} style={{ left: menu.x, top: top ?? menu.y }}>
|
|
69
70
|
{panel ? panel(close) : menu.items.map((it) => (
|
|
70
71
|
<button key={it.label} onClick={() => { if (it.panel) { setPanel(() => it.panel!); return } it.onClick?.(); close() }}>{it.icon}<span>{it.label}</span></button>
|
|
71
72
|
))}
|