@ethlete/agent-rules 0.1.0-next.31 → 0.1.0-next.33

package/content/skills/agent-sessions/agent-sessions.mjs

@@ -36,8 +36,10 @@ const DRAFT_RETRY_MS = 2000;
 const RESTART_AFTER_SECONDS = 5;
 const RESTART_CLEAR_MS = 2500;
 const RESTART_POLL_MS = 2000;
-const RESTART_WAIT_MS = 30 * 60 * 1000;
+const RESTART_WAIT_MS = Number(process.env.AGENT_RESTART_WAIT_MS ?? 30 * 60 * 1000);
+const RESTART_DRAFT_NOTICE_MS = Number(process.env.AGENT_RESTART_DRAFT_NOTICE_MS ?? 2 * 60 * 1000);
 const RESTART_CLEAR_WAIT_MS = Number(process.env.AGENT_RESTART_CLEAR_WAIT_MS ?? 60 * 1000);
+const RESTART_EXIT_WAIT_MS = Number(process.env.AGENT_RESTART_EXIT_WAIT_MS ?? 30 * 1000);
 const repoSlug = basename(root).replace(/[.:]/g, '-');
 const sessionFor = (agent) => `${agent}@${repoSlug}`;
 const DISPATCH_SESSION = process.env.AGENT_MAILBOX_DISPATCH_SESSION ?? `mailbox-dispatch@${repoSlug}`;
@@ -61,6 +63,9 @@ const remove = takeFlag(args, '--remove', false);
 const afterSeconds = takeFlag(args, '--after', true);
 const now = takeFlag(args, '--now', false);
 const dryRun = takeFlag(args, '--dry-run', false);
+const role = takeFlag(args, '--role', true);
+const notify = takeFlag(args, '--notify', true);
+const newProcess = takeFlag(args, '--process', false);
 const [command, sender, ...words] = args;
 
 const help = `Shared agent mailbox: ${mailbox}
@@ -74,12 +79,18 @@ Claim:   node ${script} claim <name> <path...> [--ttl <hours>] [--force]
 Release: node ${script} release <name> [path...]      (no path: release every claim of <name>)
 Claims:  node ${script} claims
 Up:      node ${script} up <name>[=<command>]...      (start a tmux session per agent, plus one that runs dispatch)
-Run:     node ${script} run <name> <command...>       (start or attach the agent in its tmux session; starts dispatch)
+Run:     node ${script} run <name> <command...> [--role builder] [--dry-run]
+                                                      (start or attach the agent in its tmux session; starts dispatch;
+                                                       the builder role sets ETHLETE_AGENT_ROLE and gives claude a terse system prompt)
 Install: node ${script} shell-install [<agent>...] [--file <path>] [--remove] [--dry-run]
                                                       (write the shell functions into ~/.zshrc or ~/.bashrc)
 Shell:   node ${script} shell-init [<agent>...]       (print shell functions that wrap each agent with run; default: claude codex)
-Restart: node ${script} restart <name> [--after <seconds>] <prompt...>
-                                                      (type the clear command and then the prompt into the tmux session of <name>)
+Restart: node ${script} restart <name> [--after <seconds>] [--notify <agent,...>] [--process] [--role builder|none] <prompt...>
+                                                      (type the clear command and then the prompt into the tmux session of <name>;
+                                                       a long wait on a draft and a give-up go to <name> and each --notify agent;
+                                                       --process ends the agent and starts it again in the same pane with the prompt;
+                                                       it keeps the role, else takes it from a builder-* handoff name, and refuses
+                                                       a session with no role while another agent session runs in the repo)
 Down:    node ${script} down [<name>...]              (stop dispatch; stop the named sessions too)
 Dispatch: node ${script} dispatch                      (wake the tmux session named <agent> for each message sent --to <agent>)
 
@@ -94,10 +105,80 @@ Keep credentials and personal data out of the mailbox. No agent is started autom
 
 const tmux = (...tmuxArgs) => spawnSync('tmux', tmuxArgs, { encoding: 'utf8' });
 const quote = (text) => `'${text.replaceAll("'", "'\\''")}'`;
+const BUILDER_PROMPT =
+  'The user does not read this chat. Write no text between tool calls; end each turn with at most one line. Reports go to the grill session via SendMessage.';
+const withRole = (words) =>
+  role === 'builder' && basename(words[0]) === 'claude' ? [...words, '--append-system-prompt', BUILDER_PROMPT] : words;
 const sessionExists = (name) => tmux('has-session', '-t', `=${name}`).status === 0;
+const ROLE_OPTION = '@ethlete_role';
+const COMMAND_OPTION = '@ethlete_command';
+const agentCommandOf = (session) =>
+  tmux('show-options', '-v', '-t', `=${session}:`, COMMAND_OPTION).stdout.trim() ||
+  tmux('display-message', '-p', '-t', `=${session}:`, '#{pane_start_command}')
+    .stdout.trim()
+    .replace(/^"(.*)"$/, '$1');
+const roleOf = (session) => tmux('show-options', '-v', '-t', `=${session}:`, ROLE_OPTION).stdout.trim() || null;
+const arePaired = (a, b) => (roleOf(a) === 'builder') !== (roleOf(b) === 'builder');
 const ONE_SHOT_FLAGS = new Set(['-p', '--print', '-v', '--version', '-h', '--help']);
 const runsInSession = (agentArgs) =>
   Boolean(process.stdin.isTTY && process.stdout.isTTY) && !agentArgs.some((arg) => ONE_SHOT_FLAGS.has(arg));
+const TEXT_VALUE_FLAGS = new Set(['--append-system-prompt', '--system-prompt']);
+const withoutPrompt = (words) => {
+  const separator = words.indexOf('--');
+  if (separator > 0) return words.slice(0, separator);
+  const [previous, last] = words.slice(-2);
+  const isPrompt =
+    words.length > 1 &&
+    !last.startsWith('-') &&
+    (!previous.startsWith('-') || (/\s/.test(last) && !TEXT_VALUE_FLAGS.has(previous)));
+  return isPrompt ? words.slice(0, -1) : words;
+};
+const SHELL_WORD = /(?:'[^']*'|\\.|[^\s'\\])+/g;
+const ENV_WORD = /^[A-Za-z_][A-Za-z0-9_]*=/;
+const unquoteWord = (word) => word.replace(/'([^']*)'|\\(.)/g, (_, quoted, escaped) => quoted ?? escaped);
+const commandWithoutPrompt = (command) => {
+  const tokens = [...command.matchAll(SHELL_WORD)];
+  const program = tokens.findIndex(([word]) => !ENV_WORD.test(word));
+  if (program < 0) return command;
+  const words = tokens.slice(program).map(([word]) => unquoteWord(word));
+  const kept = withoutPrompt(words).length;
+  return kept === words.length ? command : command.slice(0, tokens[program + kept].index).trimEnd();
+};
+const HANDOFF_ROLE = /^\/handoff\s+resume\s+(builder|doc-agent)-/;
+const handoffRoleOf = (prompt) => prompt.match(HANDOFF_ROLE)?.[1] ?? null;
+const restartRoleOf = (session, prompt) => {
+  if (role === 'none') return null;
+  const found = role ?? roleOf(session) ?? handoffRoleOf(prompt);
+  return found === 'doc-agent' ? null : found;
+};
+const hasUnknownRole = (session, prompt) => {
+  if (role !== undefined || roleOf(session) || handoffRoleOf(prompt)) return false;
+  const peers = tmux('list-sessions', '-F', '#{session_name}')
+    .stdout.split('\n')
+    .filter((name) => name.endsWith(`@${repoSlug}`) && name !== session && name !== DISPATCH_SESSION);
+  return peers.length > 0 && !peers.some((name) => roleOf(name) === 'builder');
+};
+const commandWithRole = (command, agentRole) => {
+  const tokens = [...command.matchAll(SHELL_WORD)].map(([word]) => word);
+  const program = tokens.findIndex((word) => !ENV_WORD.test(word));
+  const env = program < 0 ? tokens : tokens.slice(0, program);
+  const words = tokens.slice(env.length).map(unquoteWord);
+  const kept = words.filter(
+    (word, index) =>
+      !(word === '--append-system-prompt' && words[index + 1] === BUILDER_PROMPT) &&
+      !(word === BUILDER_PROMPT && words[index - 1] === '--append-system-prompt'),
+  );
+  const rule =
+    agentRole === 'builder' && basename(kept[0] ?? '') === 'claude' ? ['--append-system-prompt', BUILDER_PROMPT] : [];
+  return [
+    ...env.filter((word) => !word.startsWith('ETHLETE_AGENT_ROLE=')),
+    `ETHLETE_AGENT_ROLE=${agentRole}`,
+    ...[...kept, ...rule].map(quote),
+  ].join(' ');
+};
+const bypassingShellFunction = (base) => base.replace(/^((?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*)/, '$1command ');
+const EXIT_DIALOG_JOBS = /will stop when you exit/i;
+const EXIT_AND_STOP = /exit and stop/i;
 
 /**
  * Reads the last prompt line (`❯` for Claude Code, `›` for Codex) of the pane. Dim text is the empty
@@ -105,14 +186,31 @@ const runsInSession = (agentArgs) =>
  * wake-up line from answering a permission dialog.
  */
 const SGR = `${String.fromCharCode(27)}\\[([0-9;]*)m`;
-const busyLine = (session) =>
-  (tmux('capture-pane', '-p', '-t', `=${session}:`).stdout ?? '')
-    .split('\n')
-    .find((line) => /esc to inte/i.test(line)) ?? null;
+const BUSY_TEXT = /esc to interrupt|Waiting for/i;
+const isTranscript = (line) => /^\s*[●⎿]/.test(line);
+/**
+ * The line that shows a running turn: the spinner line right above the input box, or a footer line below it.
+ * A transcript line (`●`, `⎿`) never counts, since an agent can end its turn with its own "Waiting for ..." text.
+ */
+const busyLineOf = (lines) => {
+  const bottom = lastRuleIndex(lines);
+  const top = lines.slice(0, bottom).findLastIndex(isRule);
+  if (bottom === -1 || top === -1) return lines.find((line) => BUSY_TEXT.test(line) && !isTranscript(line)) ?? null;
+  const spinner = lines.slice(0, top).findLast((line) => line.trim() !== '') ?? '';
+  return [spinner, ...lines.slice(bottom + 1)].find((line) => BUSY_TEXT.test(line) && !isTranscript(line)) ?? null;
+};
+const busyLine = (session) => busyLineOf((tmux('capture-pane', '-p', '-t', `=${session}:`).stdout ?? '').split('\n'));
 const restartLog = (message) => {
   mkdirSync(dirname(mailbox), { recursive: true });
   appendFileSync(join(dirname(mailbox), 'restart.log'), `${new Date().toISOString()} ${message}\n`);
 };
+const restartNotice = (message) => {
+  restartLog(message);
+  [sender, ...(notify ?? '').split(',')]
+    .map((agent) => agent.trim())
+    .filter(Boolean)
+    .forEach((to) => append({ sender: 'restart', to, message }));
+};
 
 /**
  * Waits until the agent ended its turn and nobody types in its prompt, twice in a row; `false` after the time limit.
@@ -123,12 +221,19 @@ const waitForQuiet = (session, limitMs = RESTART_WAIT_MS, allowBusy = false) =>
   const end = Date.now() + limitMs;
   let quiet = 0;
   let reason = '';
+  let draftSince = null;
+  let told = false;
   while (Date.now() < end) {
     const busy = allowBusy ? null : busyLine(session);
     const draft = busy === null ? draftLine(session) : null;
     const next = busy !== null ? `busy: ${busy.trim()}` : draft !== null ? `draft: ${draft}` : '';
     if (next !== reason) restartLog(`${session} ${next ? `waits, ${next}` : 'is quiet'}`);
     reason = next;
+    draftSince = draft === null ? null : (draftSince ?? Date.now());
+    if (!told && draftSince !== null && Date.now() - draftSince >= RESTART_DRAFT_NOTICE_MS) {
+      told = true;
+      restartNotice(`restart of ${session} waits ${Math.round((Date.now() - draftSince) / 1000)}s, draft: ${draft}`);
+    }
     quiet = next ? 0 : quiet + 1;
     if (quiet === 2) return true;
     sleep(RESTART_POLL_MS);
@@ -138,15 +243,29 @@ const waitForQuiet = (session, limitMs = RESTART_WAIT_MS, allowBusy = false) =>
 
 /** The IDE context chip (`[⧉ In file.ts]`, `[⧉ 3 lines selected]`) shares the prompt line and survives `/clear`. */
 const IDE_CHIP = /\[⧉ [^\]]*\]/g;
-const draftLine = (session) => {
-  const pane = tmux('capture-pane', '-p', '-e', '-t', `=${session}:`).stdout ?? '';
-  const prompt = pane
-    .split('\n')
-    .reverse()
-    .find((line) => /^\s*[❯›]/.test(line.replace(new RegExp(SGR, 'g'), '')));
-  if (!prompt) return null;
+const plain = (line) => line.replace(new RegExp(SGR, 'g'), '');
+const isRule = (line) => /^─{10,}$/.test(plain(line).trim());
+const isPromptMark = (line) => /^\s*[❯›]/.test(plain(line));
+/** A row of the background-agent panel below the footer (`❯ ⏺ main`, `  ◯ general-purpose …`). */
+const isPanelRow = (line) => /^\s*❯?\s*[⏺◯]/.test(plain(line));
+const paneLines = (session) => (tmux('capture-pane', '-p', '-e', '-t', `=${session}:`).stdout ?? '').split('\n');
+const lastRuleIndex = (lines) => lines.findLastIndex(isRule);
+/**
+ * The prompt is the text between the last two rules of the input box. A `❯` line below the last rule that is not a
+ * panel row is a menu (`❯ 1. Yes`) and wins, which keeps a wake-up line from answering a permission dialog.
+ */
+const promptLines = (lines) => {
+  const below = lastRuleIndex(lines);
+  const menu = lines.slice(below + 1).findLast((line) => isPromptMark(line) && !isPanelRow(line));
+  if (menu) return [menu];
+  const above = lines.slice(0, below).findLastIndex(isRule);
+  if (below !== -1 && above !== -1) return lines.slice(above + 1, below);
+  const prompt = lines.findLast((line) => isPromptMark(line) && !isPanelRow(line));
+  return prompt ? [prompt] : [];
+};
+const withoutDim = (line) => {
   let dim = false;
-  const visible = prompt
+  return line
     .split(new RegExp(`(${SGR.replace('(', '(?:')})`))
     .map((part) => {
       const codes = part.match(new RegExp(`^${SGR}$`))?.[1].split(';');
@@ -158,12 +277,35 @@ const draftLine = (session) => {
       return '';
     })
     .join('');
-  const text = visible
+};
+const draftLine = (session) => {
+  const text = promptLines(paneLines(session))
+    .map(withoutDim)
+    .join('\n')
     .replace(/^\s*[❯›]/, '')
     .replace(IDE_CHIP, '')
     .trim();
   return text.length > 0 ? text : null;
 };
+const panelFocused = (lines) => lines.slice(lastRuleIndex(lines) + 1).some((line) => /^\s*❯\s*[⏺◯]/.test(plain(line)));
+const PANEL_UP_LIMIT = 10;
+/**
+ * Keys typed while the focus sits in the background-agent panel go into the panel. Up moves the focus back to the
+ * prompt, and an Up too many recalls history, so C-u clears the line after. `false` if the focus did not leave.
+ */
+const leavePanel = (session) => {
+  if (!panelFocused(paneLines(session))) return true;
+  for (let press = 0; press < PANEL_UP_LIMIT; press++) {
+    tmux('send-keys', '-t', `=${session}:`, 'Up');
+    sleep(ENTER_DELAY_MS);
+    if (!panelFocused(paneLines(session))) {
+      tmux('send-keys', '-t', `=${session}:`, 'C-u');
+      sleep(ENTER_DELAY_MS);
+      return true;
+    }
+  }
+  return false;
+};
 const hasDraft = (session) => draftLine(session) !== null;
 const isAttached = (name) => tmux('list-clients', '-t', `=${name}`).stdout.trim() !== '';
 const freeSessionFor = (agent) => {
@@ -271,22 +413,55 @@ if (command === 'send' && sender) {
     const [name, ...rest] = spec.split('=');
     startSession(sessionFor(name), rest.join('=') || undefined);
   });
+} else if (command === 'run' && sender && words.length && role !== undefined && role !== 'builder') {
+  process.stderr.write(`Unknown role ${role}. Only builder exists.\n`);
+  process.exitCode = 1;
+} else if (command === 'run' && sender && words.length && dryRun) {
+  process.stdout.write(`${role ? `ETHLETE_AGENT_ROLE=${role} ` : ''}${withRole(words).map(quote).join(' ')}\n`);
 } else if (command === 'run' && sender && words.length && !runsInSession(words.slice(1))) {
-  const [program, ...programArgs] = words;
-  process.exitCode = spawnSync(program, programArgs, { stdio: 'inherit' }).status ?? 1;
+  const [program, ...programArgs] = withRole(words);
+  process.exitCode =
+    spawnSync(program, programArgs, {
+      stdio: 'inherit',
+      env: role ? { ...process.env, ETHLETE_AGENT_ROLE: role } : process.env,
+    }).status ?? 1;
 } else if (command === 'run' && sender && words.length) {
   const withEnv = process.env.AGENT_MAILBOX ? `AGENT_MAILBOX=${quote(process.env.AGENT_MAILBOX)} ` : '';
   if (!sessionExists(DISPATCH_SESSION))
     startSession(DISPATCH_SESSION, `${withEnv}node ${quote(script)} dispatch`, true);
   const session = freeSessionFor(sender);
-  const shellCommand = words.map(quote).join(' ');
+  const roleEnv = role ? `ETHLETE_AGENT_ROLE=${role} ` : '';
+  const shellCommand = `${roleEnv}${withRole(words).map(quote).join(' ')}`;
+  const baseCommand = `${roleEnv}${withRole(withoutPrompt(words)).map(quote).join(' ')}`;
   if (process.env.TMUX) {
-    if (!sessionExists(session)) tmux('new-session', '-d', '-s', session, '-c', process.cwd(), shellCommand);
-    process.exitCode = spawnSync('tmux', ['switch-client', '-t', `=${session}`], { stdio: 'inherit' }).status ?? 1;
+    if (!sessionExists(session)) {
+      tmux('new-session', '-d', '-s', session, '-c', process.cwd(), shellCommand);
+      tmux('set-option', '-t', `=${session}:`, COMMAND_OPTION, baseCommand);
+      if (role) tmux('set-option', '-t', `=${session}:`, ROLE_OPTION, role);
+    }
+    const callerSession = tmux(
+      'display-message',
+      '-p',
+      '-t',
+      process.env.TMUX_PANE ?? '',
+      '#{session_id}',
+    ).stdout.trim();
+    const [callerClient] = callerSession
+      ? tmux('list-clients', '-t', callerSession, '-F', '#{client_tty}').stdout.split('\n').filter(Boolean)
+      : [];
+    process.exitCode = callerClient
+      ? (spawnSync('tmux', ['switch-client', '-c', callerClient, '-t', `=${session}`], { stdio: 'inherit' }).status ??
+        1)
+      : 0;
   } else {
-    process.exitCode =
-      spawnSync('tmux', ['new-session', '-A', '-s', session, '-c', process.cwd(), shellCommand], { stdio: 'inherit' })
-        .status ?? 1;
+    const created = sessionExists(session)
+      ? []
+      : ['new-session', '-d', '-s', session, '-c', process.cwd(), shellCommand];
+    if (created.length && tmux(...created).status === 0) {
+      tmux('set-option', '-t', `=${session}:`, COMMAND_OPTION, baseCommand);
+      if (role) tmux('set-option', '-t', `=${session}:`, ROLE_OPTION, role);
+    }
+    process.exitCode = spawnSync('tmux', ['attach-session', '-t', `=${session}`], { stdio: 'inherit' }).status ?? 1;
   }
 } else if (command === 'shell-init' || command === 'shell-install') {
   const agents = [sender, ...words].filter(Boolean);
@@ -344,30 +519,96 @@ if (command === 'send' && sender) {
   if (!session) {
     process.stderr.write(`No tmux session for ${sender}.\n`);
     process.exitCode = 1;
-  } else if (own && own !== session) {
+  } else if (own && own !== session && !arePaired(own, session)) {
     process.stderr.write(
       `Refused: ${session} is not your session. You run in ${own}, so pass ${own.replace(`@${repoSlug}`, '')}.\n`,
     );
     process.exitCode = 1;
+  } else if (role !== undefined && role !== 'builder' && role !== 'none') {
+    process.stderr.write(`Unknown role ${role}. Pass --role builder or --role none.\n`);
+    process.exitCode = 1;
+  } else if (newProcess && hasUnknownRole(session, words.join(' '))) {
+    process.stderr.write(
+      `Refused: ${session} has no role and another agent session runs in this repo, so the new process could lose the builder rule. Resume a builder-* or doc-agent-* handoff, or pass --role builder or --role none.\n`,
+    );
+    process.exitCode = 1;
   } else if (now) {
     const type = (...keys) => tmux('send-keys', '-t', `=${session}:`, ...keys);
     sleep(Number(afterSeconds ?? RESTART_AFTER_SECONDS) * 1000);
     if (!waitForQuiet(session)) {
+      restartNotice(`restart of ${session} gave up after ${RESTART_WAIT_MS / 1000}s, reason in restart.log`);
       process.exitCode = 1;
+    } else if (!leavePanel(session)) {
+      restartNotice(
+        `restart of ${session} gave up, the focus did not leave the agent panel after ${PANEL_UP_LIMIT} Up`,
+      );
+      process.exitCode = 1;
+    } else if (newProcess) {
+      const pane = `=${session}:`;
+      const restartRole = restartRoleOf(session, words.join(' '));
+      const stored = commandWithoutPrompt(agentCommandOf(session));
+      const base = restartRole ? commandWithRole(stored, restartRole) : stored;
+      if (restartRole) tmux('set-option', '-t', pane, ROLE_OPTION, restartRole);
+      tmux('set-option', '-p', '-t', pane, 'remain-on-exit', 'on');
+      type('-l', sender.startsWith('codex') ? '/quit' : '/exit');
+      sleep(ENTER_DELAY_MS);
+      type('Enter');
+      const end = Date.now() + RESTART_EXIT_WAIT_MS;
+      const dead = () => tmux('display-message', '-p', '-t', pane, '#{pane_dead}').stdout.trim() === '1';
+      const answerExitDialog = () => {
+        const lines = (tmux('capture-pane', '-p', '-t', pane).stdout ?? '').split('\n');
+        const start = lines.findIndex((line) => EXIT_DIALOG_JOBS.test(line));
+        const stop = lines.findIndex((line, index) => index > start && EXIT_AND_STOP.test(line));
+        if (start < 0 || stop < 0) return false;
+        const selected = lines.findIndex((line, index) => index > start && line.trim().startsWith('❯'));
+        const jobs = lines
+          .slice(start + 1, stop)
+          .map((line) => line.trim())
+          .filter(Boolean);
+        restartNotice(
+          `restart of ${session} stopped its background work, start it again: ${jobs.join('; ') || '(none listed)'}`,
+        );
+        const between = (from, to) => lines.slice(from, to).filter((line) => line.trim()).length;
+        const [key, steps] = selected > stop ? ['Up', between(stop, selected)] : ['Down', between(selected, stop)];
+        for (let step = 0; selected >= 0 && step < steps; step++) type(key);
+        type('Enter');
+        return true;
+      };
+      let answered = false;
+      while (!dead() && Date.now() < end) {
+        if (!answered) answered = answerExitDialog();
+        sleep(RESTART_POLL_MS / 4);
+      }
+      if (!dead()) restartLog(`${session} did not exit ${RESTART_EXIT_WAIT_MS / 1000}s after the exit command, killed`);
+      const shell = process.env.SHELL || 'sh';
+      tmux(
+        'respawn-pane',
+        '-k',
+        '-t',
+        pane,
+        '-c',
+        root,
+        shell,
+        '-lic',
+        `${bypassingShellFunction(base)} ${quote(words.join(' '))}`,
+      );
+      tmux('set-option', '-p', '-t', pane, 'remain-on-exit', 'off');
+      tmux('set-option', '-t', pane, COMMAND_OPTION, base);
+      restartLog(`${session} started a new process: ${base}`);
     } else {
       type('-l', sender.startsWith('codex') ? '/new' : '/clear');
       sleep(ENTER_DELAY_MS);
       type('Enter');
       sleep(RESTART_CLEAR_MS);
-      if (waitForQuiet(session, RESTART_CLEAR_WAIT_MS, true)) {
+      if (waitForQuiet(session, RESTART_CLEAR_WAIT_MS, true) && leavePanel(session)) {
         type('-l', words.join(' '));
         sleep(ENTER_DELAY_MS);
         type('Enter');
       } else {
         const saved = join(dirname(mailbox), `restart.prompt.${session}.txt`);
         writeFileSync(saved, `${words.join(' ')}\n`);
-        restartLog(
-          `${session} prompt not empty ${RESTART_CLEAR_WAIT_MS / 1000}s after the clear, prompt not typed, saved to ${saved}`,
+        restartNotice(
+          `restart of ${session} gave up: prompt not empty ${RESTART_CLEAR_WAIT_MS / 1000}s after the clear, prompt not typed, saved to ${saved}`,
         );
         tmux(
           'display-message',
@@ -379,13 +620,20 @@ if (command === 'send' && sender) {
       }
     }
   } else {
+    if (own && own !== session) restartLog(`peer restart: ${own} restarted ${session}`);
     const delay = Number(afterSeconds ?? RESTART_AFTER_SECONDS);
-    spawn(process.execPath, [script, 'restart', sender, '--now', '--after', String(delay), ...words], {
-      detached: true,
-      stdio: 'ignore',
-    }).unref();
+    const forward = notify ? ['--notify', notify] : [];
+    const mode = [...(newProcess ? ['--process'] : []), ...(role ? ['--role', role] : [])];
+    spawn(
+      process.execPath,
+      [script, 'restart', sender, '--now', '--after', String(delay), ...forward, ...mode, ...words],
+      {
+        detached: true,
+        stdio: 'ignore',
+      },
+    ).unref();
     process.stdout.write(
-      `Restarting ${session} once its turn ended and its prompt is empty, ${delay} seconds at the earliest. End your turn now.\n`,
+      `${newProcess ? 'Starting a new process in' : 'Restarting'} ${session} once its turn ended and its prompt is empty, ${delay} seconds at the earliest. End your turn now.\n`,
     );
   }
 } else if (command === 'down') {
@@ -411,6 +659,7 @@ if (command === 'send' && sender) {
       return;
     }
     waiting.delete(agent);
+    if (!leavePanel(session)) return process.stderr.write(`The focus of ${session} stays in the agent panel.\n`);
     spawnSync('tmux', ['send-keys', '-t', `=${session}:`, '-l', text]);
     sleep(ENTER_DELAY_MS);
     spawnSync('tmux', ['send-keys', '-t', `=${session}:`, 'Enter']);