tryharness 0.7.60 → 0.7.62
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/lib/adoption.mjs +252 -0
- package/lib/boardProtocol.json +22 -1
- package/lib/daemon.mjs +46 -4
- package/lib/environments.mjs +19 -2
- package/lib/harnessOffers.mjs +2 -1
- package/lib/jobAnswers.mjs +13 -4
- package/lib/landed.mjs +36 -1
- package/lib/ownMachines.mjs +13 -1
- package/lib/phones.mjs +27 -0
- package/lib/plans.mjs +33 -1
- package/lib/recentRead.mjs +42 -0
- package/lib/store.mjs +41 -0
- package/lib/swarm.mjs +48 -2
- package/lib/threadActions.mjs +1 -1
- package/lib/threadAuthority.mjs +14 -8
- package/npm-shrinkwrap.json +14 -14
- package/package.json +4 -4
- package/release.json +19 -17
package/lib/adoption.mjs
ADDED
|
@@ -0,0 +1,252 @@
|
|
|
1
|
+
// A thread that started in another tool (T3 Code) becomes a Harness thread the moment the person adds work to it, so
|
|
2
|
+
// every agent in the swarm can take part, not only the ones that tool runs. The thread keeps the tool's session as its
|
|
3
|
+
// agent's session there: Claude Code's next turn carries on in the same T3 Code thread (threadRuns.mjs t3Turn reads
|
|
4
|
+
// `t3-thread:<thread>:<agent>`), the conversation so far comes along, and the work already finished there becomes the
|
|
5
|
+
// thread's first runs, which new steps can wait on and take answers from like any other work. Work still going in the
|
|
6
|
+
// tool stays there; the thread shows it, steps wait on it (plans.mjs `outside`), and once it ends it is kept here too.
|
|
7
|
+
// The tool's own listing of the thread stops showing in Harness (environments.mjs `adopted`), so the person sees one
|
|
8
|
+
// thread.
|
|
9
|
+
|
|
10
|
+
const INDEX_KEY = "adopted";
|
|
11
|
+
const recordKey = (outsideId) => `adopted:${outsideId}`;
|
|
12
|
+
const fromKey = (threadId) => `adopted-from:${threadId}`;
|
|
13
|
+
const ENDED = { done: "done", failed: "failed" };
|
|
14
|
+
|
|
15
|
+
export function createAdoption({
|
|
16
|
+
store,
|
|
17
|
+
environments,
|
|
18
|
+
worktrees,
|
|
19
|
+
roomAgents,
|
|
20
|
+
provenanceFor,
|
|
21
|
+
defaults,
|
|
22
|
+
notifyBoard = () => {},
|
|
23
|
+
log = () => {},
|
|
24
|
+
}) {
|
|
25
|
+
const json = (key, fallback) => {
|
|
26
|
+
try {
|
|
27
|
+
return JSON.parse(store.meta(key) || "null") ?? fallback;
|
|
28
|
+
} catch {
|
|
29
|
+
return fallback;
|
|
30
|
+
}
|
|
31
|
+
};
|
|
32
|
+
const recordOf = (outsideId) => {
|
|
33
|
+
const record = json(recordKey(outsideId), null);
|
|
34
|
+
return record && store.getTask(record.thread) ? record : null;
|
|
35
|
+
};
|
|
36
|
+
const save = (outsideId, record) =>
|
|
37
|
+
store.meta(recordKey(outsideId), JSON.stringify(record));
|
|
38
|
+
const recordOfThread = (threadId) => {
|
|
39
|
+
const outsideId = store.meta(fromKey(threadId));
|
|
40
|
+
return outsideId ? { outsideId, record: recordOf(outsideId) } : null;
|
|
41
|
+
};
|
|
42
|
+
const agentHere = (agent) => roomAgents.includes(agent);
|
|
43
|
+
// Each adoption under way, so two presses at once make one thread.
|
|
44
|
+
const adopting = new Map();
|
|
45
|
+
|
|
46
|
+
/** A finished run from the tool, kept as the thread's own task. */
|
|
47
|
+
const keep = (threadId, run) =>
|
|
48
|
+
store.recordOutsideRun({
|
|
49
|
+
goalId: threadId,
|
|
50
|
+
agent: run.agent,
|
|
51
|
+
objective: String(run.ask || "Work in T3 Code")
|
|
52
|
+
.trim()
|
|
53
|
+
.slice(0, 2_000),
|
|
54
|
+
result: run.answer ?? null,
|
|
55
|
+
status: ENDED[run.status] ?? "unknown",
|
|
56
|
+
sessionId: run.sessionId ?? null,
|
|
57
|
+
startedAt: run.startedAt,
|
|
58
|
+
endedAt: run.endedAt,
|
|
59
|
+
});
|
|
60
|
+
/** What the canvas needs of a run still going in the tool, kept so it shows after a restart too. */
|
|
61
|
+
const snapshot = (run) => ({
|
|
62
|
+
id: run.id,
|
|
63
|
+
agent: run.agent,
|
|
64
|
+
ask: run.ask,
|
|
65
|
+
askedBy: run.askedBy,
|
|
66
|
+
after: run.after ?? [],
|
|
67
|
+
status: "running",
|
|
68
|
+
startedAt: run.startedAt,
|
|
69
|
+
sessionId: run.sessionId ?? null,
|
|
70
|
+
folder: run.folder ?? null,
|
|
71
|
+
source: run.source ?? null,
|
|
72
|
+
model: run.model ?? null,
|
|
73
|
+
});
|
|
74
|
+
|
|
75
|
+
async function take(outsideId) {
|
|
76
|
+
const read = await environments.read(outsideId);
|
|
77
|
+
if (!read.ok) return read;
|
|
78
|
+
const kept = recordOf(outsideId);
|
|
79
|
+
if (kept) return { ok: true, thread: kept.thread, runs: kept.runs };
|
|
80
|
+
const { thread: outside, runs, posts } = read;
|
|
81
|
+
const root = runs.find((run) => run.id === outsideId) ?? runs[0];
|
|
82
|
+
const team = [...new Set([...outside.agents.filter(agentHere), "harness"])];
|
|
83
|
+
const thread = store.createGoal({
|
|
84
|
+
objective: String(outside.title || "Work from T3 Code").slice(0, 120),
|
|
85
|
+
originAgent: "user",
|
|
86
|
+
provenance: provenanceFor("user"),
|
|
87
|
+
team,
|
|
88
|
+
facilitator: "harness",
|
|
89
|
+
workspace: outside.folder ?? root?.folder ?? null,
|
|
90
|
+
maxPosts: defaults.maxPosts,
|
|
91
|
+
maxWakes: defaults.maxWakes,
|
|
92
|
+
});
|
|
93
|
+
// The agent's turns from here go into the same T3 Code thread, in the checkout T3 made for it or in the project.
|
|
94
|
+
const own = environments.work(outsideId);
|
|
95
|
+
if (own && !own.inPlace) worktrees.inT3(thread.id, own.path, own.branch);
|
|
96
|
+
else {
|
|
97
|
+
worktrees.inPlace(thread.id);
|
|
98
|
+
worktrees.inT3(thread.id);
|
|
99
|
+
}
|
|
100
|
+
if (root && agentHere(root.agent) && root.source?.threadId)
|
|
101
|
+
store.meta(`t3-thread:${thread.id}:${root.agent}`, root.source.threadId);
|
|
102
|
+
store.roomPost({
|
|
103
|
+
goalId: thread.id,
|
|
104
|
+
author: "harness",
|
|
105
|
+
kind: "note",
|
|
106
|
+
text: `This thread started in ${outside.source?.environmentName ?? "T3 Code"}. What was said there is below; ${root ? `${root.agent}'s next turn carries on in the same session there` : "its session stays there"}.`,
|
|
107
|
+
});
|
|
108
|
+
for (const post of posts)
|
|
109
|
+
if (post.author === "user" || agentHere(post.author))
|
|
110
|
+
store.roomPost({
|
|
111
|
+
goalId: thread.id,
|
|
112
|
+
author: post.author,
|
|
113
|
+
kind: "post",
|
|
114
|
+
text: post.text,
|
|
115
|
+
});
|
|
116
|
+
const record = {
|
|
117
|
+
thread: thread.id,
|
|
118
|
+
runs: {},
|
|
119
|
+
parents: {},
|
|
120
|
+
sources: {},
|
|
121
|
+
pending: {},
|
|
122
|
+
};
|
|
123
|
+
for (const run of runs) {
|
|
124
|
+
if (!agentHere(run.agent)) continue;
|
|
125
|
+
record.parents[run.id] = run.after ?? [];
|
|
126
|
+
if (run.status === "running") {
|
|
127
|
+
record.pending[run.id] = snapshot(run);
|
|
128
|
+
continue;
|
|
129
|
+
}
|
|
130
|
+
const task = keep(thread.id, run);
|
|
131
|
+
record.runs[run.id] = task.id;
|
|
132
|
+
record.sources[task.id] = { ...run.source, outsideRun: run.id };
|
|
133
|
+
}
|
|
134
|
+
save(outsideId, record);
|
|
135
|
+
store.meta(fromKey(thread.id), outsideId);
|
|
136
|
+
store.meta(
|
|
137
|
+
INDEX_KEY,
|
|
138
|
+
JSON.stringify([...new Set([...json(INDEX_KEY, []), outsideId])])
|
|
139
|
+
);
|
|
140
|
+
log(`adopted ${outsideId} as ${thread.id}`);
|
|
141
|
+
notifyBoard(store.getTask(thread.id));
|
|
142
|
+
return { ok: true, thread: thread.id, runs: record.runs };
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
/** The tool's work as one Harness thread: the thread's id and each run's id there, made once. */
|
|
146
|
+
function adopt(outsideId) {
|
|
147
|
+
const kept = recordOf(outsideId);
|
|
148
|
+
if (kept)
|
|
149
|
+
return Promise.resolve({
|
|
150
|
+
ok: true,
|
|
151
|
+
thread: kept.thread,
|
|
152
|
+
runs: kept.runs,
|
|
153
|
+
});
|
|
154
|
+
if (!adopting.has(outsideId))
|
|
155
|
+
adopting.set(
|
|
156
|
+
outsideId,
|
|
157
|
+
take(outsideId).finally(() => adopting.delete(outsideId))
|
|
158
|
+
);
|
|
159
|
+
return adopting.get(outsideId);
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
/** Runs that ended in the tool since the last look are kept here; steps waiting on them move on. */
|
|
163
|
+
async function sync() {
|
|
164
|
+
for (const outsideId of json(INDEX_KEY, [])) {
|
|
165
|
+
const record = recordOf(outsideId);
|
|
166
|
+
if (!record || !Object.keys(record.pending).length) continue;
|
|
167
|
+
const read = await environments.read(outsideId).catch((error) => ({
|
|
168
|
+
ok: false,
|
|
169
|
+
error: error.message,
|
|
170
|
+
}));
|
|
171
|
+
if (!read.ok) continue;
|
|
172
|
+
const ended = [];
|
|
173
|
+
for (const [id, waiting] of Object.entries(record.pending)) {
|
|
174
|
+
const run = read.runs.find((entry) => entry.id === id);
|
|
175
|
+
if (run?.status === "running") continue;
|
|
176
|
+
const task = keep(
|
|
177
|
+
record.thread,
|
|
178
|
+
run ?? {
|
|
179
|
+
...waiting,
|
|
180
|
+
status: "unknown",
|
|
181
|
+
answer: "This work is no longer in T3 Code.",
|
|
182
|
+
}
|
|
183
|
+
);
|
|
184
|
+
record.runs[id] = task.id;
|
|
185
|
+
record.sources[task.id] = { ...waiting.source, outsideRun: id };
|
|
186
|
+
delete record.pending[id];
|
|
187
|
+
ended.push({ id, task });
|
|
188
|
+
}
|
|
189
|
+
if (!ended.length) continue;
|
|
190
|
+
save(outsideId, record);
|
|
191
|
+
for (const { id, task } of ended) {
|
|
192
|
+
plans?.remap(record.thread, id, task.id);
|
|
193
|
+
notifyBoard(task);
|
|
194
|
+
}
|
|
195
|
+
}
|
|
196
|
+
}
|
|
197
|
+
let plans = null;
|
|
198
|
+
|
|
199
|
+
return {
|
|
200
|
+
adopt,
|
|
201
|
+
sync,
|
|
202
|
+
/** Plans are made after this; they learn of work that ends in the tool through `remap`. */
|
|
203
|
+
usePlans: (made) => {
|
|
204
|
+
plans = made;
|
|
205
|
+
},
|
|
206
|
+
/** Whether a Harness thread took over this work in the tool. */
|
|
207
|
+
adopted: (outsideId) => Boolean(store.meta(recordKey(outsideId))),
|
|
208
|
+
/** Whether work in the tool is still going for a thread here: then the tool is read while nothing else asks. */
|
|
209
|
+
waiting: () =>
|
|
210
|
+
json(INDEX_KEY, []).some(
|
|
211
|
+
(id) => Object.keys(recordOf(id)?.pending ?? {}).length
|
|
212
|
+
),
|
|
213
|
+
/** For plans: work still going in the tool waits; anything else is not the tool's. */
|
|
214
|
+
outside: (threadId, ref) =>
|
|
215
|
+
recordOfThread(threadId)?.record?.pending[ref]
|
|
216
|
+
? { state: "waiting" }
|
|
217
|
+
: null,
|
|
218
|
+
/** The thread's runs still going in the tool, as the canvas draws runs. */
|
|
219
|
+
pending: (threadId) =>
|
|
220
|
+
Object.values(recordOfThread(threadId)?.record?.pending ?? {}).map(
|
|
221
|
+
(run) => ({
|
|
222
|
+
...run,
|
|
223
|
+
after: run.after.map(
|
|
224
|
+
(ref) => recordOfThread(threadId).record.runs[ref] ?? ref
|
|
225
|
+
),
|
|
226
|
+
kind: "task",
|
|
227
|
+
answer: null,
|
|
228
|
+
endedAt: null,
|
|
229
|
+
steps: [],
|
|
230
|
+
subagents: [],
|
|
231
|
+
usage: null,
|
|
232
|
+
})
|
|
233
|
+
),
|
|
234
|
+
/** Where a kept run came from and what it was delegated from, for the canvas's wires and Open. */
|
|
235
|
+
decorate: (threadId, taskId) => {
|
|
236
|
+
const record = recordOfThread(threadId)?.record;
|
|
237
|
+
const source = record?.sources[taskId];
|
|
238
|
+
if (!source) return {};
|
|
239
|
+
const after = (record.parents[source.outsideRun] ?? []).map(
|
|
240
|
+
(ref) => record.runs[ref] ?? ref
|
|
241
|
+
);
|
|
242
|
+
// Harness writes to it through the thread now: Message goes to the agent there, as in any thread.
|
|
243
|
+
return {
|
|
244
|
+
source: {
|
|
245
|
+
...source,
|
|
246
|
+
controls: { read: true, send: true, stop: false },
|
|
247
|
+
},
|
|
248
|
+
after,
|
|
249
|
+
};
|
|
250
|
+
},
|
|
251
|
+
};
|
|
252
|
+
}
|
package/lib/boardProtocol.json
CHANGED
|
@@ -190,6 +190,7 @@
|
|
|
190
190
|
"board.project.goal": "projects",
|
|
191
191
|
"board.project.retry": "projects",
|
|
192
192
|
"board.swarm.follow": "swarm",
|
|
193
|
+
"board.swarm.adopt": "swarm",
|
|
193
194
|
"board.swarm.seen": "swarm",
|
|
194
195
|
"board.swarm.context": "swarm",
|
|
195
196
|
"board.native.read": "nativeRequests",
|
|
@@ -349,6 +350,7 @@
|
|
|
349
350
|
"board.environments.list",
|
|
350
351
|
"board.environments.control",
|
|
351
352
|
"board.swarm.follow",
|
|
353
|
+
"board.swarm.adopt",
|
|
352
354
|
"board.swarm.seen",
|
|
353
355
|
"board.swarm.context",
|
|
354
356
|
"board.native.read",
|
|
@@ -382,7 +384,16 @@
|
|
|
382
384
|
"board.swarm.models",
|
|
383
385
|
"board.project.answer",
|
|
384
386
|
"board.project.share",
|
|
385
|
-
"board.project.held"
|
|
387
|
+
"board.project.held",
|
|
388
|
+
"board.project.list",
|
|
389
|
+
"board.landed.thread",
|
|
390
|
+
"board.landed.folder",
|
|
391
|
+
"board.landed.open",
|
|
392
|
+
"board.swarm.specialties",
|
|
393
|
+
"board.swarm.specialty",
|
|
394
|
+
"board.swarm.pin",
|
|
395
|
+
"board.swarm.offices",
|
|
396
|
+
"board.swarm.office"
|
|
386
397
|
],
|
|
387
398
|
"browserPerson": [
|
|
388
399
|
"board.list",
|
|
@@ -738,6 +749,7 @@
|
|
|
738
749
|
"board.environments.list",
|
|
739
750
|
"board.environments.control",
|
|
740
751
|
"board.swarm.follow",
|
|
752
|
+
"board.swarm.adopt",
|
|
741
753
|
"board.swarm.seen",
|
|
742
754
|
"board.swarm.context",
|
|
743
755
|
"board.native.read",
|
|
@@ -780,6 +792,15 @@
|
|
|
780
792
|
"machines.live",
|
|
781
793
|
"machines.live.read"
|
|
782
794
|
],
|
|
795
|
+
"phoneMachines": [
|
|
796
|
+
"machines.list",
|
|
797
|
+
"machines.live",
|
|
798
|
+
"machines.live.read",
|
|
799
|
+
"machines.models",
|
|
800
|
+
"machines.model",
|
|
801
|
+
"machines.home",
|
|
802
|
+
"machines.remove"
|
|
803
|
+
],
|
|
783
804
|
"browserSignIn": [
|
|
784
805
|
"agents.signin.status",
|
|
785
806
|
"agents.signin.start",
|
package/lib/daemon.mjs
CHANGED
|
@@ -117,6 +117,7 @@ import { createOwnMachines, FROM_MACHINE } from "./ownMachines.mjs";
|
|
|
117
117
|
import { createBoardBackup } from "./boardBackup.mjs";
|
|
118
118
|
import { createMachineRuns } from "./machineRuns.mjs";
|
|
119
119
|
import { createPlans } from "./plans.mjs";
|
|
120
|
+
import { createAdoption } from "./adoption.mjs";
|
|
120
121
|
import { createBoardWatches } from "./boardWatches.mjs";
|
|
121
122
|
import { createBoardTools } from "./boardTools.mjs";
|
|
122
123
|
import { createBoardThreads } from "./boardThreads.mjs";
|
|
@@ -1722,18 +1723,39 @@ export async function startDaemon() {
|
|
|
1722
1723
|
log,
|
|
1723
1724
|
changed: () => boardWaits.bump(),
|
|
1724
1725
|
});
|
|
1726
|
+
// Work from T3 Code becomes a Harness thread when the person adds to it (adoption.mjs); T3 is read while work it
|
|
1727
|
+
// took over is still going there, and what ended is kept.
|
|
1728
|
+
let adoption = null;
|
|
1725
1729
|
const environments = createEnvironments({
|
|
1726
1730
|
store,
|
|
1727
1731
|
log,
|
|
1728
1732
|
threadLine,
|
|
1729
1733
|
guestRequests,
|
|
1730
|
-
notify: () =>
|
|
1731
|
-
|
|
1734
|
+
notify: () => {
|
|
1735
|
+
boardWaits.bump();
|
|
1736
|
+
void adoption
|
|
1737
|
+
?.sync()
|
|
1738
|
+
.catch((error) => log(`adoption sync: ${error.message}`));
|
|
1739
|
+
},
|
|
1740
|
+
watched: () => boardWaits.watched() || Boolean(adoption?.waiting()),
|
|
1741
|
+
adopted: (id) => Boolean(adoption?.adopted(id)),
|
|
1742
|
+
computer: () => ({ id: machine.id, label: machine.label }),
|
|
1743
|
+
});
|
|
1744
|
+
adoption = createAdoption({
|
|
1745
|
+
store,
|
|
1746
|
+
environments,
|
|
1747
|
+
worktrees,
|
|
1748
|
+
roomAgents: ROOM_AGENTS,
|
|
1749
|
+
provenanceFor,
|
|
1750
|
+
defaults: { maxPosts: DEFAULT_MAX_POSTS, maxWakes: DEFAULT_MAX_WAKES },
|
|
1751
|
+
notifyBoard,
|
|
1752
|
+
log,
|
|
1732
1753
|
});
|
|
1733
1754
|
const swarmCommand = createSwarm({
|
|
1734
1755
|
landed,
|
|
1735
1756
|
browserWake,
|
|
1736
1757
|
environments,
|
|
1758
|
+
adoption,
|
|
1737
1759
|
// The coding agents found here that are not in the swarm yet and the person never took out, with their last check:
|
|
1738
1760
|
// setup walks the person through signing each in, or the agent watch adds it once it answers. The page setup opens
|
|
1739
1761
|
// lists them beside the swarm, so the browser says what the terminal is doing.
|
|
@@ -1768,6 +1790,7 @@ export async function startDaemon() {
|
|
|
1768
1790
|
projects?.addressesPartner(threadId, text) ?? false,
|
|
1769
1791
|
withMachines: (card) => actors.withMachines(card),
|
|
1770
1792
|
whereIs,
|
|
1793
|
+
here: () => machine.id,
|
|
1771
1794
|
store,
|
|
1772
1795
|
plansOf: (threadId) => plans?.of(threadId) ?? [],
|
|
1773
1796
|
goals,
|
|
@@ -2046,7 +2069,8 @@ export async function startDaemon() {
|
|
|
2046
2069
|
// On a worker, a read home cannot answer comes from this computer's copy, saying how old it is, and a write that
|
|
2047
2070
|
// reached home brings the copy up to date.
|
|
2048
2071
|
const swarmBoard = (request) => {
|
|
2049
|
-
|
|
2072
|
+
// Work in this computer's own T3 Code is answered here: home has no such thread.
|
|
2073
|
+
if (!ownMachines?.forwards(request) || environments.mine(request.id)) {
|
|
2050
2074
|
const result = boardCommand(request);
|
|
2051
2075
|
boardChanged();
|
|
2052
2076
|
return result;
|
|
@@ -2081,7 +2105,9 @@ export async function startDaemon() {
|
|
|
2081
2105
|
home: paths.home,
|
|
2082
2106
|
log,
|
|
2083
2107
|
onPlanChange: (threadId) => notifyBoard(store.getTask(threadId)),
|
|
2108
|
+
outside: (threadId, ref) => adoption.outside(threadId, ref),
|
|
2084
2109
|
});
|
|
2110
|
+
adoption.usePlans(plans);
|
|
2085
2111
|
|
|
2086
2112
|
// The board worker. An authorized task for an agent installed here is claimed by the daemon
|
|
2087
2113
|
// in that agent's name, run through the same runner as a pushed run (so `tryharness task <id>
|
|
@@ -2197,6 +2223,17 @@ export async function startDaemon() {
|
|
|
2197
2223
|
// This computer's own running sessions, and one session's latest messages from its own file, as the person: what home
|
|
2198
2224
|
// gathers from every computer for the Agents tab, the phone and PiP (ownMachines.mjs sessions, readSession).
|
|
2199
2225
|
const ownLive = async (live) => {
|
|
2226
|
+
// A thread in this computer's T3 Code, read here for the person at another of their computers.
|
|
2227
|
+
if (live?.read?.thread) {
|
|
2228
|
+
if (!environments.owns(live.read.thread))
|
|
2229
|
+
return { ok: false, error: "only work in T3 Code is read this way" };
|
|
2230
|
+
const result = boardCommand({
|
|
2231
|
+
command: "board.swarm.read",
|
|
2232
|
+
agent: "user",
|
|
2233
|
+
id: live.read.thread,
|
|
2234
|
+
});
|
|
2235
|
+
return result?.pending ? await result.pending : result;
|
|
2236
|
+
}
|
|
2200
2237
|
if (live?.read)
|
|
2201
2238
|
return liveCommand(
|
|
2202
2239
|
{
|
|
@@ -2210,7 +2247,12 @@ export async function startDaemon() {
|
|
|
2210
2247
|
);
|
|
2211
2248
|
if (live?.list) {
|
|
2212
2249
|
const listed = liveCommand({ command: "board.live" }, "user");
|
|
2213
|
-
|
|
2250
|
+
// This computer's own T3 Code threads: a worker's are on no board, so every computer learns of them here.
|
|
2251
|
+
await environments.ready()?.catch(() => null);
|
|
2252
|
+
const threads = environments
|
|
2253
|
+
.roots()
|
|
2254
|
+
.map(({ activityVersion, ...thread }) => thread);
|
|
2255
|
+
return { ok: true, sessions: listed.sessions ?? [], threads };
|
|
2214
2256
|
}
|
|
2215
2257
|
return { ok: false, error: "only sessions are listed or read this way" };
|
|
2216
2258
|
};
|
package/lib/environments.mjs
CHANGED
|
@@ -59,6 +59,10 @@ export function createEnvironments({
|
|
|
59
59
|
watched = () => false,
|
|
60
60
|
threadLine = null,
|
|
61
61
|
guestRequests = null,
|
|
62
|
+
// Whether a Harness thread took this work over (adoption.mjs): then that thread is where the person sees it.
|
|
63
|
+
adopted = () => false,
|
|
64
|
+
// The computer whose T3 Code this is, { id, label }: a worker's list is home's, so its threads say where they run.
|
|
65
|
+
computer = () => null,
|
|
62
66
|
}) {
|
|
63
67
|
let providers = [];
|
|
64
68
|
let threads = new Map();
|
|
@@ -128,6 +132,7 @@ export function createEnvironments({
|
|
|
128
132
|
relationship: entry.relationshipToParent ?? null,
|
|
129
133
|
native: entry.creationSource === "provider",
|
|
130
134
|
url: t3Link(entry.threadId),
|
|
135
|
+
computer: computer(),
|
|
131
136
|
controls: {
|
|
132
137
|
read: true,
|
|
133
138
|
send:
|
|
@@ -422,7 +427,9 @@ export function createEnvironments({
|
|
|
422
427
|
)
|
|
423
428
|
.map(summary)
|
|
424
429
|
.filter(
|
|
425
|
-
(thread) =>
|
|
430
|
+
(thread) =>
|
|
431
|
+
hidden[thread.id] !== JSON.stringify(thread.activityVersion) &&
|
|
432
|
+
!adopted(thread.id)
|
|
426
433
|
);
|
|
427
434
|
};
|
|
428
435
|
/** Removed from Harness's list (T3 keeps it): until it does something new, when it shows again. */
|
|
@@ -479,6 +486,8 @@ export function createEnvironments({
|
|
|
479
486
|
],
|
|
480
487
|
});
|
|
481
488
|
const owns = (id) => typeof id === "string" && id.startsWith("outside-t3-");
|
|
489
|
+
/** Whether a thread is in this computer's own T3 Code, as last read: a worker answers those itself. */
|
|
490
|
+
const mine = (id) => owns(id) && threads.has(id);
|
|
482
491
|
async function read(id) {
|
|
483
492
|
if (!authorized())
|
|
484
493
|
return {
|
|
@@ -492,7 +501,14 @@ export function createEnvironments({
|
|
|
492
501
|
if (!root)
|
|
493
502
|
return { ok: false, error: "This source thread is no longer available." };
|
|
494
503
|
const version = JSON.stringify([grant, summary(root).activityVersion]);
|
|
495
|
-
|
|
504
|
+
// Whether it landed anything is known once the threads' commits are read, which can be after this read was kept:
|
|
505
|
+
// a kept read says it as it stands now.
|
|
506
|
+
const cached = reads.get(id);
|
|
507
|
+
if (cached?.version === version)
|
|
508
|
+
return {
|
|
509
|
+
...cached.result,
|
|
510
|
+
thread: { ...cached.result.thread, landed: summary(root).landed },
|
|
511
|
+
};
|
|
496
512
|
const selected = treeOf(root);
|
|
497
513
|
const runs = [];
|
|
498
514
|
const posts = [];
|
|
@@ -823,6 +839,7 @@ export function createEnvironments({
|
|
|
823
839
|
ready,
|
|
824
840
|
roots,
|
|
825
841
|
owns,
|
|
842
|
+
mine,
|
|
826
843
|
read,
|
|
827
844
|
hide,
|
|
828
845
|
control,
|
package/lib/harnessOffers.mjs
CHANGED
|
@@ -185,7 +185,8 @@ export function createHarnessOffers({
|
|
|
185
185
|
? `${outcome.detail}. To let Harness answer here while your window is closed, turn on "Harness Relay may use it" in Harness's settings, under Models`
|
|
186
186
|
: outcome.detail || "Harness could not take it here"
|
|
187
187
|
);
|
|
188
|
-
// Its words are Harness's server's, not the window's: they
|
|
188
|
+
// Its words are Harness's server's, not the window's: they carry the person's go only on the guard's clean
|
|
189
|
+
// reading (jobAnswers.mjs).
|
|
189
190
|
if (outcome.status === "done")
|
|
190
191
|
store.meta(`harness-served:${taskId}`, "1");
|
|
191
192
|
if (outcome.status === "done")
|
package/lib/jobAnswers.mjs
CHANGED
|
@@ -81,7 +81,7 @@ export function createJobAnswers({
|
|
|
81
81
|
if (!ENDED.includes(task.status)) return;
|
|
82
82
|
const who = task.claimed_by || task.target_agent || "an agent";
|
|
83
83
|
// An answer that came through Harness's server (Bankr's, Quotient's, Harness's server answering for a closed
|
|
84
|
-
// window) wakes no one with the person's go (personsGo).
|
|
84
|
+
// window) wakes no one with the person's go (personsGo), except Harness's words the guard reads as clean.
|
|
85
85
|
const hosted =
|
|
86
86
|
member(who)?.runs === "server" &&
|
|
87
87
|
(who !== "harness" || Boolean(store.meta(`harness-served:${task.id}`)));
|
|
@@ -158,12 +158,21 @@ export function createJobAnswers({
|
|
|
158
158
|
status: task.status,
|
|
159
159
|
result: task.result || "",
|
|
160
160
|
});
|
|
161
|
-
} else if (
|
|
162
|
-
|
|
161
|
+
} else if (
|
|
162
|
+
goal.status === "open" &&
|
|
163
|
+
(fromElsewhere(who) || (who === "harness" && hosted)) &&
|
|
164
|
+
!flag
|
|
165
|
+
)
|
|
166
|
+
// An answer from the person's agents elsewhere, or Harness's server's for a closed window, wakes whoever it names
|
|
167
|
+
// on the guard's reading of it, as their posts do.
|
|
163
168
|
void readByGuard(text).then((guard) => {
|
|
164
169
|
if (guard?.verdict === "flag" || guard?.verdict === "hold")
|
|
165
170
|
store.meta(`flagged:${post.id}`, String(guard.score));
|
|
166
|
-
actions.wakeFor(goal.id, post, who, undefined, {
|
|
171
|
+
actions.wakeFor(goal.id, post, who, undefined, {
|
|
172
|
+
guard,
|
|
173
|
+
answering,
|
|
174
|
+
hosted,
|
|
175
|
+
});
|
|
167
176
|
notifyBoard(store.getTask(goal.id));
|
|
168
177
|
});
|
|
169
178
|
// A restricted job's answer is that run's words: the asker it wakes gets no go from it.
|
package/lib/landed.mjs
CHANGED
|
@@ -854,7 +854,42 @@ export function createLanded({
|
|
|
854
854
|
: { ok: false, error: "this thread's folder is not a repository" };
|
|
855
855
|
}
|
|
856
856
|
if (request.command === "board.landed.thread") return threadView(context);
|
|
857
|
-
|
|
857
|
+
const plan = await openWork(context);
|
|
858
|
+
return request.onComputer === true ? openHere(plan) : plan;
|
|
859
|
+
}
|
|
860
|
+
|
|
861
|
+
/**
|
|
862
|
+
* The phone's Open: this computer opens the work itself, where the buddy would have opened it (a T3 Code or Codex
|
|
863
|
+
* link, or the app). The link and the app are this computer's own reading of the work, never the caller's. A test
|
|
864
|
+
* stands in for the opener with HARNESS_OPEN_COMMAND, as notify.mjs takes HARNESS_NOTIFY_COMMAND.
|
|
865
|
+
*/
|
|
866
|
+
function openHere(plan) {
|
|
867
|
+
if (!plan.ok || (!plan.link && !plan.app)) return plan;
|
|
868
|
+
const args =
|
|
869
|
+
process.platform === "darwin"
|
|
870
|
+
? plan.link
|
|
871
|
+
? [plan.link]
|
|
872
|
+
: ["-a", plan.app]
|
|
873
|
+
: plan.link
|
|
874
|
+
? [plan.link]
|
|
875
|
+
: null;
|
|
876
|
+
if (!args)
|
|
877
|
+
return {
|
|
878
|
+
ok: false,
|
|
879
|
+
error: `${plan.opensIn ?? "Its app"} can only be opened on this computer itself.`,
|
|
880
|
+
};
|
|
881
|
+
const child = spawn(
|
|
882
|
+
process.env.HARNESS_OPEN_COMMAND ||
|
|
883
|
+
(process.platform === "darwin" ? "open" : "xdg-open"),
|
|
884
|
+
args,
|
|
885
|
+
{
|
|
886
|
+
detached: true,
|
|
887
|
+
stdio: "ignore",
|
|
888
|
+
}
|
|
889
|
+
);
|
|
890
|
+
child.on("error", () => {});
|
|
891
|
+
child.unref();
|
|
892
|
+
return { ok: true, opensIn: plan.opensIn, openedHere: true };
|
|
858
893
|
}
|
|
859
894
|
|
|
860
895
|
const COMMANDS = new Set([
|
package/lib/ownMachines.mjs
CHANGED
|
@@ -2042,13 +2042,23 @@ export function createOwnMachines({
|
|
|
2042
2042
|
|
|
2043
2043
|
// ---- every computer's running sessions, for the Agents tab, the phone and PiP ----
|
|
2044
2044
|
|
|
2045
|
-
/** One computer's sessions as it answered, or why there are none: offline, or it did not answer. */
|
|
2045
|
+
/** One computer's sessions and T3 Code threads as it answered, or why there are none: offline, or it did not answer. */
|
|
2046
2046
|
const liveEntry = (computer, answer) => ({
|
|
2047
2047
|
id: computer.id,
|
|
2048
2048
|
label: computer.label,
|
|
2049
2049
|
role: computer.role ?? "home",
|
|
2050
2050
|
online: computer.online,
|
|
2051
2051
|
sessions: answer?.ok ? (answer.sessions ?? []) : [],
|
|
2052
|
+
// Each says the computer it is on, whatever an older daemon there wrote.
|
|
2053
|
+
threads: (answer?.ok ? (answer.threads ?? []) : []).map((thread) => ({
|
|
2054
|
+
...thread,
|
|
2055
|
+
source: thread.source
|
|
2056
|
+
? {
|
|
2057
|
+
...thread.source,
|
|
2058
|
+
computer: { id: computer.id, label: computer.label },
|
|
2059
|
+
}
|
|
2060
|
+
: thread.source,
|
|
2061
|
+
})),
|
|
2052
2062
|
...(answer?.ok
|
|
2053
2063
|
? {}
|
|
2054
2064
|
: {
|
|
@@ -2129,6 +2139,8 @@ export function createOwnMachines({
|
|
|
2129
2139
|
sessionId: request.sessionId,
|
|
2130
2140
|
folder: request.folder,
|
|
2131
2141
|
limit: request.limit,
|
|
2142
|
+
// Or a thread in that computer's T3 Code.
|
|
2143
|
+
thread: request.thread,
|
|
2132
2144
|
};
|
|
2133
2145
|
if (target === machine.id) return ownLive({ read });
|
|
2134
2146
|
if (isHome()) {
|
package/lib/phones.mjs
CHANGED
|
@@ -133,6 +133,10 @@ const BROWSER_READS = boardCommandsFor("browserReads");
|
|
|
133
133
|
// The person's linked window adds a computer to the swarm: how a cloud worker joins, with home pinning its key exactly
|
|
134
134
|
// as for a code the person typed here. Only as the person, never in a Harness chat call.
|
|
135
135
|
const MACHINE_COMMANDS = boardCommandsFor("browserMachines");
|
|
136
|
+
// The phone, as the person: their computers and every one's sessions, the model each agent runs on, read and set on
|
|
137
|
+
// the computer that runs it, and which computer is Home or taken off the swarm (the Swarm tab, # in a message,
|
|
138
|
+
// sessions by computer). Adding a computer stays on the computers themselves, which pair by a code typed there.
|
|
139
|
+
const PHONE_MACHINE_COMMANDS = boardCommandsFor("phoneMachines");
|
|
136
140
|
// The person's window signs a cloud computer's agents in (agentSignIn.mjs) and picks the model each runs on
|
|
137
141
|
// (models.mjs): only there, and only as the person.
|
|
138
142
|
const SIGN_IN_COMMANDS = boardCommandsFor("browserSignIn");
|
|
@@ -814,6 +818,29 @@ export async function createPhoneDesk({
|
|
|
814
818
|
})
|
|
815
819
|
);
|
|
816
820
|
}
|
|
821
|
+
if (PHONE_MACHINE_COMMANDS.has(command)) {
|
|
822
|
+
const own = machines();
|
|
823
|
+
if (!own) return { ok: false, error: "this computer has no swarm list" };
|
|
824
|
+
if (command === "machines.list") return own.list();
|
|
825
|
+
if (command === "machines.live") return own.sessions();
|
|
826
|
+
if (command === "machines.live.read") return own.readSession(callInput);
|
|
827
|
+
if (command === "machines.models")
|
|
828
|
+
return own.models({ refresh: callInput.refresh === true });
|
|
829
|
+
if (command === "machines.home" || command === "machines.remove") {
|
|
830
|
+
// The phone names the computer it means; it never moves Home or removes one by leaving it out.
|
|
831
|
+
const computer = String(callInput.computer || "");
|
|
832
|
+
if (!computer) return { ok: false, error: "name the computer" };
|
|
833
|
+
return command === "machines.home"
|
|
834
|
+
? own.makeHome(computer)
|
|
835
|
+
: own.remove(computer);
|
|
836
|
+
}
|
|
837
|
+
return own.setModel({
|
|
838
|
+
computer: callInput.computer,
|
|
839
|
+
target: callInput.target,
|
|
840
|
+
model: callInput.model,
|
|
841
|
+
effort: callInput.effort ?? null,
|
|
842
|
+
});
|
|
843
|
+
}
|
|
817
844
|
// Lid-Closed Mode's wake: no arguments, never queued, and it can only keep the Mac awake and say how it is.
|
|
818
845
|
if (command === "machine.wake") return { ok: true, machine: machine() };
|
|
819
846
|
if (!PHONE_COMMANDS.has(command))
|
package/lib/plans.mjs
CHANGED
|
@@ -159,7 +159,8 @@ const fill = (text, values) =>
|
|
|
159
159
|
|
|
160
160
|
/**
|
|
161
161
|
* `post(request)` posts a task the way any agent's post does (the daemon's own board command); `changed(task)` hears
|
|
162
|
-
* every task change in a thread.
|
|
162
|
+
* every task change in a thread. `outside(threadId, ref)` says how work the thread took over from another tool and that
|
|
163
|
+
* is still going there stands ({ state, name }), or null when `ref` is not such work (adoption.mjs).
|
|
163
164
|
*/
|
|
164
165
|
export function createPlans({
|
|
165
166
|
store,
|
|
@@ -168,6 +169,7 @@ export function createPlans({
|
|
|
168
169
|
home,
|
|
169
170
|
log = () => {},
|
|
170
171
|
onPlanChange = () => {},
|
|
172
|
+
outside = () => null,
|
|
171
173
|
}) {
|
|
172
174
|
const folder = path.join(home, "templates");
|
|
173
175
|
const planOf = (threadId) => {
|
|
@@ -185,6 +187,14 @@ export function createPlans({
|
|
|
185
187
|
const thread = store.getTask(String(id || ""));
|
|
186
188
|
return thread && thread.kind === "goal" ? thread : null;
|
|
187
189
|
};
|
|
190
|
+
// The person brings any agent into the thread by giving it a step; an agent's own steps stay within the thread's team
|
|
191
|
+
// (taskCommands.mjs refuses work for anyone else).
|
|
192
|
+
const join = (thread, by, agents) => {
|
|
193
|
+
if (by !== "user") return;
|
|
194
|
+
const team = thread.goal.team;
|
|
195
|
+
const added = [...new Set(agents)].filter((agent) => !team.includes(agent));
|
|
196
|
+
if (added.length) store.setGoalTeam(thread.id, [...team, ...added]);
|
|
197
|
+
};
|
|
188
198
|
// A plan node's id stands for the task it became once it was posted.
|
|
189
199
|
const taskFor = (plan, ref) =>
|
|
190
200
|
plan.find((node) => node.id === ref)?.taskId ?? ref;
|
|
@@ -205,6 +215,8 @@ export function createPlans({
|
|
|
205
215
|
state: planned.state === "blocked" ? "stopped" : "waiting",
|
|
206
216
|
name: planned.agent,
|
|
207
217
|
};
|
|
218
|
+
const away = outside(threadId, ref);
|
|
219
|
+
if (away) return { ref, ...away };
|
|
208
220
|
const task = store.getTask(taskFor(plan, ref));
|
|
209
221
|
if (!task || task.removed_at)
|
|
210
222
|
return { ref, state: "stopped", name: "work that was removed" };
|
|
@@ -310,6 +322,7 @@ export function createPlans({
|
|
|
310
322
|
for (const node of nodes)
|
|
311
323
|
for (const ref of node.after) {
|
|
312
324
|
if (keys.has(ref) || plan.some((other) => other.id === ref)) continue;
|
|
325
|
+
if (outside(thread.id, ref)) continue;
|
|
313
326
|
const task = store.getTask(ref);
|
|
314
327
|
if (!task || task.parent_id !== thread.id)
|
|
315
328
|
return { ok: false, error: `${ref} is not work in this thread` };
|
|
@@ -321,6 +334,11 @@ export function createPlans({
|
|
|
321
334
|
const ids = new Map(
|
|
322
335
|
nodes.map((node) => [node.key, `plan_${randomUUID().slice(0, 12)}`])
|
|
323
336
|
);
|
|
337
|
+
join(
|
|
338
|
+
thread,
|
|
339
|
+
by,
|
|
340
|
+
nodes.map((node) => node.agent)
|
|
341
|
+
);
|
|
324
342
|
const at = new Date().toISOString();
|
|
325
343
|
for (const node of order)
|
|
326
344
|
plan.push({
|
|
@@ -361,6 +379,7 @@ export function createPlans({
|
|
|
361
379
|
/** Whether `ref` is something a node in this thread may wait on: another plan node, or a task in the thread. */
|
|
362
380
|
const waitable = (threadId, plan, ref) =>
|
|
363
381
|
plan.some((other) => other.id === ref) ||
|
|
382
|
+
Boolean(outside(threadId, ref)) ||
|
|
364
383
|
store.getTask(ref)?.parent_id === threadId;
|
|
365
384
|
const loops = (plan) => {
|
|
366
385
|
const ids = new Set(plan.map((node) => node.id));
|
|
@@ -388,6 +407,7 @@ export function createPlans({
|
|
|
388
407
|
error: `${agent || "no one"} cannot be in a thread`,
|
|
389
408
|
};
|
|
390
409
|
next.agent = agent;
|
|
410
|
+
join(thread, "user", [agent]);
|
|
391
411
|
}
|
|
392
412
|
if (change.prompt !== undefined) {
|
|
393
413
|
const asked = askOf({ prompt: change.prompt }, node.key);
|
|
@@ -544,6 +564,18 @@ export function createPlans({
|
|
|
544
564
|
at,
|
|
545
565
|
})
|
|
546
566
|
),
|
|
567
|
+
/** Steps that wait on `from` wait on `to` instead: work from another tool, once it is kept here as a task. */
|
|
568
|
+
remap(threadId, from, to) {
|
|
569
|
+
const plan = planOf(threadId);
|
|
570
|
+
if (!plan.some((node) => node.after.includes(from))) return;
|
|
571
|
+
savePlan(
|
|
572
|
+
threadId,
|
|
573
|
+
plan.map((node) => ({
|
|
574
|
+
...node,
|
|
575
|
+
after: node.after.map((ref) => (ref === from ? to : ref)),
|
|
576
|
+
}))
|
|
577
|
+
);
|
|
578
|
+
},
|
|
547
579
|
/** A task changed: plans in its thread may move on. */
|
|
548
580
|
changed(task) {
|
|
549
581
|
const threadId = task?.parent_id;
|
|
@@ -0,0 +1,42 @@
|
|
|
1
|
+
import { createHash } from "node:crypto";
|
|
2
|
+
|
|
3
|
+
// A thread's read for a reader away from this computer (the phone, or a browser through Harness). Its answer comes
|
|
4
|
+
// back sealed through Harness in one piece, and Harness takes about 1 MB (src/shared/bridge/sealedWire.ts MAX_CT),
|
|
5
|
+
// while a long T3 Code thread read whole is 1 to 3 MB. So such a reader gets the newest of the timeline up to
|
|
6
|
+
// RECENT_BYTES, a page a phone takes in a moment, and `start`, how many entries came before; asking with `before` (a
|
|
7
|
+
// `start` it holds) gives the page that ends there. A reader that sends the `version` it holds and still has it hears
|
|
8
|
+
// only that, so an open thread asked about every two seconds costs nothing while it is quiet.
|
|
9
|
+
export const RECENT_BYTES = 200_000;
|
|
10
|
+
|
|
11
|
+
/** `read` is board.swarm.read's whole answer; what goes back to a reader away from this computer. */
|
|
12
|
+
export function recentRead(read, { since, before } = {}) {
|
|
13
|
+
if (!read?.ok) return read;
|
|
14
|
+
const version = createHash("sha256")
|
|
15
|
+
.update(JSON.stringify(read))
|
|
16
|
+
.digest("base64url");
|
|
17
|
+
const paging = Number.isInteger(before);
|
|
18
|
+
if (!paging && since === version)
|
|
19
|
+
return { ok: true, unchanged: true, version };
|
|
20
|
+
const timeline = read.timeline ?? [];
|
|
21
|
+
const end = paging
|
|
22
|
+
? Math.max(0, Math.min(before, timeline.length))
|
|
23
|
+
: timeline.length;
|
|
24
|
+
let start = end;
|
|
25
|
+
let bytes = 0;
|
|
26
|
+
while (start > 0) {
|
|
27
|
+
const size = JSON.stringify(timeline[start - 1]).length;
|
|
28
|
+
// One entry is always given, however long, so a reader never waits on a page that cannot come.
|
|
29
|
+
if (start < end && bytes + size > RECENT_BYTES) break;
|
|
30
|
+
bytes += size;
|
|
31
|
+
start--;
|
|
32
|
+
}
|
|
33
|
+
const shown = timeline.slice(start, end);
|
|
34
|
+
const seqs = new Set(shown.map((entry) => entry.seq));
|
|
35
|
+
return {
|
|
36
|
+
...read,
|
|
37
|
+
timeline: shown,
|
|
38
|
+
posts: (read.posts ?? []).filter((post) => seqs.has(post.seq)),
|
|
39
|
+
start,
|
|
40
|
+
version,
|
|
41
|
+
};
|
|
42
|
+
}
|
package/lib/store.mjs
CHANGED
|
@@ -885,6 +885,47 @@ export function openStore(file) {
|
|
|
885
885
|
});
|
|
886
886
|
return this.getTask(id);
|
|
887
887
|
},
|
|
888
|
+
// Work an agent finished in another tool (T3 Code), kept in the Harness thread that took that work over
|
|
889
|
+
// (adoption.mjs): who did it, what they were asked and what came back. It is born finished, so nothing claims or
|
|
890
|
+
// runs it here.
|
|
891
|
+
recordOutsideRun({
|
|
892
|
+
goalId,
|
|
893
|
+
agent,
|
|
894
|
+
objective,
|
|
895
|
+
result,
|
|
896
|
+
status,
|
|
897
|
+
sessionId,
|
|
898
|
+
startedAt,
|
|
899
|
+
endedAt,
|
|
900
|
+
}) {
|
|
901
|
+
const id = randomUUID();
|
|
902
|
+
const now = new Date().toISOString();
|
|
903
|
+
execute(
|
|
904
|
+
"run",
|
|
905
|
+
`insert into board_tasks(id, objective, brief, origin_agent, target_agent, status, parent_id, context_refs, claimed_by, claimed_at, result, reported_at, holder, version, kind, session_id, trust, origin_chain, created_at, updated_at)
|
|
906
|
+
values(@id, @objective, '', 'user', @agent, @status, @goalId, '[]', @agent, @startedAt, @result, @endedAt, null, 1, 'task', @sessionId, 'user', '[]', @startedAt, @now)`,
|
|
907
|
+
{
|
|
908
|
+
id,
|
|
909
|
+
objective,
|
|
910
|
+
agent,
|
|
911
|
+
status,
|
|
912
|
+
goalId,
|
|
913
|
+
result,
|
|
914
|
+
sessionId,
|
|
915
|
+
startedAt: startedAt || now,
|
|
916
|
+
endedAt: endedAt || now,
|
|
917
|
+
now,
|
|
918
|
+
}
|
|
919
|
+
);
|
|
920
|
+
this.addContribution({
|
|
921
|
+
taskId: id,
|
|
922
|
+
kind: "brief",
|
|
923
|
+
author: "user",
|
|
924
|
+
text: objective,
|
|
925
|
+
source: "task",
|
|
926
|
+
});
|
|
927
|
+
return this.getTask(id);
|
|
928
|
+
},
|
|
888
929
|
// A task for several agents at once: one group task the person sees, one part per agent that
|
|
889
930
|
// each agent claims, runs and reports on its own. The group closes when the last part does,
|
|
890
931
|
// carrying every result; it cannot itself be claimed.
|
package/lib/swarm.mjs
CHANGED
|
@@ -27,6 +27,7 @@ import {
|
|
|
27
27
|
import { askOfRun } from "./threadView.mjs";
|
|
28
28
|
import { createWorkFocus } from "./workFocus.mjs";
|
|
29
29
|
import { createListVersions } from "./listVersions.mjs";
|
|
30
|
+
import { recentRead } from "./recentRead.mjs";
|
|
30
31
|
import { createWorkLinks } from "./workLinks.mjs";
|
|
31
32
|
import {
|
|
32
33
|
DEFAULT_ROUTING,
|
|
@@ -157,6 +158,8 @@ export function createSwarm({
|
|
|
157
158
|
withMachines = (card) => card,
|
|
158
159
|
// Where an agent calling from a computer is (ownMachines.mjs whereIs), for what it is told of itself; null when unknown.
|
|
159
160
|
whereIs = () => null,
|
|
161
|
+
// This computer's id: a run claimed before claims named their computer ran on the one holding the board.
|
|
162
|
+
here = () => null,
|
|
160
163
|
authorizeRun,
|
|
161
164
|
pickable,
|
|
162
165
|
listModels,
|
|
@@ -186,6 +189,8 @@ export function createSwarm({
|
|
|
186
189
|
// The person's words name an agent of the other side of a shared project: theirs to answer, not this swarm's to sort.
|
|
187
190
|
addressesPartner = () => false,
|
|
188
191
|
environments = null,
|
|
192
|
+
// Work from another tool taken over as a Harness thread (adoption.mjs).
|
|
193
|
+
adoption = null,
|
|
189
194
|
notifyFocus = () => {},
|
|
190
195
|
// What the person's words just did to a run they steered (threadRuns.mjs steered): a promise of the thread's note.
|
|
191
196
|
steered = () => null,
|
|
@@ -300,6 +305,19 @@ export function createSwarm({
|
|
|
300
305
|
: null;
|
|
301
306
|
};
|
|
302
307
|
|
|
308
|
+
/** The computer each agent's latest run in a thread ran or runs on, { id, label }: where the buddy lists it. */
|
|
309
|
+
const runsOnOf = (runs) => {
|
|
310
|
+
const latest = new Map();
|
|
311
|
+
for (const run of runs)
|
|
312
|
+
if (run.claimed_by)
|
|
313
|
+
latest.set(run.target_agent, run.claimed_machine ?? here());
|
|
314
|
+
return Object.fromEntries(
|
|
315
|
+
[...latest]
|
|
316
|
+
.map(([agent, id]) => [agent, { id, label: whereIs(id)?.computer }])
|
|
317
|
+
.filter(([, computer]) => computer.id && computer.label)
|
|
318
|
+
);
|
|
319
|
+
};
|
|
320
|
+
|
|
303
321
|
const summary = (thread, includeRelated = true) => {
|
|
304
322
|
const posts = store.roomPosts(thread.id, 0, 500);
|
|
305
323
|
const runs = store.threadRuns(thread.id);
|
|
@@ -336,6 +354,7 @@ export function createSwarm({
|
|
|
336
354
|
.map((run) => run.target_agent)
|
|
337
355
|
),
|
|
338
356
|
],
|
|
357
|
+
runsOn: runsOnOf(runs),
|
|
339
358
|
// Why each agent given work here has not started, in a sentence: every surface says it the same way.
|
|
340
359
|
waits: runs
|
|
341
360
|
.map((run) => ({
|
|
@@ -509,7 +528,10 @@ export function createSwarm({
|
|
|
509
528
|
startedAt: run.created_at,
|
|
510
529
|
endedAt: run.reported_at,
|
|
511
530
|
}),
|
|
531
|
+
...adoption?.decorate(thread.id, run.id),
|
|
512
532
|
}));
|
|
533
|
+
// Work this thread took over that is still going in the tool it started in.
|
|
534
|
+
if (!hostedCaller) runs.push(...(adoption?.pending(thread.id) ?? []));
|
|
513
535
|
const posts = store.roomPosts(thread.id, 0, 500);
|
|
514
536
|
return {
|
|
515
537
|
ok: true,
|
|
@@ -879,6 +901,25 @@ export function createSwarm({
|
|
|
879
901
|
error: error.message,
|
|
880
902
|
})),
|
|
881
903
|
});
|
|
904
|
+
// The person adds work to it: it becomes a Harness thread, so any agent can take part.
|
|
905
|
+
if (command === "board.swarm.adopt") {
|
|
906
|
+
if (agent !== "user" || !adoption)
|
|
907
|
+
return {
|
|
908
|
+
ok: false,
|
|
909
|
+
error: "Only the person brings work into Harness.",
|
|
910
|
+
};
|
|
911
|
+
return pending(
|
|
912
|
+
adoption.adopt(request.id).then((taken) =>
|
|
913
|
+
taken.ok
|
|
914
|
+
? {
|
|
915
|
+
ok: true,
|
|
916
|
+
thread: summary(store.getTask(taken.thread)),
|
|
917
|
+
runs: taken.runs,
|
|
918
|
+
}
|
|
919
|
+
: taken
|
|
920
|
+
)
|
|
921
|
+
);
|
|
922
|
+
}
|
|
882
923
|
if (command === "board.swarm.read")
|
|
883
924
|
return pending(
|
|
884
925
|
environments
|
|
@@ -888,6 +929,9 @@ export function createSwarm({
|
|
|
888
929
|
? { ...result, thread: focus.decorate(result.thread) }
|
|
889
930
|
: result
|
|
890
931
|
)
|
|
932
|
+
.then((result) =>
|
|
933
|
+
request.recent === true ? recentRead(result, request) : result
|
|
934
|
+
)
|
|
891
935
|
);
|
|
892
936
|
if (command === "board.swarm.post" || command === "board.swarm.stop")
|
|
893
937
|
return pending(
|
|
@@ -1594,8 +1638,10 @@ export function createSwarm({
|
|
|
1594
1638
|
thread: summary(store.getTask(thread.id)),
|
|
1595
1639
|
};
|
|
1596
1640
|
}
|
|
1597
|
-
if (command === "board.swarm.read")
|
|
1598
|
-
|
|
1641
|
+
if (command === "board.swarm.read") {
|
|
1642
|
+
const whole = read(thread, request.hostedCaller === true);
|
|
1643
|
+
return request.recent === true ? recentRead(whole, request) : whole;
|
|
1644
|
+
}
|
|
1599
1645
|
if (command === "board.swarm.diff")
|
|
1600
1646
|
return worktrees.diff(
|
|
1601
1647
|
thread.id,
|
package/lib/threadActions.mjs
CHANGED
|
@@ -201,7 +201,7 @@ export function createThreadActions({
|
|
|
201
201
|
held:
|
|
202
202
|
guard === undefined
|
|
203
203
|
? null
|
|
204
|
-
: authority.guardWait(author, agent, guard),
|
|
204
|
+
: authority.guardWait(author, agent, guard, { hosted }),
|
|
205
205
|
answer: agent === answering,
|
|
206
206
|
});
|
|
207
207
|
else if (askable(agent))
|
package/lib/threadAuthority.mjs
CHANGED
|
@@ -7,11 +7,12 @@ import { member, nameOf } from "./members.mjs";
|
|
|
7
7
|
*
|
|
8
8
|
* In such a thread the person's own agents asking for work carry the person's go, as the person's @mention does:
|
|
9
9
|
* Harness in the person's own window (its words come sealed from their device), and the coding agents on this
|
|
10
|
-
* computer; full permissions, Stop always there. Nothing that arrived through Harness's server carries it: Bankr
|
|
11
|
-
* Quotient, which only ever speak from there, Harness's
|
|
12
|
-
*
|
|
13
|
-
*
|
|
14
|
-
* injection guard read and found clean, since only what actually needs the person
|
|
10
|
+
* computer; full permissions, Stop always there. Nothing else that arrived through Harness's server carries it: Bankr
|
|
11
|
+
* and Quotient, which only ever speak from there, Harness's files and renders (`hosted`). Those run restricted where the
|
|
12
|
+
* agent can be held in, as below, or wait for the Start. The rounds it coordinates keep the go (the daemon's handOn). An
|
|
13
|
+
* agent the person set to wait still waits. Grok Bot, Muse and Harness's server answering for a closed window carry it
|
|
14
|
+
* too, for words the injection guard on this computer read and found clean, since only what actually needs the person
|
|
15
|
+
* should wait for them. Work any other
|
|
15
16
|
* agent asked for (another person's agent, a call through Harness, Grok Bot's or Muse's flagged words) runs on a
|
|
16
17
|
* thread's authority only where it can be held in: Claude Code in restricted mode, in a copy of the folder this daemon
|
|
17
18
|
* made. Anything else waits.
|
|
@@ -45,6 +46,11 @@ export function createThreadAuthority({
|
|
|
45
46
|
const guardClean = (guard) =>
|
|
46
47
|
guard?.verdict === "clean" && !guard.unavailable;
|
|
47
48
|
|
|
49
|
+
// Whose asks carry the person's go on the guard's reading: the person's agents elsewhere, and Harness's server
|
|
50
|
+
// speaking in their thread while their window is closed.
|
|
51
|
+
const readByGuard = (asker, hosted) =>
|
|
52
|
+
fromElsewhere(asker) || (asker === "harness" && hosted);
|
|
53
|
+
|
|
48
54
|
/** Whether `asker`'s request for `agent` carries the person's go. `hosted`: the request came through Harness. */
|
|
49
55
|
// A coding agent here asking from a restricted run or a review carries no go: that run had none to pass on.
|
|
50
56
|
// `window`: Harness's call as a linked window sealed it (phones.mjs fromWindow). The page that window runs is served
|
|
@@ -58,12 +64,12 @@ export function createThreadAuthority({
|
|
|
58
64
|
(!window &&
|
|
59
65
|
((asker === "harness" && !hosted && !limited) ||
|
|
60
66
|
(!hosted && !limited && member(asker)?.runs === "machine") ||
|
|
61
|
-
(
|
|
67
|
+
(readByGuard(asker, hosted) && guardClean(guard))) &&
|
|
62
68
|
!setToWait(agent));
|
|
63
69
|
|
|
64
70
|
/** What the thread says when the guard keeps an agent's request from carrying the person's go; null otherwise. */
|
|
65
|
-
const guardWait = (asker, agent, guard) => {
|
|
66
|
-
if (!
|
|
71
|
+
const guardWait = (asker, agent, guard, { hosted = false } = {}) => {
|
|
72
|
+
if (!readByGuard(asker, hosted) || setToWait(agent) || guardClean(guard))
|
|
67
73
|
return null;
|
|
68
74
|
return !guard || guard.unavailable
|
|
69
75
|
? `The guard that reads ${nameOf(asker)}'s words for planted instructions is not running on this computer, so ${nameOf(agent)} waits for your Start.`
|
package/npm-shrinkwrap.json
CHANGED
|
@@ -1,12 +1,12 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "tryharness",
|
|
3
|
-
"version": "0.7.
|
|
3
|
+
"version": "0.7.62",
|
|
4
4
|
"lockfileVersion": 3,
|
|
5
5
|
"requires": true,
|
|
6
6
|
"packages": {
|
|
7
7
|
"": {
|
|
8
8
|
"name": "tryharness",
|
|
9
|
-
"version": "0.7.
|
|
9
|
+
"version": "0.7.62",
|
|
10
10
|
"license": "MIT",
|
|
11
11
|
"dependencies": {
|
|
12
12
|
"@agentclientprotocol/sdk": "2.0.0",
|
|
@@ -32,9 +32,9 @@
|
|
|
32
32
|
"node": ">=18"
|
|
33
33
|
},
|
|
34
34
|
"optionalDependencies": {
|
|
35
|
-
"tryharness-desktop-darwin-arm64": "0.7.
|
|
36
|
-
"tryharness-desktop-darwin-x64": "0.7.
|
|
37
|
-
"tryharness-desktop-linux-x64": "0.7.
|
|
35
|
+
"tryharness-desktop-darwin-arm64": "0.7.62",
|
|
36
|
+
"tryharness-desktop-darwin-x64": "0.7.62",
|
|
37
|
+
"tryharness-desktop-linux-x64": "0.7.62"
|
|
38
38
|
}
|
|
39
39
|
},
|
|
40
40
|
"node_modules/@agentclientprotocol/sdk": {
|
|
@@ -1051,9 +1051,9 @@
|
|
|
1051
1051
|
}
|
|
1052
1052
|
},
|
|
1053
1053
|
"node_modules/tryharness-desktop-darwin-arm64": {
|
|
1054
|
-
"version": "0.7.
|
|
1055
|
-
"resolved": "https://registry.npmjs.org/tryharness-desktop-darwin-arm64/-/tryharness-desktop-darwin-arm64-0.7.
|
|
1056
|
-
"integrity": "sha512-
|
|
1054
|
+
"version": "0.7.62",
|
|
1055
|
+
"resolved": "https://registry.npmjs.org/tryharness-desktop-darwin-arm64/-/tryharness-desktop-darwin-arm64-0.7.62.tgz",
|
|
1056
|
+
"integrity": "sha512-zlyu7H1UTLOeEUFsPwbYy6qBmGK6nnbBd2q9/vbFQCWzAM8iUD7fLL4OFygWx9abuCTm0q2RCZEs5aUlddzptA==",
|
|
1057
1057
|
"cpu": [
|
|
1058
1058
|
"arm64"
|
|
1059
1059
|
],
|
|
@@ -1064,9 +1064,9 @@
|
|
|
1064
1064
|
]
|
|
1065
1065
|
},
|
|
1066
1066
|
"node_modules/tryharness-desktop-darwin-x64": {
|
|
1067
|
-
"version": "0.7.
|
|
1068
|
-
"resolved": "https://registry.npmjs.org/tryharness-desktop-darwin-x64/-/tryharness-desktop-darwin-x64-0.7.
|
|
1069
|
-
"integrity": "sha512-
|
|
1067
|
+
"version": "0.7.62",
|
|
1068
|
+
"resolved": "https://registry.npmjs.org/tryharness-desktop-darwin-x64/-/tryharness-desktop-darwin-x64-0.7.62.tgz",
|
|
1069
|
+
"integrity": "sha512-5MT/t1tjuRQkyKWKSOlqMalc9jvYqEIA8Paci+ujyKaRw7bbQ5Rp3sMYgeX3SLy4Cb8fxA0PhVw7KGh2w4Bi8A==",
|
|
1070
1070
|
"cpu": [
|
|
1071
1071
|
"x64"
|
|
1072
1072
|
],
|
|
@@ -1077,9 +1077,9 @@
|
|
|
1077
1077
|
]
|
|
1078
1078
|
},
|
|
1079
1079
|
"node_modules/tryharness-desktop-linux-x64": {
|
|
1080
|
-
"version": "0.7.
|
|
1081
|
-
"resolved": "https://registry.npmjs.org/tryharness-desktop-linux-x64/-/tryharness-desktop-linux-x64-0.7.
|
|
1082
|
-
"integrity": "sha512-
|
|
1080
|
+
"version": "0.7.62",
|
|
1081
|
+
"resolved": "https://registry.npmjs.org/tryharness-desktop-linux-x64/-/tryharness-desktop-linux-x64-0.7.62.tgz",
|
|
1082
|
+
"integrity": "sha512-5/wL+oV15r07i85mZM3WglLrS3x/xrTmYOVMxt6NjhS4ySUnjBaL1udZbQxmiYLmSS9Hhvo360td2xt3pbTEAw==",
|
|
1083
1083
|
"cpu": [
|
|
1084
1084
|
"x64"
|
|
1085
1085
|
],
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "tryharness",
|
|
3
|
-
"version": "0.7.
|
|
3
|
+
"version": "0.7.62",
|
|
4
4
|
"description": "Harness Relay: the daemon that turns the agents on this machine into your personal swarm. Memory, history, and work handed between any of them.",
|
|
5
5
|
"bin": {
|
|
6
6
|
"tryharness": "cli.mjs"
|
|
@@ -48,8 +48,8 @@
|
|
|
48
48
|
"zod": "4.6.7"
|
|
49
49
|
},
|
|
50
50
|
"optionalDependencies": {
|
|
51
|
-
"tryharness-desktop-darwin-arm64": "0.7.
|
|
52
|
-
"tryharness-desktop-darwin-x64": "0.7.
|
|
53
|
-
"tryharness-desktop-linux-x64": "0.7.
|
|
51
|
+
"tryharness-desktop-darwin-arm64": "0.7.62",
|
|
52
|
+
"tryharness-desktop-darwin-x64": "0.7.62",
|
|
53
|
+
"tryharness-desktop-linux-x64": "0.7.62"
|
|
54
54
|
}
|
|
55
55
|
}
|
package/release.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"manifest": {
|
|
3
3
|
"name": "tryharness",
|
|
4
|
-
"version": "0.7.
|
|
4
|
+
"version": "0.7.62",
|
|
5
5
|
"files": {
|
|
6
6
|
"README.md": "b1c3d6f614dd896b6ffda089c512811ea21c41f2970181162cdba230ac7fb77e",
|
|
7
7
|
"assets/dsh-plugin.mjs": "143d31361d3c34b0a9effdeaa9248f1df6166f9bb45826a9a96ec9aa21899411",
|
|
@@ -11,6 +11,7 @@
|
|
|
11
11
|
"lib/activity.mjs": "e90b877d34bd4a8af84621f0475a99789d871dfc9cfea1dfffaf37b76e5a1459",
|
|
12
12
|
"lib/actorRoster.mjs": "8cea41c9f6225618f3e6b52c4ae9dedd3584882e757ca70273b389c306548d29",
|
|
13
13
|
"lib/adapters.mjs": "f349e8651610bcd4e6517365edbb72d6722726aa85868320907867dffdb151ca",
|
|
14
|
+
"lib/adoption.mjs": "8a15ac48b7e7e1ef623d6c6a61b82d49bdc47de7b9b7160b35ea4c9ce15323d1",
|
|
14
15
|
"lib/agentBinaries.mjs": "940d8877c6a400ce53224f15e701928d069873ff3fe011775443544dcdc49c11",
|
|
15
16
|
"lib/agentRuntimeConfig.mjs": "f80c0cccfd0096cef037b8209848e898804943d5ae390b21a3ebe95cd6597877",
|
|
16
17
|
"lib/agentRuntimes.mjs": "ea4718132a01d5b475662abaacc51a20fc0e59de9fc44e174a8ecf39cf626fc8",
|
|
@@ -30,7 +31,7 @@
|
|
|
30
31
|
"lib/boardFileCommands.mjs": "464449d6c2119f749e7f03796c8b1cab2d66ee005ffb93722bf4ba6f97931a32",
|
|
31
32
|
"lib/boardFiles.mjs": "3e0855e7153824cdfb75e2a0a6fe15fd6c2b2d0761403fb9cb144cabb1756c92",
|
|
32
33
|
"lib/boardMirror.mjs": "063e62a981011420207eecd8b8689f8afc1939f6b4ecd6b1409d5634298c0844",
|
|
33
|
-
"lib/boardProtocol.json": "
|
|
34
|
+
"lib/boardProtocol.json": "eedad65c88f7b6175a00558c3bd7cbaf85371fe682719f7fec7bb0c02e47467c",
|
|
34
35
|
"lib/boardProtocol.mjs": "9148f3e2905b5de761d5c5651686d131da66285579650fd1ad7b46b6ecc17a47",
|
|
35
36
|
"lib/boardThreads.mjs": "e78dc7fd22540ad0e201f312ea8e575d21463079e7ad42aae76d89c465698fdc",
|
|
36
37
|
"lib/boardTools.mjs": "54a6b354b1316c1380b788e394511cc568a2bfc22b553e0f8a58a786450a1a63",
|
|
@@ -62,13 +63,13 @@
|
|
|
62
63
|
"lib/controlSocket.mjs": "24b366d24c0cc9ca6b9c9b3490d47440edac1b1be91e2bc04e8b693b635a952e",
|
|
63
64
|
"lib/coordinator.mjs": "e5d7e800c5ee05c1f1c42a6e60a45c546aa9f0edc7a29472c6e4996913def29c",
|
|
64
65
|
"lib/coreModels.mjs": "481633a56283bbed58688300c5139962ae3d8602559015df5801decd8aa8d233",
|
|
65
|
-
"lib/daemon.mjs": "
|
|
66
|
+
"lib/daemon.mjs": "0c64bbb48b273dc91594003c076495f13ba1fe84bf609f3383eaade1e9e4932d",
|
|
66
67
|
"lib/desk.mjs": "e769e1f68117d9d6163538ba73318b2fdae48c179274e6da4f93db8f4febcdf8",
|
|
67
68
|
"lib/desktop.mjs": "74cb9e0516209f563c5764478e333ff545126422c4f10756a88c3fdba6175f23",
|
|
68
69
|
"lib/digest.mjs": "bcfb988a02dfc118f20d67a9e549be5640eae374a714a3d484fec86454caf04a",
|
|
69
70
|
"lib/directLink.mjs": "ea6a56006c1a50aebe37bf65a9a3e3ae4d90d3be460103437ecf6372011af072",
|
|
70
71
|
"lib/environment.mjs": "edbb17ec89177ebe6945bdc431acbab9df4eaf1a79f21794ebd85cf64104b3c4",
|
|
71
|
-
"lib/environments.mjs": "
|
|
72
|
+
"lib/environments.mjs": "cad566554166a0350b3196db2f53ee62409733fc29b1828f61fd9982da62423f",
|
|
72
73
|
"lib/files.mjs": "39145b9c2722f2024d37631d6dfeb44951221f3ff02b5b8dabe6182814b7adfa",
|
|
73
74
|
"lib/firewall.mjs": "9f5b1dc3a4e24283a0427a59f35731442dc8d7a507a64a60bb36c66c2a5fa0a8",
|
|
74
75
|
"lib/fit.mjs": "8d25fac513347975894babb6c93eb7bac6c8329cf487865a31960343957f0e2d",
|
|
@@ -81,11 +82,11 @@
|
|
|
81
82
|
"lib/handoffs.mjs": "1ff2c706f5fe62438c66e24f47539443451584af4e411c68e7f299757f7bd24f",
|
|
82
83
|
"lib/handover.mjs": "09cb8d6a17f73c47e36df709e7e632dac8a11dcb400ec1e6abac14337258ec1c",
|
|
83
84
|
"lib/harnessModel.mjs": "9bfcd931f37f8fd05f26dfb8a4551b62475c7d2fcbd0aa4fd77b2fb1c1545b2f",
|
|
84
|
-
"lib/harnessOffers.mjs": "
|
|
85
|
+
"lib/harnessOffers.mjs": "34fba77cbba5e8bb684359afc2ebfeb7cebf4bd57219030a6266926d2768b463",
|
|
85
86
|
"lib/hookDialects.mjs": "da62365cc29fd232b01664e4df9b7c514812791013f5d66590bd401669da7041",
|
|
86
87
|
"lib/inference.mjs": "c4806947a38cf8e4cf0bf19056cf581d3a31cc20d88ed545655a60726c231dec",
|
|
87
|
-
"lib/jobAnswers.mjs": "
|
|
88
|
-
"lib/landed.mjs": "
|
|
88
|
+
"lib/jobAnswers.mjs": "c7ac2b0a44c336bc34945d45e8daf1d9974280200e90c0dbbc4d2b6cb048c217",
|
|
89
|
+
"lib/landed.mjs": "7844a475a1b1e23c4a03dca3f2773934882f9c0d724f56777fb2a25b3d84b0b4",
|
|
89
90
|
"lib/lane.mjs": "613befd439d81e8c291d9acad2a21fe29bcadfb3c8aa80e71dcda33c7fac0950",
|
|
90
91
|
"lib/learn.mjs": "cf87dfb0fc5bfafb8dec277c6c0b824ecb57531934fc762d6066f486936a11ff",
|
|
91
92
|
"lib/lessons.mjs": "481ebe472010c0d0a4cedfdaea94570065d68ee8dc1c2e8e0e4e67b7e2a8f176",
|
|
@@ -121,7 +122,7 @@
|
|
|
121
122
|
"lib/oneLine.mjs": "0864a8fcc1138dd5f62bc1147fbcc70a9d181d7ec3301b51e00aca25ee93d249",
|
|
122
123
|
"lib/oneclawLocal.mjs": "da17884178b1a88e5cc4125b5112ae5def66806fdf934e0ad73bafb641a7dc97",
|
|
123
124
|
"lib/onnxWorker.mjs": "b94f5ec718c8fac80446d1fe21252abbccfec7f3f79186f7a54861c71f6e2410",
|
|
124
|
-
"lib/ownMachines.mjs": "
|
|
125
|
+
"lib/ownMachines.mjs": "d0f405bc3d9f8aa761cd7220d7d5c35b453849a239a6f5e02936442b3b1b4735",
|
|
125
126
|
"lib/pairing.mjs": "4f0328f1876ff9a7275759a061cee69e44108db490966489ef0eb7ff6c0804c9",
|
|
126
127
|
"lib/parsers.mjs": "b329b683cf36939984dfc7463b8584f74bb5eb00f34ad89bf7e80abd7145bbf2",
|
|
127
128
|
"lib/paths.mjs": "087afff9453fad097e766ee3a46af5d76c8cd1112ffce291db7e35cde08a0088",
|
|
@@ -129,10 +130,10 @@
|
|
|
129
130
|
"lib/personModel.mjs": "257ce37a85d0d2b6693ab1c7c720d338e9d03f2a7fe38702d475dfd0c3061565",
|
|
130
131
|
"lib/personNotices.mjs": "2f7a8bc4701ce57440ef29ee7fdbddd98488ef35b2e82a0c3812f56556a440c1",
|
|
131
132
|
"lib/personal.mjs": "0261690805651e6590eb6cbcccc713f034bf2acdd5248b8238880b2ff783c722",
|
|
132
|
-
"lib/phones.mjs": "
|
|
133
|
+
"lib/phones.mjs": "c9140852b71b24da5c27d971f21020e4c7065144b23394bf03dd1f33bd452cbb",
|
|
133
134
|
"lib/placeCommands.mjs": "ca9572fbe6ac36761b00e8d734d7e18a82a887388294eb89970edd65dd1577ef",
|
|
134
135
|
"lib/places.mjs": "8cca0d5806aa6d23f52fced69fc2d87ee47779b352d71765792cf12521ed12ed",
|
|
135
|
-
"lib/plans.mjs": "
|
|
136
|
+
"lib/plans.mjs": "53b63d7f5af98cdab735c8d2fec1372b967c675585e501f4e98adedcaebcd75d",
|
|
136
137
|
"lib/profile.mjs": "c68da90a70d41b6281f0f451cd5cb37a5a7b0a985497b3e9e5be8a567ce4046d",
|
|
137
138
|
"lib/projectGit.mjs": "5e2b88d1c0200176d529df2f17e842cae003160e67ef089ef90e0555d837ddba",
|
|
138
139
|
"lib/projectPieces.mjs": "87cc1e30835899a032eef56c093a5934e78450e9d0c1b254f9ab7cb88cf35234",
|
|
@@ -144,6 +145,7 @@
|
|
|
144
145
|
"lib/readers.mjs": "1e7c851751a25658e2348d05223a344a9047870c7fb77818a60fc837d5cc46b8",
|
|
145
146
|
"lib/readiness.mjs": "a7d5e4142a08e66c3dc90f1babc31032df872a00a629ca47e9d4cdc0f69a860e",
|
|
146
147
|
"lib/receipts.mjs": "b73e263055dd3293f71027b69c12dd99a53a7388a49ac9cbcdf525ba0f599c31",
|
|
148
|
+
"lib/recentRead.mjs": "a800f306f5f102914e41ba17d7ae20d64e8d027a322572d5183a325a448fbb5b",
|
|
147
149
|
"lib/record.mjs": "9acc85150049201edcd6d380e25e0d228838e4801fd4e51818439b76a2178d5a",
|
|
148
150
|
"lib/redact.mjs": "31e5f1dc32009c52f387fd7c9cd979e639a11a6eef78d165c7ce802d3095492e",
|
|
149
151
|
"lib/relayLimits.mjs": "bd6c9b8338b5a29f66434aa62bf39c1c9501383ece6f89ed9da1a1c68b284ebc",
|
|
@@ -177,10 +179,10 @@
|
|
|
177
179
|
"lib/specialtyNotice.mjs": "47398fe23db8b3f175a87ec8a5f063e06d15dd38b053def82cd253bdab849ebf",
|
|
178
180
|
"lib/specialtySnapshot.mjs": "fb270c64b80a5de7ef019888aab8803af45221669b2956aba1a19a987d4c9c2e",
|
|
179
181
|
"lib/speech.mjs": "6d6681632a75c98ec67683ef71d36c66998a64db99b6d2e177328afe08b8372a",
|
|
180
|
-
"lib/store.mjs": "
|
|
182
|
+
"lib/store.mjs": "c84ebdf86236ee7502b4e7dddbde60cde765057685b29bbc5fd2f163f7fb3fb9",
|
|
181
183
|
"lib/stuck.mjs": "2b69af1712be31484ac0d88e05ca88d8be72d5653f2c9510d3c793362c43dfc2",
|
|
182
184
|
"lib/subagents.mjs": "bf3d18a213881b49e1bd5e093353d0cccff8121f9859a9bd34ad30ec108f4125",
|
|
183
|
-
"lib/swarm.mjs": "
|
|
185
|
+
"lib/swarm.mjs": "9a344fca4a5ad54dafc3885785b787d053ea0b71ecaa6413079eea24cb32fbca",
|
|
184
186
|
"lib/swarmDevices.mjs": "9b6af0854c3fe3c673fc552b6dcc93a8f2f881cba215975151b083c7c6aeb353",
|
|
185
187
|
"lib/swarmMemory.mjs": "2e166c87ef5eb186d10ba8937ab3a454fb7900e1951cb3ba5adc15d2091e86de",
|
|
186
188
|
"lib/t3.mjs": "9b2b452d52a2e862f5fa84a81e51c448f0a05465c249fc3ec83eba1b308afb83",
|
|
@@ -189,8 +191,8 @@
|
|
|
189
191
|
"lib/taskRuns.mjs": "4f3a05c3479348fd760af73fa565c3ced9a99fe5b353375c10cef6b50722a359",
|
|
190
192
|
"lib/team.json": "5ab27433bdafc5be8aa98e4ad1e75c43446541005dd62de632b827bafc730cc1",
|
|
191
193
|
"lib/team.mjs": "83c4bfbdfc4f0c99b57729ddaed14e6833884370b103289ee416195089cec7da",
|
|
192
|
-
"lib/threadActions.mjs": "
|
|
193
|
-
"lib/threadAuthority.mjs": "
|
|
194
|
+
"lib/threadActions.mjs": "285f0596e23898b8fcefd33bb11d8a43c106c5b99da07274532bcf7cd90bea0a",
|
|
195
|
+
"lib/threadAuthority.mjs": "3288f4d8e2bbc5f4d9baf7433587f0b7bc817a61f75152639c41a3bd6c8923f8",
|
|
194
196
|
"lib/threadBriefs.mjs": "f4012411846171ddd3fbdd8b7d4a1c8567b0b933fcfa0bc8fc0e0c4470ff470c",
|
|
195
197
|
"lib/threadLine.mjs": "3418d262e0711f6513236805105b2b550b984b2474daa40ecbd44864f5dbfce8",
|
|
196
198
|
"lib/threadRuns.mjs": "99967409136c6f1a0c91c9b9355e1a77fe2f84777386c8da88c1eed572c70ebe",
|
|
@@ -213,10 +215,10 @@
|
|
|
213
215
|
"lib/workFocus.mjs": "08d3002d6114859bf7623fbcb62a5ed1dd12cecba6c8e37ed55a550a15a207a4",
|
|
214
216
|
"lib/workLinks.mjs": "8269180900fdf5fbd547a4c2337bcde4d5f733621c5b72bc2c23f01e72ad3d7d",
|
|
215
217
|
"lib/worktrees.mjs": "a040441863ee76e39e292e262b903b392e12d4158aa886e4c237b6fa98c0d7d2",
|
|
216
|
-
"npm-shrinkwrap.json": "
|
|
217
|
-
"package.json": "
|
|
218
|
+
"npm-shrinkwrap.json": "50df49e6cc1be1b7bfb0696af9424f3e6b085df8a1947238ad531bdcf6e5bbfc",
|
|
219
|
+
"package.json": "6aa518be26dc986667b3f54ba262548f430a3afd61bc317fbd31f7030713673a"
|
|
218
220
|
}
|
|
219
221
|
},
|
|
220
222
|
"key": "5bf9e60f5cabb530",
|
|
221
|
-
"signature": "
|
|
223
|
+
"signature": "MA+n6cUpC+tgfMaD+3DcYWzbVA4pKlc1KfyDlf9nSA9nmr2ex1anPkEGJ9MT+jVV7CzmoAn3xQZKm30MxU0YBw=="
|
|
222
224
|
}
|