tryharness 0.7.61 → 0.7.64
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 +3 -0
- package/lib/coordinator.mjs +1 -1
- package/lib/daemon.mjs +46 -4
- package/lib/environments.mjs +11 -1
- package/lib/harnessOffers.mjs +2 -1
- package/lib/jobAnswers.mjs +13 -4
- package/lib/ownMachines.mjs +13 -1
- package/lib/plans.mjs +33 -1
- package/lib/runner.mjs +35 -2
- package/lib/sessionControl.mjs +29 -9
- package/lib/store.mjs +41 -0
- package/lib/swarm.mjs +40 -0
- package/lib/team.mjs +7 -3
- 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 +20 -19
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",
|
|
@@ -747,6 +749,7 @@
|
|
|
747
749
|
"board.environments.list",
|
|
748
750
|
"board.environments.control",
|
|
749
751
|
"board.swarm.follow",
|
|
752
|
+
"board.swarm.adopt",
|
|
750
753
|
"board.swarm.seen",
|
|
751
754
|
"board.swarm.context",
|
|
752
755
|
"board.native.read",
|
package/lib/coordinator.mjs
CHANGED
|
@@ -92,7 +92,7 @@ Routing, when \`team\` is null or \`team.nextPiece\` is given, and \`teamMembers
|
|
|
92
92
|
.map(([level, rigor]) => `${level}: ${rigor.steps.join(", ")}`)
|
|
93
93
|
.join(
|
|
94
94
|
"; "
|
|
95
|
-
)}; combine also runs when several agents make. At light the work goes straight to one maker. Anything the person depends on, or that moves money, is careful at least. Make may have several agents side by side, only when its parts are independent; every other step has one. Check and judge never go to a maker, judge never to the framer, and combine is one agent, never a vote. An agent the person tagged fills a step, Make unless they said otherwise; a pin in \`pins\` (specialty: agent) holds the step that asks for that specialty. An agent with work running or waiting elsewhere is less available. When you route, hand on to the agents of the route's first step. Specialty ids: ${SPECIALTIES.map((specialty) => specialty.id).join(", ")}.`;
|
|
95
|
+
)}; combine also runs when several agents make. At light the work goes straight to one maker. Anything the person depends on, or that moves money, is careful at least. Make may have several agents side by side, only when its parts are independent; when the person wants every agent to take part (each answering, or all pitching in), add "everyone": true to the plan and put every agent in \`teamMembers\` on make. Every other step has one. Check and judge never go to a maker, judge never to the framer, and combine is one agent, never a vote. An agent the person tagged fills a step, Make unless they said otherwise; a pin in \`pins\` (specialty: agent) holds the step that asks for that specialty. An agent with work running or waiting elsewhere is less available. When you route, hand on to the agents of the route's first step. Specialty ids: ${SPECIALTIES.map((specialty) => specialty.id).join(", ")}.`;
|
|
96
96
|
|
|
97
97
|
const localDecision = (agent, facts) =>
|
|
98
98
|
askLocalAgent(agent, `${LOCAL_PROMPT}\n\n${JSON.stringify(facts)}`);
|
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 {
|
|
@@ -830,6 +839,7 @@ export function createEnvironments({
|
|
|
830
839
|
ready,
|
|
831
840
|
roots,
|
|
832
841
|
owns,
|
|
842
|
+
mine,
|
|
833
843
|
read,
|
|
834
844
|
hide,
|
|
835
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/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/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;
|
package/lib/runner.mjs
CHANGED
|
@@ -9,7 +9,7 @@ import { agentEnvironment } from "./agentnode.mjs";
|
|
|
9
9
|
import { runtimeOf } from "./agentRuntimeConfig.mjs";
|
|
10
10
|
import { runProtocolTask } from "./agentRuntimes.mjs";
|
|
11
11
|
import { scrubValues } from "./vault.mjs";
|
|
12
|
-
import { paths } from "./paths.mjs";
|
|
12
|
+
import { historyRoots, paths } from "./paths.mjs";
|
|
13
13
|
|
|
14
14
|
const running = new Set();
|
|
15
15
|
const children = new Map();
|
|
@@ -234,6 +234,33 @@ const MODEL_FLAGS = {
|
|
|
234
234
|
effort: (level) => ["--variant", level],
|
|
235
235
|
},
|
|
236
236
|
};
|
|
237
|
+
// Pi keeps each session in `<sessions>/<project>/<time>_<id>.jsonl`. Given only an id, Pi asks on the terminal whether
|
|
238
|
+
// to fork a session from another folder, and a non-interactive run cannot answer; given the file, it opens it. With
|
|
239
|
+
// no file, the run starts a new session: an id Pi can't find ends the run.
|
|
240
|
+
const piSessionFile = (sessionId) => {
|
|
241
|
+
const name = `_${sessionId}.jsonl`;
|
|
242
|
+
for (const root of historyRoots("pi")) {
|
|
243
|
+
let projects = [];
|
|
244
|
+
try {
|
|
245
|
+
projects = fs.readdirSync(root, { withFileTypes: true });
|
|
246
|
+
} catch {
|
|
247
|
+
continue;
|
|
248
|
+
}
|
|
249
|
+
for (const project of projects) {
|
|
250
|
+
if (!project.isDirectory()) continue;
|
|
251
|
+
const folder = path.join(root, project.name);
|
|
252
|
+
let files = [];
|
|
253
|
+
try {
|
|
254
|
+
files = fs.readdirSync(folder);
|
|
255
|
+
} catch {
|
|
256
|
+
continue;
|
|
257
|
+
}
|
|
258
|
+
const file = files.find((entry) => entry.endsWith(name));
|
|
259
|
+
if (file) return path.join(folder, file);
|
|
260
|
+
}
|
|
261
|
+
}
|
|
262
|
+
return null;
|
|
263
|
+
};
|
|
237
264
|
const modelFlags = ({ agent, model, effort }) => [
|
|
238
265
|
...(model ? (MODEL_FLAGS[agent]?.model(model) ?? []) : []),
|
|
239
266
|
...(effort ? (MODEL_FLAGS[agent]?.effort(effort) ?? []) : []),
|
|
@@ -386,7 +413,10 @@ export function agentInvocation(task) {
|
|
|
386
413
|
// Pi has no permission prompts. --approve trusts project-local configuration for
|
|
387
414
|
// this non-interactive run; its complete built-in tool set remains enabled. Another
|
|
388
415
|
// person's ask ignores project-local files instead (--no-approve).
|
|
389
|
-
if (task.agent === "pi")
|
|
416
|
+
if (task.agent === "pi") {
|
|
417
|
+
const session = task.resumeSession
|
|
418
|
+
? piSessionFile(task.resumeSession)
|
|
419
|
+
: null;
|
|
390
420
|
return {
|
|
391
421
|
command: "pi",
|
|
392
422
|
args: [
|
|
@@ -394,10 +424,12 @@ export function agentInvocation(task) {
|
|
|
394
424
|
"json",
|
|
395
425
|
task.ownSettingsOnly ? "--no-approve" : "--approve",
|
|
396
426
|
...modelFlags(task),
|
|
427
|
+
...(session ? ["--session", session] : []),
|
|
397
428
|
"-p",
|
|
398
429
|
task.brief,
|
|
399
430
|
],
|
|
400
431
|
};
|
|
432
|
+
}
|
|
401
433
|
if (task.agent === "opencode") {
|
|
402
434
|
return {
|
|
403
435
|
command: "opencode",
|
|
@@ -756,6 +788,7 @@ export function runAgentTask(task, emit, observe = () => {}, hooks = {}) {
|
|
|
756
788
|
continue;
|
|
757
789
|
}
|
|
758
790
|
const sessionId =
|
|
791
|
+
(event.type === "session" ? event.id : null) ||
|
|
759
792
|
event.session_id ||
|
|
760
793
|
event.sessionId ||
|
|
761
794
|
event.sessionID ||
|
package/lib/sessionControl.mjs
CHANGED
|
@@ -422,6 +422,13 @@ export function createSessionControl({
|
|
|
422
422
|
return app ? { name: path.basename(app, ".app"), app } : setupTerminal();
|
|
423
423
|
};
|
|
424
424
|
const lastResort = () => personTerminal() ?? { name: "Terminal", app: null };
|
|
425
|
+
// DeepSeek Harness and Muse Code take no session to resume from a terminal: their sessions reopen only in their own
|
|
426
|
+
// apps. Open starts the agent in the session's folder there instead, and says it is not that session.
|
|
427
|
+
const startsFresh = (agentId, sessionId) =>
|
|
428
|
+
Boolean(sessionId && agentCommand(agentId)) &&
|
|
429
|
+
!resumeLine(agentId, sessionId);
|
|
430
|
+
const freshNote = (agentId, where) =>
|
|
431
|
+
`${nameOf(agentId)} can't be opened at an earlier session from Harness, so it starts fresh in ${where}. Its earlier sessions are in its own app.`;
|
|
425
432
|
const terminalPlace = ({ name, app }) => ({ kind: "terminal", name, app });
|
|
426
433
|
|
|
427
434
|
// An agent's home: the place most of its sessions started in over the last thirty days (ties: the latest), where its
|
|
@@ -647,22 +654,30 @@ export function createSessionControl({
|
|
|
647
654
|
: { opensIn: name, note: busy };
|
|
648
655
|
// In a Neovim of theirs still open (this one first, else the latest they used the agent in), in a new tab; with
|
|
649
656
|
// none open, the buddy opens their terminal with Neovim running the session.
|
|
650
|
-
const
|
|
651
|
-
|
|
652
|
-
|
|
657
|
+
const fresh = startsFresh(agentId, sessionId);
|
|
658
|
+
const command =
|
|
659
|
+
sessionId && !fresh
|
|
660
|
+
? resumeLine(agentId, sessionId)
|
|
661
|
+
: agentCommand(agentId);
|
|
653
662
|
for (const open of act ? neovimsFor(agentId, place) : []) {
|
|
654
663
|
const shown = resumeInNeovim(open.server, command, folder);
|
|
655
|
-
if (shown)
|
|
664
|
+
if (shown)
|
|
665
|
+
return {
|
|
666
|
+
opensIn: name,
|
|
667
|
+
...focusTerminal(shown, open),
|
|
668
|
+
...(fresh ? { note: freshNote(agentId, name) } : {}),
|
|
669
|
+
};
|
|
656
670
|
}
|
|
657
671
|
return {
|
|
658
672
|
opensIn: name,
|
|
659
673
|
resume: {
|
|
660
674
|
agent: agentId,
|
|
661
|
-
session: sessionId ?? null,
|
|
675
|
+
session: fresh ? null : (sessionId ?? null),
|
|
662
676
|
cwd: folder ?? null,
|
|
663
677
|
app: place.app ?? null,
|
|
664
678
|
within: "nvim",
|
|
665
679
|
},
|
|
680
|
+
...(fresh ? { note: freshNote(agentId, name) } : {}),
|
|
666
681
|
};
|
|
667
682
|
}
|
|
668
683
|
if (place.kind === "terminal") {
|
|
@@ -671,14 +686,16 @@ export function createSessionControl({
|
|
|
671
686
|
return place.app
|
|
672
687
|
? { opensIn: name, app: place.app, note: busy }
|
|
673
688
|
: { opensIn: name, note: busy };
|
|
689
|
+
const fresh = startsFresh(agentId, sessionId);
|
|
674
690
|
return {
|
|
675
691
|
opensIn: name,
|
|
676
692
|
resume: {
|
|
677
693
|
agent: agentId,
|
|
678
|
-
session: sessionId ?? null,
|
|
694
|
+
session: fresh ? null : (sessionId ?? null),
|
|
679
695
|
cwd: folder ?? null,
|
|
680
696
|
app: place.app ?? null,
|
|
681
697
|
},
|
|
698
|
+
...(fresh ? { note: freshNote(agentId, name) } : {}),
|
|
682
699
|
};
|
|
683
700
|
}
|
|
684
701
|
return place.app ? { opensIn: name, app: place.app } : null;
|
|
@@ -841,9 +858,11 @@ export function createSessionControl({
|
|
|
841
858
|
placePlan(agentId, homeOf(agentId), sessionId, where, act) ??
|
|
842
859
|
placePlan(agentId, usable(own), sessionId, where, act);
|
|
843
860
|
if (plan) return plan;
|
|
844
|
-
// Nothing else shows it (T3 never had it, say): the exact session, picked up in the person's terminal
|
|
845
|
-
|
|
861
|
+
// Nothing else shows it (T3 never had it, say): the exact session, picked up in the person's terminal; an agent
|
|
862
|
+
// that can't resume one there starts in its folder.
|
|
863
|
+
if (CODING_AGENTS.includes(agentId) || startsFresh(agentId, sessionId)) {
|
|
846
864
|
const terminal = lastResort();
|
|
865
|
+
const fresh = startsFresh(agentId, sessionId);
|
|
847
866
|
// Until Harness may send into T3, a thread's runs happen in Harness's own copy of the repo, which T3 doesn't list.
|
|
848
867
|
const inCopy =
|
|
849
868
|
sessionId &&
|
|
@@ -854,10 +873,11 @@ export function createSessionControl({
|
|
|
854
873
|
opensIn: terminal.name,
|
|
855
874
|
resume: {
|
|
856
875
|
agent: agentId,
|
|
857
|
-
session: sessionId,
|
|
876
|
+
session: fresh ? null : sessionId,
|
|
858
877
|
cwd: where,
|
|
859
878
|
app: terminal.app,
|
|
860
879
|
},
|
|
880
|
+
...(fresh ? { note: freshNote(agentId, terminal.name) } : {}),
|
|
861
881
|
...(inCopy
|
|
862
882
|
? {
|
|
863
883
|
note: `This run happened in Harness's own copy of the repo, which T3 Code doesn't list, so it opens in ${terminal.name}. Approve Harness in T3 Code and this thread's next turns run there.`,
|
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
|
@@ -158,6 +158,8 @@ export function createSwarm({
|
|
|
158
158
|
withMachines = (card) => card,
|
|
159
159
|
// Where an agent calling from a computer is (ownMachines.mjs whereIs), for what it is told of itself; null when unknown.
|
|
160
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,
|
|
161
163
|
authorizeRun,
|
|
162
164
|
pickable,
|
|
163
165
|
listModels,
|
|
@@ -187,6 +189,8 @@ export function createSwarm({
|
|
|
187
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.
|
|
188
190
|
addressesPartner = () => false,
|
|
189
191
|
environments = null,
|
|
192
|
+
// Work from another tool taken over as a Harness thread (adoption.mjs).
|
|
193
|
+
adoption = null,
|
|
190
194
|
notifyFocus = () => {},
|
|
191
195
|
// What the person's words just did to a run they steered (threadRuns.mjs steered): a promise of the thread's note.
|
|
192
196
|
steered = () => null,
|
|
@@ -301,6 +305,19 @@ export function createSwarm({
|
|
|
301
305
|
: null;
|
|
302
306
|
};
|
|
303
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
|
+
|
|
304
321
|
const summary = (thread, includeRelated = true) => {
|
|
305
322
|
const posts = store.roomPosts(thread.id, 0, 500);
|
|
306
323
|
const runs = store.threadRuns(thread.id);
|
|
@@ -337,6 +354,7 @@ export function createSwarm({
|
|
|
337
354
|
.map((run) => run.target_agent)
|
|
338
355
|
),
|
|
339
356
|
],
|
|
357
|
+
runsOn: runsOnOf(runs),
|
|
340
358
|
// Why each agent given work here has not started, in a sentence: every surface says it the same way.
|
|
341
359
|
waits: runs
|
|
342
360
|
.map((run) => ({
|
|
@@ -510,7 +528,10 @@ export function createSwarm({
|
|
|
510
528
|
startedAt: run.created_at,
|
|
511
529
|
endedAt: run.reported_at,
|
|
512
530
|
}),
|
|
531
|
+
...adoption?.decorate(thread.id, run.id),
|
|
513
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) ?? []));
|
|
514
535
|
const posts = store.roomPosts(thread.id, 0, 500);
|
|
515
536
|
return {
|
|
516
537
|
ok: true,
|
|
@@ -880,6 +901,25 @@ export function createSwarm({
|
|
|
880
901
|
error: error.message,
|
|
881
902
|
})),
|
|
882
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
|
+
}
|
|
883
923
|
if (command === "board.swarm.read")
|
|
884
924
|
return pending(
|
|
885
925
|
environments
|
package/lib/team.mjs
CHANGED
|
@@ -73,6 +73,8 @@ export function validPlan(
|
|
|
73
73
|
? proposed.rigor
|
|
74
74
|
: "standard";
|
|
75
75
|
const split = !piece && Boolean(proposed?.split);
|
|
76
|
+
// The person wants every agent in: Make keeps every one the round put there, past the side-by-side cap.
|
|
77
|
+
const everyone = !piece && proposed?.everyone === true;
|
|
76
78
|
const given = new Map(
|
|
77
79
|
(Array.isArray(proposed?.steps) ? proposed.steps : [])
|
|
78
80
|
.filter((step) => STEP_IDS.includes(step?.id))
|
|
@@ -116,9 +118,11 @@ export function validPlan(
|
|
|
116
118
|
}
|
|
117
119
|
// Make is never left empty while the person tagged someone.
|
|
118
120
|
if (id === "make" && !agents.length && !split) agents = tagged;
|
|
119
|
-
agents = stepOf(id).together
|
|
120
|
-
? agents.slice(0,
|
|
121
|
-
:
|
|
121
|
+
agents = !stepOf(id).together
|
|
122
|
+
? agents.slice(0, 1)
|
|
123
|
+
: everyone
|
|
124
|
+
? agents
|
|
125
|
+
: agents.slice(0, TEAM.mostSideBySide);
|
|
122
126
|
holders[id] = agents;
|
|
123
127
|
return { id, specialty: step.specialty, agents };
|
|
124
128
|
});
|
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.64",
|
|
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.64",
|
|
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.64",
|
|
36
|
+
"tryharness-desktop-darwin-x64": "0.7.64",
|
|
37
|
+
"tryharness-desktop-linux-x64": "0.7.64"
|
|
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.64",
|
|
1055
|
+
"resolved": "https://registry.npmjs.org/tryharness-desktop-darwin-arm64/-/tryharness-desktop-darwin-arm64-0.7.64.tgz",
|
|
1056
|
+
"integrity": "sha512-hB/HjdMGZzLAmKUmIa1+4+UnxFVAjIgT1vvb8d1kop/0nLn/uZk7xkzZTtQMTeBcdHdieozS5+OZhSczb9Uk2w==",
|
|
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.64",
|
|
1068
|
+
"resolved": "https://registry.npmjs.org/tryharness-desktop-darwin-x64/-/tryharness-desktop-darwin-x64-0.7.64.tgz",
|
|
1069
|
+
"integrity": "sha512-oDwPfrA6jav82YzYhLAJ/IxLpWFLJwjj/MeOjMq75bvWnsSKr5lj6Ft+I6XdAkfs+e72BhM1J8pnQOPbdVAehA==",
|
|
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.64",
|
|
1081
|
+
"resolved": "https://registry.npmjs.org/tryharness-desktop-linux-x64/-/tryharness-desktop-linux-x64-0.7.64.tgz",
|
|
1082
|
+
"integrity": "sha512-P9OC73WTR3TgSeeQKyAQ83VVtFqvO9Pd/mSvB5ViiX+jtXD+j9Ql6SnU5oHVKp7urK3ymauO1wG5op6tgZ2Dcg==",
|
|
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.64",
|
|
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.64",
|
|
52
|
+
"tryharness-desktop-darwin-x64": "0.7.64",
|
|
53
|
+
"tryharness-desktop-linux-x64": "0.7.64"
|
|
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.64",
|
|
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",
|
|
@@ -60,15 +61,15 @@
|
|
|
60
61
|
"lib/contractGate.mjs": "f6c2f7ebe5834bf1716c5d4298a4e0636f81a981fef9b8ce4f38ff2d4cf4e0fb",
|
|
61
62
|
"lib/control-client.mjs": "16130df5d4a04cfea5a327a4c57a1177b268b7073b4f060dd3d2732ff8ac91d5",
|
|
62
63
|
"lib/controlSocket.mjs": "24b366d24c0cc9ca6b9c9b3490d47440edac1b1be91e2bc04e8b693b635a952e",
|
|
63
|
-
"lib/coordinator.mjs": "
|
|
64
|
+
"lib/coordinator.mjs": "3e3163d5b6d58e888704d833f8e7d34ce022f9b6073f9791ad04e3f1cbc6c8fe",
|
|
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,10 +82,10 @@
|
|
|
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/jobAnswers.mjs": "c7ac2b0a44c336bc34945d45e8daf1d9974280200e90c0dbbc4d2b6cb048c217",
|
|
88
89
|
"lib/landed.mjs": "7844a475a1b1e23c4a03dca3f2773934882f9c0d724f56777fb2a25b3d84b0b4",
|
|
89
90
|
"lib/lane.mjs": "613befd439d81e8c291d9acad2a21fe29bcadfb3c8aa80e71dcda33c7fac0950",
|
|
90
91
|
"lib/learn.mjs": "cf87dfb0fc5bfafb8dec277c6c0b824ecb57531934fc762d6066f486936a11ff",
|
|
@@ -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",
|
|
@@ -132,7 +133,7 @@
|
|
|
132
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",
|
|
@@ -157,7 +158,7 @@
|
|
|
157
158
|
"lib/runBrief.mjs": "e7a65a83e6e5554c746e10e3a48cd68b6bf6c9520c1c32b384c1b7099c07f848",
|
|
158
159
|
"lib/runRequests.mjs": "3f35d95f7204ef60b3be2d9852d84aed063e83420b26b83701930cc826e1b170",
|
|
159
160
|
"lib/runWorker.mjs": "ac86dd9bdc54aee8684b21766fa8be640496dc4130909a4216d6650ca5a4fa95",
|
|
160
|
-
"lib/runner.mjs": "
|
|
161
|
+
"lib/runner.mjs": "6e2050a4a5026abf76f43df9fa204b1b99a0967182856761c83a8c73ad9ab914",
|
|
161
162
|
"lib/runtime-install.mjs": "da24b88a8106adf61443a66dc5eeef12162dc4a51b49137d9b76641f6bc24025",
|
|
162
163
|
"lib/schedules.mjs": "1746435cfe3722ea2fb99c89c051384de6b2db1548968d2b8af36292e4410248",
|
|
163
164
|
"lib/screens.mjs": "dd573149e1d49771b9d7257811f2162f4345e78bae5b04265724265e2ec8e295",
|
|
@@ -168,7 +169,7 @@
|
|
|
168
169
|
"lib/seen.mjs": "2d1f7c75897d7046bdc72ff201f2613ffa909d05f333b502c7b5d707907679d6",
|
|
169
170
|
"lib/serverWords.mjs": "fab6e31b59e8b57de80d3dd060b874a5801eb745cbf58f2aaed5ed1d4147a37e",
|
|
170
171
|
"lib/service.mjs": "5ed3df2e4b19dd4c5b91c87a736d97bf8d183a4ba6b2deff65d989bc2f15dc1f",
|
|
171
|
-
"lib/sessionControl.mjs": "
|
|
172
|
+
"lib/sessionControl.mjs": "2623e0239fdaaff3e0eb4e86f6d3b38eed0e4845951df467fdb217ae13403c59",
|
|
172
173
|
"lib/sessionIndex.mjs": "a2f2478dbe8350927421423fc5bf74a1bdd409f7b2d659ede88d3f30eafef5f2",
|
|
173
174
|
"lib/snippets.mjs": "f1f68da74bcaf7b1fd5f769804b2868c7ead1e930532483e42f9663d88b77519",
|
|
174
175
|
"lib/specialties.json": "8d129882d8b968662e29fb1e35b0539852fe76d933c6f14045030a0ef4928eb4",
|
|
@@ -178,10 +179,10 @@
|
|
|
178
179
|
"lib/specialtyNotice.mjs": "47398fe23db8b3f175a87ec8a5f063e06d15dd38b053def82cd253bdab849ebf",
|
|
179
180
|
"lib/specialtySnapshot.mjs": "fb270c64b80a5de7ef019888aab8803af45221669b2956aba1a19a987d4c9c2e",
|
|
180
181
|
"lib/speech.mjs": "6d6681632a75c98ec67683ef71d36c66998a64db99b6d2e177328afe08b8372a",
|
|
181
|
-
"lib/store.mjs": "
|
|
182
|
+
"lib/store.mjs": "c84ebdf86236ee7502b4e7dddbde60cde765057685b29bbc5fd2f163f7fb3fb9",
|
|
182
183
|
"lib/stuck.mjs": "2b69af1712be31484ac0d88e05ca88d8be72d5653f2c9510d3c793362c43dfc2",
|
|
183
184
|
"lib/subagents.mjs": "bf3d18a213881b49e1bd5e093353d0cccff8121f9859a9bd34ad30ec108f4125",
|
|
184
|
-
"lib/swarm.mjs": "
|
|
185
|
+
"lib/swarm.mjs": "9a344fca4a5ad54dafc3885785b787d053ea0b71ecaa6413079eea24cb32fbca",
|
|
185
186
|
"lib/swarmDevices.mjs": "9b6af0854c3fe3c673fc552b6dcc93a8f2f881cba215975151b083c7c6aeb353",
|
|
186
187
|
"lib/swarmMemory.mjs": "2e166c87ef5eb186d10ba8937ab3a454fb7900e1951cb3ba5adc15d2091e86de",
|
|
187
188
|
"lib/t3.mjs": "9b2b452d52a2e862f5fa84a81e51c448f0a05465c249fc3ec83eba1b308afb83",
|
|
@@ -189,9 +190,9 @@
|
|
|
189
190
|
"lib/taskRooms.mjs": "a5c1179a30787f36b3435d57799d5a33c23222482bbc2584b69e1a5b3d95619e",
|
|
190
191
|
"lib/taskRuns.mjs": "4f3a05c3479348fd760af73fa565c3ced9a99fe5b353375c10cef6b50722a359",
|
|
191
192
|
"lib/team.json": "5ab27433bdafc5be8aa98e4ad1e75c43446541005dd62de632b827bafc730cc1",
|
|
192
|
-
"lib/team.mjs": "
|
|
193
|
-
"lib/threadActions.mjs": "
|
|
194
|
-
"lib/threadAuthority.mjs": "
|
|
193
|
+
"lib/team.mjs": "f838fe0a9afd4b75a56bb4ed2b9646d09e85176997d2419b30b268b937e0626b",
|
|
194
|
+
"lib/threadActions.mjs": "285f0596e23898b8fcefd33bb11d8a43c106c5b99da07274532bcf7cd90bea0a",
|
|
195
|
+
"lib/threadAuthority.mjs": "3288f4d8e2bbc5f4d9baf7433587f0b7bc817a61f75152639c41a3bd6c8923f8",
|
|
195
196
|
"lib/threadBriefs.mjs": "f4012411846171ddd3fbdd8b7d4a1c8567b0b933fcfa0bc8fc0e0c4470ff470c",
|
|
196
197
|
"lib/threadLine.mjs": "3418d262e0711f6513236805105b2b550b984b2474daa40ecbd44864f5dbfce8",
|
|
197
198
|
"lib/threadRuns.mjs": "99967409136c6f1a0c91c9b9355e1a77fe2f84777386c8da88c1eed572c70ebe",
|
|
@@ -214,10 +215,10 @@
|
|
|
214
215
|
"lib/workFocus.mjs": "08d3002d6114859bf7623fbcb62a5ed1dd12cecba6c8e37ed55a550a15a207a4",
|
|
215
216
|
"lib/workLinks.mjs": "8269180900fdf5fbd547a4c2337bcde4d5f733621c5b72bc2c23f01e72ad3d7d",
|
|
216
217
|
"lib/worktrees.mjs": "a040441863ee76e39e292e262b903b392e12d4158aa886e4c237b6fa98c0d7d2",
|
|
217
|
-
"npm-shrinkwrap.json": "
|
|
218
|
-
"package.json": "
|
|
218
|
+
"npm-shrinkwrap.json": "892bcdd0ae0c1d70cedcca9ee27858f7320fcf5392a3eab56ecac4af24916023",
|
|
219
|
+
"package.json": "29a49890c924c539c7c72b8dc017cfd96e77ce4f242f3747bb8a6ededa5d91ba"
|
|
219
220
|
}
|
|
220
221
|
},
|
|
221
222
|
"key": "5bf9e60f5cabb530",
|
|
222
|
-
"signature": "
|
|
223
|
+
"signature": "dluZA+0jzT62bDJVmm87q57LLywyB5/BwtSSjazAcofFaHdkGf4YkgfMCDCAL57tvt+SZglmrQPHb5x0jdB9CA=="
|
|
223
224
|
}
|