agentbox-app 0.1.13 → 0.1.16

package/main/picture-shape.mjs

@@ -0,0 +1,114 @@
+// A PICTURE'S WIDTH AND HEIGHT, OFF THE FIRST BYTES OF ITS FILE.
+//
+// The phone draws a picture it has never seen as a 4:3 box until the last byte
+// arrives, because WebKit gives a picture no size before it is whole, and then
+// the words under it jump by the difference: 514px for a phone screenshot at
+// 390px wide (tests/a-picture-the-phone-has-never-seen-gets-its-shape-before-it-arrives).
+// The phone asks for this first (main/serve.mjs, /f/<key>/shape/) and draws
+// the box at the picture's own shape.
+//
+// PNG, GIF, JPEG and WebP, which is what agents and phones make. Anything else,
+// or a file cut short, is null: the box stays 4:3, which is no worse than it
+// was, rather than a guessed shape that is wrong.
+import fs from 'node:fs';
+
+/** How much of a file is read. A JPEG's frame sits after its Exif and colour profile. */
+const HEAD_BYTES = 256 * 1024;
+
+const shape = (w, h) => (w > 0 && h > 0 ? { w, h } : null);
+
+function png(b) {
+  if (b.length < 24 || b.readUInt32BE(0) !== 0x89504e47 || b.toString('latin1', 12, 16) !== 'IHDR') return null;
+  return shape(b.readUInt32BE(16), b.readUInt32BE(20));
+}
+
+function gif(b) {
+  if (b.length < 10 || b.toString('latin1', 0, 4) !== 'GIF8') return null;
+  return shape(b.readUInt16LE(6), b.readUInt16LE(8));
+}
+
+function webp(b) {
+  if (b.length < 30 || b.toString('latin1', 0, 4) !== 'RIFF' || b.toString('latin1', 8, 12) !== 'WEBP') return null;
+  const chunk = b.toString('latin1', 12, 16);
+  if (chunk === 'VP8X') return shape(1 + b.readUIntLE(24, 3), 1 + b.readUIntLE(27, 3));
+  if (chunk === 'VP8 ') return shape(b.readUInt16LE(26) & 0x3fff, b.readUInt16LE(28) & 0x3fff);
+  if (chunk === 'VP8L') {
+    const bits = b.readUInt32LE(21);
+    return shape(1 + (bits & 0x3fff), 1 + ((bits >>> 14) & 0x3fff));
+  }
+  return null;
+}
+
+/** The Exif orientation in an APP1 block, or 0. 5 to 8 mean it is drawn turned a quarter. */
+function orientation(b, start, end) {
+  if (b.toString('latin1', start, start + 6) !== 'Exif\0\0') return 0;
+  const tiff = start + 6;
+  if (tiff + 8 > end) return 0;
+  const little = b.toString('latin1', tiff, tiff + 2) === 'II';
+  const u16 = (at) => (little ? b.readUInt16LE(at) : b.readUInt16BE(at));
+  const u32 = (at) => (little ? b.readUInt32LE(at) : b.readUInt32BE(at));
+  const ifd = tiff + u32(tiff + 4);
+  if (ifd + 2 > end) return 0;
+  const count = u16(ifd);
+  for (let i = 0; i < count; i++) {
+    const entry = ifd + 2 + i * 12;
+    if (entry + 12 > end) return 0;
+    if (u16(entry) === 0x0112) return u16(entry + 8);
+  }
+  return 0;
+}
+
+function jpeg(b) {
+  if (b.length < 4 || b[0] !== 0xff || b[1] !== 0xd8) return null;
+  let turned = 0;
+  let i = 2;
+  while (i + 4 <= b.length) {
+    if (b[i] !== 0xff) return null;
+    const marker = b[i + 1];
+    // Fill bytes before a marker.
+    if (marker === 0xff) { i += 1; continue; }
+    const length = b.readUInt16BE(i + 2);
+    // Every start-of-frame but the three that are not frames (DHT, JPG, DAC).
+    if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+      if (i + 9 > b.length) return null;
+      const h = b.readUInt16BE(i + 5);
+      const w = b.readUInt16BE(i + 7);
+      return turned >= 5 && turned <= 8 ? shape(h, w) : shape(w, h);
+    }
+    if (marker === 0xe1 && !turned) turned = orientation(b, i + 4, Math.min(b.length, i + 2 + length));
+    i += 2 + length;
+  }
+  return null;
+}
+
+/** `{ w, h }` as the browser will draw it, or null. */
+export function pictureShape(bytes) {
+  if (!bytes?.length) return null;
+  try {
+    return png(bytes) ?? gif(bytes) ?? webp(bytes) ?? jpeg(bytes);
+  } catch {
+    return null;
+  }
+}
+
+/** The same, read off a file on disk without waiting, for a pass that lists many. */
+export function readPictureShapeSync(file) {
+  const fd = fs.openSync(file, 'r');
+  try {
+    const buffer = Buffer.alloc(HEAD_BYTES);
+    return pictureShape(buffer.subarray(0, fs.readSync(fd, buffer, 0, HEAD_BYTES, 0)));
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+/** The same, read off a file on disk. */
+export async function readPictureShape(file) {
+  const handle = await fs.promises.open(file, 'r');
+  try {
+    const { buffer, bytesRead } = await handle.read({ buffer: Buffer.alloc(HEAD_BYTES), position: 0 });
+    return pictureShape(buffer.subarray(0, bytesRead));
+  } finally {
+    await handle.close();
+  }
+}

package/main/quit-sequence.mjs

@@ -0,0 +1,143 @@
+// THE WAY OUT, AND NOTHING ON IT MAY KILL THE APP (w-60c8ddbab6, 2026-10-15).
+//
+// Quitting used to be six bare `app.on('before-quit', ...)` listeners and one
+// `will-quit` that started the analytics flush and did not wait for it. Both
+// halves of that cost us the end of every session.
+//
+// ONE STEP THAT THROWS ENDED THE WHOLE QUIT. On 0.1.13 the phone step did:
+// closing the main window nulls `window`, and `phone.close()` makes the relay
+// report the change back to a handler that asked the window whether it was
+// destroyed (main/main.mjs, the `zero:phone-changed` line). An EventEmitter
+// stops calling listeners at the first one that throws, `main/crash-report.mjs`
+// rethrows an uncaught main error on purpose, and the process then dies
+// fatally. Measured on an Electron harness: `updater.stop()` never ran,
+// `will-quit` never fired, `analytics.flush()` never ran, and `quit` never
+// came. The window's own guard is fixed where it lives, but the shape was the
+// real fault: a quit built so that any one step can swallow the rest is a quit
+// that will do this again for some other reason.
+//
+// AND THE FLUSH WAS FIRE AND FORGET. `will-quit` without `preventDefault` means
+// the process goes as soon as the listeners return, so a batch handed to
+// `posthog-node` a moment earlier is a POST that never leaves. Measured the
+// same way: the flush resolved AFTER `process.on('exit')` had already run, and
+// it only resolved at all because the harness's destination was in the same
+// process. Against us.i.posthog.com it is a race the app loses.
+//
+// WHICH MATTERS BECAUSE THE END OF A SESSION IS WHAT WE READ RETENTION FROM.
+// Of the fourteen installs that arrived on 0.1.13 or 0.1.14, thirteen opened
+// the app once and never opened it again (PostHog, 2026-10-15), so for thirteen
+// of fourteen people the batch dropped here is the LAST thing we would ever
+// have heard, and the crash report explaining it is still sitting on their disk
+// waiting for a launch that is not coming.
+
+/** How long the quit is held open for the last batch of counts, and no longer. */
+export const FLUSH_DEADLINE_MS = 2000;
+
+/**
+ * How long a quit we asked for is given before the process is ended outright.
+ *  Longer than the flush above on purpose: a quit holding itself open for the
+ *  last counts is a quit that is working. */
+export const EXIT_DEADLINE_MS = 8000;
+
+/**
+ * How long the second ask gets, once the counts are out and there is nothing
+ *  left to wait for. On Linux a quit asked for with a window still open — the
+ *  menu's Quit, the tray's Quit — ignores it outright
+ *  (tests/a-quit-held-for-the-last-counts-still-ends-the-app), and by then the
+ *  window is gone and there is nothing left to show anybody. */
+export const SECOND_QUIT_DEADLINE_MS = 2000;
+
+/**
+ * A STEP ON THE WAY OUT, which runs once and cannot throw.
+ *
+ *  `name` is in the warning rather than in a comment, because the one thing
+ *  somebody reading a log needs to know is which step gave up. A swallow with
+ *  nothing said is how this bug lived through three releases.
+ *
+ *  ONCE, not once per `app.quit()`. Holding the quit for the flush below means
+ *  calling `app.quit()` a second time, which emits `before-quit` again, and a
+ *  `killAll` or a `close` run twice is at best wasted and at worst a second
+ *  teardown of something already gone.
+ */
+export function quitStep(app, event, name, fn, { log = console } = {}) {
+  let ran = false;
+  app.on(event, () => {
+    if (ran) return;
+    ran = true;
+    try {
+      fn();
+    } catch (err) {
+      // Never rethrown: the app is on its way out and every step after this one
+      // still has to happen.
+      log?.warn?.(`zero: ${name} failed while quitting: ${err?.message ?? err}`);
+    }
+  });
+}
+
+/**
+ * HOLD THE QUIT OPEN FOR THE LAST BATCH OF COUNTS.
+ *
+ *  Three things it will not do, each of them a way a quit becomes a hang:
+ *
+ *   - It will not wait past `FLUSH_DEADLINE_MS`. A machine with no network, or
+ *     a destination that accepts the connection and never answers, must cost
+ *     somebody two seconds on the way out and not their afternoon.
+ *   - It will not care whether the flush worked. There is nothing to be done
+ *     about a flush that failed, and a count is never worth a quit.
+ *   - It will not hold twice. `will-quit` comes round again when we ask again,
+ *     and holding that one too is a quit that never happens.
+ *   - It will not trust the second ask either. On Linux, a quit that began with
+ *     a window open ignores it and the process stays for ever, which is what
+ *     `quitThenExit` is for
+ *     (tests/a-quit-held-for-the-last-counts-still-ends-the-app).
+ */
+export function flushBeforeQuit(app, flush, { deadlineMs = FLUSH_DEADLINE_MS, log = console } = {}) {
+  let held = false;
+  app.on('will-quit', (event) => {
+    if (held) return;          // the second time round is the one we asked for
+    held = true;
+    event?.preventDefault?.();
+    let gone = false;
+    const go = () => {
+      if (gone) return;
+      gone = true;
+      clearTimeout(timer);
+      quitThenExit(app, { what: 'the last counts', deadlineMs: SECOND_QUIT_DEADLINE_MS, log });
+    };
+    const timer = setTimeout(go, deadlineMs);
+    // The deadline is armed before the flush is even called, so a `flush` that
+    // throws synchronously is covered by the same promise as one that rejects.
+    Promise.resolve()
+      .then(() => flush())
+      .catch((err) => { log?.warn?.(`zero: the last counts did not get out: ${err?.message ?? err}`); })
+      .then(go, go);
+  });
+}
+
+/**
+ * ASK TO QUIT, AND GO ANYWAY IF THE QUIT DOES NOT COME.
+ *
+ *  `app.quit()` only asks, and on Linux an app that has already refused one
+ *  `will-quit` ignores every ask after it: the measurement is in
+ *  tests/a-quit-held-for-the-last-counts-still-ends-the-app. It is still asked,
+ *  because that is what runs the quit steps, lets the workers go and fires
+ *  `quit` for whoever is listening, and the deadline ends the process when the
+ *  quit has not.
+ *
+ *  Both callers pass a deadline that suits what they are waiting for: a
+ *  screenshot run has a whole quit ahead of it, the flush above has nothing
+ *  left but the `quit` event. The timer is unreffed: an app with nothing left
+ *  to do must not be kept alive by the thing watching it. */
+export function quitThenExit(app, { what = 'this run', deadlineMs = EXIT_DEADLINE_MS, log = console } = {}) {
+  let over = false;
+  const timer = setTimeout(() => {
+    if (over) return;
+    over = true;
+    log?.warn?.(`zero: ${what} asked the app to quit ${deadlineMs} ms ago and it is still here, so it is ending now`);
+    app.exit(0);
+  }, deadlineMs);
+  timer.unref?.();
+  app.once?.('quit', () => { over = true; clearTimeout(timer); });
+  app.quit();
+  return timer;
+}

package/main/refresh-agent-models.mjs

@@ -4,11 +4,24 @@ import {rememberCodexModels} from './codex-models.mjs';
 import {forget,claudeModels} from './claude-models.mjs';
 import {terminalEnv} from './task-terminals.mjs';
 import {codexLaunchEnv} from './codex-launch-env.mjs';
-export async function refreshAgentModels(engine,config,home){
+import {ensureCodexHome} from './codex-account.mjs';
+// `homes` is every Codex login to ask, one after another. A login that cannot
+// answer keeps its last list and does not cost the others theirs; only all of
+// them failing is an error.
+export async function refreshAgentModels(engine,config,homes,{open=home=>openAppServer(config,home)}={}){
  if(engine==='claude'){forget();claudeModels({bin:config.claudeBin});return;}
  // Codex is optional and codexBin is null without it: nothing to ask, and spawn(null) only threw into the terminal.
  if(!config.codexBin)return;
- const client=createCodexAppServer({spawn:()=>spawn(config.codexBin,['app-server'],{cwd:config.home,env:codexLaunchEnv(config.codexBin,{...terminalEnv(),CODEX_HOME:home}),stdio:['pipe','pipe','pipe']}),requestTimeoutMs:10000});
+ const list=[...new Set([homes].flat().filter(Boolean))];const errors=[];
+ for(const home of list){try{await refreshOne(open(home),home);}catch(error){errors.push(error);}}
+ if(list.length&&errors.length===list.length)throw errors[0];
+}
+function openAppServer(config,home){
+ // codex-cli refuses a CODEX_HOME that does not exist rather than making it.
+ ensureCodexHome(home);
+ return createCodexAppServer({spawn:()=>spawn(config.codexBin,['app-server'],{cwd:config.home,env:codexLaunchEnv(config.codexBin,{...terminalEnv(),CODEX_HOME:home}),stdio:['pipe','pipe','pipe']}),requestTimeoutMs:10000});
+}
+async function refreshOne(client,home){
  const deadline=setTimeout(()=>client.close('Model refresh timed out'),15000);
  try{
   await client.initialize();let cursor=null;const models=[];const seen=new Set();

package/main/relay-client.mjs

@@ -26,6 +26,19 @@ const PASS = ['accept', 'content-type', 'range', 'user-agent', 'if-none-match',
  * 30 s the room gives a Mac to start answering (relay/room.mjs).
  */
 const WAIT_MS = 10_000;
+/**
+ * THE LINK IS CHECKED, NOT TRUSTED (tests/the-computer-notices-a-dead-relay-link-and-reconnects).
+ * A socket that carries nothing cannot tell this end it has died: a laptop that
+ * slept or changed networks kept one it believed open while the relay had let
+ * it go, and phones were told the computer was not connected. So this end says
+ * "ping" this often and the relay answers "pong" without waking the room.
+ */
+export const PING_MS = 25_000;
+/** How long past a ping's turn a missing pong is allowed before the link is called dead. */
+export const PONG_GRACE_MS = 10_000;
+/** What the platform sends as text on the socket. Never a request: those are bytes. */
+const PING = 'ping';
+const PONG = 'pong';
 /** What the phone does not want back: the relay's stream is its own framing. */
 const DROP = new Set(['connection', 'keep-alive', 'transfer-encoding', 'content-length', 'content-encoding']);
 
@@ -34,9 +47,14 @@ const hex = (bytes) => Array.from(bytes, (b) => b.toString(16).padStart(2, '0'))
 
 export function createRelayClient({
   relayUrl, key, port, WebSocketImpl = globalThis.WebSocket, fetchImpl = (...a) => globalThis.fetch(...a),
-  log = console, onChange = () => {}, waitMs = WAIT_MS,
+  log = console, onChange = () => {}, waitMs = WAIT_MS, pingMs = PING_MS, graceMs = PONG_GRACE_MS,
 }) {
   let ws = null;
+  let pinger = null;
+  /** When the relay last answered a ping on this link; null until it ever has. */
+  let ponged = null;
+  /** When the ping timer last ran, to tell a sleep from a slow tick. */
+  let ticked = 0;
   let want = false;
   let connected = false;
   let error = null;
@@ -147,6 +165,10 @@ export function createRelayClient({
   }
 
   async function onMessage(sock, data) {
+    if (typeof data === 'string') {
+      if (data === PONG) ponged = Date.now();
+      return;
+    }
     const bytes = data instanceof ArrayBuffer ? new Uint8Array(data)
       : data instanceof Uint8Array ? data
         : new Uint8Array(await data.arrayBuffer());
@@ -178,6 +200,49 @@ export function createRelayClient({
     }
   }
 
+  // Two ways a link is known dead without waiting on the operating system: a
+  // relay that has answered pings stops answering, or this timer ran far too
+  // late, which is a laptop waking from sleep with every socket gone under it.
+  // A relay that never answers (one deployed before pings) is only ever judged
+  // by the second, so an old relay is not mistaken for a dead link.
+  function startPinging(sock) {
+    stopPinging();
+    ponged = null;
+    ticked = Date.now();
+    pinger = setInterval(() => {
+      const now = Date.now();
+      const slept = now - ticked > pingMs * 2;
+      ticked = now;
+      const silent = ponged !== null && now - ponged > pingMs + graceMs;
+      if (slept || silent) {
+        log.info?.(`[relay] the link went quiet (${slept ? 'woke from sleep' : 'no answer to ping'}); reconnecting`);
+        replace(sock);
+        return;
+      }
+      send(sock, PING);
+    }, pingMs);
+  }
+
+  function stopPinging() {
+    if (pinger) clearInterval(pinger);
+    pinger = null;
+  }
+
+  /** Let a dead link go and open a new one now, not after the backoff. */
+  function replace(sock) {
+    if (ws !== sock) return;
+    stopPinging();
+    ws = null;
+    connected = false;
+    for (const c of live.values()) c.abort();
+    live.clear();
+    try { sock.close(4002, 'No answer; reconnecting.'); } catch { /* already gone */ }
+    if (timer) { clearTimeout(timer); timer = null; }
+    retry = 1000;
+    onChange();
+    void connect();
+  }
+
   function schedule() {
     if (!want || timer) return;
     timer = setTimeout(() => { timer = null; void connect(); }, retry);
@@ -198,12 +263,14 @@ export function createRelayClient({
       connected = true;
       error = null;
       retry = 1000;
+      startPinging(sock);
       onChange();
     };
     sock.onmessage = (event) => { if (ws === sock) void onMessage(sock, event.data); };
     sock.onerror = () => { if (ws === sock && !connected) error = 'Could not reach the relay.'; };
     sock.onclose = (event) => {
       if (ws !== sock) return;
+      stopPinging();
       ws = null;
       const was = connected;
       connected = false;
@@ -226,6 +293,7 @@ export function createRelayClient({
     stop() {
       want = false;
       gen += 1;
+      stopPinging();
       if (timer) { clearTimeout(timer); timer = null; }
       const sock = ws;
       ws = null;

package/main/repeats.mjs

@@ -16,6 +16,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import {
   DAY_NAMES, foldRepeats, isOwed, isRepeatRule, occurrenceId, periodKey, repeatLabel,
+  standingInstruction, PROTOCOL_OPENS, INSTRUCTION_MARK,
 } from '../shared/repeats.mjs';
 import { machineryPath } from './store/home.mjs';
 import { NAME } from '../shared/product-name.mjs';
@@ -41,8 +42,8 @@ const MISSES_BEFORE_ALERT = 3;
 // last can be truncated away entirely, and a worker that never saw it cannot
 // know that a quiet finish has to be marked.
 export const OCCURRENCE_PROTOCOL = [
-  'THIS IS ONE RUN OF A REPEATING TASK. It runs again tomorrow whatever happens',
-  'here, so this run does not have to carry the future.',
+  `${PROTOCOL_OPENS} It runs again at its next time whatever`,
+  'happens here, so this run does not have to carry the future.',
   '',
   'FINISH ONE OF TWO WAYS.',
   '',
@@ -60,7 +61,12 @@ export const OCCURRENCE_PROTOCOL = [
   `only place in ${NAME} where finishing quietly hides something, so the marker is`,
   'required to hide, never to show.',
   '',
-  'HER INSTRUCTION FOLLOWS.',
+  'IF THEY TELL YOU HOW THIS TASK SHOULD GO FROM NOW ON, CHANGE IT YOURSELF with',
+  'the store tool set_repeating_task. Editing this run or writing a memory note',
+  'reaches no later run: this body is a copy, and every run gets a new task',
+  'folder. Never ask them to go and edit the task by hand.',
+  '',
+  INSTRUCTION_MARK,
 ].join('\n');
 
 export class Repeats {
@@ -212,7 +218,7 @@ export class Repeats {
 
       const { created } = workItemsDisk.createWorkItemIfAbsent(productDir, id, {
         title: `${rule.title} · ${dayStamp(key)}`,
-        body: `${OCCURRENCE_PROTOCOL.replace('<REPEAT_LABEL>', repeatLabel(ruleId))}\n\n${rule.body ?? rule.title}`,
+        body: `${OCCURRENCE_PROTOCOL.replace('<REPEAT_LABEL>', repeatLabel(ruleId))}\n\n${standingInstruction(rule)}`,
         kind: 'directive',
         priority: rule.priority ?? 5,
         labels: ['founder', repeatLabel(ruleId)],

package/main/row-label.mjs

@@ -1,4 +1,5 @@
 import { harnessFor } from './harnesses.mjs';
+import { teammateIdOf } from '../shared/teammates.mjs';
 // THE NAME ON THE ROW, WRITTEN RATHER THAN TAKEN FROM THE FIRST SENTENCE.
 //
 // A dictated message keeps its first line as its title, verbatim and forever
@@ -62,51 +63,18 @@ export const NAME_MAX = 64;
  *  archive; everything else is a row that can still appear in a list. */
 const LIVE = new Set(['open', 'claimed', 'blocked']);
 
-/**
- * PURE. Is this title already a name somebody wrote?
- *
- * The one question that decides whether this module speaks at all, and it is
- * answered off the words alone because that is all there is: nothing on a row
- * records whether its title was typed or derived.
- *
- * Three marks, and together they separate the two shapes `splitMessage` makes
- * (renderer/src/message-split.ts). A first line of 120 characters or less is
- * kept VERBATIM and is the name its person wrote. A longer one is clipped into
- * a title by the app, and every clip it can produce is either a whole sentence
- * of at least 25 characters or a hard cut ending in an ellipsis.
- *
- *   as short as a name we would write   NAME_MAX, so a title already that tight
- *                                       has nothing for us to improve,
- *   as few words as a name has          the same eight `cleanName` allows,
- *   not ending as a sentence does       '.', '!', '?' and '…' are how a clipped
- *                                       title ends and not how a name does.
- *
- * It errs towards leaving the words alone, which is the right way to be wrong:
- * the cost is a short typed sentence keeping its own first line, and the cost
- * the other way is somebody losing the thread they named.
- */
-export function isWrittenName(title) {
-  const t = String(title ?? '').trim();
-  if (!t) return false;
-  if (t.length > NAME_MAX) return false;
-  if (t.split(/\s+/).length > 8) return false;
-  return !/[.!?…]$/.test(t);
-}
-
 /**
  * PURE. Does this row want naming?
  *
- * Four ways to say no, and the last two are the fix for a tester losing their
- * own threads on 2026-10-01: "Add comment to cart.js" became "Improve cart.js
- * header comment" and then "Update cart file comment" inside two minutes.
+ * Three ways to say no:
  *
  *   - it is done, so nobody is scanning for it,
  *   - it has nothing to name from, which is a row with no words on it yet,
- *   - ITS PERSON ALREADY NAMED IT. A short clear title is the name they will
- *     look for, and on a team it is the name they will point someone else at.
- *     Improving it is not an improvement.
  *   - IT HAS BEEN NAMED. Once, when the thread was made, and then never again.
  *
+ * A short typed title is named too: a list where some rows are typed lines and
+ * the rest are names reads as two styles. The prompt keeps such a line's words.
+ *
  * That last line used to read `wroteAt < contentTouchedAt(item)`, so the name
  * followed where the thread stood: an agent writes a note and a result on every
  * run, so every run earned a new name. Following the thread was the intended
@@ -122,8 +90,8 @@ export function isWrittenName(title) {
  */
 export function wantsName(item) {
   if (!item || !LIVE.has(item.status)) return false;
+  if (teammateIdOf(item)) return false;
   if (!String(item.title ?? '').trim() && !String(item.body ?? '').trim()) return false;
-  if (isWrittenName(item.title)) return false;
   return !String(item.label ?? '').trim();
 }
 
@@ -139,12 +107,15 @@ export function namePrompt(item) {
     'Here is a work thread: the message that opened it, and the latest thing',
     'written on it. Write a short name for the thread AS IT STANDS NOW: 3 to 7',
     'words, sentence case, no quotes, no trailing punctuation, naming the thing',
-    'being worked on rather than restating the sentence. Reply with the name and',
-    'nothing else.',
+    'being worked on rather than restating the sentence. If the opening line is',
+    'already a short name, keep its words and only fix the case. Reply with the',
+    'name and nothing else.',
     '',
     '--- opened with ---',
     cut(item?.title, 300),
-    cut(item?.body, 1200),
+    // A teammate's run is titled with its own part of a message that may have
+    // woken several (shared/teammates.mjs `runTitle`); the whole would mix them.
+    (item?.labels ?? []).some((l) => String(l).startsWith('teammate:')) ? '' : cut(item?.body, 1200),
     '--- latest ---',
     latest || '(nothing written yet)',
     '---',

package/main/run-change.mjs

@@ -0,0 +1,13 @@
+// WHAT A RUN CHANGED: the checkout read back against its photograph, then the
+// change file written. Git commands and a whole transcript, so it runs on the
+// git thread (main/git-change-offthread.mjs), not on the app's main thread.
+import { changeFromRepo } from './git-change.mjs';
+import { writeChangeForRun } from './code-change.mjs';
+
+export function saveRunChange({ repoBefore = null, ...run }) {
+  let repos = [];
+  try {
+    if (repoBefore) repos = [changeFromRepo(repoBefore)];
+  } catch (e) { console.warn('zero: could not read the repository back:', e.message); }
+  return writeChangeForRun({ ...run, repos });
+}