6c3796d · diagonal · git.iko.soy

git.iko.soy/diagonal

on master help sign in

Keep the helper within its time limit, name new groups without duplicates, finish installs

6c3796dClaude3 weeks ago

.github/workflows/release.yml+4−1

compare with master

unifiedsplit

@@ -9,8 +9,11 @@ on:

9permissions:

10 contents: write

12+# One release at a time, in push order: an older run finishing last must not become the latest release,

13+# which is what the Homebrew cask downloads.

12concurrency:

14concurrency:

13− group: release-${{ github.sha }}

15+ group: release

16+ cancel-in-progress: false

15jobs:

18jobs:

16 release:

19 release:

host/diagonal-host.py+44−25

@@ -255,28 +255,41 @@ PERMISSIVE = ["--guardrails", "permissive-content-transformations"]

255USAGE_EXIT = 64

256

257

258+# Below this much time left in a request, a second fm call (the permissive retry, naming one more new

259+# group) is not started: it would only be cut off.

260+MIN_CALL_S = 5.0

261+

262+

258−def run_fm(prompt, schema, model, timeout_s):

263+def run_fm(prompt, schema, opts):

259− """`prompt` is a prompts.Prompt: its fixed rules go to -i, the tab text on stdin."""

264+ """`prompt` is a prompts.Prompt: its fixed rules go to -i, the tab text on stdin. Every call in one

265+ request shares its deadline, so the extension's guard (its timeout plus 10 s) is a real upper bound."""

260 try:

266 try:

261− return _run_fm(prompt, schema, model, timeout_s, [])

267+ return _run_fm(prompt, schema, opts, [])

262 except Fail as f:

268 except Fail as f:

263− if f.code != "GUARDRAIL":

269+ if f.code != "GUARDRAIL" or time_left(opts) < MIN_CALL_S:

264 raise

270 raise

265− return _run_fm(prompt, schema, model, timeout_s, PERMISSIVE)

271+ return _run_fm(prompt, schema, opts, PERMISSIVE)

272+

273+

274+def time_left(opts):

275+ return opts["deadline"] - time.time()

266

276

267

277

268−def _run_fm(prompt, schema, model, timeout_s, extra):

278+def _run_fm(prompt, schema, opts, extra):

269 # The tab text goes on stdin (fm reads it there when no prompt argument is given), so it never shows up

279 # The tab text goes on stdin (fm reads it there when no prompt argument is given), so it never shows up

270 # in the process list. fm has no timeout of its own; subprocess enforces ours.

280 # in the process list. fm has no timeout of its own; subprocess enforces ours.

271 # --greedy: the same tabs get the same topics and name on every run (measured on macOS 27: five runs,

281 # --greedy: the same tabs get the same topics and name on every run (measured on macOS 27: five runs,

272− # one answer), so groups don't get renamed or reshuffled each time Diagonal looks at them.

282+ # one answer), so groups don't get renamed or reshuffled each time Diagonal looks at them. The strict

283+ # retry after an unusable answer samples instead: greedy would give the same answer again.

284+ greedy = [] if opts.get("strict") else ["--greedy"]

273− args = [FM, "respond", "--model", model, "--no-stream", "--greedy", "--schema", schema, "-i", prompt.instructions, *extra]

285+ args = [FM, "respond", "--model", opts["model"], "--no-stream", *greedy, "--schema", schema, "-i", prompt.instructions, *extra]

286+ timeout_s = max(1.0, time_left(opts))

274 try:

287 try:

275 p = subprocess.run(args, input=prompt.text, capture_output=True, text=True, timeout=timeout_s, env=fm_env())

288 p = subprocess.run(args, input=prompt.text, capture_output=True, text=True, timeout=timeout_s, env=fm_env())

276 except FileNotFoundError:

289 except FileNotFoundError:

277 raise Fail("MODEL_UNAVAILABLE", f"fm not found at {FM} — requires macOS 27")

290 raise Fail("MODEL_UNAVAILABLE", f"fm not found at {FM} — requires macOS 27")

278 except subprocess.TimeoutExpired:

291 except subprocess.TimeoutExpired:

279− raise Fail("TIMEOUT", f"fm exceeded {timeout_s:g}s", retryable=True)

292+ raise Fail("TIMEOUT", f"fm exceeded {opts['timeout_s']:g}s", retryable=True)

280 if p.returncode != 0:

293 if p.returncode != 0:

281 code = classify(p.stderr, p.returncode)

294 code = classify(p.stderr, p.returncode)

282 if code == "LICENSE_REQUIRED":

295 if code == "LICENSE_REQUIRED":

@@ -295,7 +308,7 @@ def organize_mode():

295

308

296def op_ping(_payload, _opts):

309def op_ping(_payload, _opts):

297 if not os.path.exists(FM):

310 if not os.path.exists(FM):

298− return {"hostVersion": HOST_VERSION, "fmPath": FM, "fmAvailable": False,

311+ return {"hostVersion": HOST_VERSION, "fmPath": FM, "fmAvailable": False, "licenseRequired": False,

299 "fmMessage": f"fm not found at {FM} — requires macOS 27", "schemasOk": False, "organizeMode": organize_mode()}

312 "fmMessage": f"fm not found at {FM} — requires macOS 27", "schemasOk": False, "organizeMode": organize_mode()}

300 license_required = False

313 license_required = False

301 try:

314 try:

@@ -367,7 +380,7 @@ def op_name(payload, opts):

367 raise Fail("SCHEMA_MISSING", f"fm could not write {os.path.join(SCHEMAS, 'name.json')}")

380 raise Fail("SCHEMA_MISSING", f"fm could not write {os.path.join(SCHEMAS, 'name.json')}")

368 prompt = fit(lambda cap: prompts.build_name_prompt(payload, strict=opts.get("strict", False), desc_cap=cap), len(payload["items"]))

381 prompt = fit(lambda cap: prompts.build_name_prompt(payload, strict=opts.get("strict", False), desc_cap=cap), len(payload["items"]))

369 try:

382 try:

370− out = run_fm(prompt, schema, opts["model"], opts["timeout_s"])

383+ out = run_fm(prompt, schema, opts)

371 except Fail as f:

384 except Fail as f:

372 raise _fit_overflow(f, len(payload["items"]))

385 raise _fit_overflow(f, len(payload["items"]))

373 try:

386 try:

@@ -383,7 +396,7 @@ def op_organize(payload, opts):

383 raise Fail("SCHEMA_MISSING", f"fm could not write {os.path.join(SCHEMAS, 'topics.json')}")

396 raise Fail("SCHEMA_MISSING", f"fm could not write {os.path.join(SCHEMAS, 'topics.json')}")

384 prompt = fit(lambda cap: prompts.build_topics_prompt(payload, strict=opts.get("strict", False), desc_cap=cap), len(payload["items"]))

397 prompt = fit(lambda cap: prompts.build_topics_prompt(payload, strict=opts.get("strict", False), desc_cap=cap), len(payload["items"]))

385 try:

398 try:

386− out = run_fm(prompt, schema, opts["model"], opts["timeout_s"])

399+ out = run_fm(prompt, schema, opts)

387 except Fail as f:

400 except Fail as f:

388 raise _fit_overflow(f, len(payload["items"]))

401 raise _fit_overflow(f, len(payload["items"]))

389 _, owner = prompts.topic_items(payload)

402 _, owner = prompts.topic_items(payload)

@@ -393,29 +406,31 @@ def op_organize(payload, opts):

393 raise Fail("BAD_MODEL_OUTPUT", str(e), retryable=True, raw=json.dumps(out, ensure_ascii=False)[:2000])

406 raise Fail("BAD_MODEL_OUTPUT", str(e), retryable=True, raw=json.dumps(out, ensure_ascii=False)[:2000])

394 chars = prompts.size(prompt)

407 chars = prompts.size(prompt)

395 if payload.get("nameGroups") is not False: # the extension's fit check only needs the topics

408 if payload.get("nameGroups") is not False: # the extension's fit check only needs the topics

396− chars += name_new_groups(result, payload, opts, time.time() + opts["timeout_s"])

409+ chars += name_new_groups(result, payload, opts)

397 return result, chars, "topics"

410 return result, chars, "topics"

398

411

399

412

400−def name_new_groups(result, payload, opts, deadline):

413+def name_new_groups(result, payload, opts):

401 """Title each new group with the name op (well under a second each on fm), so groups appear named.

414 """Title each new group with the name op (well under a second each on fm), so groups appear named.

415+ A group that fails, runs past the request's deadline, or gets a title another group in the window

402− A group that fails, or runs past the deadline, keeps "" and the extension's naming loop names it."""

416+ already has keeps "" and the extension's naming loop, which checks every sibling, names it."""

403− taken = [g.get("title") for g in payload.get("existingGroups") or [] if g.get("title")]

417+ taken = [t for t in [g.get("title") for g in payload.get("existingGroups") or []] + list(payload.get("siblingTitles") or []) if t]

404 chars = 0

418 chars = 0

405 for g in result["groups"]:

419 for g in result["groups"]:

406 if "existing" in g or g.get("title"):

420 if "existing" in g or g.get("title"):

407 continue

421 continue

408− left = deadline - time.time()

422+ if time_left(opts) < MIN_CALL_S:

409− if left < 5:

410 break

423 break

411 sub = {"items": [dict(payload["items"][i], i=n) for n, i in enumerate(g["members"])], "siblingTitles": taken[:20]}

424 sub = {"items": [dict(payload["items"][i], i=n) for n, i in enumerate(g["members"])], "siblingTitles": taken[:20]}

412 try:

425 try:

413− named, n, _ = op_name(sub, {**opts, "timeout_s": min(opts["timeout_s"], left)})

426+ named, n, _ = op_name(sub, {**opts, "strict": False})

414 except Fail:

427 except Fail:

415 continue

428 continue

429+ chars += n

430+ if any(validate.same_label(named["title"], t) for t in taken):

431+ continue

416 g["title"], g["emoji"] = named["title"], named["emoji"]

432 g["title"], g["emoji"] = named["title"], named["emoji"]

417 taken.append(named["title"])

433 taken.append(named["title"])

418− chars += n

419 return chars

434 return chars

420

435

421

436

@@ -429,8 +444,8 @@ def handle(req):

429 raw_opts = req.get("opts") or {}

444 raw_opts = req.get("opts") or {}

430 timeout_ms = raw_opts.get("timeoutMs", 45000)

445 timeout_ms = raw_opts.get("timeoutMs", 45000)

431 timeout_ms = timeout_ms if isinstance(timeout_ms, (int, float)) and not isinstance(timeout_ms, bool) else 45000

446 timeout_ms = timeout_ms if isinstance(timeout_ms, (int, float)) and not isinstance(timeout_ms, bool) else 45000

432− opts = {"model": "system", "strict": bool(raw_opts.get("strict")),

433− "timeout_s": max(5.0, min(120.0, timeout_ms / 1000))}

447+ timeout_s = max(5.0, min(120.0, timeout_ms / 1000))

448+ opts = {"model": "system", "strict": bool(raw_opts.get("strict")), "timeout_s": timeout_s, "deadline": t0 + timeout_s}

434 op = req["op"]

449 op = req["op"]

435 if op == "ping":

450 if op == "ping":

436 return {"v": 1, "id": rid, "ok": True, "result": op_ping(req["payload"], opts)}

451 return {"v": 1, "id": rid, "ok": True, "result": op_ping(req["payload"], opts)}

@@ -553,14 +568,16 @@ def selftest():

553

568

554 ping = op_ping({}, {})

569 ping = op_ping({}, {})

555 check("fm found", os.path.exists(FM), FM)

570 check("fm found", os.path.exists(FM), FM)

571+ if not os.path.exists(FM):

572+ return 1 # nothing else can work without it

556− if ping["licenseRequired"]:

573+ if ping.get("licenseRequired"):

557 check("fm terms accepted", False, f"run: {LICENSE_FIX}")

574 check("fm terms accepted", False, f"run: {LICENSE_FIX}")

558 else:

575 else:

559 check("model available (fm available --model system)", ping["fmAvailable"], ping["fmMessage"])

576 check("model available (fm available --model system)", ping["fmAvailable"], ping["fmMessage"])

560 for name in SCHEMA_COMMANDS:

577 for name in SCHEMA_COMMANDS:

561 path = os.path.join(SCHEMAS, name)

578 path = os.path.join(SCHEMAS, name)

562 readable = os.path.isfile(path) and os.path.getsize(path) > 0

579 readable = os.path.isfile(path) and os.path.getsize(path) > 0

563− hint = f"written on their own after {LICENSE_FIX}" if ping["licenseRequired"] else "missing: run diagonal-host --install-schemas"

580+ hint = f"written on their own after {LICENSE_FIX}" if ping.get("licenseRequired") else "missing: run diagonal-host --install-schemas"

564 check(f"schema {name}", readable, path if readable else hint)

581 check(f"schema {name}", readable, path if readable else hint)

565 check("allowed origin pinned", "<" not in ALLOWED_ORIGIN, ALLOWED_ORIGIN)

582 check("allowed origin pinned", "<" not in ALLOWED_ORIGIN, ALLOWED_ORIGIN)

566 if ping["fmAvailable"] and schema_path("name.json"):

583 if ping["fmAvailable"] and schema_path("name.json"):

@@ -670,7 +687,9 @@ def register(host_path):

670 f.write("\n".join(written) + "\n")

687 f.write("\n".join(written) + "\n")

671 except OSError:

688 except OSError:

672 pass

689 pass

690+ # One browser that could not be written (a locked folder, a stale profile) does not undo the others:

691+ # the install goes on and the ones that failed were named above.

673− return 1 if failures else 0

692+ return 0 if len(dirs) - failures > 0 else 1

674

693

675

694

676def unregister():

695def unregister():

host/tests/test_host.py+56

@@ -287,6 +287,19 @@ class ErrorCodes(HostCase):

287 self.assertIn("Reply with only the object", argv[argv.index("-i") + 1])

288

289

290+ def test_strict_retry_samples_instead_of_repeating_the_greedy_answer(self):

291+ self.respond(json.dumps({"title": "Rust async", "emoji": "🦀"}))

292+ self.call("name", {"items": ITEMS3}, strict=True)

293+ self.assertNotIn("--greedy", [a for a in self.argv_log() if a[0] == "respond"][0])

294+

295+ def test_permissive_retry_shares_the_request_deadline(self):

296+ # The first call uses up the request's time: no second call runs past what the extension waits for.

297+ self.control({"respond_queue": [{"stderr": "Error: The model's safety guardrails were triggered.\n", "exit": 1, "sleep": 2.5}]})

298+ r = self.call("name", {"items": ITEMS3}, timeoutMs=5000)

299+ self.assertEqual(r["error"]["code"], "GUARDRAIL")

300+ self.assertEqual(len([a for a in self.argv_log() if a[0] == "respond"]), 1)

301+

302+

290class Organize(HostCase):

303class Organize(HostCase):

291 ITEMS = ITEMS3 + [

304 ITEMS = ITEMS3 + [

292 {"title": "Hotels in Lisbon", "url": "https://booking.com/lisbon"},

305 {"title": "Hotels in Lisbon", "url": "https://booking.com/lisbon"},

@@ -331,6 +344,33 @@ class Organize(HostCase):

331 self.assertIn("Tokio", name_calls[0])

344 self.assertIn("Tokio", name_calls[0])

332 self.assertIn('"Lisbon trip"', name_calls[0]) # existing titles are off limits

345 self.assertIn('"Lisbon trip"', name_calls[0]) # existing titles are off limits

333

346

347+ def test_a_new_group_named_like_another_group_is_left_to_the_naming_loop(self):

348+ self.control({"respond_queue": [

349+ {"stdout": json.dumps({"tabs": [{"index": i, "topic": "Programming"} for i in (0, 1, 2)]})},

350+ {"stdout": json.dumps({"title": "Rust async", "emoji": "🦀"})},

351+ ]})

352+ r = self.call("organize", {"items": self.ITEMS, "siblingTitles": ["rust async"]})

353+ self.assertEqual(r["result"]["groups"][0]["title"], "")

354+ self.assertIn('"rust async"', self.stdin_log()[1]) # the name call was told, too

355+

356+ def test_a_topic_two_groups_share_equally_joins_neither_unless_the_words_say_which(self):

357+ existing = [{"g": 0, "title": "Lisbon trip", "samples": ["Flights to Lisbon"]},

358+ {"g": 1, "title": "Porto trip", "samples": ["Porto restaurants"]}]

359+ # Examples 8 (group 0) and 9 (group 1) both got Travel: a tie.

360+ self.topics([(3, "Travel"), (4, "Travel"), (8, "Travel"), (9, "Travel")])

361+ r = self.call("organize", {"items": self.ITEMS, "existingGroups": existing})

362+ self.assertEqual([g.get("existing") for g in r["result"]["groups"]], [0]) # "Lisbon" is in both tabs' titles

363+ items = [{"title": "Beach day", "url": "https://a.example/"}, {"title": "City walk", "url": "https://b.example/"}]

364+ self.topics([(0, "Travel"), (1, "Travel"), (2, "Travel"), (3, "Travel")])

365+ r = self.call("organize", {"items": items, "existingGroups": existing})

366+ self.assertNotIn("existing", r["result"]["groups"][0])

367+

368+ def test_only_vague_topics_leave_every_tab_loose(self):

369+ self.topics([(0, "Other"), (1, "Misc"), (2, "General")])

370+ r = self.call("organize", {"items": ITEMS3})

371+ self.assertTrue(r["ok"], r)

372+ self.assertEqual(r["result"], {"groups": [], "leftovers": [0, 1, 2]})

373+

334 def test_two_topics_joining_one_group_make_one_join(self):

374 def test_two_topics_joining_one_group_make_one_join(self):

335 # The group's two example tabs (8 and 9) got different topics; both topics still join group 0 once.

375 # The group's two example tabs (8 and 9) got different topics; both topics still join group 0 once.

336 self.topics([(3, "Travel"), (4, "Hotels"), (8, "Travel"), (9, "Hotels"), (0, "Programming")])

376 self.topics([(3, "Travel"), (4, "Hotels"), (8, "Travel"), (9, "Hotels"), (0, "Programming")])

@@ -487,6 +527,15 @@ class Register(HostCase):

487 self.assertEqual(p.returncode, 1)

527 self.assertEqual(p.returncode, 1)

488 self.assertIn("missing or not executable", p.stderr)

528 self.assertIn("missing or not executable", p.stderr)

489

529

530+ def test_one_browser_that_cannot_be_written_does_not_fail_the_rest(self):

531+ chrome = self.make_profile("Google/Chrome")

532+ brave = self.make_profile("BraveSoftware/Brave-Browser")

533+ open(os.path.join(brave, "NativeMessagingHosts"), "w").close() # a file where the folder should be

534+ p = self.run_copy("--register", self.host_copy)

535+ self.assertEqual(p.returncode, 0, p.stderr)

536+ self.assertIn("BraveSoftware/Brave-Browser: could not write", p.stderr)

537+ self.assertTrue(os.path.exists(os.path.join(chrome, "NativeMessagingHosts", "io.diagonal.host.json")))

538+

490 def test_no_browser_found(self):

539 def test_no_browser_found(self):

491 os.makedirs(self.env["DIAGONAL_APP_SUPPORT"])

540 os.makedirs(self.env["DIAGONAL_APP_SUPPORT"])

492 p = self.run_copy("--register", self.host_copy)

541 p = self.run_copy("--register", self.host_copy)

@@ -508,6 +557,13 @@ class SelfTest(HostCase):

508 self.assertEqual(code, 1)

557 self.assertEqual(code, 1)

509 self.assertIn("FAIL model available", p.stdout.decode())

558 self.assertIn("FAIL model available", p.stdout.decode())

510

559

560+ def test_selftest_without_fm_says_so_and_stops(self):

561+ self.env["DIAGONAL_FM"] = os.path.join(self.tmp, "no-such-fm")

562+ code, _, p = self.run_host(args=["--selftest"])

563+ self.assertEqual(code, 1)

564+ self.assertIn("FAIL fm found", p.stdout.decode())

565+ self.assertNotIn("Traceback", p.stderr.decode())

566+

511 def test_selftest_names_the_license_fix(self):

567 def test_selftest_names_the_license_fix(self):

512 self.control({"license": True})

568 self.control({"license": True})

513 code, _, p = self.run_host(args=["--selftest"])

569 code, _, p = self.run_host(args=["--selftest"])

host/validate.py+44−4

@@ -160,6 +160,10 @@ def is_valid_label(label):

160 )

161

162

163+def same_label(a, b):

164+ return bool(a) and bool(b) and " ".join(a.split()).casefold() == " ".join(b.split()).casefold()

165+

166+

163def validate_name(out, payload):

167def validate_name(out, payload):

164 if not isinstance(out, dict):

168 if not isinstance(out, dict):

165 raise ValidationError("reply is not an object")

169 raise ValidationError("reply is not an object")

@@ -265,16 +269,52 @@ def organize_from_topics(out, payload, owner):

265 votes = group_votes.setdefault(topic, {})

269 votes = group_votes.setdefault(topic, {})

266 votes[owner[i]] = votes.get(owner[i], 0) + 1

270 votes[owner[i]] = votes.get(owner[i], 0) + 1

267 if not tab_topic:

271 if not tab_topic:

272+ if not any(isinstance(t, dict) and _in_range(t.get("index"), n_items) for t in out["tabs"]):

268− raise ValidationError("no tab got a topic")

273+ raise ValidationError("no tab got a topic")

274+ # Every tab got only a vague topic ("Other", "Misc"): the model found nothing in common.

275+ return validate_organize({"groups": [], "leftovers": []}, payload)

269 clusters = {}

276 clusters = {}

270 for i in sorted(tab_topic):

277 for i in sorted(tab_topic):

271 clusters.setdefault(tab_topic[i], []).append(i)

278 clusters.setdefault(tab_topic[i], []).append(i)

272 groups = []

279 groups = []

273 for topic, members in clusters.items():

280 for topic, members in clusters.items():

274− votes = group_votes.get(topic)

281+ g = _winner(group_votes.get(topic) or {}, members, payload)

275− if votes:

282+ if g is not None:

276− g = max(sorted(votes), key=lambda k: votes[k])

277 groups.append({"existing": g, "members": members})

283 groups.append({"existing": g, "members": members})

278 else:

284 else:

279 groups.append({"title": "", "emoji": "", "color": "", "members": members})

285 groups.append({"title": "", "emoji": "", "color": "", "members": members})

280 return validate_organize({"groups": groups, "leftovers": []}, payload)

286 return validate_organize({"groups": groups, "leftovers": []}, payload)

287+

288+

289+def _in_range(i, n):

290+ return isinstance(i, int) and not isinstance(i, bool) and 0 <= i < n

291+

292+

293+_WORD = re.compile(r"\w{3,}")

294+

295+

296+def _words(text):

297+ return {w.casefold() for w in _WORD.findall(text or "")}

298+

299+

300+def _winner(votes, members, payload):

301+ """The existing group a topic's tabs join: the one whose example tabs share it most. When two groups tie,

302+ the one whose title and examples share more words with these tabs; when that ties too, none (the tabs

303+ form a group of their own, or stay loose), rather than whichever group happens to be listed first."""

304+ if not votes:

305+ return None

306+ top = max(votes.values())

307+ tied = sorted(k for k, v in votes.items() if v == top)

308+ if len(tied) == 1:

309+ return tied[0]

310+ tab_words = set().union(*(_words(payload["items"][i].get("title")) for i in members))

311+ groups = {g["g"]: g for g in payload.get("existingGroups") or []}

312+

313+ def overlap(k):

314+ g = groups.get(k) or {}

315+ return len(tab_words & _words(" ".join([g.get("title") or "", *(g.get("samples") or [])])))

316+

317+ scores = {k: overlap(k) for k in tied}

318+ best = max(scores.values())

319+ leaders = [k for k in tied if scores[k] == best]

320+ return leaders[0] if len(leaders) == 1 and best > 0 else None

scripts/install-manifest.sh+11−2

@@ -53,7 +53,16 @@ echo "host: $BIN -> $SHARE/diagonal-host.py"

53"$BIN" --version >/dev/null # the host must start with the python3 it was pinned to

54# Writes the manifest into every Chromium browser's NativeMessagingHosts folder (Chrome, Brave and

55# Brave Origin, Edge, Vivaldi, Arc, Opera, …) and checks each one the way the browser reads it.

56+# A browser that was never opened has no folder yet: the rest of the install still runs, and the end

57+# says how to finish.

58+register_rc=0

56−"$BIN" --register "$BIN"

59+"$BIN" --register "$BIN" || register_rc=$?

60+register_note() {

61+ if [[ $register_rc -ne 0 ]]; then

62+ echo "No browser could be set up for Diagonal yet. Open your browser once, then run: bash '$HERE/$(basename "$0")'"

63+ fi

64+}

65+trap register_note EXIT

58FM="${DIAGONAL_FM:-/usr/bin/fm}"

67FM="${DIAGONAL_FM:-/usr/bin/fm}"

@@ -89,7 +98,7 @@ fi

89# Diagonal also writes these on first use; doing it now lets the self-test below cover the model.

98# Diagonal also writes these on first use; doing it now lets the self-test below cover the model.

90schemas_out=$("$BIN" --install-schemas 2>&1) || true

99schemas_out=$("$BIN" --install-schemas 2>&1) || true

91if selftest_out=$("$BIN" --selftest 2>&1); then

100if selftest_out=$("$BIN" --selftest 2>&1); then

92− echo "Diagonal's host is ready."

101+ [[ $register_rc -ne 0 ]] || echo "Diagonal's host is ready."

93else

102else

94 echo "Diagonal's host is installed, but its self-test found a problem:"

103 echo "Diagonal's host is installed, but its self-test found a problem:"

95 echo "$schemas_out"

104 echo "$schemas_out"

src/background/naming.ts+13

@@ -312,6 +312,7 @@ export class Naming {

312 }

313 if (e.code === "BAD_MODEL_OUTPUT" && !retried.output) {

314 retried.output = true;

315+ mustDifferFrom = withRejected(mustDifferFrom, e.raw);

315 continue;

316 continue;

316 }

317 }

317 this.fail(g, e, hash);

318 this.fail(g, e, hash);

@@ -323,6 +324,7 @@ export class Naming {

323 const e: HostError = { code: "BAD_MODEL_OUTPUT", message: "label failed worker validation", raw: JSON.stringify(reply.result).slice(0, 500), at: this.d.now() };

324 const e: HostError = { code: "BAD_MODEL_OUTPUT", message: "label failed worker validation", raw: JSON.stringify(reply.result).slice(0, 500), at: this.d.now() };

324 if (!retried.output) {

325 if (!retried.output) {

325 retried.output = true;

326 retried.output = true;

327+ mustDifferFrom = withRejected(mustDifferFrom, e.raw);

326 continue;

328 continue;

327 }

329 }

328 this.fail(g, e, hash);

330 this.fail(g, e, hash);

@@ -412,6 +414,17 @@ export class Naming {

412 }

414 }

413}

415}

414

416

417+/** The retry after an unusable title lists that title as not allowed, so the model doesn't give it again. */

418+function withRejected(list: string[] | undefined, raw: string | undefined): string[] | undefined {

419+ let title: unknown;

420+ try {

421+ title = raw ? JSON.parse(raw)?.title : undefined;

422+ } catch {

423+ return list;

424+ }

425+ return typeof title === "string" && title.trim() ? [...(list ?? []), title.trim().slice(0, 60)] : list;

426+}

427+

415/** The retry bookkeeping of earlier failures, which no longer applies. */

428/** The retry bookkeeping of earlier failures, which no longer applies. */

416function clearFailures(g: GroupRecord): void {

429function clearFailures(g: GroupRecord): void {

417 g.nameAttempts = 0;

430 g.nameAttempts = 0;

src/background/organize.ts+10−2

@@ -27,6 +27,8 @@ export interface ExistingGroup {

27export interface OrganizePayload {

28 items: NameItem[];

29 existingGroups: ExistingGroup[];

30+ /** Every group label in the window: a new group the host names must not repeat one. */

31+ siblingTitles?: string[];

30 allowNew: boolean;

32 allowNew: boolean;

31 maxGroups: number;

33 maxGroups: number;

32 minGroupSize: number;

34 minGroupSize: number;

@@ -177,11 +179,17 @@ const CONTENT_ERRORS = new Set<HostErrorCode>(["OVER_BUDGET", "GUARDRAIL", "BAD_

177const MAX_TIMEOUT_SPLITS = 1;

179const MAX_TIMEOUT_SPLITS = 1;

178

180

179/** One organize call, with the retries that can rescue the same tabs: strict output, then no page text. */

181/** One organize call, with the retries that can rescue the same tabs: strict output, then no page text. */

180−async function askOrganize(rt: Runtime, part: Member[], existingGroups: ExistingGroup[], withDescriptions: boolean): Promise<HostReply<OrganizeResult>> {

182+async function askOrganize(rt: Runtime, part: Member[], windowId: number, existingGroups: ExistingGroup[], withDescriptions: boolean): Promise<HostReply<OrganizeResult>> {

181 const settings = rt.settings();

183 const settings = rt.settings();

184+ const s = rt.state();

182 const payload: OrganizePayload = {

185 const payload: OrganizePayload = {

183 items: toItems(part, settings, withDescriptions),

186 items: toItems(part, settings, withDescriptions),

184 existingGroups,

187 existingGroups,

188+ siblingTitles: Object.values(s.groups)

189+ .filter((g) => g.windowId === windowId && g.origin !== "tidy")

190+ .map((g) => labelOf(g.stripTitle || g.title))

191+ .filter(Boolean)

192+ .slice(0, 20),

185 allowNew: part.length >= 2,

193 allowNew: part.length >= 2,

186 maxGroups: maxGroupsFor(part.length),

194 maxGroups: maxGroupsFor(part.length),

187 minGroupSize: settings.organizeMinGroupSize,

195 minGroupSize: settings.organizeMinGroupSize,

@@ -224,7 +232,7 @@ export async function sortPart(rt: Runtime, part: Member[], run: SortRun, probe

224 run.left += part.length;

232 run.left += part.length;

225 return; // one tab and nothing to join: no call can place it (a probe still learns whether the model takes it)

233 return; // one tab and nothing to join: no call can place it (a probe still learns whether the model takes it)

226 }

234 }

227− const reply = await askOrganize(rt, part, existingGroups, true);

235+ const reply = await askOrganize(rt, part, run.windowId, existingGroups, true);

228 if (!reply.ok) {

236 if (!reply.ok) {

229 const e = reply.error;

237 const e = reply.error;

230 const timedOut = e.code === "TIMEOUT" && part.length > 4 && run.timeoutSplits < MAX_TIMEOUT_SPLITS;

238 const timedOut = e.code === "TIMEOUT" && part.length > 4 && run.timeoutSplits < MAX_TIMEOUT_SPLITS;

test/auto.test.ts+1

@@ -94,6 +94,7 @@ describe("auto-organize", () => {

94 await auto.run(1);

95 expect(calls[0].items.map((i) => i.title)).toEqual(["Tab 3", "Tab 2"]);

96 expect(calls[0].existingGroups).toEqual([expect.objectContaining({ g: 0, title: "Rust" })]);

97+ expect(calls[0].siblingTitles).toEqual(["Rust"]);

97 expect(live.find((t) => t.id === 3)!.groupId).toBe(50);

98 expect(live.find((t) => t.id === 3)!.groupId).toBe(50);

98 });

99 });

100

test/naming.test.ts+8

@@ -299,6 +299,14 @@ describe("naming queue", () => {

299 expect(writes).toEqual([[7, "🦀 Rust crates"]]);

300 });

301

302+ it("the retry after a title the host rejected lists that title as not allowed", async () => {

303+ replies.push({ ok: false, error: { code: "BAD_MODEL_OUTPUT", message: "rules", raw: JSON.stringify({ title: "Python", emoji: "🐍" }) } });

304+ naming.touch(7);

305+ await settle();

306+ expect(calls).toHaveLength(2);

307+ expect(calls[1].mustDifferFrom).toEqual(["Python"]);

308+ });

309+

302 it("a group renamed by hand while the model runs keeps the user's title", async () => {

310 it("a group renamed by hand while the model runs keeps the user's title", async () => {

303 const n = new Naming({

311 const n = new Naming({

304 ...(naming as any).d,

312 ...(naming as any).d,