tryharness 0.7.59 → 0.7.60

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/speech.mjs CHANGED
@@ -344,6 +344,167 @@ export function createAppleSpeech({
344
344
  };
345
345
  }
346
346
 
347
+ // The models' own work, run on the model thread (onnxWorker.mjs) beside the sessions; each returns what the daemon's
348
+ // side turns into words. Samples are sent as a copy of just their piece: a piece of a longer recording sent as is
349
+ // would copy the whole recording to the other thread.
350
+ /** The VAD's speech probability for each 32 ms frame: a job on the model thread (onnxWorker.mjs). */
351
+ export async function vadProbabilities({ ort, graph }, file, samples) {
352
+ const vad = await graph(file);
353
+ const rate = new ort.Tensor("int64", BigInt64Array.from([BigInt(RATE)]), []);
354
+ let state = new ort.Tensor("float32", new Float32Array(2 * 128), [2, 1, 128]);
355
+ const input = new Float32Array(CONTEXT + FRAME);
356
+ const probs = new Float32Array(Math.floor(samples.length / FRAME));
357
+ for (let i = 0; i < probs.length; i += 1) {
358
+ // Each frame carries the last 64 samples of the one before it, as the model was trained.
359
+ input.copyWithin(0, FRAME, FRAME + CONTEXT);
360
+ input.set(samples.subarray(i * FRAME, (i + 1) * FRAME), CONTEXT);
361
+ const out = await vad.run({
362
+ input: new ort.Tensor("float32", input.slice(), [1, CONTEXT + FRAME]),
363
+ state,
364
+ sr: rate,
365
+ });
366
+ probs[i] = out.output.data[0];
367
+ state = out.stateN;
368
+ }
369
+ return probs;
370
+ }
371
+
372
+ /** Moonshine's token ids for one piece of speech: a job on the model thread. */
373
+ export async function moonshineIds({ ort, graph }, files, config, samples) {
374
+ const [encoder, decoder] = await Promise.all([
375
+ graph(files.encoder),
376
+ graph(files.decoder),
377
+ ]);
378
+ const { last_hidden_state: states } = await encoder.run({
379
+ input_values: new ort.Tensor("float32", samples, [1, samples.length]),
380
+ });
381
+ const layers = config.decoder_num_hidden_layers,
382
+ heads = config.decoder_num_key_value_heads,
383
+ width = config.hidden_size / config.decoder_num_attention_heads;
384
+ const empty = new ort.Tensor("float32", new Float32Array(0), [
385
+ 1,
386
+ heads,
387
+ 0,
388
+ width,
389
+ ]);
390
+ const past = {};
391
+ for (let i = 0; i < layers; i += 1)
392
+ for (const part of ["decoder", "encoder"])
393
+ for (const kv of ["key", "value"])
394
+ past[`past_key_values.${i}.${part}.${kv}`] = empty;
395
+ const limit = Math.ceil((samples.length / RATE) * TOKENS_PER_SECOND) + 4;
396
+ const ids = [];
397
+ let token = config.decoder_start_token_id;
398
+ for (let step = 0; step < limit; step += 1) {
399
+ const out = await decoder.run({
400
+ input_ids: new ort.Tensor(
401
+ "int64",
402
+ BigInt64Array.from([BigInt(token)]),
403
+ [1, 1]
404
+ ),
405
+ encoder_hidden_states: states,
406
+ use_cache_branch: new ort.Tensor(
407
+ "bool",
408
+ Uint8Array.from([step > 0 ? 1 : 0]),
409
+ [1]
410
+ ),
411
+ ...past,
412
+ });
413
+ const logits = out.logits.data;
414
+ let best = 0;
415
+ for (let v = 1; v < logits.length; v += 1)
416
+ if (logits[v] > logits[best]) best = v;
417
+ // The encoder's keys and values come from the first step and stay; the decoder's grow by one each step.
418
+ for (let i = 0; i < layers; i += 1)
419
+ for (const part of step === 0 ? ["decoder", "encoder"] : ["decoder"])
420
+ for (const kv of ["key", "value"])
421
+ past[`past_key_values.${i}.${part}.${kv}`] =
422
+ out[`present.${i}.${part}.${kv}`];
423
+ if (best === config.eos_token_id) break;
424
+ ids.push(best);
425
+ token = best;
426
+ }
427
+ return ids;
428
+ }
429
+
430
+ /**
431
+ * Parakeet's token ids for one piece of speech, a job on the model thread: its feature extractor and encoder, then a
432
+ * greedy token-and-duration decode over the encoder's frames (as NeMo and onnx-asr do): each step names a token (or
433
+ * blank) and how many frames to move. `vocabulary` is how many tokens there are; `blank` the blank's id.
434
+ */
435
+ export async function parakeetIds(
436
+ { ort, graph },
437
+ files,
438
+ { vocabulary, blank },
439
+ samples
440
+ ) {
441
+ const [features, encoder, joint] = await Promise.all(
442
+ [files.features, files.encoder, files.joint].map((file) => graph(file))
443
+ );
444
+ const count = new ort.Tensor(
445
+ "int64",
446
+ BigInt64Array.from([BigInt(samples.length)]),
447
+ [1]
448
+ );
449
+ const heard = await features.run({
450
+ waveforms: new ort.Tensor("float32", samples, [1, samples.length]),
451
+ waveforms_lens: count,
452
+ });
453
+ const { outputs, encoded_lengths } = await encoder.run({
454
+ audio_signal: heard.features,
455
+ length: heard.features_lens,
456
+ });
457
+ const [, width, frames] = outputs.dims,
458
+ length = Number(encoded_lengths.data[0]);
459
+ const frame = (t) => {
460
+ const v = new Float32Array(width);
461
+ for (let d = 0; d < width; d += 1) v[d] = outputs.data[d * frames + t];
462
+ return v;
463
+ };
464
+ let states = [1, 2].map(
465
+ () => new ort.Tensor("float32", new Float32Array(2 * 640), [2, 1, 640])
466
+ );
467
+ const ids = [];
468
+ for (let t = 0, emitted = 0; t < length;) {
469
+ const out = await joint.run({
470
+ encoder_outputs: new ort.Tensor("float32", frame(t), [1, width, 1]),
471
+ targets: new ort.Tensor(
472
+ "int32",
473
+ Int32Array.from([ids.at(-1) ?? blank]),
474
+ [1, 1]
475
+ ),
476
+ target_length: new ort.Tensor("int32", Int32Array.from([1]), [1]),
477
+ input_states_1: states[0],
478
+ input_states_2: states[1],
479
+ });
480
+ const scores = out.outputs.data;
481
+ let token = 0,
482
+ step = 0;
483
+ for (let v = 1; v < vocabulary; v += 1)
484
+ if (scores[v] > scores[token]) token = v;
485
+ for (let k = 1; k < scores.length - vocabulary; k += 1)
486
+ if (scores[vocabulary + k] > scores[vocabulary + step]) step = k;
487
+ if (token !== blank) {
488
+ states = [out.output_states_1, out.output_states_2];
489
+ ids.push(token);
490
+ emitted += 1;
491
+ }
492
+ // At most ten tokens on one frame, as the model's decoding allows.
493
+ if (step > 0) {
494
+ t += step;
495
+ emitted = 0;
496
+ } else if (token === blank || emitted === 10) {
497
+ t += 1;
498
+ emitted = 0;
499
+ }
500
+ }
501
+ return ids;
502
+ }
503
+
504
+ const VAD_JOB = { module: import.meta.url, name: "vadProbabilities" };
505
+ const MOONSHINE_JOB = { module: import.meta.url, name: "moonshineIds" };
506
+ const PARAKEET_JOB = { module: import.meta.url, name: "parakeetIds" };
507
+
347
508
  export function createSpeech({
348
509
  inference,
349
510
  root,
@@ -488,194 +649,48 @@ export function createSpeech({
488
649
  const vadFile = fileOf(vadEntry, /\.onnx$/);
489
650
  /** The VAD's speech probability for each 32 ms frame. */
490
651
  const probabilities = (samples, lane) =>
491
- inference.onnx(
492
- "vad",
493
- async ({ ort, graph }) => {
494
- const vad = await graph(vadFile);
495
- const rate = new ort.Tensor(
496
- "int64",
497
- BigInt64Array.from([BigInt(RATE)]),
498
- []
499
- );
500
- let state = new ort.Tensor(
501
- "float32",
502
- new Float32Array(2 * 128),
503
- [2, 1, 128]
504
- );
505
- const input = new Float32Array(CONTEXT + FRAME);
506
- const probs = new Float32Array(Math.floor(samples.length / FRAME));
507
- for (let i = 0; i < probs.length; i += 1) {
508
- // Each frame carries the last 64 samples of the one before it, as the model was trained.
509
- input.copyWithin(0, FRAME, FRAME + CONTEXT);
510
- input.set(samples.subarray(i * FRAME, (i + 1) * FRAME), CONTEXT);
511
- const out = await vad.run({
512
- input: new ort.Tensor("float32", input.slice(), [
513
- 1,
514
- CONTEXT + FRAME,
515
- ]),
516
- state,
517
- sr: rate,
518
- });
519
- probs[i] = out.output.data[0];
520
- state = out.stateN;
521
- }
522
- return probs;
523
- },
524
- { lane }
525
- );
652
+ inference.onnx("vad", VAD_JOB, [vadFile, samples.slice()], { lane });
526
653
 
527
654
  /** Where in the samples someone spoke: [start, end) pairs, none for noise or silence. */
528
655
  const voiced = async (samples, { lane = "interactive" } = {}) =>
529
656
  speechSpans(await probabilities(samples, lane), { total: samples.length });
530
657
 
531
658
  /** Moonshine's words for one piece of speech. */
532
- const moonshine = (samples, { lane = "interactive" } = {}) =>
533
- inference.onnx(
659
+ const moonshine = async (samples, { lane = "interactive" } = {}) => {
660
+ load();
661
+ const files = {
662
+ encoder: fileOf(speechEntry, /encoder[^/]*\.onnx$/),
663
+ decoder: fileOf(speechEntry, /decoder[^/]*\.onnx$/),
664
+ };
665
+ const ids = await inference.onnx(
534
666
  "speech",
535
- async ({ ort, graph }) => {
536
- load();
537
- const [encoder, decoder] = await Promise.all([
538
- graph(fileOf(speechEntry, /encoder[^/]*\.onnx$/)),
539
- graph(fileOf(speechEntry, /decoder[^/]*\.onnx$/)),
540
- ]);
541
- const { last_hidden_state: states } = await encoder.run({
542
- input_values: new ort.Tensor("float32", samples, [1, samples.length]),
543
- });
544
- const layers = config.decoder_num_hidden_layers,
545
- heads = config.decoder_num_key_value_heads,
546
- width = config.hidden_size / config.decoder_num_attention_heads;
547
- const empty = new ort.Tensor("float32", new Float32Array(0), [
548
- 1,
549
- heads,
550
- 0,
551
- width,
552
- ]);
553
- const past = {};
554
- for (let i = 0; i < layers; i += 1)
555
- for (const part of ["decoder", "encoder"])
556
- for (const kv of ["key", "value"])
557
- past[`past_key_values.${i}.${part}.${kv}`] = empty;
558
- const limit =
559
- Math.ceil((samples.length / RATE) * TOKENS_PER_SECOND) + 4;
560
- const ids = [];
561
- let token = config.decoder_start_token_id;
562
- for (let step = 0; step < limit; step += 1) {
563
- const out = await decoder.run({
564
- input_ids: new ort.Tensor(
565
- "int64",
566
- BigInt64Array.from([BigInt(token)]),
567
- [1, 1]
568
- ),
569
- encoder_hidden_states: states,
570
- use_cache_branch: new ort.Tensor(
571
- "bool",
572
- Uint8Array.from([step > 0 ? 1 : 0]),
573
- [1]
574
- ),
575
- ...past,
576
- });
577
- const logits = out.logits.data;
578
- let best = 0;
579
- for (let v = 1; v < logits.length; v += 1)
580
- if (logits[v] > logits[best]) best = v;
581
- // The encoder's keys and values come from the first step and stay; the decoder's grow by one each step.
582
- for (let i = 0; i < layers; i += 1)
583
- for (const part of step === 0
584
- ? ["decoder", "encoder"]
585
- : ["decoder"])
586
- for (const kv of ["key", "value"])
587
- past[`past_key_values.${i}.${part}.${kv}`] =
588
- out[`present.${i}.${part}.${kv}`];
589
- if (best === config.eos_token_id) break;
590
- ids.push(best);
591
- token = best;
592
- }
593
- return tokens.decode(ids).trim();
594
- },
667
+ MOONSHINE_JOB,
668
+ [files, config, samples.slice()],
595
669
  { lane }
596
670
  );
671
+ return tokens.decode(ids).trim();
672
+ };
597
673
 
598
- /**
599
- * Parakeet's words for one piece of speech: its feature extractor and encoder, then a greedy token-and-duration decode
600
- * over the encoder's frames (as NeMo and onnx-asr do): each step names a token (or blank) and how many frames to move.
601
- */
602
- const parakeet = (samples, { lane = "interactive" } = {}) =>
603
- inference.onnx(
674
+ /** Parakeet's words for one piece of speech. */
675
+ const parakeet = async (samples, { lane = "interactive" } = {}) => {
676
+ load();
677
+ const files = {
678
+ features: fileOf(speechEntry, /nemo\d+\.onnx$/),
679
+ encoder: fileOf(speechEntry, /encoder[^/]*\.onnx$/),
680
+ joint: fileOf(speechEntry, /decoder_joint[^/]*\.onnx$/),
681
+ };
682
+ const ids = await inference.onnx(
604
683
  "speech",
605
- async ({ ort, graph }) => {
606
- load();
607
- const [features, encoder, joint] = await Promise.all(
608
- [
609
- /nemo\d+\.onnx$/,
610
- /encoder[^/]*\.onnx$/,
611
- /decoder_joint[^/]*\.onnx$/,
612
- ].map((pattern) => graph(fileOf(speechEntry, pattern)))
613
- );
614
- const count = new ort.Tensor(
615
- "int64",
616
- BigInt64Array.from([BigInt(samples.length)]),
617
- [1]
618
- );
619
- const heard = await features.run({
620
- waveforms: new ort.Tensor("float32", samples, [1, samples.length]),
621
- waveforms_lens: count,
622
- });
623
- const { outputs, encoded_lengths } = await encoder.run({
624
- audio_signal: heard.features,
625
- length: heard.features_lens,
626
- });
627
- const [, width, frames] = outputs.dims,
628
- length = Number(encoded_lengths.data[0]);
629
- const frame = (t) => {
630
- const v = new Float32Array(width);
631
- for (let d = 0; d < width; d += 1)
632
- v[d] = outputs.data[d * frames + t];
633
- return v;
634
- };
635
- const { pieces, blank } = tokens;
636
- let states = [1, 2].map(
637
- () =>
638
- new ort.Tensor("float32", new Float32Array(2 * 640), [2, 1, 640])
639
- );
640
- const ids = [];
641
- for (let t = 0, emitted = 0; t < length;) {
642
- const out = await joint.run({
643
- encoder_outputs: new ort.Tensor("float32", frame(t), [1, width, 1]),
644
- targets: new ort.Tensor(
645
- "int32",
646
- Int32Array.from([ids.at(-1) ?? blank]),
647
- [1, 1]
648
- ),
649
- target_length: new ort.Tensor("int32", Int32Array.from([1]), [1]),
650
- input_states_1: states[0],
651
- input_states_2: states[1],
652
- });
653
- const scores = out.outputs.data;
654
- let token = 0,
655
- step = 0;
656
- for (let v = 1; v < pieces.length; v += 1)
657
- if (scores[v] > scores[token]) token = v;
658
- for (let k = 1; k < scores.length - pieces.length; k += 1)
659
- if (scores[pieces.length + k] > scores[pieces.length + step])
660
- step = k;
661
- if (token !== blank) {
662
- states = [out.output_states_1, out.output_states_2];
663
- ids.push(token);
664
- emitted += 1;
665
- }
666
- // At most ten tokens on one frame, as the model's decoding allows.
667
- if (step > 0) {
668
- t += step;
669
- emitted = 0;
670
- } else if (token === blank || emitted === 10) {
671
- t += 1;
672
- emitted = 0;
673
- }
674
- }
675
- return tokens.decode(ids).trim();
676
- },
684
+ PARAKEET_JOB,
685
+ [
686
+ files,
687
+ { vocabulary: tokens.pieces.length, blank: tokens.blank },
688
+ samples.slice(),
689
+ ],
677
690
  { lane }
678
691
  );
692
+ return tokens.decode(ids).trim();
693
+ };
679
694
  const recognise = engine === "parakeet" ? parakeet : moonshine;
680
695
 
681
696
  /** Speech stretches joined into pieces Moonshine can take, cut between stretches. */
package/lib/swarm.mjs CHANGED
@@ -26,6 +26,7 @@ import {
26
26
  } from "./specialties.mjs";
27
27
  import { askOfRun } from "./threadView.mjs";
28
28
  import { createWorkFocus } from "./workFocus.mjs";
29
+ import { createListVersions } from "./listVersions.mjs";
29
30
  import { createWorkLinks } from "./workLinks.mjs";
30
31
  import {
31
32
  DEFAULT_ROUTING,
@@ -694,6 +695,12 @@ export function createSwarm({
694
695
  };
695
696
  };
696
697
 
698
+ // The thread list's versions, one for each list a reader can ask for (all of it, or what is open).
699
+ const listVersions = {
700
+ all: createListVersions(),
701
+ open: createListVersions(),
702
+ };
703
+
697
704
  return function swarmCommand(request, agent, machine = null) {
698
705
  const command = String(request.command);
699
706
  if (command === "board.swarm.list") {
@@ -702,9 +709,9 @@ export function createSwarm({
702
709
  ok: false,
703
710
  error: "only the person and Harness read the swarm",
704
711
  };
705
- const listed = () => ({
706
- ok: true,
707
- threads: [
712
+ const listed = () => {
713
+ // activityVersion only tells this side when a T3 thread moved (focus.decorate has read it); no reader uses it.
714
+ const threads = [
708
715
  ...store
709
716
  .goals({ all: request.all === true })
710
717
  .filter((thread) => !SETUP_CHECK.test(thread.objective))
@@ -712,13 +719,30 @@ export function createSwarm({
712
719
  ...(!request.hostedCaller
713
720
  ? (environments?.roots() ?? []).map(focus.decorate)
714
721
  : []),
715
- ],
716
- sessions: request.sessions === false ? [] : sessions(),
717
- agents: roster(),
718
- joining: request.hostedCaller ? [] : joining(),
719
- // What waits on the person about an agent, outside any thread (threadView.mjs swarmNeeds).
720
- needsYou: request.hostedCaller ? [] : (threadView?.swarmNeeds() ?? []),
721
- });
722
+ ].map(({ activityVersion, ...shown }) => shown);
723
+ // A reader on the person's computers that keeps the list (the buddy) sends the version its copy is at and gets
724
+ // what changed since (listVersions.mjs); one that sends none gets it whole, as before.
725
+ const sent = request.hostedCaller
726
+ ? null
727
+ : listVersions[request.all === true ? "all" : "open"](threads, {
728
+ epoch: request.epoch,
729
+ after: request.after,
730
+ });
731
+ return {
732
+ ok: true,
733
+ threads: sent ? sent.items : threads,
734
+ ...(sent
735
+ ? { gone: sent.gone, whole: sent.whole, listVersion: sent.version }
736
+ : {}),
737
+ sessions: request.sessions === false ? [] : sessions(),
738
+ agents: roster(),
739
+ joining: request.hostedCaller ? [] : joining(),
740
+ // What waits on the person about an agent, outside any thread (threadView.mjs swarmNeeds).
741
+ needsYou: request.hostedCaller
742
+ ? []
743
+ : (threadView?.swarmNeeds() ?? []),
744
+ };
745
+ };
722
746
  // The work in T3 Code beside the board as T3 Code last said it; only the first read waits for it.
723
747
  const loading = request.hostedCaller ? null : environments?.ready();
724
748
  return loading ? { pending: loading.then(listed) } : listed();
@@ -148,8 +148,12 @@ export function createThreadActions({
148
148
  const goal = store.goal(goalId);
149
149
  const { picks } = picksIn(store, post.text, names);
150
150
  // `@codex #pop-os`: the computer named with # is where the agents named work. A # naming no runner sets it for
151
- // whoever takes the thread's work.
152
- const computer = ownMachines()?.computerNamed(post.text) ?? null;
151
+ // whoever takes the thread's work. Only the person and their own agents choose among the person's computers;
152
+ // another person's post (author "maya/codex") never does.
153
+ const ownWords = !String(author ?? "").includes("/");
154
+ const computer = ownWords
155
+ ? (ownMachines()?.computerNamed(post.text) ?? null)
156
+ : null;
153
157
  if (computer && !names.some((agent) => runsHere(agent)))
154
158
  store.meta(`thread-computer:${goalId}`, computer.id);
155
159
  const told = [];
@@ -2,6 +2,7 @@ import fs from "node:fs";
2
2
  import path from "node:path";
3
3
  import { randomUUID } from "node:crypto";
4
4
  import { MEMBERS, nameOf } from "./members.mjs";
5
+ import { computerHandle } from "./ownMachines.mjs";
5
6
  import { oneLine } from "./oneLine.mjs";
6
7
  import { setRunPick } from "./models.mjs";
7
8
  import { t3Access, steerT3Run } from "./t3.mjs";
@@ -328,78 +329,56 @@ export function createThreadRuns({
328
329
  } = {}
329
330
  ) => {
330
331
  const task = store.getTask(goalId);
332
+ if (!task || task.status !== "open" || !RUNNERS.has(agent)) return;
333
+ const noteOnce = (key, text) => {
334
+ if (store.meta(key)) return;
335
+ store.meta(key, "1");
336
+ store.roomPost({ goalId, author: "harness", kind: "note", text });
337
+ notifyBoard(store.getTask(goalId));
338
+ };
331
339
  // The computer named now, else the one last named in this thread for this agent or for everyone: an agent's work
332
340
  // in a thread stays where its checkout is until the person names another.
333
- if (on && computers) {
334
- store.meta(`thread-computer:${goalId}:${agent}`, on);
341
+ if (on) store.meta(`thread-computer:${goalId}:${agent}`, on);
342
+ const earlier =
343
+ store.meta(`thread-computer:${goalId}:${agent}`) ||
344
+ store.meta(`thread-computer:${goalId}`) ||
345
+ null;
346
+ const named = on ?? earlier;
347
+ const self = computers?.self() ?? null;
348
+ // Why the named computer cannot take this turn, or null when it can: { machine, folder } goes in `placed`.
349
+ let placed = null,
350
+ refused = null;
351
+ if (named && named === self && !installedAgents.includes(agent))
352
+ refused = `${nameOf(agent)} is not installed there`;
353
+ else if (named && named !== self) {
354
+ const tried = computers.placeOn(
355
+ agent,
356
+ task.goal?.workspace ?? null,
357
+ named
358
+ );
359
+ if (tried.error) refused = tried.error;
360
+ else placed = tried;
335
361
  }
336
- const named =
337
- on ??
338
- (computers
339
- ? store.meta(`thread-computer:${goalId}:${agent}`) ||
340
- store.meta(`thread-computer:${goalId}`) ||
341
- null
342
- : null);
343
- const here = !named || named === computers?.self();
344
- const placed =
345
- task && !here
346
- ? computers.placeOn(agent, task.goal?.workspace ?? null, named)
347
- : null;
348
- if (placed?.error) {
349
- store.roomPost({
350
- goalId,
351
- author: "harness",
352
- kind: "note",
353
- text: `${nameOf(agent)} cannot work on ${computers.labelOf(named) ?? "that computer"}: ${placed.error}.`,
354
- });
355
- notifyBoard(store.getTask(goalId));
356
- return;
362
+ if (refused) {
363
+ const label = computers.labelOf(named) ?? "that computer";
364
+ // Named for this turn: it waits for the person, said once. Named earlier: it goes where it would have, said once.
365
+ noteOnce(
366
+ `computer-refused:${goalId}:${agent}:${named}:${refused}`,
367
+ on
368
+ ? `${nameOf(agent)} cannot work on ${label}: ${refused}.`
369
+ : `${nameOf(agent)} cannot work on ${label} now (${refused}), so it works where it would have.`
370
+ );
371
+ if (on) return;
357
372
  }
373
+ const chosen = Boolean(named) && !refused;
358
374
  // An agent on another of the person's computers takes its turn there, in that computer's checkout of the thread's
359
375
  // repository (machineRuns.mjs); here it works in the thread's own worktree.
360
376
  const elsewhere =
361
377
  placed ??
362
- (task && !named && !installedAgents.includes(agent)
378
+ (!chosen && !installedAgents.includes(agent)
363
379
  ? placeElsewhere(agent, task.goal?.workspace ?? null)
364
380
  : null);
365
- if (
366
- task &&
367
- named === computers?.self() &&
368
- !installedAgents.includes(agent)
369
- ) {
370
- store.roomPost({
371
- goalId,
372
- author: "harness",
373
- kind: "note",
374
- text: `${nameOf(agent)} is not installed on ${computers.labelOf(named)}.`,
375
- });
376
- notifyBoard(store.getTask(goalId));
377
- return;
378
- }
379
- // The agent is on more than one computer and the person named none: the thread says once which took it, and how
380
- // to name the other.
381
- const choices = computers?.withAgent(agent) ?? [];
382
- if (task && !named && choices.length > 1) {
383
- const key = `computer-note:${goalId}:${agent}`;
384
- if (!store.meta(key)) {
385
- store.meta(key, "1");
386
- const took = computers.labelOf(elsewhere?.machine ?? computers.self());
387
- const others = choices.filter((label) => label !== took);
388
- store.roomPost({
389
- goalId,
390
- author: "harness",
391
- kind: "note",
392
- text: `${nameOf(agent)} on ${took} took this. For ${others.length > 1 ? "another" : "the one on " + others[0]}, write @${agent === "claude-code" ? "claude" : agent} #${others[0]}.`,
393
- });
394
- }
395
- }
396
- if (
397
- !task ||
398
- task.status !== "open" ||
399
- !RUNNERS.has(agent) ||
400
- (!installedAgents.includes(agent) && !elsewhere)
401
- )
402
- return;
381
+ if (!installedAgents.includes(agent) && !elsewhere) return;
403
382
  const goal = task.goal;
404
383
  if (!goal.workspace) {
405
384
  if (!store.meta(`goal-folder-note:${goalId}:${agent}`)) {
@@ -508,6 +487,18 @@ export function createThreadRuns({
508
487
  asker === "user" || writers.at(-1) === asker
509
488
  ? writers
510
489
  : [...writers, asker];
490
+ // The agent is on more than one computer and the person named none: the thread says once which took it, and how
491
+ // to name the other.
492
+ const choices = computers?.withAgent(agent) ?? [];
493
+ if (!chosen && choices.length > 1) {
494
+ const took = computers.labelOf(elsewhere?.machine ?? self);
495
+ const others = choices.filter((label) => label !== took);
496
+ if (took && others.length)
497
+ noteOnce(
498
+ `computer-note:${goalId}:${agent}`,
499
+ `${nameOf(agent)} on ${took} took this. For ${others.length > 1 ? "another" : "the one on " + others[0]}, write @${agent === "claude-code" ? "claude" : agent} #${computerHandle(others[0])}.`
500
+ );
501
+ }
511
502
  const wake = store.postTask({
512
503
  objective: `Room: ${task.objective}`.slice(0, 500),
513
504
  brief,