worktrust 0.10.38 → 0.11.1

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.
Files changed (49) hide show
  1. package/LICENSE +43 -18
  2. package/README.md +55 -2
  3. package/SECURITY.md +25 -0
  4. package/engine-release.json +1 -1
  5. package/log-session.mjs +6 -6
  6. package/package-release.json +1 -1
  7. package/package.json +43 -2
  8. package/remote-adapter-claude-code.mjs +113 -0
  9. package/remote-adapter-codex.mjs +159 -0
  10. package/remote-adapter-terminal.mjs +248 -0
  11. package/remote-approval-bridge.mjs +145 -0
  12. package/remote-approvals.mjs +134 -0
  13. package/remote-attachments.mjs +129 -0
  14. package/remote-cdp.mjs +60 -0
  15. package/remote-changes.mjs +94 -0
  16. package/remote-claude-events.mjs +212 -0
  17. package/remote-claude-progress.mjs +328 -0
  18. package/remote-cli.mjs +330 -0
  19. package/remote-coalesce.mjs +40 -0
  20. package/remote-codex-events.mjs +153 -0
  21. package/remote-daemon.mjs +220 -0
  22. package/remote-inventory.mjs +143 -0
  23. package/remote-journal.mjs +155 -0
  24. package/remote-live-preview.mjs +205 -0
  25. package/remote-pairing.mjs +104 -0
  26. package/remote-pipeline-config.mjs +177 -0
  27. package/remote-pipeline-parsers.mjs +121 -0
  28. package/remote-pipeline.mjs +234 -0
  29. package/remote-policy.mjs +199 -0
  30. package/remote-preview.mjs +146 -0
  31. package/remote-projects.mjs +87 -0
  32. package/remote-protocol.mjs +4010 -0
  33. package/remote-qr.mjs +175 -0
  34. package/remote-release-plans.mjs +88 -0
  35. package/remote-releases.mjs +297 -0
  36. package/remote-run.mjs +189 -0
  37. package/remote-screen-approvals.mjs +79 -0
  38. package/remote-screen-push.mjs +76 -0
  39. package/remote-screen-states.mjs +113 -0
  40. package/remote-service.mjs +101 -0
  41. package/remote-session-list.mjs +48 -0
  42. package/remote-sessions.mjs +337 -0
  43. package/remote-steered.mjs +114 -0
  44. package/remote-steering.mjs +97 -0
  45. package/remote-store.mjs +124 -0
  46. package/remote-terminal-cli.mjs +85 -0
  47. package/remote-terminal-sessions.mjs +291 -0
  48. package/remote-transport.mjs +88 -0
  49. package/worktrust.mjs +11 -4
package/remote-qr.mjs ADDED
@@ -0,0 +1,175 @@
1
+ /**
2
+ * A QR CODE FOR THE TERMINAL, WITHOUT A DEPENDENCY (2026-11-07; owner: pairing by scanning the computer's screen with the
3
+ * WorkTrust app). ISO/IEC 18004: byte mode, error correction level M, the smallest version 1 to 40 that holds the data,
4
+ * the mask with the lowest penalty, format and version information. `qrMatrix(text)` gives the modules (true = dark);
5
+ * `renderQr(matrix)` draws them with half-block characters, two module rows per line, black on an explicitly white
6
+ * background with a four-module white quiet zone, so it scans in a light or a dark terminal.
7
+ *
8
+ * Held by scripts/test-remote-qr.mjs against reference matrices from an independent encoder (recorded fixtures) and an
9
+ * independent structural decoder in the test itself.
10
+ */
11
+
12
+ // Level M, per version: [error correction codewords per block, blocks in group 1, data codewords each, group 2, each].
13
+ const EC_M = [null,
14
+ [10, 1, 16], [16, 1, 28], [26, 1, 44], [18, 2, 32], [24, 2, 43], [16, 4, 27], [18, 4, 31], [22, 2, 38, 2, 39], [22, 3, 36, 2, 37], [26, 4, 43, 1, 44],
15
+ [30, 1, 50, 4, 51], [22, 6, 36, 2, 37], [22, 8, 37, 1, 38], [24, 4, 40, 5, 41], [24, 5, 41, 5, 42], [28, 7, 45, 3, 46], [28, 10, 46, 1, 47], [26, 9, 43, 4, 44], [26, 3, 44, 11, 45], [26, 3, 41, 13, 42],
16
+ [26, 17, 42], [28, 17, 46], [28, 4, 47, 14, 48], [28, 6, 45, 14, 46], [28, 8, 47, 13, 48], [28, 19, 46, 4, 47], [28, 22, 45, 3, 46], [28, 3, 45, 23, 46], [28, 21, 45, 7, 46], [28, 19, 47, 10, 48],
17
+ [28, 2, 46, 29, 47], [28, 10, 46, 23, 47], [28, 14, 46, 21, 47], [28, 14, 46, 23, 47], [28, 12, 47, 26, 48], [28, 6, 47, 34, 48], [28, 29, 46, 14, 47], [28, 13, 46, 32, 47], [28, 40, 47, 7, 48], [28, 18, 47, 31, 48]];
18
+
19
+ const blocksOf = (v) => { const [ec, n1, d1, n2 = 0, d2 = 0] = EC_M[v]; return { ec, groups: [[n1, d1], [n2, d2]].filter(([n]) => n > 0) }; };
20
+ const dataCodewords = (v) => blocksOf(v).groups.reduce((s, [n, d]) => s + n * d, 0);
21
+
22
+ // GF(256) with the QR polynomial x^8 + x^4 + x^3 + x^2 + 1.
23
+ const EXP = new Uint8Array(512), LOG = new Uint8Array(256);
24
+ for (let i = 0, x = 1; i < 255; i += 1) { EXP[i] = x; LOG[x] = i; x <<= 1; if (x & 0x100) x ^= 0x11d; }
25
+ for (let i = 255; i < 512; i += 1) EXP[i] = EXP[i - 255];
26
+ const mul = (a, b) => (a === 0 || b === 0 ? 0 : EXP[LOG[a] + LOG[b]]);
27
+
28
+ function generator(degree) {
29
+ let g = [1];
30
+ for (let i = 0; i < degree; i += 1) {
31
+ const next = new Array(g.length + 1).fill(0);
32
+ for (let j = 0; j < g.length; j += 1) { next[j] ^= g[j]; next[j + 1] ^= mul(g[j], EXP[i]); }
33
+ g = next;
34
+ }
35
+ return g;
36
+ }
37
+ export function reedSolomon(data, degree) {
38
+ const g = generator(degree), rem = new Array(degree).fill(0);
39
+ for (const byte of data) {
40
+ const factor = byte ^ rem.shift();
41
+ rem.push(0);
42
+ for (let i = 0; i < degree; i += 1) rem[i] ^= mul(g[i + 1], factor);
43
+ }
44
+ return rem;
45
+ }
46
+
47
+ function codewords(bytes) {
48
+ let version = 1;
49
+ const need = (v) => 4 + (v < 10 ? 8 : 16) + bytes.length * 8;
50
+ while (version <= 40 && need(version) > dataCodewords(version) * 8) version += 1;
51
+ if (version > 40) throw new RangeError("too much data for one QR code");
52
+ const capacity = dataCodewords(version) * 8, bits = [];
53
+ const put = (value, length) => { for (let i = length - 1; i >= 0; i -= 1) bits.push((value >>> i) & 1); };
54
+ put(0b0100, 4);
55
+ put(bytes.length, version < 10 ? 8 : 16);
56
+ for (const b of bytes) put(b, 8);
57
+ put(0, Math.min(4, capacity - bits.length));
58
+ while (bits.length % 8) bits.push(0);
59
+ for (let pad = 0; bits.length < capacity; pad += 1) put(pad % 2 ? 0x11 : 0xec, 8);
60
+ const data = [];
61
+ for (let i = 0; i < bits.length; i += 8) data.push(bits.slice(i, i + 8).reduce((a, b) => (a << 1) | b, 0));
62
+ const { ec, groups } = blocksOf(version), blocks = [];
63
+ let at = 0;
64
+ for (const [n, d] of groups) for (let i = 0; i < n; i += 1) { const block = data.slice(at, at + d); at += d; blocks.push({ data: block, ec: reedSolomon(block, ec) }); }
65
+ const out = [], longest = Math.max(...blocks.map((b) => b.data.length));
66
+ for (let i = 0; i < longest; i += 1) for (const b of blocks) if (i < b.data.length) out.push(b.data[i]);
67
+ for (let i = 0; i < ec; i += 1) for (const b of blocks) out.push(b.ec[i]);
68
+ return { version, out };
69
+ }
70
+
71
+ export function alignmentCenters(version) {
72
+ if (version === 1) return [];
73
+ const count = Math.floor(version / 7) + 2, size = version * 4 + 17;
74
+ const step = size === 145 ? 26 : Math.ceil((size - 13) / (2 * count - 2)) * 2;
75
+ const centers = [size - 7];
76
+ for (let i = 1; i < count - 1; i += 1) centers[i] = centers[i - 1] - step;
77
+ centers.push(6);
78
+ return centers.reverse();
79
+ }
80
+
81
+ const bch = (value, poly, bitsOfPoly) => { let v = value << (bitsOfPoly - 1); while (31 - Math.clz32(v) >= bitsOfPoly - 1) v ^= poly << (31 - Math.clz32(v) - (bitsOfPoly - 1)); return v; };
82
+ export const formatBits = (mask) => { const data = (0b00 << 3) | mask; return ((data << 10) | bch(data, 0x537, 11)) ^ 0x5412; };
83
+ export const versionBits = (version) => (version << 12) | bch(version, 0x1f25, 13);
84
+
85
+ export const MASKS = [(r, c) => (r + c) % 2 === 0, (r) => r % 2 === 0, (r, c) => c % 3 === 0, (r, c) => (r + c) % 3 === 0,
86
+ (r, c) => (Math.floor(r / 2) + Math.floor(c / 3)) % 2 === 0, (r, c) => ((r * c) % 2) + ((r * c) % 3) === 0,
87
+ (r, c) => (((r * c) % 2) + ((r * c) % 3)) % 2 === 0, (r, c) => (((r * c) % 3) + ((r + c) % 2)) % 2 === 0];
88
+
89
+ function base(version) {
90
+ const size = version * 4 + 17;
91
+ const m = Array.from({ length: size }, () => new Array(size).fill(false));
92
+ const fixed = Array.from({ length: size }, () => new Array(size).fill(false));
93
+ const set = (r, c, dark) => { m[r][c] = dark; fixed[r][c] = true; };
94
+ for (const [r0, c0] of [[0, 0], [size - 7, 0], [0, size - 7]])
95
+ for (let r = -1; r <= 7; r += 1) for (let c = -1; c <= 7; c += 1) {
96
+ const rr = r0 + r, cc = c0 + c;
97
+ if (rr < 0 || cc < 0 || rr >= size || cc >= size) continue;
98
+ set(rr, cc, (r >= 0 && r <= 6 && (c === 0 || c === 6)) || (c >= 0 && c <= 6 && (r === 0 || r === 6)) || (r >= 2 && r <= 4 && c >= 2 && c <= 4));
99
+ }
100
+ for (let i = 8; i < size - 8; i += 1) { set(6, i, i % 2 === 0); set(i, 6, i % 2 === 0); }
101
+ const centers = alignmentCenters(version), last = centers.length - 1;
102
+ for (const [i, r] of centers.entries()) for (const [j, c] of centers.entries()) {
103
+ if ((i === 0 && j === 0) || (i === 0 && j === last) || (i === last && j === 0)) continue; // under a finder
104
+ for (let dr = -2; dr <= 2; dr += 1) for (let dc = -2; dc <= 2; dc += 1) set(r + dr, c + dc, Math.max(Math.abs(dr), Math.abs(dc)) !== 1);
105
+ }
106
+ for (let i = 0; i < 9; i += 1) { if (!fixed[8][i]) set(8, i, false); if (!fixed[i][8]) set(i, 8, false); }
107
+ for (let i = 0; i < 8; i += 1) { set(8, size - 1 - i, false); set(size - 1 - i, 8, false); }
108
+ set(size - 8, 8, true);
109
+ if (version >= 7) for (let i = 0; i < 18; i += 1) { const r = Math.floor(i / 3), c = (i % 3) + size - 11; set(r, c, false); set(c, r, false); }
110
+ return { size, m, fixed };
111
+ }
112
+
113
+ function place(version, words, mask) {
114
+ const { size, m, fixed } = base(version);
115
+ let bit = 0;
116
+ const total = words.length * 8, take = () => (bit < total ? (words[bit >> 3] >>> (7 - (bit++ & 7))) & 1 : 0);
117
+ for (let col = size - 1, up = true; col > 0; col -= 2, up = !up) {
118
+ if (col === 6) col -= 1;
119
+ for (let i = 0; i < size; i += 1) {
120
+ const r = up ? size - 1 - i : i;
121
+ for (const c of [col, col - 1]) if (!fixed[r][c]) m[r][c] = (take() === 1) !== MASKS[mask](r, c);
122
+ }
123
+ }
124
+ const f = formatBits(mask);
125
+ for (let i = 0; i < 15; i += 1) {
126
+ const dark = ((f >> i) & 1) === 1;
127
+ if (i < 6) m[i][8] = dark; else if (i < 8) m[i + 1][8] = dark; else m[size - 15 + i][8] = dark;
128
+ if (i < 8) m[8][size - i - 1] = dark; else if (i < 9) m[8][15 - i] = dark; else m[8][14 - i] = dark;
129
+ }
130
+ m[size - 8][8] = true;
131
+ if (version >= 7) { const v = versionBits(version); for (let i = 0; i < 18; i += 1) { const dark = ((v >> i) & 1) === 1, r = Math.floor(i / 3), c = (i % 3) + size - 11; m[r][c] = dark; m[c][r] = dark; } }
132
+ return m;
133
+ }
134
+
135
+ /** The penalty of ISO/IEC 18004 section 7.8.3 (N1 runs, N2 blocks, N3 finder-like patterns, N4 balance). */
136
+ export function penalty(m) {
137
+ const size = m.length;
138
+ let points = 0, dark = 0;
139
+ for (let line = 0; line < size; line += 1) for (const get of [(i) => m[line][i], (i) => m[i][line]]) {
140
+ let run = 1, bits = 0;
141
+ for (let i = 0; i < size; i += 1) {
142
+ if (i > 0) { if (get(i) === get(i - 1)) run += 1; else { if (run >= 5) points += run - 2; run = 1; } }
143
+ bits = ((bits << 1) & 0x7ff) | (get(i) ? 1 : 0);
144
+ if (i >= 10 && (bits === 0x5d0 || bits === 0x05d)) points += 40;
145
+ }
146
+ if (run >= 5) points += run - 2;
147
+ }
148
+ for (let r = 0; r < size; r += 1) for (let c = 0; c < size; c += 1) {
149
+ if (m[r][c]) dark += 1;
150
+ if (r < size - 1 && c < size - 1) { const s = m[r][c] + m[r][c + 1] + m[r + 1][c] + m[r + 1][c + 1]; if (s === 0 || s === 4) points += 3; }
151
+ }
152
+ return points + Math.abs(Math.ceil((dark * 100) / (size * size) / 5) - 10) * 10;
153
+ }
154
+
155
+ /** The modules of the QR code for `text` (UTF-8 bytes), `mask` chosen by penalty unless given. */
156
+ export function qrMatrix(text, forcedMask = null) {
157
+ const { version, out } = codewords(new TextEncoder().encode(text));
158
+ if (forcedMask !== null) return { version, mask: forcedMask, modules: place(version, out, forcedMask) };
159
+ let best = null;
160
+ for (let mask = 0; mask < 8; mask += 1) { const modules = place(version, out, mask), score = penalty(modules); if (!best || score < best.score) best = { version, mask, modules, score }; }
161
+ return { version: best.version, mask: best.mask, modules: best.modules };
162
+ }
163
+
164
+ /** Half blocks, black on white, a four-module quiet zone. `color` false gives the plain characters (dark = block). */
165
+ export function renderQr(modules, { color = true } = {}) {
166
+ const quiet = 4, size = modules.length + quiet * 2;
167
+ const dark = (r, c) => { const rr = r - quiet, cc = c - quiet; return rr >= 0 && cc >= 0 && rr < modules.length && cc < modules.length && modules[rr][cc]; };
168
+ const lines = [];
169
+ for (let r = 0; r < size; r += 2) {
170
+ let line = "";
171
+ for (let c = 0; c < size; c += 1) { const top = dark(r, c), bottom = r + 1 < size && dark(r + 1, c); line += top && bottom ? "█" : top ? "▀" : bottom ? "▄" : " "; }
172
+ lines.push(color ? `\x1b[30;107m${line}\x1b[0m` : line);
173
+ }
174
+ return lines.join("\n");
175
+ }
@@ -0,0 +1,88 @@
1
+ /**
2
+ * THE LOCAL AGENT'S PLANS ON THE COMPUTER'S ONE RELEASE QUEUE (owner, 2026-11-08), split out of remote-releases.mjs (its
3
+ * size), unchanged: the queue hands in what a plan may touch (its releases, its order, release.create, save, reopen,
4
+ * evaluate, the live feed, every task) and gets back `plan(session, op, args)`.
5
+ */
6
+ import * as P from "./remote-protocol.mjs";
7
+
8
+ /**
9
+ * THE LOCAL AGENT PLANS ITS OWN WORK (owner, 2026-11-08; remote-approval-bridge.mjs's plan_* tools, over the daemon's
10
+ * socket with the session's token). Scoped to the session's own project, validated as the phone's commands are, and it
11
+ * never runs anything: a planned task is the agent's own (`own`, its session), skipped by the scheduler, moved only by
12
+ * that session's plan_task. Each change is saved and sent at once (release.updated), so the phone sees it.
13
+ */
14
+ export function createPlanner(q) {
15
+ // q: { ctx, releases, order(), commands, save, reopen, evaluate, liveSoon, allTasks }, the queue's own (remote-releases.mjs)
16
+ const { ctx, releases, commands, save, reopen, evaluate, liveSoon, allTasks } = q;
17
+ const SELF_STATES = new Set(["running", "done", "failed"]);
18
+ const minutes = (m) => (m === undefined ? null : Number.isSafeInteger(m) && m >= 1 && m <= 7 * 24 * 60 ? { total_s: m * 60, confidence: "medium" } : false);
19
+ const text = (v, max) => (typeof v === "string" && v.trim() && v.trim().length <= max ? v.trim() : null);
20
+ const own = (session, t) => ({ task_id: P.mintId("tsk", ctx.random), label: t.title, adapter: session.adapter, model: session.model ?? null, mode: null, prompt: null, state: "queued", reason: null, note: null,
21
+ after_release: null, follow_up_of: null, session_id: null, started_at: null, ended_at: null, own: session.session_id, estimate: t.estimate });
22
+ const tasksOf = (list) => {
23
+ if (list === undefined) return [];
24
+ if (!Array.isArray(list) || list.length > P.MAX_RELEASE_TASKS) return null;
25
+ const out = list.map((t) => ({ title: text(t?.title, P.MAX_TASK_LABEL), estimate: minutes(t?.estimate_min) }));
26
+ return out.some((t) => t.title === null || t.estimate === false) ? null : out;
27
+ };
28
+ const inProject = (session, number) => [...releases.values()].find((r) => r.number === number && r.project_id === session.project_id) ?? null;
29
+ const KNOWN = { release: ["title", "label", "estimate_min", "after", "tasks"], task: ["release", "title", "estimate_min", "task_id", "state", "note"], list: [] };
30
+
31
+ function plan(session, op, args) {
32
+ if (!Object.hasOwn(KNOWN, op)) return { ok: false, reason: "unknown_type" };
33
+ const a = args && typeof args === "object" && !Array.isArray(args) ? args : {};
34
+ if (Object.keys(a).some((k) => !KNOWN[op].includes(k))) return { ok: false, reason: "payload" }; // no project, no path: the session's own
35
+ if (!ctx.projects().some((p) => p.project_id === session.project_id)) return { ok: false, reason: "not_found" };
36
+ if (op === "list") {
37
+ const open = [...releases.values()].filter((r) => r.project_id === session.project_id && !P.isEndedRelease(r.state)).sort((x, y) => q.order().indexOf(x.release_id) - q.order().indexOf(y.release_id));
38
+ return { ok: true, releases: open.map((r) => ({ release: r.number, ...(r.label ? { label: r.label } : {}), title: r.title, state: r.state, after: r.after_release ? releases.get(r.after_release)?.number ?? null : null,
39
+ tasks: r.tasks.map((t) => ({ task_id: t.task_id, title: t.label, state: t.state, mine: t.own === session.session_id })) })) };
40
+ }
41
+ if (op === "release") {
42
+ const tasks = tasksOf(a.tasks), estimate = minutes(a.estimate_min);
43
+ const after = a.after === undefined ? null : inProject(session, a.after);
44
+ if (a.after !== undefined && !after) return { ok: false, reason: "not_found" };
45
+ if (!tasks || estimate === false) return { ok: false, reason: "payload" };
46
+ const payload = { release_id: P.mintId("rel", ctx.random), title: typeof a.title === "string" ? a.title.trim() : "", ...(typeof a.label === "string" ? { label: a.label.trim() } : {}), ...(estimate ? { estimate } : {}),
47
+ project_id: session.project_id, after_release: after?.release_id ?? null, parallel: 1 };
48
+ if (!P.validateCommandPayload("release.create", payload).ok) return { ok: false, reason: "payload" };
49
+ const made = commands["release.create"](payload, { command_id: null });
50
+ if (made !== "taken") return { ok: false, reason: made };
51
+ const r = releases.get(payload.release_id);
52
+ r.tasks.push(...tasks.map((t) => own(session, t)));
53
+ save(r);
54
+ return { ok: true, release: r.number, release_id: r.release_id, tasks: r.tasks.map((t) => ({ task_id: t.task_id, title: t.label })) };
55
+ }
56
+ // op === "task": add one to a release of the project, or move one of the agent's own
57
+ if (a.task_id === undefined) {
58
+ const r = typeof a.release === "number" ? inProject(session, a.release) : null;
59
+ const [t] = tasksOf([{ title: a.title, estimate_min: a.estimate_min }]) ?? [];
60
+ if (!r) return { ok: false, reason: "not_found" };
61
+ if (!t) return { ok: false, reason: "payload" };
62
+ if (r.state === "released") return { ok: false, reason: "unsupported" };
63
+ if (r.tasks.length >= P.MAX_RELEASE_TASKS) return { ok: false, reason: "busy" };
64
+ reopen(r);
65
+ const task = own(session, t);
66
+ r.tasks.push(task);
67
+ save(r);
68
+ return { ok: true, release: r.number, task_id: task.task_id };
69
+ }
70
+ const found = allTasks().find(({ t }) => t.task_id === a.task_id);
71
+ if (!found || found.t.own !== session.session_id || found.r.project_id !== session.project_id) return { ok: false, reason: "not_found" };
72
+ const note = a.note === undefined ? null : text(a.note, P.MAX_TASK_NOTE);
73
+ if (!SELF_STATES.has(a.state) || (a.note !== undefined && note === null)) return { ok: false, reason: "payload" };
74
+ const { r, t } = found;
75
+ if (P.isEndedTask(t.state) || (a.state !== "running" && t.state !== "running")) return { ok: false, reason: "unsupported" };
76
+ if (a.state === "running") {
77
+ if (t.state === "running") return { ok: true, release: r.number, task_id: t.task_id };
78
+ Object.assign(t, { state: "running", session_id: session.session_id, started_at: ctx.now() });
79
+ if (r.state === "planned") Object.assign(r, { state: "in_progress", started_at: ctx.now() });
80
+ } else Object.assign(t, a.state === "done" ? { state: "done" } : { state: "failed", reason: "agent_failed", note }, { ended_at: ctx.now() });
81
+ save(r);
82
+ evaluate(r);
83
+ liveSoon();
84
+ return { ok: true, release: r.number, task_id: t.task_id };
85
+ }
86
+
87
+ return plan;
88
+ }
@@ -0,0 +1,297 @@
1
+ /**
2
+ * RELEASES AND THE ONE TASK QUEUE OF A COMPUTER (owner, 2026-11-07; docs/remote-agents/PROTOCOL.md "Releases").
3
+ *
4
+ * A release is a bundle of tasks in one project; several run at once and share ONE scheduler, so every task of every
5
+ * release waits in the same queue and none runs twice. A task runs as an ordinary remote session (remote-sessions.mjs:
6
+ * the steered ledger before the agent, events on the session's own stream), under the computer's session cap
7
+ * (settings max_sessions, default 4, the same cap the phone's own sessions count against). When a slot frees, the
8
+ * scheduler takes passes over the releases in their queue order and starts at most one task per release per pass, up to
9
+ * the release's own `parallel` (1 by default: its tasks share a working tree), so a long release never starves the next
10
+ * one and the first in line always goes first. A task or a release that waits for another release (`after_release`)
11
+ * starts once that release is ready or released; a follow-up task waits for the task it continues and resumes its agent
12
+ * session.
13
+ *
14
+ * At most once: a task is journaled `running`, with its session id, BEFORE its agent is started; a daemon that stops
15
+ * leaves it `running` in the journal and the next daemon closes it `failed` / `interrupted`, never starting it again.
16
+ * Queued tasks survive a restart and run. The prompt of a queued task is kept in the journal until it starts, then
17
+ * dropped (its label stays). When a release's tasks are all done, its reviewed pipeline runs (remote-pipeline.mjs); a
18
+ * release is `ready` only after that pipeline passed, or when the project has no pipeline at all. `released` is set at
19
+ * the desk (`worktrust remote releases released <number>`), never from the phone. A release may carry its own short name
20
+ * (`label`, "CLI 0.11.0") and its creator's estimate for the whole of it; the body sends the label and what is left of
21
+ * that estimate (releaseEta), only while the release has not ended and only as etaForDisplay shows it.
22
+ */
23
+ import * as P from "./remote-protocol.mjs";
24
+ import { adapterOf } from "./remote-inventory.mjs";
25
+ import { createPlanner } from "./remote-release-plans.mjs";
26
+ import { createCoalescer, DEFAULT_MAX_SESSIONS } from "./remote-sessions.mjs";
27
+
28
+ const HISTORY = 40;
29
+ /** The backlog is kept whole, so it is bounded (review 2026-11-07, P3-9). */
30
+ export const MAX_RELEASES = 500;
31
+
32
+ export function createReleases(ctx) {
33
+ // ctx: { journal, now, random, emit, projects(), settings(), paused(), inventory(), sessions, pipelines, deskMarks(), log }
34
+ const releases = new Map(ctx.journal.releases().map((r) => [r.release_id, structuredClone(r)]));
35
+ let order = [...new Set([...ctx.journal.releaseOrder().filter((id) => releases.has(id)), ...[...releases.values()].sort((a, b) => a.number - b.number).map((r) => r.release_id)])];
36
+ const coalesce = createCoalescer({ now: ctx.now });
37
+ const allTasks = () => [...releases.values()].flatMap((r) => r.tasks.map((t) => ({ r, t })));
38
+ const taskBySession = (sessionId) => { const all = allTasks().filter(({ t }) => t.session_id === sessionId); return all.find(({ t }) => t.state === "running") ?? all[0] ?? null; };
39
+ const delivered = (id) => id === null || P.releaseDelivered(releases.get(id)?.state ?? "planned");
40
+ const projectOf = (r) => ctx.projects().find((p) => p.project_id === r.project_id) ?? null;
41
+ const cap = () => ctx.settings().max_sessions ?? DEFAULT_MAX_SESSIONS;
42
+
43
+ function etaOf(r, t) {
44
+ if (t.state !== "queued" && t.state !== "running") return undefined;
45
+ // A task the agent planned: what is left of its own estimate, if it gave one; never history's guess for its work.
46
+ if (t.own) return P.releaseEta({ state: "in_progress", started_at: t.started_at }, t.estimate, ctx.now());
47
+ const durations = allTasks().filter(({ r: x, t: y }) => x.project_id === r.project_id && y.adapter === t.adapter && y.state === "done" && y.started_at !== null && y.ended_at !== null)
48
+ .slice(-HISTORY).map(({ t: y }) => (y.ended_at - y.started_at) / 1000);
49
+ const elapsed = t.state === "running" ? Math.max(0, (ctx.now() - t.started_at) / 1000) : 0;
50
+ const eta = P.etaForDisplay(P.etaFromHistory(durations, elapsed));
51
+ return eta.kind === "estimate" ? eta : undefined;
52
+ }
53
+
54
+ function body(r) {
55
+ const project = projectOf(r);
56
+ const tasks = r.tasks.map((t) => {
57
+ const eta = etaOf(r, t);
58
+ return { task_id: t.task_id, label: t.label, adapter: t.adapter, model: t.model, state: t.state, reason: t.reason, after_release: t.after_release, follow_up_of: t.follow_up_of,
59
+ session_id: t.session_id, started_at: t.started_at, duration_ms: t.started_at !== null && t.ended_at !== null ? Math.max(0, t.ended_at - t.started_at) : null, ...(eta ? { eta } : {}), ...(t.note && t.state === "failed" ? { note: t.note } : {}) };
60
+ });
61
+ // Its own name and what is left of its creator's estimate, only when it has them: nothing summed, nothing made up.
62
+ const eta = P.releaseEta(r, r.estimate, ctx.now());
63
+ return { release_id: r.release_id, number: r.number, title: r.title, ...(r.label ? { label: r.label } : {}), project_id: r.project_id, state: r.state, after_release: r.after_release, position: Math.max(0, order.indexOf(r.release_id)),
64
+ parallel: r.parallel, tasks, counts: P.releaseCounts(tasks), pipeline_config: project ? ctx.pipelines.state(project) : "absent", pipeline_run_id: r.pipeline_run_id,
65
+ created_at: r.created_at, started_at: r.started_at, ended_at: r.ended_at, ...(eta ? { eta } : {}) };
66
+ }
67
+
68
+ /** Journal first (fsync), then the phone. */
69
+ function save(r, commandId = null) {
70
+ ctx.journal.recordRelease(r);
71
+ ctx.emit(null, "release.updated", body(r), commandId);
72
+ }
73
+
74
+ function live() {
75
+ const sessions = ctx.sessions.activeList().slice(0, P.MAX_ACTIVE_SESSIONS).map((s) => {
76
+ const owner = taskBySession(s.session_id);
77
+ return { ...s, release_id: owner?.r.release_id ?? null, task_id: owner?.t.task_id ?? null };
78
+ });
79
+ const queued = allTasks().filter(({ r, t }) => t.state === "queued" && !t.own && r.state === "in_progress").length;
80
+ return { sessions, slots: { cap: Math.min(64, Math.max(1, cap())), running: ctx.sessions.runningCount(), queued }, pipelines: ctx.pipelines.running().slice(0, 16) };
81
+ }
82
+ const sendLive = () => ctx.emit(null, "agents.active", live());
83
+ const liveSoon = () => coalesce.offer("agents.active", sendLive);
84
+ const liveNow = () => coalesce.now("agents.active", sendLive);
85
+
86
+ function end(r, state) {
87
+ r.state = state;
88
+ r.ended_at = Math.max(ctx.now(), r.started_at ?? r.created_at);
89
+ save(r);
90
+ schedule(); // a release others wait for may have delivered
91
+ }
92
+
93
+ function startPipeline(r) {
94
+ const started = ctx.pipelines.start({ release_id: r.release_id, project_id: r.project_id });
95
+ if (!started.ok) return started.reason;
96
+ r.state = "verifying";
97
+ r.pipeline_run_id = started.run.pipeline_run_id;
98
+ save(r);
99
+ return "taken";
100
+ }
101
+
102
+ /** Every task ended: failed, or verify (a reviewed pipeline), or ready (no pipeline); an unreviewed one waits for the desk. */
103
+ function evaluate(r) {
104
+ if (r.state !== "in_progress" || r.tasks.length === 0) return;
105
+ const c = P.releaseCounts(r.tasks);
106
+ if (c.queued + c.running > 0) return;
107
+ if (c.failed > 0) return end(r, "failed");
108
+ if (c.done === 0) return;
109
+ const project = projectOf(r);
110
+ const state = project ? ctx.pipelines.state(project) : "absent";
111
+ if (state === "absent") return end(r, "ready");
112
+ if (state === "reviewed" && ctx.pipelines.runsAfterTasks(project)) startPipeline(r);
113
+ }
114
+
115
+ function startTask(r, t) {
116
+ const prior = t.follow_up_of ? r.tasks.find((x) => x.task_id === t.follow_up_of) : null;
117
+ const resume = prior?.session_id ? ctx.journal.session(prior.session_id)?.agent_session_ref ?? null : null;
118
+ const prompt = t.prompt;
119
+ Object.assign(t, { state: "running", session_id: P.mintId("ses", ctx.random), started_at: ctx.now(), prompt: null });
120
+ ctx.journal.recordRelease(r); // running, with its session, on disk before the agent starts
121
+ const refused = ctx.sessions.startTask({ session_id: t.session_id, project_id: r.project_id, adapter: t.adapter, model: t.model, permission_mode: t.mode, prompt, resume, name: t.label.slice(0, P.MAX_SESSION_NAME) });
122
+ if (refused) { Object.assign(t, { state: "failed", reason: "refused", ended_at: ctx.now() }); ctx.log("task_refused", { reason: refused }); }
123
+ save(r);
124
+ liveNow();
125
+ return !refused;
126
+ }
127
+
128
+ /** Free slots go to releases in queue order, one task per release per pass, each release up to its parallel. */
129
+ function schedule() {
130
+ if (ctx.paused()) return;
131
+ let free = cap() - ctx.sessions.runningCount();
132
+ let progressed = true;
133
+ while (free > 0 && progressed) {
134
+ progressed = false;
135
+ for (const id of order) {
136
+ if (free <= 0) break;
137
+ const r = releases.get(id);
138
+ if (!r || r.state !== "in_progress" || !delivered(r.after_release)) continue;
139
+ if (r.tasks.filter((t) => t.state === "running").length >= r.parallel) continue;
140
+ const t = r.tasks.find((x) => x.state === "queued" && !x.own && delivered(x.after_release) && (!x.follow_up_of || P.isEndedTask(r.tasks.find((y) => y.task_id === x.follow_up_of)?.state ?? "done")));
141
+ if (!t) continue;
142
+ if (startTask(r, t)) free -= 1;
143
+ progressed = true;
144
+ }
145
+ }
146
+ for (const r of releases.values()) evaluate(r);
147
+ }
148
+
149
+ /** remote-sessions.mjs reports a task's turn: completed, failed or stopped. */
150
+ function taskEnded(sessionId, outcome) {
151
+ const owner = taskBySession(sessionId);
152
+ if (!owner || owner.t.state !== "running") return;
153
+ const { r, t } = owner;
154
+ Object.assign(t, outcome === "completed" ? { state: "done" } : outcome === "stopped" ? { state: "cancelled", reason: "stopped" } : { state: "failed", reason: "agent_failed" }, { ended_at: ctx.now() });
155
+ save(r);
156
+ Promise.resolve(ctx.sessions.closeTask(sessionId)).catch(() => {}).finally(() => { schedule(); liveNow(); });
157
+ evaluate(r);
158
+ }
159
+
160
+ /** remote-pipeline.mjs reports a run's end. */
161
+ function pipelineEnded(p) {
162
+ const r = p.release_id ? releases.get(p.release_id) : null;
163
+ // A run journaled before its release was saved verifying (a stop in between) still ends that release (P3-6).
164
+ const unsaved = r && r.state === "in_progress" && r.pipeline_run_id === null && p.reason === "interrupted";
165
+ if (unsaved) { r.pipeline_run_id = p.pipeline_run_id; r.state = "verifying"; }
166
+ if (!r || r.pipeline_run_id !== p.pipeline_run_id || r.state !== "verifying") { liveSoon(); return; }
167
+ if (p.state === "passed") end(r, "ready");
168
+ else if (p.state === "cancelled") { r.state = "in_progress"; save(r); }
169
+ else end(r, "failed");
170
+ liveNow();
171
+ }
172
+
173
+ const reopen = (r) => {
174
+ if (r.state === "verifying" && r.pipeline_run_id) ctx.pipelines.cancel(r.pipeline_run_id);
175
+ if (r.state === "verifying" || r.state === "ready" || r.state === "failed") Object.assign(r, { state: "in_progress", ended_at: null });
176
+ };
177
+
178
+ const commands = {
179
+ "release.create"(p, env) {
180
+ if (releases.has(p.release_id)) return "conflict";
181
+ if (releases.size >= MAX_RELEASES) return "busy";
182
+ if (!ctx.projects().some((x) => x.project_id === p.project_id) || (p.after_release && !releases.has(p.after_release))) return "not_found";
183
+ const number = Math.max(0, ...[...releases.values()].map((r) => r.number)) + 1;
184
+ // The label is the creator's own words (the person's or the agent's), trimmed and capped; never a path or a folder name.
185
+ const label = typeof p.label === "string" ? p.label.trim().slice(0, P.MAX_RELEASE_LABEL) || null : null;
186
+ const r = { release_id: p.release_id, number, title: p.title, label, estimate: p.estimate ?? null, project_id: p.project_id, state: "planned", after_release: p.after_release, parallel: p.parallel, tasks: [], pipeline_run_id: null, created_at: ctx.now(), started_at: null, ended_at: null };
187
+ releases.set(r.release_id, r);
188
+ order.push(r.release_id);
189
+ ctx.journal.recordReleaseOrder(order);
190
+ save(r, env.command_id);
191
+ return "taken";
192
+ },
193
+ "release.add_task"(p, env) {
194
+ const r = releases.get(p.release_id);
195
+ if (!r || (p.after_release && !releases.has(p.after_release)) || (p.follow_up_of && !r.tasks.some((t) => t.task_id === p.follow_up_of))) return "not_found";
196
+ if (allTasks().some(({ t }) => t.task_id === p.task_id)) return "conflict";
197
+ if (r.state === "released") return "unsupported";
198
+ if (r.tasks.length >= P.MAX_RELEASE_TASKS) return "busy";
199
+ const refused = P.checkStart({ adapter: p.adapter, model: p.model, permission_mode: p.permission_mode, resume: null, prompt: p.prompt }, adapterOf(ctx.inventory(), p.adapter));
200
+ if (refused) return refused;
201
+ if (p.adapter !== "claude-code") return "unsupported";
202
+ const label = (p.label ?? p.prompt.split("\n").map((l) => l.trim()).find(Boolean) ?? "Task").slice(0, P.MAX_TASK_LABEL);
203
+ reopen(r);
204
+ r.tasks.push({ task_id: p.task_id, label, adapter: p.adapter, model: p.model, mode: p.permission_mode, prompt: p.prompt, state: "queued", reason: null, after_release: p.after_release, follow_up_of: p.follow_up_of, session_id: null, started_at: null, ended_at: null });
205
+ save(r, env.command_id);
206
+ schedule();
207
+ return "taken";
208
+ },
209
+ "release.reorder"(p, env) {
210
+ if (p.what === "tasks") {
211
+ const r = releases.get(p.release_id);
212
+ if (!r) return "not_found";
213
+ const queued = r.tasks.filter((t) => t.state === "queued").map((t) => t.task_id);
214
+ if (queued.length !== p.task_ids.length || !queued.every((id) => p.task_ids.includes(id))) return "conflict";
215
+ const next = [...p.task_ids], byId = new Map(r.tasks.map((t) => [t.task_id, t]));
216
+ r.tasks = r.tasks.map((t) => (t.state === "queued" ? byId.get(next.shift()) : t)); // the queued slots, in the new order
217
+ save(r, env.command_id);
218
+ } else {
219
+ const open = order.filter((id) => !P.isEndedRelease(releases.get(id).state));
220
+ if (open.length !== p.release_ids.length || !open.every((id) => p.release_ids.includes(id))) return "conflict";
221
+ order = [...p.release_ids, ...order.filter((id) => !p.release_ids.includes(id))];
222
+ ctx.journal.recordReleaseOrder(order);
223
+ for (const id of p.release_ids) save(releases.get(id), env.command_id);
224
+ }
225
+ schedule();
226
+ return "taken";
227
+ },
228
+ async "release.cancel_task"(p) {
229
+ const r = releases.get(p.release_id);
230
+ const t = r?.tasks.find((x) => x.task_id === p.task_id);
231
+ if (!t) return "not_found";
232
+ if (t.state === "queued") { Object.assign(t, { state: "cancelled", prompt: null, ended_at: ctx.now() }); save(r); evaluate(r); schedule(); return "taken"; }
233
+ if (t.state !== "running") return "unsupported";
234
+ if (!(await ctx.sessions.stopTask(t.session_id))) taskEnded(t.session_id, "stopped"); // its agent was already gone
235
+ return "taken";
236
+ },
237
+ "release.start"(p, env) {
238
+ const r = releases.get(p.release_id);
239
+ if (!r) return "not_found";
240
+ if (r.state !== "planned") return r.state === "in_progress" ? "taken" : "unsupported";
241
+ Object.assign(r, { state: "in_progress", started_at: ctx.now() });
242
+ save(r, env.command_id);
243
+ schedule();
244
+ return "taken";
245
+ },
246
+ "release.list"(p, env) {
247
+ const all = [...releases.values()].filter((r) => p.project_id === null || r.project_id === p.project_id).sort((a, b) => b.number - a.number);
248
+ const after = all.filter((r) => p.before_number === null || r.number < p.before_number);
249
+ const page = after.slice(0, p.limit);
250
+ ctx.emit(null, "release.page", { releases: page.map(body), next_before: after.length > page.length ? page.at(-1).number : null, total: all.length }, env.command_id);
251
+ return "taken";
252
+ },
253
+ "pipeline.start"(p) {
254
+ const r = releases.get(p.release_id);
255
+ if (!r) return "not_found";
256
+ if (!["in_progress", "ready", "failed"].includes(r.state)) return r.state === "verifying" ? "busy" : "unsupported";
257
+ const c = P.releaseCounts(r.tasks);
258
+ if (c.queued + c.running > 0) return "busy";
259
+ return startPipeline(r);
260
+ },
261
+ "pipeline.cancel"(p) { return ctx.pipelines.cancel(p.pipeline_run_id) ? "taken" : "not_found"; },
262
+ };
263
+
264
+ // The local agent plans its own work (remote-release-plans.mjs): the same queue, scoped to the session's project.
265
+ const plan = createPlanner({ ctx, releases, order: () => order, commands, save, reopen, evaluate, liveSoon, allTasks });
266
+
267
+ return {
268
+ plan,
269
+ /** One release or pipeline command → "taken" or a reject reason. */
270
+ handle: async (env, payload) => (Object.hasOwn(commands, env.type) ? commands[env.type](payload, env) : "unknown_type"),
271
+ taskEnded,
272
+ pipelineEnded,
273
+ activity: liveSoon,
274
+ /** At start: tasks an earlier daemon left running are interrupted (never run again); queued ones wait and run. */
275
+ recover() {
276
+ let interrupted = 0;
277
+ for (const r of releases.values()) {
278
+ const open = r.tasks.filter((t) => t.state === "running");
279
+ for (const t of open) Object.assign(t, { state: "failed", reason: "interrupted", ended_at: Math.max(ctx.now(), t.started_at ?? 0) });
280
+ if (open.length > 0) { interrupted += open.length; save(r); }
281
+ }
282
+ return interrupted;
283
+ },
284
+ /** The desk's marks (`worktrust remote releases released <n>`), and whatever a freed slot or a lifted pause allows. */
285
+ poll() {
286
+ const marks = new Set(ctx.deskMarks());
287
+ for (const r of releases.values()) if (r.state === "ready" && marks.has(r.number)) { r.state = "released"; save(r); }
288
+ schedule();
289
+ },
290
+ schedule,
291
+ /** The release task a session runs for, or null (the inventory's project tree). */
292
+ ownerOf: (sessionId) => { const o = taskBySession(sessionId); return o ? { release_id: o.r.release_id, task_id: o.t.task_id } : null; },
293
+ body: (id) => (releases.has(id) ? body(releases.get(id)) : null),
294
+ all: () => [...releases.values()].map(body),
295
+ live,
296
+ };
297
+ }