ai-agentmanager 1.0.0 → 1.0.2

package/src/doctor.js

@@ -0,0 +1,113 @@
+// `agentmgr doctor`: checks what AI Agent Manager needs on this machine and says how to fix
+// what's missing. Each check is { name, status: 'ok' | 'warn' | 'fail' | 'info', detail, fix }.
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { HOST, PORT, loadConfig, paths } from './config.js';
+import { api, BASE, isRunning } from './client.js';
+import { ENGINES, installed, notInstalled } from './engines/index.js';
+import { findBrowser } from './livebrowser.js';
+
+const run = (bin, args, timeout = 8000) =>
+  new Promise((resolve) => {
+    execFile(bin, args, { timeout }, (err, stdout, stderr) => resolve({ ok: !err, out: `${stdout}${stderr}`.trim(), err }));
+  });
+
+const firstLine = (s) => s.split('\n')[0].trim();
+
+function portFree(port) {
+  return new Promise((resolve) => {
+    const srv = net.createServer();
+    srv.once('error', () => resolve(false));
+    srv.listen(port, HOST, () => srv.close(() => resolve(true)));
+  });
+}
+
+/** Whether Claude Code has credentials, without reading them: an API key, or a signed-in account. */
+function claudeSignedIn() {
+  if (process.env.ANTHROPIC_API_KEY) return 'an API key (ANTHROPIC_API_KEY)';
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.claude.json'), 'utf8'));
+    if (cfg.oauthAccount) return 'a Claude account';
+  } catch {}
+  return null;
+}
+
+async function ptyWorks() {
+  try {
+    const pty = (await import('node-pty')).default;
+    return await new Promise((resolve) => {
+      const p = pty.spawn(process.platform === 'win32' ? 'cmd.exe' : '/bin/sh', process.platform === 'win32' ? ['/c', 'exit 0'] : ['-c', 'exit 0'], {});
+      const t = setTimeout(() => resolve('started but did not finish'), 5000);
+      p.onExit(() => {
+        clearTimeout(t);
+        resolve(null);
+      });
+    });
+  } catch (err) {
+    return err.message;
+  }
+}
+
+export async function doctor() {
+  const config = loadConfig();
+  const checks = [];
+  const add = (name, status, detail, fix) => checks.push({ name, status, detail, ...(fix ? { fix } : {}) });
+
+  const major = Number(process.versions.node.split('.')[0]);
+  add('Node.js', major >= 20 ? 'ok' : 'fail', `${process.versions.node}`, major >= 20 ? null : 'Install Node.js 20 or newer (https://nodejs.org)');
+
+  const ptyErr = await ptyWorks();
+  add('Terminals (node-pty)', ptyErr ? 'fail' : 'ok', ptyErr ? `can't start a terminal: ${ptyErr}` : 'can start terminals',
+    ptyErr ? 'Reinstall: npm install -g ai-agentmanager (or npm rebuild node-pty in a git checkout)' : null);
+
+  // The daemon's view wins: a login service may have a different PATH than this shell.
+  const running = await isRunning();
+  const daemonEngines = running ? await api('GET', '/engines').catch(() => null) : null;
+  for (const engine of Object.values(ENGINES)) {
+    const has = daemonEngines ? daemonEngines.find((e) => e.id === engine.id)?.installed : installed(engine, config);
+    const main = engine.id === (config.engine ?? 'claude');
+    if (!has) {
+      add(engine.label, main ? 'fail' : 'info', main ? 'not found' : 'not installed (optional)', main ? notInstalled(engine, config) : null);
+      continue;
+    }
+    const v = await run(engine.bin(config), ['--version']);
+    add(engine.label, 'ok', v.ok ? firstLine(v.out) : 'installed');
+  }
+
+  const signedIn = claudeSignedIn();
+  add('Claude sign-in', signedIn ? 'ok' : 'warn', signedIn ? `uses ${signedIn}` : "couldn't tell whether Claude Code is signed in",
+    signedIn ? null : 'Run `claude` in a terminal once and sign in');
+
+  const git = await run('git', ['--version']);
+  add('git', git.ok ? 'ok' : 'fail', git.ok ? firstLine(git.out) : 'not found', git.ok ? null : 'Install git (agents work in git worktrees)');
+
+  const gh = await run('gh', ['auth', 'status']);
+  if (gh.err?.code === 'ENOENT') add('GitHub CLI (gh)', 'warn', 'not installed: PRs and checks are not tracked', 'Install it (https://cli.github.com) and run `gh auth login`');
+  else add('GitHub CLI (gh)', gh.ok ? 'ok' : 'warn', gh.ok ? 'signed in' : 'not signed in: PRs and checks are not tracked', gh.ok ? null : 'Run `gh auth login`');
+
+  try {
+    fs.mkdirSync(paths.home, { recursive: true });
+    fs.accessSync(paths.home, fs.constants.W_OK);
+    add('Data folder', 'ok', paths.home);
+  } catch (err) {
+    add('Data folder', 'fail', `${paths.home}: ${err.message}`, 'Make it writable, or point AGENTMGR_HOME at another folder');
+  }
+
+  if (running) {
+    const a = await api('GET', '/about').catch(() => null);
+    add('Daemon', 'ok', `running at ${BASE}${a ? ` (version ${a.version}, pid ${a.daemon.pid})` : ''}`);
+  } else if (await portFree(PORT)) {
+    add('Daemon', 'info', `not running; port ${PORT} is free`, 'Start it with `agentmgr ui`');
+  } else {
+    add('Daemon', 'fail', `port ${PORT} is used by another program`, 'Stop that program, or set AGENTMGR_PORT to another port');
+  }
+
+  const chrome = findBrowser(config);
+  add('Chrome (live browser tabs)', chrome ? 'ok' : 'warn', chrome ?? 'not found: live browser tabs are unavailable (Lite mode still works)',
+    chrome ? null : 'Install Chrome, Chromium, Brave or Edge, or set "browserBin" in config.json');
+
+  return checks;
+}

package/src/engines/antigravity.js

@@ -14,7 +14,7 @@ import path from 'node:path';
 import { norm, tailOf } from '../stuck.js';
 import { extractRefs } from '../tracker.js';
 
-// ANTIGRAVITY_CLI_HOME is Agent Manager's own override (tests); agy itself always uses this folder.
+// ANTIGRAVITY_CLI_HOME is AI Agent Manager's own override (tests); agy itself always uses this folder.
 const home = () => process.env.ANTIGRAVITY_CLI_HOME || path.join(os.homedir(), '.gemini', 'antigravity-cli');
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 const transcript = (id) => path.join(home(), 'brain', id, '.system_generated', 'logs', 'transcript_full.jsonl');

package/src/engines/claude.js

@@ -84,6 +84,20 @@ export default {
   ],
   promptChoices: (screen) => promptChoices(screen),
 
+  /** Lines of Claude Code's own frame (input box, mode and status bar): never a question to the person. */
+  screenChrome: [
+    /\b(accept edits|bypass permissions|plan mode|auto mode|auto-accept edits) on\b/i,
+    /shift\+tab to cycle/i,
+    /\? for shortcuts/i,
+    /esc to interrupt/i,
+    /ctrl\+[a-z] to (expand|edit|show|hide)/i,
+    /update available/i,
+    /^[─━═-]{3,}/,
+    /^\/\w+$/,
+    /^[❯>]\s*$/,
+  ],
+  install: 'Install Claude Code (https://docs.claude.com/en/docs/claude-code) and run `claude` once to sign in',
+
   trust: (dir) => trustFolder(dir),
 
   /** A one-shot, tool-less call; the prompt goes on stdin and the answer comes back as text. */

package/src/engines/codex.js

@@ -155,7 +155,7 @@ export default {
 
   /** Full arguments for a launch. Codex takes options after `resume`, and instructions only as text. */
   launchArgs({ extra = [], permissionMode, model, writableDir, instructions, sessionId, resume, prompt }) {
-    // Inline mode keeps the conversation in the terminal's scrollback, which Agent Manager replays.
+    // Inline mode keeps the conversation in the terminal's scrollback, which AI Agent Manager replays.
     const opts = [...extra, '--no-alt-screen', ...(MODES[permissionMode] ?? MODES.default)];
     if (model) opts.push('--model', model);
     if (writableDir) opts.push('--add-dir', writableDir);

package/src/engines/index.js

@@ -1,4 +1,4 @@
-// The agent engines Agent Manager can run. Each agent records its engine; agents from
+// The agent engines AI Agent Manager can run. Each agent records its engine; agents from
 // before engines existed are Claude Code agents.
 import fs from 'node:fs';
 import path from 'node:path';
@@ -23,6 +23,14 @@ export function installed(engine, config) {
   return (process.env.PATH ?? '').split(path.delimiter).some((d) => d && fs.existsSync(path.join(d, bin)));
 }
 
+/** What to tell the person when an engine's command isn't on this machine. */
+export function notInstalled(engine, config) {
+  const bin = engine.bin(config);
+  const how = engine.install ?? `Install ${engine.label}`;
+  const where = path.isAbsolute(bin) ? `${bin} doesn't exist` : `\`${bin}\` isn't on the daemon's PATH`;
+  return `${engine.label} not found: ${where}. ${how}, then run \`agentmgr restart\`. If it's installed somewhere else, set its path in config.json${engine.id === 'claude' ? ' ("claudeBin") or AGENTMGR_CLAUDE_BIN' : ` ("engines": {"${engine.id}": {"bin": "…"}})`}.`;
+}
+
 /** Every engine, with whether it can run here, for pickers and the hub. */
 export function listEngines(config) {
   return Object.values(ENGINES).map((e) => ({ id: e.id, label: e.label, installed: installed(e, config), permissionModes: e.permissionModes, supports: e.supports }));

package/src/git.js

@@ -278,9 +278,9 @@ export async function changes(dir, baseSha) {
 }
 
 const SNAPSHOT_ENV = {
-  GIT_AUTHOR_NAME: 'Agent Manager',
+  GIT_AUTHOR_NAME: 'AI Agent Manager',
   GIT_AUTHOR_EMAIL: 'agentmgr@localhost',
-  GIT_COMMITTER_NAME: 'Agent Manager',
+  GIT_COMMITTER_NAME: 'AI Agent Manager',
   GIT_COMMITTER_EMAIL: 'agentmgr@localhost',
 };
 

package/src/inbox.js

@@ -12,7 +12,7 @@ export const questionsPath = (agentId) => path.join(briefDir(agentId), QUESTIONS
 export const questionsPrompt = (file) =>
   `When you need a decision from the user that doesn't have to stop all your work (a choice between options, ` +
   `a preference, a missing detail), don't wait in the terminal: add it to ${file} and keep going on whatever you can ` +
-  'do meanwhile, using your best default. Agent Manager collects these into the user\'s inbox. One question per heading, ' +
+  'do meanwhile, using your best default. AI Agent Manager collects these into the user\'s inbox. One question per heading, ' +
   'never edit or remove earlier ones:\n' +
   '## <the question, one line>\n' +
   'Options: <option A> | <option B>   (optional)\n' +

package/src/judge.js

@@ -78,6 +78,16 @@ export function stuckPrompt(ctx, finding, events, past = []) {
   ].join('\n');
 }
 
+/** The screen without the engine's own frame (input box, mode indicators, status bar). */
+export function stripChrome(screen, patterns = []) {
+  if (!patterns.length) return screen;
+  return screen
+    .split('\n')
+    .filter((line) => !patterns.some((re) => re.test(line.trim())))
+    .join('\n')
+    .trim();
+}
+
 export function screenPrompt(ctx, screen, past = []) {
   return [
     'You supervise an AI coding agent running in a terminal. It has stopped producing output.',
@@ -87,6 +97,8 @@ export function screenPrompt(ctx, screen, past = []) {
     '- "error": it crashed, hit an error it cannot recover from, or a limit (rate limit, auth, quota)',
     '- "idle": finished a step and is simply waiting for the next instruction, nothing specific to answer',
     'For "question", copy the question in plain words and list the choices it offered, if any.',
+    'The tool\'s own input box, mode indicators and status bar (for example "accept edits on", "plan mode on",',
+    '"shift+tab to cycle", "? for shortcuts", "update available") are not questions: only the agent\'s own words count.',
     RULES,
     'Shape: {"state": "question|done|error|idle", "confidence": 0.0, "summary": "one line for an inbox", "question": "or empty", "choices": ["..."]}',
     '',

package/src/manager.js

@@ -4,7 +4,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import pty from 'node-pty';
 import { expandHome, paths } from './config.js';
-import { DEFAULT_ENGINE, ENGINES, engineOf, installed } from './engines/index.js';
+import { DEFAULT_ENGINE, ENGINES, engineOf, installed, notInstalled } from './engines/index.js';
 import {
   DOC_KINDS,
   briefDir,
@@ -42,7 +42,7 @@ import * as git from './git.js';
 import { conflictMessage, findConflicts, related, repoKey, summarize as summarizeConflicts } from './conflicts.js';
 import { answerMessage, loadQuestions, questionsPath, questionsPrompt } from './inbox.js';
 import { STUCK_DEFAULTS, detectStuck } from './stuck.js';
-import { Judge, clashPrompt, finishMessage, hash, reviewPrompt, screenPrompt, stuckPrompt } from './judge.js';
+import { Judge, clashPrompt, finishMessage, hash, reviewPrompt, screenPrompt, stripChrome, stuckPrompt } from './judge.js';
 import { findLocalUrls, findSignInLinks, parseCallback, parseUrl } from './preview.js';
 import { Plugins } from './plugins.js';
 import { runningClaude, scanClaudeSessions } from './sessions.js';
@@ -191,6 +191,7 @@ export class AgentManager extends EventEmitter {
     this.config = config;
     this.plugins = plugins; // policies before actions, listeners after (src/plugins.js)
     this.runtimes = new Map(); // agent id -> { pty, chunks, size, clients, lastOutputAt, busy, stopping, exited }
+    this.inputAt = new Map(); // agent id -> when you last typed into its session or a shell
     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();
@@ -268,6 +269,7 @@ export class AgentManager extends EventEmitter {
       ...agent,
       results: this.results(agent, rt, prs),
       priority: agent.priority ?? 2,
+      activeAt: this.activeAt(agent, rt),
       projectInfo: this.projectInfo(agent),
       usage,
       // Claude Code's own cost figure from the transcripts (absent until it records one).
@@ -295,9 +297,22 @@ export class AgentManager extends EventEmitter {
     };
   }
 
+  /**
+   * When the agent last did real work or you last worked with it: its conversation,
+   * its brief, your typing, or output while busy (not the redraw after a restart).
+   */
+  activeAt(agent, rt) {
+    const times = [agent.createdAt, agent.brief?.updatedAt, ...(agent.sessions ?? []).map((s) => s.lastMessageAt ?? s.lastActivity)]
+      .map((t) => (t ? Date.parse(t) : 0));
+    times.push(this.inputAt.get(agent.id) ?? 0);
+    if (rt?.pty && rt.busy && rt.lastOutputAt - (rt.startedAt ?? 0) > 60_000) times.push(rt.lastOutputAt);
+    const t = Math.max(0, ...times.filter(Number.isFinite));
+    return t ? new Date(t).toISOString() : null;
+  }
+
   /**
    * The end result / status / blockers for an agent: what the agent wrote under
-   * "## Results", plus what Agent Manager knows (PRs, checks, prompts, errors).
+   * "## Results", plus what AI Agent Manager knows (PRs, checks, prompts, errors).
    */
   results(agent, rt, prs) {
     const r = agent.brief?.results;
@@ -749,7 +764,7 @@ export class AgentManager extends EventEmitter {
    */
   start(ref, { fresh = false, sessionId } = {}) {
     const agent = this.mustGet(ref);
-    if (this.closing) throw Object.assign(new Error('Agent Manager is shutting down'), { status: 503 });
+    if (this.closing) throw Object.assign(new Error('AI Agent Manager is shutting down'), { status: 503 });
     const live = this.runtimes.get(agent.id);
     if (!live?.pty) {
       this.plugins.check('agent.start', { agent: this.auditView(agent), fresh });
@@ -892,6 +907,11 @@ export class AgentManager extends EventEmitter {
       }
     }
 
+    if (!installed(engine, this.config)) {
+      const error = notInstalled(engine, this.config);
+      this.patch(agent.id, { status: 'error', error });
+      throw Object.assign(new Error(error), { status: 400 });
+    }
     let proc;
     try {
       proc = pty.spawn(engine.bin(this.config), args, {
@@ -1198,6 +1218,8 @@ export class AgentManager extends EventEmitter {
   }
 
   write(id, data, kind = 'claude') {
+    // Focus reports and terminal replies are not you typing.
+    if (!/^(\x1b\[[\d;?>]*[IOcRnt])+$/.test(data)) this.inputAt.set(id, Date.now());
     this.termRuntime(id, kind)?.pty?.write(data);
   }
 
@@ -1432,7 +1454,7 @@ export class AgentManager extends EventEmitter {
 
   // ------------------------------------------------- sessions started elsewhere
 
-  /** Claude Code sessions started outside Agent Manager (in a terminal), to continue here. */
+  /** Claude Code sessions started outside AI Agent Manager (in a terminal), to continue here. */
   scanSessions({ days = 30 } = {}) {
     const known = new Set(this.store.list().flatMap((a) => a.sessions.map((x) => x.id)));
     return scanClaudeSessions({ days: Math.max(1, Math.min(365, Number(days) || 30)), known, excludeDir: paths.home });
@@ -1898,7 +1920,7 @@ export class AgentManager extends EventEmitter {
           session.usage = usage;
           changed = true;
         }
-        for (const key of ['title', 'lastPrompt', 'cost', 'lastActivity']) {
+        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;
@@ -2253,7 +2275,7 @@ export class AgentManager extends EventEmitter {
   async judgeScreen(id, rt) {
     const agent = this.store.get(id);
     if (!agent) return;
-    const screen = this.screenText(rt);
+    const screen = stripChrome(this.screenText(rt), engineOf(agent).screenChrome);
     if (!screen) return;
     const h = hash(screen);
     if (rt.screenVerdict?.hash === h) return this.applyScreen(id, rt, rt.screenVerdict.data);

package/src/notify.js

@@ -269,7 +269,7 @@ export class Notifier {
     const link = this.linkFor(agent.id);
     const intent = n.includeIntent && agent.intent ? `\n> ${agent.intent.replace(/\s+/g, ' ').slice(0, 200)}` : '';
     const prio = agent.priority <= 1 ? `[P${agent.priority}] ` : '';
-    const text = `${icon} ${prio ? `*${prio.trim()}* ` : ''}*${agent.name}*${project} ${what}${intent}${link ? `\n<${link}|Open in Agent Manager>` : ''}`;
+    const text = `${icon} ${prio ? `*${prio.trim()}* ` : ''}*${agent.name}*${project} ${what}${intent}${link ? `\n<${link}|Open in AI Agent Manager>` : ''}`;
     const plain = `${icon} ${prio}${agent.name}${project} ${what.replace(/\*/g, '')}${intent}${link ? `\nOpen: ${link}` : ''}`;
     sendSlack(text, n, plain)
       .then(() => this.record(kind, agent, null, urgency))

package/src/plugins.js

@@ -1,4 +1,4 @@
-// Plugins: how a separate package extends Agent Manager without changing it. A plugin is an
+// Plugins: how a separate package extends AI Agent Manager without changing it. A plugin is an
 // ES module listed in config.json "plugins" (the daemon) or AGENTMGR_HUB_PLUGINS (the hub),
 // whose default export (or `register`) receives the API below:
 //

package/src/preview.js

@@ -4,7 +4,7 @@
 // On this computer the tab loads the URL directly. From another device each site gets its
 // own HTTPS listener (same certificate and sign-in as remote access) that relays everything
 // to it at the root path, so apps that use absolute paths, redirects and WebSockets (hot
-// reload) keep working. This daemon's own ports are never relayed, and the Agent Manager
+// reload) keep working. This daemon's own ports are never relayed, and the AI Agent Manager
 // session cookie is stripped before forwarding.
 import http from 'node:http';
 import https from 'node:https';
@@ -170,7 +170,7 @@ export class Previews {
     const tport = targetPort(url);
     const own = new Set([...this.reserved(), ...[...this.listeners.values()].map((l) => l.port)]);
     const self = isLoopback(url) || this.ownHosts().has(url.hostname.replace(/^\[|\]$/g, '').toLowerCase());
-    if (self && own.has(tport)) throw Object.assign(new Error("That is Agent Manager's own port"), { status: 400 });
+    if (self && own.has(tport)) throw Object.assign(new Error("That is AI Agent Manager's own port"), { status: 400 });
     const key = `${url.protocol}//${url.hostname}:${tport}`;
     const existing = this.listeners.get(key);
     if (existing) return existing.port;
@@ -223,13 +223,13 @@ export class Previews {
     const cookies = req.headers.cookie ?? '';
     const until = this.okCookies.get(cookies);
     if (until && until > Date.now()) return null;
-    if (!this.signedIn(cookies)) return [401, 'Sign in to Agent Manager on this machine first, then open this tab again.'];
+    if (!this.signedIn(cookies)) return [401, 'Sign in to AI Agent Manager on this machine first, then open this tab again.'];
     if (this.okCookies.size > 100) this.okCookies.clear();
     this.okCookies.set(cookies, Date.now() + 10_000);
     return null;
   }
 
-  /** Request headers as the local server expects them: its own Host and Origin, no Agent Manager cookie. */
+  /** Request headers as the local server expects them: its own Host and Origin, no AI Agent Manager cookie. */
   forwardHeaders(entry, req, upgrade) {
     const { target } = entry;
     const self = `${target.protocol}//${target.label}`;

package/src/server.js

@@ -18,6 +18,7 @@ import { Previews, parseUrl } from './preview.js';
 import { LiveBrowser } from './livebrowser.js';
 import * as remote from './remote.js';
 import { Store } from './store.js';
+import { about, latestRelease } from './about.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
@@ -337,7 +338,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   api.post(
     '/notify/test',
     wrap(async () => {
-      await sendSlack(':wave: Test from Agent Manager: alerts will arrive here when an agent needs you.', loadNotify());
+      await sendSlack(':wave: Test from AI Agent Manager: alerts will arrive here when an agent needs you.', loadNotify());
       return { ok: true };
     }),
   );
@@ -370,6 +371,8 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   api.post('/agents/:id/waiting/dismiss', wrap((req) => manager.dismissWaiting(req.params.id)));
   api.post('/agents/:id/review', wrap((req) => manager.requestReview(req.params.id, { force: true })));
   api.post('/agents/:id/review/ack', wrap((req) => manager.ackReview(req.params.id, req.body?.action)));
+  api.get('/about', wrap(() => about({ port, config: { home: paths.home, claudeBin: config.claudeBin } })));
+  api.get('/about/latest', wrap(() => latestRelease()));
   api.get('/judge', wrap(() => manager.judge.status()));
   // On or off for this daemon, kept in config.json. The judge spends calls on your own engine plan.
   api.put('/judge', wrap((req) => {

package/src/service.js

@@ -75,7 +75,7 @@ export function unit() {
   const env = Object.entries(passEnv()).map(([k, v]) => `Environment=${k}=${v}\n`).join('');
   const cmd = command().map((a) => `"${a.replace(/(["\\])/g, '\\$1')}"`).join(' ');
   return `[Unit]
-Description=Agent Manager daemon (background Claude Code agents)
+Description=AI Agent Manager daemon (background Claude Code agents)
 
 [Service]
 ExecStart=${cmd}

package/src/sessions.js

@@ -1,4 +1,4 @@
-// Claude Code sessions started outside Agent Manager (a plain `claude` in a terminal), so they
+// Claude Code sessions started outside AI Agent Manager (a plain `claude` in a terminal), so they
 // can be continued here. Claude Code keeps each session as ~/.claude/projects/<cwd>/<id>.jsonl;
 // the start and end of each file say where it ran, its title, branch and first ask.
 import { execFileSync } from 'node:child_process';
@@ -85,7 +85,7 @@ export function runningClaude() {
 
 /**
  * Interactive Claude Code sessions from the last `days`, newest first, leaving out `known`
- * session IDs (Agent Manager's own) and anything run under `excludeDir` (its one-off calls and
+ * session IDs (AI Agent Manager's own) and anything run under `excludeDir` (its one-off calls and
  * workspaces). inUse: "open" when a running claude names the session, "maybe" when one runs in
  * its folder and the session was active in the last 10 minutes.
  */

package/src/store.js

@@ -12,7 +12,7 @@ const MIGRATIONS = {};
  * so a crash mid-write never loses the session IDs.
  *
  * Upgrades: older files are copied to `<file>.v<N>.bak` and migrated one version at a time.
- * A file from a newer Agent Manager is refused rather than overwritten (downgrades would lose
+ * A file from a newer AI Agent Manager is refused rather than overwritten (downgrades would lose
  * fields). The file as it was at startup is kept as `<file>.bak`.
  */
 export class Store {
@@ -38,7 +38,7 @@ export class Store {
     }
     const version = Number(parsed.version ?? 1);
     if (version > STATE_VERSION) {
-      throw new Error(`${this.file} was written by a newer Agent Manager (state version ${version}; this one reads up to ${STATE_VERSION}). Upgrade Agent Manager, or restore a backup.`);
+      throw new Error(`${this.file} was written by a newer AI Agent Manager (state version ${version}; this one reads up to ${STATE_VERSION}). Upgrade AI Agent Manager, or restore a backup.`);
     }
     if (version < STATE_VERSION) {
       fs.copyFileSync(this.file, `${this.file}.v${version}.bak`);

package/src/tracker.js

@@ -132,7 +132,7 @@ function textOf(content) {
  * subsequent calls only parse newly appended lines.
  */
 export function scanTranscript(file, cursor, bugPatterns = []) {
-  const result = { prs: [], bugs: [], title: null, lastPrompt: null, cost: null, lastActivity: null };
+  const result = { prs: [], bugs: [], title: null, lastPrompt: null, cost: null, lastActivity: null, lastMessageAt: null };
   // Token usage per API response, kept on the cursor so incremental scans accumulate.
   cursor.usage ??= new Map();
   let fd;
@@ -160,6 +160,10 @@ export function scanTranscript(file, cursor, bugPatterns = []) {
       } catch {
         continue;
       }
+      // The last real message: resuming a session appends bookkeeping lines, which have no timestamp.
+      if ((rec.type === 'user' || rec.type === 'assistant') && !rec.isMeta && rec.timestamp > (result.lastMessageAt ?? '')) {
+        result.lastMessageAt = rec.timestamp;
+      }
       switch (rec.type) {
         case 'pr-link':
           if (rec.prUrl) result.prs.push({ ...prFromUrl(rec.prUrl, 'session'), number: rec.prNumber ?? null });