ai-agentmanager 1.1.0 → 1.3.0

package/src/landing.js

@@ -0,0 +1,212 @@
+// Landing: getting agents' pull requests merged. Failing checks and requested changes are sent
+// back to the agent that owns the PR (a few times per PR at most), a branch that fell behind is
+// brought up to date with the branch it targets, and ready PRs are merged with one click.
+import os from 'node:os';
+import * as git from './git.js';
+import { NO_REPO } from './manager.js';
+import { ghBin } from './tracker.js';
+import { parseBaseRef } from './review.js';
+
+export const MERGE_METHODS = ['squash', 'merge', 'rebase'];
+export const LANDING_DEFAULTS = { fixChecks: true, fixReviews: true, maxFixes: 3, mergeMethod: 'squash', deleteBranch: true };
+const LAND_ORDER = ['ready', 'fix', 'behind', 'waiting', 'draft'];
+
+const err = (status, message) => Object.assign(new Error(message), { status });
+
+/** Settings from config.json's "landing", with defaults and sane bounds. */
+export function landingSettings(config = {}) {
+  const c = { ...LANDING_DEFAULTS, ...config.landing };
+  const n = Number(c.maxFixes);
+  return {
+    fixChecks: c.fixChecks !== false,
+    fixReviews: c.fixReviews !== false,
+    maxFixes: Number.isFinite(n) && n >= 0 ? Math.min(20, Math.floor(n)) : LANDING_DEFAULTS.maxFixes,
+    mergeMethod: MERGE_METHODS.includes(c.mergeMethod) ? c.mergeMethod : LANDING_DEFAULTS.mergeMethod,
+    deleteBranch: c.deleteBranch !== false,
+  };
+}
+
+export function checksMessage(pr) {
+  const names = pr.checks?.failed?.length ? pr.checks.failed.join(', ') : 'some checks';
+  return [
+    `CI is failing on your pull request ${pr.url} (${names}).`,
+    `Look at the failures (\`gh pr checks ${pr.number ?? pr.url}\`, and \`gh run view <run id> --log-failed\` for the logs), fix the cause, run the relevant tests locally, then commit and push.`,
+    'If a failure is unrelated to your change (a flaky test or a broken main), say so instead of changing unrelated code.',
+  ].join('\n');
+}
+
+export function reviewMessage(pr) {
+  return [
+    `A reviewer requested changes on your pull request ${pr.url}.`,
+    `Read the review and its comments (\`gh pr view ${pr.number ?? pr.url} --comments\`, and \`gh api repos/{owner}/{repo}/pulls/${pr.number ?? '<number>'}/comments\` for line comments), address each one, then commit and push and reply on the PR with what you changed.`,
+  ].join('\n');
+}
+
+export function updateMessage(base) {
+  return `Your branch is behind ${base}. Merge ${base} into it (git fetch, then git merge ${base}), resolve any conflicts keeping both sides' intent, run the tests, then commit and push.`;
+}
+
+export class Landing {
+  constructor({ manager, store, config = {}, log = (m) => console.log(`[agentmgr] ${m}`) }) {
+    this.manager = manager;
+    this.store = store;
+    this.config = config;
+    this.log = log;
+    this.onPrs = (agent) => this.react(agent).catch((e) => this.log(`landing: ${e.message}`));
+    manager.on('prs', this.onPrs);
+    // Running agents' PRs are refreshed by the manager; closed agents with an open PR every few minutes.
+    this.timer = setInterval(() => this.refreshClosed().catch(() => {}), (config.landingRefreshMin ?? 6) * 60_000);
+    this.timer.unref?.();
+  }
+
+  close() {
+    clearInterval(this.timer);
+    this.manager.off('prs', this.onPrs);
+  }
+
+  get settings() {
+    return landingSettings(this.config);
+  }
+
+  update(patch = {}) {
+    if (patch.mergeMethod !== undefined && !MERGE_METHODS.includes(patch.mergeMethod)) throw err(400, `mergeMethod must be one of ${MERGE_METHODS.join(', ')}`);
+    if (patch.maxFixes !== undefined && !(Number(patch.maxFixes) >= 0)) throw err(400, 'maxFixes must be 0 or more');
+    const next = landingSettings({ landing: { ...this.config.landing, ...patch } });
+    this.config.landing = next;
+    return next;
+  }
+
+  /** Open PRs that the agent opened or that were found on its branch (not ones it only mentioned). */
+  openPrs(agent) {
+    return Object.values(agent.prs ?? {}).filter((p) => p.state === 'OPEN' && p.source !== 'mentioned');
+  }
+
+  /** After a PR refresh: send failing checks and requested changes back to the agent, once per commit. */
+  async react(agent) {
+    const s = this.settings;
+    if (!this.store.get(agent.id) || NO_REPO.has(agent.kind) || !s.maxFixes) return;
+    agent.landing ??= { sent: {} };
+    let sent = false;
+    for (const pr of this.openPrs(agent)) {
+      if (!pr.head) continue;
+      const count = Object.keys(agent.landing.sent).filter((k) => k.startsWith(`${pr.url}#`)).length;
+      if (count >= s.maxFixes) continue;
+      const send = (kind, text) => {
+        const key = `${pr.url}#${kind}@${pr.head}`;
+        if (agent.landing.sent[key]) return;
+        agent.landing.sent[key] = new Date().toISOString();
+        this.manager.tell(agent.id, text, { source: 'landing' });
+        this.log(`landing: told ${agent.name} about ${kind} on ${pr.url}`);
+        sent = true;
+      };
+      if (s.fixChecks && pr.checks?.state === 'failed') send('checks', checksMessage(pr));
+      else if (s.fixReviews && pr.review === 'CHANGES_REQUESTED') send('review', reviewMessage(pr));
+    }
+    if (sent) this.store.save();
+  }
+
+  async refreshClosed() {
+    for (const agent of this.store.list()) {
+      if (this.manager.runtimes.get(agent.id)?.pty || !agent.workdir || !this.openPrs(agent).length) continue;
+      await this.manager.refresh(agent.id, { withPrs: true }).catch(() => {});
+    }
+  }
+
+  /** Every agent's open pull request with where it stands, ready ones first. */
+  list() {
+    const rows = [];
+    for (const agent of this.store.list()) {
+      const view = this.manager.view(agent);
+      for (const pr of view.prs.filter((p) => p.state === 'OPEN' && p.source !== 'mentioned')) {
+        const fixes = Object.keys(agent.landing?.sent ?? {}).filter((k) => k.startsWith(`${pr.url}#`)).length;
+        rows.push({ agent: { id: agent.id, name: agent.name, priority: view.priority, busy: view.runtime.busy, running: view.runtime.running }, pr, land: pr.land ?? 'waiting', fixes });
+      }
+    }
+    const rank = (r) => (LAND_ORDER.includes(r.land) ? LAND_ORDER.indexOf(r.land) : LAND_ORDER.length);
+    return { settings: this.settings, rows: rows.sort((a, b) => rank(a) - rank(b) || a.agent.priority - b.agent.priority) };
+  }
+
+  agentPr(ref, url) {
+    const agent = this.manager.mustGet(ref);
+    const open = this.openPrs(agent);
+    const pr = url ? open.find((p) => p.url === url) : open[0];
+    if (!pr) throw err(404, url ? 'That pull request is not open on this agent' : 'This agent has no open pull request');
+    return { agent, pr };
+  }
+
+  /**
+   * Bring the branch up to date with the one it targets: merge it in here when the agent is idle
+   * and its worktree clean (and push), else ask the agent. A conflict is aborted and handed to the agent.
+   */
+  async updateBranch(ref, { via = 'auto' } = {}) {
+    const agent = this.manager.mustGet(ref);
+    if (!agent.workdir || NO_REPO.has(agent.kind)) throw err(400, 'This agent has no repository');
+    const dir = agent.workdir;
+    const opts = { cwd: dir, timeout: 120_000 };
+    const b = parseBaseRef(agent.baseRef);
+    const target = b?.ref && b.ref !== 'HEAD' ? b.ref : (await git.resolveBase(dir).catch(() => null))?.ref;
+    if (!target || target === 'HEAD') throw err(409, "Couldn't tell which branch this one should follow");
+    const ask = (why) => {
+      this.manager.tell(agent.id, updateMessage(target), { source: 'landing' });
+      return { asked: true, why, target };
+    };
+    if (via === 'agent') return ask('asked');
+    const rt = this.manager.runtimes.get(agent.id);
+    if (rt?.pty && rt.busy) return ask('the agent is working');
+    if ((await git.run('git', ['status', '--porcelain'], opts)).trim()) return ask('it has uncommitted changes');
+    if (target.startsWith('origin/')) await git.fetch(dir).catch(() => {});
+    const behind = Number(await git.run('git', ['rev-list', '--count', `HEAD..${target}`], opts).catch(() => '0')) || 0;
+    if (!behind) return { upToDate: true, target };
+    try {
+      await git.run('git', ['merge', '--no-edit', target], { ...opts, env: { GIT_MERGE_AUTOEDIT: 'no' } });
+    } catch (e) {
+      await git.run('git', ['merge', '--abort'], opts).catch(() => {});
+      return { ...ask('the merge has conflicts'), conflict: true };
+    }
+    let pushed = false;
+    const upstream = await git.run('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], opts).catch(() => '');
+    if (upstream) {
+      await git.run('git', ['push'], opts);
+      pushed = true;
+    }
+    this.manager.refresh(agent.id, { withPrs: true }).catch(() => {});
+    return { merged: behind, target, pushed };
+  }
+
+  /** Ask the agent to fix what stands in the way: failing checks, requested changes, conflicts. */
+  fix(ref, { url } = {}) {
+    const { agent, pr } = this.agentPr(ref, url);
+    const parts = [];
+    if (pr.checks?.state === 'failed') parts.push(checksMessage(pr));
+    if (pr.review === 'CHANGES_REQUESTED') parts.push(reviewMessage(pr));
+    if (pr.mergeable === 'CONFLICTING' || pr.mergeState === 'DIRTY' || pr.mergeState === 'BEHIND') {
+      const b = parseBaseRef(agent.baseRef);
+      parts.push(updateMessage(b?.ref && b.ref !== 'HEAD' ? b.ref : 'the base branch'));
+    }
+    if (!parts.length) throw err(409, 'Nothing to fix on this pull request right now');
+    this.manager.tell(agent.id, parts.join('\n\n'), { source: 'landing' });
+    return { sent: parts.length };
+  }
+
+  /** Merge the PR with gh (or turn on auto-merge so GitHub merges it once it may). */
+  async merge(ref, { url, method, auto = false } = {}) {
+    const { agent, pr } = this.agentPr(ref, url);
+    const s = this.settings;
+    method = method ?? s.mergeMethod;
+    if (!MERGE_METHODS.includes(method)) throw err(400, `method must be one of ${MERGE_METHODS.join(', ')}`);
+    this.manager.plugins.check('agent.merge', { agent: this.manager.auditView(agent), url: pr.url, method, auto: Boolean(auto) });
+    const args = ['pr', 'merge', pr.url, `--${method}`];
+    if (auto) args.push('--auto');
+    if (s.deleteBranch && !auto) args.push('--delete-branch');
+    try {
+      // Outside the worktree, so gh deletes only the remote branch and leaves the worktree alone.
+      await git.run(ghBin(), args, { cwd: os.tmpdir(), timeout: 120_000 });
+    } catch (e) {
+      throw err(502, e.message.replace(/^\S+ pr merge .*? failed: /, ''));
+    }
+    this.manager.plugins.emit('agent.merge', { agent: this.manager.auditView(agent), url: pr.url, method, auto: Boolean(auto) });
+    this.log(`landing: ${auto ? 'auto-merge on for' : 'merged'} ${pr.url}`);
+    await this.manager.refresh(agent.id, { withPrs: true }).catch(() => {});
+    return { url: pr.url, merged: !auto, auto: Boolean(auto) };
+  }
+}

package/src/manager.js

@@ -46,10 +46,13 @@ import { Judge, clashPrompt, finishMessage, hash, reviewPrompt, screenPrompt, st
 import { findLocalUrls, findSignInLinks, parseCallback, parseUrl } from './preview.js';
 import { Plugins } from './plugins.js';
 import { leadPrompt, subagents, teamDir, teamPrompt } from './teams.js';
+import { assistantDir, assistantPrompt, assistantSettings } from './assistant.js';
+import { learnCommand, memoryKey, memoryPrompt, memoryText } from './memory.js';
 import { runningClaude, scanClaudeSessions } from './sessions.js';
 import {
   bugFromRef,
   extractRefs,
+  landState,
   leadingJiraKey,
   prDetails,
   prFromUrl,
@@ -119,9 +122,15 @@ export function repoCacheDir(repo) {
   return path.join(paths.repos, `${git.repoNameFromUrl(repo)}-${hash}`);
 }
 
+/** Sessions with no repo or folder of their own. */
+export const NO_REPO = new Set(['general', 'assistant']);
+
 export function projectOf(agent) {
+  // Moved under another known project by hand.
+  if (agent.projectMove?.key) return { key: agent.projectMove.key, name: agent.projectMove.name, ...(agent.projectMove.full ? { full: agent.projectMove.full } : {}), source: 'moved' };
   if (agent.project) return { key: `custom:${agent.project.toLowerCase()}`, name: agent.project, source: 'custom' };
   if (agent.kind === 'general') return { key: 'general', name: 'General', source: 'general' };
+  if (agent.kind === 'assistant') return { key: 'assistant', name: 'Assistant', source: 'assistant' };
   const url = agent.repo || agent.git?.remote;
   if (url && /[:/]/.test(url)) {
     const path = url
@@ -197,7 +206,7 @@ export class AgentManager extends EventEmitter {
     this.shells = new Map(); // agent id -> ancillary shell runtime in the agent's folder
     this.cursors = new Map(); // session id -> transcript scan cursor
     this.locks = new Map();
-    this.refreshing = new Set();
+    this.refreshing = new Map(); // agent id -> the refresh in progress
     this.lastPrCheck = new Map();
     this.changeSets = new Map(); // agent id -> { files, baseSha, at }: what its branch changed (conflict radar)
     this.conflicts = new Map(); // agent id -> [conflict]
@@ -276,7 +285,7 @@ export class AgentManager extends EventEmitter {
       usage,
       // Claude Code's own cost figure from the transcripts (absent until it records one).
       costUsd: costs.length ? costs.reduce((a, b) => a + b, 0) : null,
-      prs: Object.values(agent.prs ?? {}),
+      prs: Object.values(agent.prs ?? {}).map((p) => ({ ...p, land: landState(p) })),
       bugs: Object.values(agent.bugs ?? {}),
       conflicts: this.conflictGroups(agent),
       stuck: this.activeStuck(agent),
@@ -363,7 +372,9 @@ export class AgentManager extends EventEmitter {
 
   /** Make sure the agent's project has a shortcut; remember where it lives for "add @cc". */
   registerProject(agent) {
-    if (!agent || agent.kind === 'general') return null;
+    if (!agent || NO_REPO.has(agent.kind)) return null;
+    // A moved agent's repo says nothing about the project it was moved to.
+    if (agent.projectMove) return null;
     const info = projectOf(agent);
     if (info.key === 'other') return null;
     const reg = this.store.data.projects;
@@ -512,6 +523,8 @@ export class AgentManager extends EventEmitter {
     engine,
     sessionId: adopt,
     imported,
+    startedBy,
+    trigger,
   }) {
     intent = (intent ?? '').trim();
     const engineDef = engineOf(engine || this.config.engine || DEFAULT_ENGINE);
@@ -524,7 +537,7 @@ export class AgentManager extends EventEmitter {
     }
     // Planning while cloning moves the session between folders, which needs the engine's support.
     if (!engineDef.supports.planHandoff) plan = false;
-    const general = kind === 'general';
+    const general = NO_REPO.has(kind);
     // A project shortcut (or name) fills in the repo / folder / base branch.
     const entry = !general && project ? this.resolveProject(project) : null;
     if (entry) {
@@ -548,10 +561,12 @@ export class AgentManager extends EventEmitter {
 
     const agent = {
       id,
-      kind: general ? 'general' : 'task',
+      kind: general ? kind : 'task',
       engine: engineId,
       project: project?.trim() || null,
       priority: parsePriority(priority),
+      ...(startedBy ? { startedBy } : {}),
+      ...(trigger ? { trigger } : {}),
       name: name?.trim() || jiraKey || slug,
       slug,
       intent,
@@ -687,6 +702,10 @@ export class AgentManager extends EventEmitter {
       fs.mkdirSync(paths.general, { recursive: true });
       return { workdir: paths.general };
     }
+    if (agent.kind === 'assistant') {
+      fs.mkdirSync(assistantDir(), { recursive: true });
+      return { workdir: assistantDir() };
+    }
     let repo = agent.repo;
     let dir = agent.requestedDir ? path.resolve(expandHome(agent.requestedDir)) : null;
     const branch = `agent/${slug}-${id}`;
@@ -858,7 +877,7 @@ export class AgentManager extends EventEmitter {
     let writableDir = null;
     let agents = null;
     const prompts = [];
-    const task = agent.kind !== 'general';
+    const task = !NO_REPO.has(agent.kind);
     const withBrief = Boolean(this.config.brief && task);
     if (this.config.reviewConventions && task) prompts.push(conventionsPrompt({ withBrief, rulesFiles: engine.rulesFiles ?? null }));
     if (withBrief) {
@@ -876,6 +895,18 @@ export class AgentManager extends EventEmitter {
       prompts.push(agent.planReview.status === 'approved' ? planApprovedPrompt(file) : planReviewPrompt(file));
     }
     if (planning) prompts.push(planningPrompt(agent));
+    // What earlier agents learned in this repo, and the one command to add to it.
+    let allowedTools = null;
+    if (task && this.config.memory !== false) {
+      prompts.push(memoryPrompt(memoryText(memoryKey(agent))));
+      allowedTools = [`Bash(${learnCommand()}:*)`];
+    }
+    if (agent.kind === 'assistant') {
+      fs.mkdirSync(assistantDir(), { recursive: true });
+      const dir = fs.realpathSync(assistantDir());
+      writableDir = dir;
+      prompts.push(assistantPrompt(assistantSettings(this.config), dir));
+    }
     if (agent.team) {
       // Team members write their handoff files in the team's folder.
       fs.mkdirSync(teamDir(agent.team.id), { recursive: true });
@@ -890,7 +921,7 @@ export class AgentManager extends EventEmitter {
       }
     }
     // Appended system prompts last only for the process they're passed to, so they go on every launch.
-    return { extra: engine.extraArgs(this.config), permissionMode: agent.permissionMode, model: agent.model, writableDir, instructions: prompts.join('\n\n') || null, agents };
+    return { extra: engine.extraArgs(this.config), permissionMode: agent.permissionMode, model: agent.model, writableDir, instructions: prompts.join('\n\n') || null, agents, allowedTools };
   }
 
   /** Spawn the agent's engine in a PTY, reusing its terminal clients and scrollback. */
@@ -1190,16 +1221,62 @@ export class AgentManager extends EventEmitter {
 
   update(ref, fields) {
     const agent = this.mustGet(ref);
+    const bad = (m) => Object.assign(new Error(m), { status: 400 });
     const allowed = {};
-    for (const key of ['name', 'notes', 'permissionMode', 'model', 'project']) if (key in fields) allowed[key] = fields[key];
+    for (const key of ['notes']) if (key in fields) allowed[key] = fields[key];
+    if ('name' in fields) {
+      const name = String(fields.name ?? '').trim();
+      if (!name) throw bad('Name is required');
+      allowed.name = name.slice(0, 80);
+    }
+    // The request as recorded; the session only hears about a change when told.
+    if ('intent' in fields) {
+      const intent = String(fields.intent ?? '').trim();
+      if (!intent && !NO_REPO.has(agent.kind)) throw bad('The request is required');
+      allowed.intent = intent;
+    }
+    // Permission mode and model apply from the next launch.
+    if ('permissionMode' in fields) {
+      const mode = fields.permissionMode || null;
+      const modes = engineOf(agent).permissionModes;
+      if (mode && !modes.includes(mode)) throw bad(`${engineOf(agent).label} has no "${mode}" mode (use ${modes.join(', ')})`);
+      allowed.permissionMode = mode;
+    }
+    if ('model' in fields) allowed.model = String(fields.model ?? '').trim() || null;
     // Keep: clean up never closes or deletes it.
     if ('keep' in fields) allowed.keep = Boolean(fields.keep);
+    if ('budgetUsd' in fields) {
+      // Its own spending limit in US dollars; empty for the default (budgets.perAgentUsd).
+      const raw = fields.budgetUsd;
+      const b = raw === null || raw === '' ? null : Number(raw);
+      if (b !== null && !(Number.isFinite(b) && b > 0)) throw Object.assign(new Error('budgetUsd must be a positive number of dollars, or empty'), { status: 400 });
+      allowed.budgetUsd = b === null ? null : Math.round(b * 100) / 100;
+      allowed.budgetHit = null;
+    }
     if ('priority' in fields) {
       const p = parsePriority(fields.priority, null);
       if (p === null) throw Object.assign(new Error('priority must be P0, P1, P2 or P3'), { status: 400 });
       allowed.priority = p;
     }
-    if ('project' in allowed) allowed.project = String(allowed.project ?? '').trim() || null;
+    // Move: under a known project (shortcut or name), under a new project name, or back to its own ("").
+    if ('project' in fields) {
+      if (NO_REPO.has(agent.kind)) throw bad(`A ${agent.kind} session has no project`);
+      const ref = String(fields.project ?? '').trim();
+      const entry = ref ? this.resolveProject(ref) : null;
+      if (!ref) Object.assign(allowed, { project: null, projectMove: null });
+      else if (entry && entry.key !== projectOf({ ...agent, project: null, projectMove: null }).key) {
+        // Its full name (org/repo), as the project's own agents show it.
+        const info = this.store.list().map((a) => (a.projectMove ? null : projectOf(a))).find((i) => i?.key === entry.key);
+        Object.assign(allowed, { project: null, projectMove: { key: entry.key, name: entry.name, ...(info?.full ? { full: info.full } : {}), at: now() } });
+      } else if (entry) Object.assign(allowed, { project: null, projectMove: null });
+      else Object.assign(allowed, { project: ref.slice(0, 60), projectMove: null });
+    }
+    if ('intent' in allowed) {
+      const refs = extractRefs(allowed.intent, this.config.bugPatterns);
+      const bugs = { ...(agent.bugs ?? {}) };
+      for (const b of refs.bugs) bugs[b.key] ??= { ...b, source: 'intent' };
+      allowed.bugs = bugs;
+    }
     return this.view(this.patch(agent.id, allowed));
   }
 
@@ -1912,80 +1989,93 @@ export class AgentManager extends EventEmitter {
 
   async refresh(ref, { withPrs = false } = {}) {
     const id = this.mustGet(ref).id;
-    if (this.refreshing.has(id)) return this.view(this.store.get(id));
-    this.refreshing.add(id);
+    const running = this.refreshing.get(id);
+    if (running) {
+      // A pull request check asked for during a plain refresh runs right after it.
+      if (!withPrs || running.withPrs) return running.promise.then(() => this.store.get(id) && this.view(this.store.get(id)));
+      await running.promise.catch(() => {});
+      return this.refresh(id, { withPrs });
+    }
+    const promise = this.doRefresh(id, { withPrs });
+    this.refreshing.set(id, { promise, withPrs });
     try {
-      this.reloadBrief(id);
-      const agent = this.store.get(id);
-      // Before handoff, a planning session's transcript lives in the planning folder.
-      const planningOnly = agent?.planning && !agent.planning.handedOffAt && !agent.workdir;
-      const sessionDir = planningOnly ? agent.planning.dir : agent?.workdir;
-      if (!sessionDir) return agent && this.view(agent);
-      let changed = agent.workdir ? this.adoptSessions(agent) : false;
-
-      const info = agent.workdir ? await git.gitInfo(agent.workdir) : agent.git;
-      if (!this.store.get(id)) return null;
-      if (info !== undefined && JSON.stringify({ ...info, updatedAt: 0 }) !== JSON.stringify({ ...agent.git, updatedAt: 0 })) {
-        agent.git = info;
+      return await promise;
+    } finally {
+      this.refreshing.delete(id);
+    }
+  }
+
+  async doRefresh(id, { withPrs }) {
+    this.reloadBrief(id);
+    const agent = this.store.get(id);
+    // Before handoff, a planning session's transcript lives in the planning folder.
+    const planningOnly = agent?.planning && !agent.planning.handedOffAt && !agent.workdir;
+    const sessionDir = planningOnly ? agent.planning.dir : agent?.workdir;
+    if (!sessionDir) return agent && this.view(agent);
+    let changed = agent.workdir ? this.adoptSessions(agent) : false;
+
+    const info = agent.workdir ? await git.gitInfo(agent.workdir) : agent.git;
+    if (!this.store.get(id)) return null;
+    if (info !== undefined && JSON.stringify({ ...info, updatedAt: 0 }) !== JSON.stringify({ ...agent.git, updatedAt: 0 })) {
+      agent.git = info;
+      changed = true;
+    }
+
+    const engine = engineOf(agent);
+    for (const session of agent.sessions) {
+      const file = engine.sessionFile(sessionDir, session.id);
+      const key = `${session.id}:${file}`; // the transcript moves at handoff; rescan the new copy
+      const cursor = this.cursors.get(key) ?? { offset: 0 };
+      this.cursors.set(key, cursor);
+      const res = engine.scan(file, cursor, this.config.bugPatterns);
+      const subMaps = engine.subagentFiles(sessionDir, session.id).map((sub) => {
+        const c = this.cursors.get(sub) ?? { offset: 0 };
+        this.cursors.set(sub, c);
+        engine.scan(sub, c);
+        return c.usage;
+      });
+      const usage = sumUsage(cursor.usage, ...subMaps);
+      if (usage.requests && JSON.stringify(session.usage) !== JSON.stringify(usage)) {
+        session.usage = usage;
         changed = true;
       }
-
-      const engine = engineOf(agent);
-      for (const session of agent.sessions) {
-        const file = engine.sessionFile(sessionDir, session.id);
-        const key = `${session.id}:${file}`; // the transcript moves at handoff; rescan the new copy
-        const cursor = this.cursors.get(key) ?? { offset: 0 };
-        this.cursors.set(key, cursor);
-        const res = engine.scan(file, cursor, this.config.bugPatterns);
-        const subMaps = engine.subagentFiles(sessionDir, session.id).map((sub) => {
-          const c = this.cursors.get(sub) ?? { offset: 0 };
-          this.cursors.set(sub, c);
-          engine.scan(sub, c);
-          return c.usage;
-        });
-        const usage = sumUsage(cursor.usage, ...subMaps);
-        if (usage.requests && JSON.stringify(session.usage) !== JSON.stringify(usage)) {
-          session.usage = usage;
+      for (const key of ['title', 'lastPrompt', 'cost', 'lastActivity', 'lastMessageAt']) {
+        if (res[key] != null && JSON.stringify(session[key]) !== JSON.stringify(res[key])) {
+          session[key] = res[key];
           changed = true;
         }
-        for (const key of ['title', 'lastPrompt', 'cost', 'lastActivity', 'lastMessageAt']) {
-          if (res[key] != null && JSON.stringify(session[key]) !== JSON.stringify(res[key])) {
-            session[key] = res[key];
-            changed = true;
-          }
-        }
-        const prs = res.prs.map((p) => ({ ...p, sessionId: session.id }));
-        changed = this.mergeLinks(agent, agent.prs, prs, (p) => p.url) || changed;
-        changed = this.mergeLinks(agent, agent.bugs, res.bugs, (b) => b.key) || changed;
       }
-
-      if (withPrs) {
-        this.lastPrCheck.set(id, Date.now());
-        // A shared worktree's pull requests belong to the agent that owns it.
-        const branchPrs = agent.sharedWith ? [] : await prsForBranch(agent.workdir, info?.branch);
-        changed = this.mergeLinks(agent, agent.prs, branchPrs, (p) => p.url) || changed;
-        // Fill in title/state for PRs we only know by URL, and keep open ones current.
-        const stale = Object.values(agent.prs).filter(
-          (p) => p.source !== 'branch' && (!p.state || p.state === 'OPEN'),
-        );
-        for (const pr of stale.slice(0, 10)) {
-          const d = await prDetails(pr.url);
-          if (d) changed = this.mergeLinks(agent, agent.prs, [{ ...d, source: pr.source }], (p) => p.url) || changed;
-        }
+      const prs = res.prs.map((p) => ({ ...p, sessionId: session.id }));
+      changed = this.mergeLinks(agent, agent.prs, prs, (p) => p.url) || changed;
+      changed = this.mergeLinks(agent, agent.bugs, res.bugs, (b) => b.key) || changed;
+    }
+
+    if (withPrs) {
+      this.lastPrCheck.set(id, Date.now());
+      // A shared worktree's pull requests belong to the agent that owns it.
+      const branchPrs = agent.sharedWith ? [] : await prsForBranch(agent.workdir, info?.branch);
+      changed = this.mergeLinks(agent, agent.prs, branchPrs, (p) => p.url) || changed;
+      // Fill in title/state for PRs we only know by URL, and keep open ones current.
+      const stale = Object.values(agent.prs).filter(
+        (p) => p.source !== 'branch' && (!p.state || p.state === 'OPEN'),
+      );
+      for (const pr of stale.slice(0, 10)) {
+        const d = await prDetails(pr.url);
+        if (d) changed = this.mergeLinks(agent, agent.prs, [{ ...d, source: pr.source }], (p) => p.url) || changed;
       }
+      // Landing reacts to failing checks and requested changes.
+      this.emit('prs', agent);
+    }
 
-      await this.updateChanges(agent);
-      this.updateStuck(agent, sessionDir);
+    await this.updateChanges(agent);
+    this.updateStuck(agent, sessionDir);
 
-      if (changed && this.store.get(id)) {
-        agent.updatedAt = now();
-        this.store.save();
-        this.changed(agent);
-      }
-      return this.view(agent);
-    } finally {
-      this.refreshing.delete(id);
+    if (changed && this.store.get(id)) {
+      agent.updatedAt = now();
+      this.store.save();
+      this.changed(agent);
     }
+    return this.view(agent);
   }
 
   // ------------------------------------------------------ telling an agent
@@ -2049,7 +2139,7 @@ export class AgentManager extends EventEmitter {
   /** Recompute what an agent's branch changed since it branched (needs a base commit). */
   async updateChanges(agent) {
     const baseSha = agent.baseRef?.split(' @ ')[1];
-    if (!agent.workdir || !baseSha || agent.kind === 'general' || !fs.existsSync(agent.workdir)) return;
+    if (!agent.workdir || !baseSha || NO_REPO.has(agent.kind) || !fs.existsSync(agent.workdir)) return;
     // A full diff against the base is heavier than git status; once a minute is enough for overlaps.
     const prev0 = this.changeSets.get(agent.id);
     if (prev0 && Date.now() - Date.parse(prev0.at) < (this.config.conflictRefreshSec ?? 60) * 1000) return;
@@ -2087,7 +2177,7 @@ export class AgentManager extends EventEmitter {
     const byRepo = new Map();
     for (const e of entries) {
       const k = repoKey(e.agent);
-      if (k && e.agent.kind !== 'general') (byRepo.get(k) ?? byRepo.set(k, []).get(k)).push(e);
+      if (k && !NO_REPO.has(e.agent.kind)) (byRepo.get(k) ?? byRepo.set(k, []).get(k)).push(e);
     }
     for (const group of byRepo.values()) {
       for (let i = 0; i < group.length; i++) {
@@ -2323,7 +2413,7 @@ export class AgentManager extends EventEmitter {
     const a = this.store.get(id);
     if (!a) return;
     this.changed(a);
-    if (sure && data.state === 'done' && a.kind !== 'general') this.requestReview(id, { trigger: 'screen' }).catch(() => {});
+    if (sure && data.state === 'done' && !NO_REPO.has(a.kind)) this.requestReview(id, { trigger: 'screen' }).catch(() => {});
   }
 
   /** The person says the agent is not actually waiting on them. */
@@ -2404,7 +2494,7 @@ export class AgentManager extends EventEmitter {
   // ------------------------------------------------------- decision inbox
 
   questionsView(agent) {
-    if (agent.kind === 'general') return [];
+    if (NO_REPO.has(agent.kind)) return [];
     const answers = agent.answers ?? {};
     return loadQuestions(agent.id).map((q) => ({ ...q, answer: answers[q.id] ?? null }));
   }
@@ -2464,7 +2554,7 @@ export class AgentManager extends EventEmitter {
    */
   async checkpoint(id) {
     const agent = this.store.get(id);
-    if (!agent?.workdir || agent.kind === 'general' || !agent.branch || this.checkpointing?.has(id)) return null;
+    if (!agent?.workdir || NO_REPO.has(agent.kind) || !agent.branch || this.checkpointing?.has(id)) return null;
     // Output pauses mid-turn too (a slow command); one snapshot per half minute is plenty.
     this.lastCheckpointTry ??= new Map();
     if (Date.now() - (this.lastCheckpointTry.get(id) ?? 0) < 30_000) return null;