@milpa/comal 0.2.6 → 0.2.7

package/README.md

@@ -28,7 +28,7 @@ comal --help
 
 Keep the PATH line in your shell startup file if you use that prefix. If your Node manager already provides a user prefix, you can omit `--prefix "$HOME/.local"`. The package registers the `comal` executable; you do not need to create a shell alias.
 
-You can pin a version with `npx @milpa/comal@0.2.6` or `npm install --global @milpa/comal@0.2.6`. The local release manifest preserves SHA-256 and SHA-512 integrity is checked against npm at publish time. No independent publisher signature is claimed.
+You can pin a version with `npx @milpa/comal@0.2.7` or `npm install --global @milpa/comal@0.2.7`. The local release manifest preserves SHA-256 and SHA-512 integrity is checked against npm at publish time. No independent publisher signature is claimed.
 
 ## Test without account or model
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milpa/comal",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Comal: governed operations, execution receipts, and programming assistance in any language",
   "type": "module",
   "private": false,

package/src/agent-status.mjs

@@ -0,0 +1,106 @@
+import net from 'node:net';
+import path from 'node:path';
+
+// What an interactive Comal is doing, said to the outside in two ways:
+// - the terminal title (OSC 0), which any terminal, tab bar or workspace manager can read:
+//   "◐ Comal · name" while it works, "? Comal · name" while a question waits for you, "✳ Comal · name" when idle;
+// - herdr's agent socket (pane.report_agent), when Comal runs inside a herdr pane (HERDR_ENV=1).
+// Both are best-effort: a failure is ignored and never touches the session. COMAL_TERMINAL_TITLE=off keeps the title.
+
+export const STATES = Object.freeze(['working', 'blocked', 'idle']);
+const GLYPH = { working: '◐', blocked: '?', idle: '✳' };
+const TITLE_MAX = 80;
+
+/**
+ * blocked while a permission card, or a choice or input pushed to the human (setup.waits: a swarm card, a connection
+ * review), waits for an answer; working while a turn runs; idle otherwise. A picker the human opened is not a question.
+ */
+export function agentState({ busy = false, permission = null, setup = null } = {}) {
+  if (permission || setup?.waits) return 'blocked';
+  return busy ? 'working' : 'idle';
+}
+
+const clean = text => String(text ?? '').replace(/[\x00-\x1f\x7f-\x9f]/g, '').replace(/\s+/g, ' ').trim();
+
+/** The label after "Comal ·": the session name, else the folder name. */
+export function statusLabel({ name, cwd } = {}) {
+  return clean(name) || clean(cwd ? path.basename(cwd) : '');
+}
+
+export function terminalTitle(state, label) {
+  const text = `${GLYPH[state] || GLYPH.idle} Comal${label ? ' · ' + clean(label) : ''}`;
+  return [...text].slice(0, TITLE_MAX).join('');
+}
+
+/** Sends one JSON line to herdr's socket; resolves true when herdr answered. Never rejects. */
+function sendLine(socketPath, request, { connect = net.createConnection, timeoutMs = 500 } = {}) {
+  return new Promise(resolve => {
+    let done = false, socket, timer;
+    const finish = ok => { if (done) return; done = true; clearTimeout(timer); try { socket?.destroy(); } catch {} resolve(ok); };
+    try { socket = connect(socketPath); } catch { finish(false); return; }
+    socket.on('error', () => finish(false));
+    socket.on('connect', () => socket.write(JSON.stringify(request) + '\n'));
+    socket.on('data', () => finish(true));
+    socket.on('end', () => finish(false));
+    timer = setTimeout(() => finish(false), timeoutMs); timer.unref?.();
+  });
+}
+
+export class HerdrReporter {
+  constructor({ env = process.env, connect, now = Date.now } = {}) {
+    this.socketPath = env.HERDR_SOCKET_PATH; this.paneId = env.HERDR_PANE_ID; this.connect = connect; this.now = now;
+    this.enabled = env.HERDR_ENV === '1' && Boolean(this.socketPath) && Boolean(this.paneId);
+    this.seq = now() * 1000; this.sessionId = null; this.chain = Promise.resolve();
+  }
+  // Reports go out one at a time, in order, each with a rising seq, so herdr never keeps an older state.
+  send(method, params) {
+    if (!this.enabled) return this.chain;
+    const request = { id: `comal:${method}:${this.now()}:${Math.random().toString(36).slice(2, 8)}`, method, params: { pane_id: this.paneId, source: 'comal', agent: 'comal', ...params } };
+    this.chain = this.chain.then(() => sendLine(this.socketPath, request, { connect: this.connect }));
+    return this.chain;
+  }
+  session(id) {
+    if (!id || id === this.sessionId) return this.chain;
+    this.sessionId = id;
+    return this.send('pane.report_agent_session', { seq: ++this.seq, agent_session_id: id });
+  }
+  report(state, message) {
+    return this.send('pane.report_agent', { state, ...(message ? { message } : {}), seq: ++this.seq, ...(this.sessionId ? { agent_session_id: this.sessionId } : {}) });
+  }
+  release() { return this.send('pane.release_agent', {}); }
+}
+
+export class AgentStatus {
+  constructor({ output, env = process.env, herdr = new HerdrReporter({ env }), exitTarget = process } = {}) {
+    // Only a real terminal says anything: a screen drawn into a pipe or a test double reports nothing anywhere.
+    this.output = output; this.herdr = herdr; this.live = Boolean(output?.isTTY);
+    this.titles = this.live && !/^(?:off|0|false|no)$/i.test(env.COMAL_TERMINAL_TITLE || '');
+    this.title = null; this.state = null; this.message = null; this.closed = false; this.pushed = false;
+    // A crash or an exit that never reaches close() still puts the terminal's title back.
+    this.exitTarget = exitTarget; this.onExit = () => { if (this.pushed && !this.closed) { try { this.output.write('\x1b[23;0t'); } catch {} } };
+  }
+  /** The next update writes the title again (after an editor or another program owned the terminal). */
+  forgetTitle() { this.title = null; }
+  update({ state, label, message, sessionId, titles = true } = {}) {
+    if (this.closed || !this.live || !STATES.includes(state)) return;
+    if (this.titles && titles) {
+      const title = terminalTitle(state, label);
+      if (title !== this.title) {
+        // Save the terminal's own title once, so closing puts it back (xterm title stack; ignored where unsupported).
+        try {
+          if (!this.pushed) this.exitTarget?.once?.('exit', this.onExit);
+          this.output.write((this.pushed ? '' : '\x1b[22;0t') + `\x1b]0;${title}\x07`); this.pushed = true; this.title = title;
+        } catch {}
+      }
+    }
+    if (sessionId) this.herdr.session(sessionId);
+    const text = state === 'blocked' ? clean(message).slice(0, 200) : '';
+    if (state !== this.state || text !== this.message) { this.state = state; this.message = text; this.herdr.report(state, text || undefined); }
+  }
+  close() {
+    if (this.closed) return this.herdr.chain; this.closed = true;
+    this.exitTarget?.off?.('exit', this.onExit);
+    if (this.pushed) { try { this.output.write('\x1b[23;0t'); } catch {} }
+    return this.state ? this.herdr.release() : this.herdr.chain;
+  }
+}

package/src/i18n/es.mjs

@@ -160,6 +160,8 @@ export default Object.freeze({
   "vision": "visión",
   "connecting": "conectando",
   "Enlarge the terminal to 24×10": "Amplía el terminal a 24×10",
+  "Permission: {v0}": "Permiso: {v0}",
+  "Waiting for your answer": "Esperando tu respuesta",
   "  {v0} interrupted message(s); not resent. R requeues the first.": "  {v0} mensaje(s) interrumpidos; no se reenviaron. R reencola el primero.",
   "  Empty queue. Send a message while the agent works.": "  Cola vacía. Envía un mensaje mientras el agente trabaja.",
   "  Running: ": "  En ejecución: ",

package/src/relay/flow.mjs

@@ -558,7 +558,7 @@ export class RelayFlow {
       if (got?.proposal?.status && got.proposal.status !== 'pending') { this.ui.notice(t('Plan {id} is already {status}.', { id: proposal_id, status: got.proposal.status })); return 'decided'; }
       // Cómo se comprueba cada tarea: la descripción de los checks del proyecto (project.json del hub).
       const checks = (await this.#projectFile({ root }, project))?.checks || [];
-      const choice = await this.ui.setupChoice({ ...planCard({ got, checks }), signal: card.signal });
+      const choice = await this.ui.setupChoice({ waits: true, ...planCard({ got, checks }), signal: card.signal });
       if (this.#elsewhere(key)) return 'decided';
       const digest = got.proposal.digest, apply = extra => () => this.applyPlan({ project, root, swarm, proposal_id, digest, ...extra });
       const done = result => {
@@ -569,7 +569,7 @@ export class RelayFlow {
       };
       if (choice === 'approve') return await this.#confirm(key, apply({ choice: 'approve' }), done);
       if (choice === 'reject') {
-        const reason = await this.ui.setupInput({ title: t('Reason for the lead'), description: t('The lead is woken up with exactly this text and proposes again.'), signal: card.signal });
+        const reason = await this.ui.setupInput({ waits: true, title: t('Reason for the lead'), description: t('The lead is woken up with exactly this text and proposes again.'), signal: card.signal });
         if (this.#elsewhere(key)) return 'decided';
         if (!reason?.trim()) return 'later';
         return await this.#confirm(key, apply({ choice: 'reject', reason: reason.trim() }), done);
@@ -618,7 +618,7 @@ export class RelayFlow {
     if (this.#elsewhere(key)) return 'decided';
     const card = this.broker.open(key, this.signal);
     try {
-      const choice = await this.ui.setupChoice({ ...criteriaCard({ got, swarm }), signal: card.signal });
+      const choice = await this.ui.setupChoice({ waits: true, ...criteriaCard({ got, swarm }), signal: card.signal });
       if (this.#elsewhere(key)) return 'decided';
       const done = result => {
         if (result.outcome === 'approved') this.ui.notice(t('Success criteria v{version} accepted ({status}): the lead can plan.', { version: got.current.version, status: result.status }));
@@ -630,14 +630,14 @@ export class RelayFlow {
         // open-relay v2.33: con avisos, aceptar se confirma aparte (por omisión, volver).
         const warnings = criteriaWarnings(got.current.items, { checked: got.basis_checked === true });
         if (warnings.size) {
-          const sure = await this.ui.setupChoice({ ...criteriaConfirmCard({ got, swarm, warnings }), signal: card.signal });
+          const sure = await this.ui.setupChoice({ waits: true, ...criteriaConfirmCard({ got, swarm, warnings }), signal: card.signal });
           if (this.#elsewhere(key)) return 'decided';
           if (sure !== 'accept') return 'later';
         }
         return await this.#confirm(key, () => this.applyCriteria({ project, root, swarm, digest, choice: 'accept' }), done);
       }
       if (choice === 'reject') {
-        const reason = await this.ui.setupInput({ title: t('Reason for the reviewer'), description: t('The reviewer is woken up with exactly this text and proposes again.'), signal: card.signal });
+        const reason = await this.ui.setupInput({ waits: true, title: t('Reason for the reviewer'), description: t('The reviewer is woken up with exactly this text and proposes again.'), signal: card.signal });
         if (this.#elsewhere(key)) return 'decided';
         if (!reason?.trim()) return 'later';
         return await this.#confirm(key, () => this.applyCriteria({ project, root, swarm, digest, choice: 'reject', reason: reason.trim() }), done);
@@ -653,7 +653,7 @@ export class RelayFlow {
     const { call, mutate } = this.#calls(project, root);
     const got = await call('criteria.get', { swarm_id: swarm }, this.signal);
     if (got?.status !== 'accepted' || got?.current?.digest !== digest) { this.ui.notice(t('Criteria of {swarm} are already {status}.', { swarm, status: got?.status || '?' })); return 'decided'; }
-    const reason = await this.ui.setupInput({ title: t('Why reopen the criteria'), description: t('The reviewer is woken up with exactly this text and proposes a new version; v{version} stays in force until you accept the new one.', { version: got.current.version }), signal: this.signal });
+    const reason = await this.ui.setupInput({ waits: true, title: t('Why reopen the criteria'), description: t('The reviewer is woken up with exactly this text and proposes a new version; v{version} stays in force until you accept the new one.', { version: got.current.version }), signal: this.signal });
     if (!reason?.trim()) return 'later';
     const result = await reopenCriteria(mutate, { swarm_id: swarm, digest, reason: reason.trim() }, this.signal);
     await this.record({ action: 'criteria.reopen', project, swarm, digest, version: got.current.version, reason: reason.trim(), status: result.status, idempotency_key: result.idempotency_key });
@@ -683,9 +683,9 @@ export class RelayFlow {
     const { call, mutate } = this.#calls(project, root);
     const got = await call('task.get', { task_id: brief?.id }, this.signal), task = got?.task || got;
     if (task?.state !== 'needs_attention' || !task?.review?.pending) { this.ui.notice(t('The review of {task} no longer waits for you.', { task: line(brief?.id || '?', 60) })); return 'decided'; }
-    const choice = await this.ui.setupChoice({ ...escalationCard({ task }), signal: this.signal });
+    const choice = await this.ui.setupChoice({ waits: true, ...escalationCard({ task }), signal: this.signal });
     if (choice === 'retry') {
-      const why = await this.ui.setupInput({ title: t('Why another review'), description: t('Recorded in relayd as your decision (review.retry) with exactly this text; the reviewer gets a new review task.'), signal: this.signal });
+      const why = await this.ui.setupInput({ waits: true, title: t('Why another review'), description: t('Recorded in relayd as your decision (review.retry) with exactly this text; the reviewer gets a new review task.'), signal: this.signal });
       if (!why?.trim()) return 'later';
       const retried = await retryReview(mutate, { task_id: task.id, reason: why.trim() }, this.signal);
       await this.record({ action: 'review.retry', project, swarm, task: task.id, reason: why.trim(), status: retried.status, idempotency_key: retried.idempotency_key });
@@ -693,7 +693,7 @@ export class RelayFlow {
       return 'decided';
     }
     if (choice !== 'override') return 'later';
-    const reason = await this.ui.setupInput({ title: t('Why you accept over the reviewer'), description: t('Recorded in relayd as your decision (review.override) with exactly this text.'), signal: this.signal });
+    const reason = await this.ui.setupInput({ waits: true, title: t('Why you accept over the reviewer'), description: t('Recorded in relayd as your decision (review.override) with exactly this text.'), signal: this.signal });
     if (!reason?.trim()) return 'later';
     const result = await overrideReview(mutate, { task_id: task.id, reason: reason.trim() }, this.signal);
     await this.record({ action: 'review.override', project, swarm, task: task.id, reason: reason.trim(), status: result.status, idempotency_key: result.idempotency_key });
@@ -723,7 +723,7 @@ export class RelayFlow {
     try {
       const { call } = this.#calls(project, root);
       const message = await call('msg.get', { message_id }, card.signal), block = decisionBlock(message);
-      const choice = await this.ui.setupChoice({ ...questionCard({ message, block, task }), signal: card.signal });
+      const choice = await this.ui.setupChoice({ waits: true, ...questionCard({ message, block, task }), signal: card.signal });
       if (this.#elsewhere(key)) return 'decided';
       const done = result => {
         if (result.outcome === 'decided') this.ui.notice(t('Decision recorded as {adr} and sent to {to}.', { adr: result.adr || '?', to: result.to }));
@@ -733,14 +733,14 @@ export class RelayFlow {
       };
       if (choice?.startsWith('option:') && block) {
         const index = Number(choice.slice(7)), option = block.options[index]?.label; if (!option) return 'later';
-        const note = await this.ui.setupInput({ title: t('Note for the ADR (optional)'), description: t('Why you choose «{option}». Enter with nothing skips it; it goes into the ADR decision.', { option }), signal: card.signal });
+        const note = await this.ui.setupInput({ waits: true, title: t('Note for the ADR (optional)'), description: t('Why you choose «{option}». Enter with nothing skips it; it goes into the ADR decision.', { option }), signal: card.signal });
         if (this.#elsewhere(key)) return 'decided';
         if (note === null || note === undefined) return 'later';
         return await this.#confirm(key, () => this.applyQuestion({ project, root, swarm, message_id, mode: 'option', option_index: index, text: note }), done);
       }
       if (choice === 'reply') {
         const to = message?.from?.role ? `role ${line(message.from.role, 60)}` : line(message?.from?.kind || '?', 40);
-        const body = await this.ui.setupInput({ title: t('Your answer'), description: t('Exact text sent to {to} (msg.reply).', { to }), signal: card.signal });
+        const body = await this.ui.setupInput({ waits: true, title: t('Your answer'), description: t('Exact text sent to {to} (msg.reply).', { to }), signal: card.signal });
         if (this.#elsewhere(key)) return 'decided';
         if (!body?.trim()) return 'later';
         return await this.#confirm(key, () => this.applyQuestion({ project, root, swarm, message_id, mode: 'reply', text: body }), done);
@@ -856,7 +856,7 @@ export class RelayFlow {
     const id = line(task?.id || '?', 60), controlDir = path.join(hubRoot || '.', 'projects', project, 'ctl');
     const command = `relay --control-dir ${shellWord(controlDir)} task resume ${shellWord(String(task?.id || '?'))}`;
     const why = String(detail?.state || '').startsWith('blocked') || detail?.state === 'needs_attention' ? blockLabel(detail.state) : null;
-    const choice = await this.ui.setupChoice({ ...blockedCard({ task: detail, reason, check, at: at ?? task?.since, why, retry: { command } }), signal: this.signal });
+    const choice = await this.ui.setupChoice({ waits: true, ...blockedCard({ task: detail, reason, check, at: at ?? task?.since, why, retry: { command } }), signal: this.signal });
     if (choice !== 'retry') return 'later';
     this.ui.notice(t('Retry it yourself in your terminal, exactly: {command}', { command }));
     await this.record({ action: 'blocked.shown', project, swarm, task: task?.id || null, check: check || null, reason: line(reason || '', 200) });
@@ -876,7 +876,7 @@ export class RelayFlow {
     const review = await this.#finalReview({ root: root || this.current?.hub_root, project, tasks });
     await this.state.setSwarm(project, swarm, { finished_at: new Date().toISOString() });
     await this.record({ action: 'swarm.finished', project, swarm, branch, base_commit: base || null, counts, ok, evidence: evidence.length });
-    const choice = await this.ui.setupChoice({ ...finishCard({ swarm, objective: info.objective || view?.objective, branch, counts, diffStat: stat, base: base || '?', ok, evidence, review }), signal: this.signal });
+    const choice = await this.ui.setupChoice({ waits: true, ...finishCard({ swarm, objective: info.objective || view?.objective, branch, counts, diffStat: stat, base: base || '?', ok, evidence, review }), signal: this.signal });
     if (choice === 'diff' && base) {
       const diff = await this.git.diff(repo, base, branch);
       this.ui.commandResult?.('relay', 'diff', (diff.truncated ? t('Diff of {branch} ({count} more lines not shown; git diff {base}..{branch})', { branch, count: diff.truncated, base: base.slice(0, 8) }) + '\n\n' : '') + diff.text);

package/src/tui/controller.mjs

@@ -280,7 +280,7 @@ export class InteractiveController {
     if(state.reason==='authentication' && loginProvider)items.push({id:'login',label:t('Sign in to the selected provider'),description:loginProvider});
     items.push({id:'choose',label:t('Choose another connection'),description:t('Open the provider and workspace profile selector.')});
     const reason=CONNECTION_REASON_HINTS[state.reason];
-    const choice=await this.ui.setupChoice({title:t(state.confirmedUnchanged?'Connection change not applied':'Connection status needs review'),description:t(state.message)+(reason?'\n\n'+t(reason):''),items});
+    const choice=await this.ui.setupChoice({waits:true,title:t(state.confirmedUnchanged?'Connection change not applied':'Connection status needs review'),description:t(state.message)+(reason?'\n\n'+t(reason):''),items});
     if(this.closed)return;
     if(choice==='retry' && this.connections.canRetry(id))await this.submit(`/${action.command} ${action.argument}`);
     else if(choice==='login')await this.submit(`/login ${loginProvider}`);

package/src/tui/screen.mjs

@@ -14,6 +14,7 @@ import { noticeMailbox } from '../plugin-notices.mjs';
 import { presentResultBlock, presentToolBlock, presentPermission } from './present.mjs';
 import { normalizeSwarmView, swarmPanelLines, swarmStripLines, swarmActions } from './swarm-panel.mjs';
 import { formatTurnTiming, measureHumanWait } from '../turn-timing.mjs';
+import { AgentStatus, agentState, statusLabel } from '../agent-status.mjs';
 
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const MOUSE_ON = '\x1b[?1000h\x1b[?1006h';
@@ -33,6 +34,7 @@ export class TerminalScreen {
   start() {
     if (this.started || this.closed) return this;
     this.started = true;
+    this.agentStatus ||= new AgentStatus({ output: this.output, env: this.env });
     this.originalRaw = this.input.isRaw || false;
     this.input.setRawMode?.(true); this.input.resume();
     this.decoder = new TerminalInput({ onKey: (text, key) => { Promise.resolve(this.handleKey(text, key)).catch(error => this.notice(error.message, true)); }, onMouse: event => this.handleMouse(event), onPaste: text => this.paste(text), onError: error => this.notice(error.message, true) });
@@ -67,20 +69,22 @@ export class TerminalScreen {
   clearSetup() { this.setup?.finish(null); }
   // keys: atajos de una letra → id de opción (p. ej. {e:'edit', r:'reject'}), sólo sin filtro.
   // hint: línea de ayuda propia. Una descripción larga (tarjetas de /relay) se desplaza con PgUp/PgDn.
-  setupChoice({ title, description = '', items, signal, searchable = false, selected, keys, hint } = {}) {
+  // waits: the choice was pushed to the human (a swarm card, a connection review) and Comal waits on the answer; it is
+  // reported as a question waiting. A picker the human opened (/model, /provider) is not.
+  setupChoice({ title, description = '', items, signal, searchable = false, selected, keys, hint, waits = false } = {}) {
     if (!Array.isArray(items) || !items.length || items.length > 1024 || items.some(item => typeof item?.id !== 'string' || !item.id || typeof item.label !== 'string') || new Set(items.map(item => item.id)).size !== items.length) throw new Error(t('Choose between 1 and 1024 distinct options.'));
     const shortcuts = !searchable && keys && typeof keys === 'object' ? Object.fromEntries(Object.entries(keys).filter(([key, id]) => /^[a-z]$/.test(key) && items.some(item => item.id === id))) : null;
-    return new Promise(resolve => this.beginSetup({ kind: 'choice', title: safeText(title || t('Choose a connection')), description: safeText(description), items: items.map(item => ({ id: item.id, label: safeText(item.label), description: safeText(item.description || ''), badge: safeText(item.badge || '') })), index: Math.max(0,items.findIndex(item=>item.id===selected)), searchable, query: '', keys: shortcuts, hint: hint ? safeText(hint) : null, scroll: 0 }, signal, resolve));
+    return new Promise(resolve => this.beginSetup({ kind: 'choice', waits: Boolean(waits), title: safeText(title || t('Choose a connection')), description: safeText(description), items: items.map(item => ({ id: item.id, label: safeText(item.label), description: safeText(item.description || ''), badge: safeText(item.badge || '') })), index: Math.max(0,items.findIndex(item=>item.id===selected)), searchable, query: '', keys: shortcuts, hint: hint ? safeText(hint) : null, scroll: 0 }, signal, resolve));
   }
   setupItems() {
     const state=this.setup;
     const terms=(state?.query || '').toLocaleLowerCase().split(/\s+/).filter(Boolean);
     return (state?.items || []).filter(item=>terms.every(term=>`${item.label} ${item.id} ${item.description}`.toLocaleLowerCase().includes(term)));
   }
-  setupInput({ title, description = '', value = '', secret = false, signal, validate } = {}) {
+  setupInput({ title, description = '', value = '', secret = false, signal, validate, waits = false } = {}) {
     const clean = safeText(value).replace(/[\r\n\t]+/g, ' ');
     if (Buffer.byteLength(clean) > 4096) throw new Error(t('Setup values support up to 4096 bytes.'));
-    return new Promise(resolve => this.beginSetup({ kind: 'input', title: safeText(title || t('Connection settings')), description: safeText(description), editor: new Composer(clean), secret: Boolean(secret), validate }, signal, resolve));
+    return new Promise(resolve => this.beginSetup({ kind: 'input', waits: Boolean(waits), title: safeText(title || t('Connection settings')), description: safeText(description), editor: new Composer(clean), secret: Boolean(secret), validate }, signal, resolve));
   }
   setupStatus({ title, description = '', signal } = {}) {
     this.beginSetup({ kind: 'status', title: safeText(title || t('Connecting')), description: safeText(description) }, signal);
@@ -193,6 +197,8 @@ export class TerminalScreen {
   }
 
   schedule() {
+    // The state goes out even while an editor owns the terminal (Ctrl+G) or a selection freezes the screen.
+    if (!this.closed && (this.suspended || this.selecting)) this.syncAgentStatus();
     if (this.closed || this.suspended || this.selecting || this.renderTimer) return;
     this.renderTimer = setTimeout(() => { this.renderTimer = null; this.render(); }, 24);
   }
@@ -710,6 +716,7 @@ export class TerminalScreen {
   }
   render(selectionEntry = false) {
     if (this.closed || this.suspended || (this.selecting && !selectionEntry)) return;
+    this.syncAgentStatus();
     const columns = Math.max(1, (this.output.columns || 80) - 1), rows = this.output.rows || 24;
     if (columns < 23 || rows < 10) { this.draw([clip(t("Enlarge the terminal to 24×10"), columns)], null, columns, rows); return; }
     if (this.setup && !this.permission) { this.renderSetup(columns, rows); return; }
@@ -803,9 +810,18 @@ export class TerminalScreen {
     this.suspended = true; clearTimeout(this.renderTimer); this.renderTimer = null;
     this.input.setRawMode?.(this.originalRaw); this.input.pause(); this.output.write(MOUSE_OFF + '\x1b[?2004l\x1b[?25h\x1b[?1049l');
   }
-  resume() { this.input.setRawMode?.(true); this.input.resume(); this.suspended = false; this.previous = []; this.output.write('\x1b[?1049h\x1b[?2004h' + MOUSE_ON); this.render(); }
+  resume() { this.input.setRawMode?.(true); this.input.resume(); this.suspended = false; this.previous = []; this.agentStatus?.forgetTitle(); this.output.write('\x1b[?1049h\x1b[?2004h' + MOUSE_ON); this.render(); }
+  // The terminal title and, inside herdr, the pane's agent state follow what the screen shows (working, a question
+  // waiting for the human, or idle). Best-effort: see agent-status.mjs.
+  syncAgentStatus() {
+    if (!this.agentStatus) return;
+    const state = agentState({ busy: this.busy, permission: this.permission, setup: this.setup });
+    const message = state !== 'blocked' ? '' : this.permission ? t('Permission: {v0}', { v0: this.permission.name }) : (this.setup?.title || t('Waiting for your answer'));
+    this.agentStatus.update({ state, label: statusLabel({ name: this.metadata.name, cwd: this.metadata.cwd }), message, sessionId: this.metadata.sessionId, titles: !this.suspended });
+  }
   close() {
     if (this.closed) return; this.closed = true;
+    this.agentStatus?.close();
     this.clearSetup();
     this.permission?.finish(false); clearInterval(this.timer); clearTimeout(this.renderTimer); this.decoder?.close();
     if (this.onData) this.input.off('data', this.onData); if (this.onResize) this.output.off('resize', this.onResize);