ai-agentmanager 1.16.0 → 1.17.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.17.0 (2026-11-03)
+
+- **Sessions go both ways with the Claude desktop app.** **Open in Claude desktop** on a Claude agent (and `agentmgr desktop <agent>`) continues its conversation in the desktop app through Claude Code's `claude --desktop --resume`. The agent's session here closes first, messages for it wait until you resume it here, and **Resume** picks up what was said in the desktop app. **Import** now lists sessions started in the desktop app's Code tab (marked **Claude desktop**, with their title there) and in editors. Before, it only listed sessions started from a terminal. A session open in the desktop app is protected like one open in a terminal: close it there, or continue a copy.
+
 ## 1.16.0 (2026-11-03)
 
 - **Faster typing and switching with many agents:** the page no longer redraws everything on every agent update. Updates are drawn once per frame, only the views they touch are redrawn (another agent's update leaves the open agent's details and terminal alone), and lists change only the cards that changed. With 40 busy agents, the page's redraw work went from about 870 ms to 35 ms per 10 seconds. Add `?perf` to the address to see how long redraws take.

package/README.md

@@ -75,7 +75,7 @@ Claude Code on its own, including its built-in ways to run work in parallel, is
 - **Keeping up without reading transcripts:** a brief per agent (result, problem, fix, checks) and one inbox for every prompt and question.
 - **From anywhere:** your phone, another computer, or several machines through the hub.
 
-**Trying it costs little.** It runs the same `claude` you already use, with your plan and your repo's `CLAUDE.md` and skills. Sessions you started with `claude` in a terminal can be continued in it (**Import** above the agent list), and you can go back to a plain terminal any time with `claude --resume`.
+**Trying it costs little.** It runs the same `claude` you already use, with your plan and your repo's `CLAUDE.md` and skills. Sessions you started with `claude` in a terminal or in the Claude desktop app can be continued in it (**Import** above the agent list), and you can go back any time: to a plain terminal with `claude --resume`, or to the desktop app with **Open in Claude desktop**.
 
 ## Install
 
@@ -235,11 +235,17 @@ Every agent gets **its own worktree and its own branch** (`agent/<name>-<id>`) o
 - **No upstream.** Agent branches are created without an upstream, so Claude's first `git push -u origin <branch>` sets the right one. They never accidentally track `origin/main`.
 - **Where it shows.** The agent shows **Branched from** with the ref and commit it started at.
 
-## Continue sessions started in a terminal
+## Continue sessions started in a terminal or the Claude desktop app
 
-**Import** (next to **Save now** in the agent list) lists the Claude Code sessions you started yourself with `claude` in a terminal on this machine, from the last 7, 30 or 90 days: grouped by folder, with title, first and last ask, branch, size and last activity. Headless runs (`claude -p`, the SDK) and AI Agent Manager's own agents are left out. Each one you pick becomes an agent in the same folder that continues the same conversation (`--resume`), with the brief, inbox, PRs and usage tracked from then on.
+**Import** (next to **Save now** in the agent list) lists the Claude Code sessions you started yourself on this machine, from the last 7, 30 or 90 days: with `claude` in a terminal, in the Claude desktop app's Code tab (marked **Claude desktop**, with its title there), or in an editor. They're grouped by folder, with title, first and last ask, branch, size and last activity. Headless runs (`claude -p`, the SDK, built agents) and AI Agent Manager's own agents are left out. Each one you pick becomes an agent in the same folder that continues the same conversation (`--resume`), with the brief, inbox, PRs and usage tracked from then on.
 
-A session still open in a terminal is marked **open in a terminal** (a running `claude` names it) or **maybe open** (a `claude` runs in that folder and the session was active minutes ago). Two places writing one conversation would mix it up, so those continue as a **copy** under a new session ID and the terminal keeps the original. For the same reason, an agent that follows a `/clear` to a new session never picks up a headless run or a session a terminal has open in its folder.
+A session still open in a terminal or the desktop app is marked **open in a terminal** / **open in the desktop app** (a running `claude` names it) or **maybe open** (a `claude` runs in that folder and the session was active minutes ago). Two places writing one conversation would mix it up, so those continue as a **copy** under a new session ID and the terminal keeps the original. For the same reason, an agent that follows a `/clear` to a new session never picks up a headless run or a session a terminal has open in its folder.
+
+### Open an agent in the Claude desktop app
+
+**Open in Claude desktop** on a Claude agent (or `agentmgr desktop <agent>`) continues its conversation in the Claude desktop app, using Claude Code's own hand-off (`claude --desktop --resume`). Its session here closes first, and until you resume it here, messages for it (yours, Autopilot's, Landing's) wait instead of starting a second copy. **Resume** picks up what was said in the desktop app, since it's the same session; close it in the desktop app first. Needs macOS or Windows and Claude Code signed in with a Claude subscription; when Claude Code refuses, the reason is shown. Agents in a container, and agents moved to another machine, can't be opened there.
+
+With Remote Control on (`"remoteControlAtStartup": true` in `~/.claude/settings.json`), running agents also show in the Claude apps while they run, as live sessions.
 
 ## Restarts and reboots
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-agentmanager",
-  "version": "1.16.0",
+  "version": "1.17.0",
   "description": "Run background coding agents (Claude Code, Codex) per intent, and keep track of them from a web UI, your phone or the CLI",
   "keywords": [
     "claude",

package/public/app.js

@@ -834,7 +834,7 @@ function renderList() {
   $('#counts').innerHTML = agents.size
     ? `<span title="Projects">${projects} project${projects === 1 ? '' : 's'}</span><span>${agents.size} agents</span><span>${running} running</span>
        ${waiting ? `<span class="fail">${waiting} need${waiting === 1 ? 's' : ''} input</span>` : ''}
-       <span class="spacer"></span><button class="link" id="import-btn" title="Continue Claude sessions you started in a terminal on this machine">Import</button><button class="link" id="flush-btn" title="Save session IDs, terminal scrollback and state to disk now (also automatic every 30s)">Save now</button>`
+       <span class="spacer"></span><button class="link" id="import-btn" title="Continue Claude sessions you started in a terminal or the Claude desktop app on this machine">Import</button><button class="link" id="flush-btn" title="Save session IDs, terminal scrollback and state to disk now (also automatic every 30s)">Save now</button>`
     : '';
 
   // Every agent a project has, also the ones a filter hides.
@@ -1843,6 +1843,7 @@ function renderDetail() {
             ? ''
             : `<button data-act="start" ${a.status === 'preparing' ? 'disabled' : ''}>Resume in background</button>`}
         <button data-act="fresh" ${running || a.status === 'preparing' ? 'disabled' : ''} title="Start over with a new session ID (old ones are kept)">New session</button>
+        ${(a.engine ?? 'claude') === 'claude' && a.isolation !== 'container' && !a.movedTo && !REMOTE ? `<button data-act="desktop" ${a.sessionId && a.workdir && a.status !== 'preparing' ? '' : 'disabled'} title="Continue this conversation in the Claude desktop app. Its session here closes; Resume here later picks up what was said there">Open in Claude desktop</button>` : ''}
         <button data-act="shell" ${a.workdir && a.status !== 'preparing' ? '' : 'disabled'} title="A separate terminal in this agent's folder for running commands by hand">Open shell</button>
         ${noRepo(a) ? '' : `<button data-act="changes" ${a.workdir && a.status !== 'preparing' ? '' : 'disabled'} title="Read its changes, comment on lines for the agent, commit and open a pull request">Review changes${a.git?.dirtyFiles ? ` <span class="count">${a.git.dirtyFiles}</span>` : ''}</button>`}
         <button data-act="fork" ${a.workdir && a.git?.branch ? '' : 'disabled'} title="A new agent with this one's code and conversation, in its own worktree, to try another approach">Fork</button>
@@ -1859,6 +1860,7 @@ function renderDetail() {
         ${it.status === 'review' ? `<span class="spacer"></span><button class="small primary" data-backlog-accept="${it.id}">Accept</button> <button class="small" data-backlog-reopen="${it.id}">Reopen</button>` : ''}</div>`;
     })()}
     ${a.error ? `<div class="error-box">${esc(a.error)}</div>` : ''}
+    ${a.desktop && !running ? `<p class="hint">Continued in the <b>Claude desktop app</b> ${ago(a.desktop.at)}. Messages for it wait here; <b>Resume</b> picks up what was said there (close it in the desktop app first).</p>` : ''}
     ${a.movedTo ? `<p class="hint">Moved to <b>${esc(a.movedTo.machine)}</b> ${ago(a.movedTo.at)}: it continues there with the same conversation and work. This copy stays closed; delete it when you no longer need its folder.</p>` : ''}
     ${a.movedFrom ? `<p class="hint">Moved here from <b>${esc(a.movedFrom.machine ?? 'another machine')}</b> ${ago(a.movedFrom.at)}, with its conversation and uncommitted work.</p>` : ''}
     ${!running && a.closedBy === 'cap' ? `<p class="hint">Closed ${ago(a.closedAt)} to stay under the limit on open agents (Settings), as the one idle longest. Resume it any time${a.keep ? '' : ', or mark it Keep'}.</p>` : ''}
@@ -2765,7 +2767,8 @@ function renderImport() {
               (s) => `<label class="import-row ${s.exists ? '' : 'off'}">
               <input type="checkbox" data-sid="${s.sessionId}" ${importPicked.has(s.sessionId) ? 'checked' : ''} ${s.exists ? '' : 'disabled'}>
               <span class="import-main"><b>${esc(s.title || s.firstAsk.slice(0, 80))}</b>
-                ${s.inUse ? `<span class="tag warn" title="${s.inUse === 'open' ? 'A claude process in a terminal has this session open' : 'A claude process runs in this folder and the session was active minutes ago'}">${s.inUse === 'open' ? 'open in a terminal' : 'maybe open in a terminal'}</span>` : ''}
+                ${s.source === 'desktop' ? `<span class="tag" title="Started in the Claude desktop app${s.archived ? '; archived there' : ''}">Claude desktop${s.archived ? ' · archived' : ''}</span>` : s.source === 'editor' ? '<span class="tag" title="Started in an editor (VS Code, JetBrains)">editor</span>' : ''}
+                ${s.inUse ? `<span class="tag warn" title="${s.inUse === 'open' ? 'A claude process has this session open' : 'A claude process runs in this folder and the session was active minutes ago'}">${s.inUse === 'open' ? 'open' : 'maybe open'} ${s.source === 'desktop' ? 'in the desktop app' : 'in a terminal'}</span>` : ''}
                 <span class="hint">${s.title ? `${esc(s.firstAsk.slice(0, 120))}${s.lastAsk ? ` … last: ${esc(s.lastAsk.slice(0, 80))}` : ''}` : s.lastAsk ? `last: ${esc(s.lastAsk.slice(0, 100))}` : ''}</span>
                 <span class="hint">${ago(s.lastActivity)}${s.branch ? ` · ⎇ ${esc(s.branch)}` : ''} · ${Math.max(1, Math.round(s.bytes / 1024))} KB · <code>${s.sessionId.slice(0, 8)}</code></span>
               </span></label>`,
@@ -2773,13 +2776,13 @@ function renderImport() {
             .join('')}</div>`,
         )
         .join('')
-    : `<p class="hint">${importSessions.length ? 'Nothing matches.' : 'No Claude sessions started in a terminal in this period (AI Agent Manager\'s own agents are left out).'}</p>`;
+    : `<p class="hint">${importSessions.length ? 'Nothing matches.' : 'No Claude sessions started in a terminal or the Claude desktop app in this period (AI Agent Manager\'s own agents are left out).'}</p>`;
   const picked = importSessions.filter((s) => importPicked.has(s.sessionId));
   const open = picked.filter((s) => s.inUse).length;
   Object.assign($('#import-go'), {
     disabled: !picked.length,
     textContent: picked.length ? `Continue ${picked.length} session${picked.length > 1 ? 's' : ''}${open ? ` (${open} as a copy)` : ''}` : 'Continue',
-    title: open ? 'Sessions still open in a terminal continue as a copy, so the terminal keeps the original' : '',
+    title: open ? 'Sessions still open in a terminal or the desktop app continue as a copy, so the original stays there' : '',
   });
 }
 $('#import-list').addEventListener('change', (e) => {
@@ -3411,6 +3414,14 @@ $('#detail-body').addEventListener('click', async (e) => {
         term.open(a.id);
       });
       break;
+    case 'desktop':
+      btn.disabled = true;
+      btn.textContent = 'Opening…';
+      act(async () => upsert(await api('POST', `/agents/${a.id}/desktop`)), 'Opened in the Claude desktop app; Resume here picks it back up').finally(() => {
+        btn.disabled = false;
+        btn.textContent = 'Open in Claude desktop';
+      });
+      break;
     case 'stop':
       btn.disabled = true;
       act(async () => upsert(await api('POST', `/agents/${a.id}/stop`)), 'Session closed; the ID is kept for resuming');

package/public/index.html

@@ -429,7 +429,7 @@
         <button type="button" id="import-close" class="small ghost">Close</button>
       </div>
       <div class="import-body">
-        <p class="hint">Sessions you started with <code>claude</code> in a terminal on this machine. Each one you pick becomes an agent in the same folder that continues the same conversation, with the brief, inbox, PRs and usage tracked here.</p>
+        <p class="hint">Sessions you started with <code>claude</code> in a terminal, or in the Claude desktop app, on this machine. Each one you pick becomes an agent in the same folder that continues the same conversation, with the brief, inbox, PRs and usage tracked here.</p>
         <input id="import-filter" placeholder="Filter by folder, title or what you asked" autocomplete="off">
         <div id="import-list" class="import-list"></div>
       </div>

package/src/cli.js

@@ -968,6 +968,17 @@ export async function main(argv) {
       console.log(`${green('✓')} sent ${a.name} its scorecard (${a.docs.scorecard.data.overall ?? '—'}/100) to improve; scored again when it updates its brief`);
     });
 
+  program
+    .command('desktop')
+    .description('Continue a Claude agent in the Claude desktop app (its session here closes; resume it here to pick up what was said there)')
+    .argument('<agent>')
+    .action(async (ref) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      await api('POST', `/agents/${a.id}/desktop`);
+      console.log(`${green('✓')} ${a.name} opened in the Claude desktop app; continue it here with: agentmgr start ${a.id}`);
+    });
+
   program
     .command('tell')
     .description("Send a message into an agent's session (typed in when it is idle; resumes it if closed)")

package/src/manager.js

@@ -955,6 +955,7 @@ export class AgentManager extends EventEmitter {
     if (!agent.workdir || !fs.existsSync(agent.workdir)) {
       throw Object.assign(new Error(`Working folder ${agent.workdir} no longer exists`), { status: 409 });
     }
+    if (agent.desktop) this.patch(agent.id, { desktop: null }); // continued here again
 
     if (sessionId) {
       if (!agent.sessions.some((s) => s.id === sessionId)) {
@@ -1763,9 +1764,52 @@ export class AgentManager extends EventEmitter {
     return this.view(this.store.get(agent.id));
   }
 
+  /**
+   * Continue a Claude agent's conversation in the Claude desktop app (`claude --desktop --resume`):
+   * its session here is closed first, and it waits until you resume it here, where it picks up
+   * what was said in the desktop app (the same session).
+   */
+  async openInDesktop(ref) {
+    const agent = this.mustGet(ref);
+    const err = (status, message) => Object.assign(new Error(message), { status });
+    if ((agent.engine ?? DEFAULT_ENGINE) !== 'claude') throw err(409, 'Only Claude Code sessions open in the Claude desktop app');
+    if (agent.isolation === 'container') throw err(409, 'Its session runs in a container; the desktop app cannot reach it');
+    if (agent.movedTo) throw err(409, `${agent.name} moved to ${agent.movedTo.machine}; open it in the desktop app there`);
+    if (!agent.sessionId) throw err(409, 'It has no session yet: start it first');
+    if (!agent.workdir || !fs.existsSync(agent.workdir)) throw err(409, `Working folder ${agent.workdir} no longer exists`);
+    if (this.runtimes.get(agent.id)?.pty) await this.stop(agent.id);
+    const args = [...(this.config.claudeArgs ?? []), '--desktop', '--resume', agent.sessionId];
+    // In a terminal of its own: Claude Code refuses --desktop when its output isn't one.
+    const out = await new Promise((resolve) => {
+      let child;
+      try {
+        child = pty.spawn(this.config.claudeBin, args, { name: 'xterm-256color', cols: 120, rows: 30, cwd: agent.workdir, env: { ...process.env, FORCE_COLOR: '0' } });
+      } catch (e) {
+        return resolve({ code: -1, text: e.message });
+      }
+      let text = '';
+      child.onData((d) => (text = (text + d).slice(-4000)));
+      const timer = setTimeout(() => {
+        child.kill();
+        resolve({ code: null, text });
+      }, 30_000);
+      child.onExit(({ exitCode }) => {
+        clearTimeout(timer);
+        resolve({ code: exitCode, text });
+      });
+    });
+    if (out.code !== 0) {
+      const why = out.text.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '').replace(/\r/g, '').trim().split('\n').filter(Boolean).slice(-3).join(' ') || (out.code === null ? 'it did not finish in 30 seconds' : `exit code ${out.code}`);
+      throw err(502, `Couldn't open it in the Claude desktop app: ${why}`);
+    }
+    this.patch(agent.id, { desktop: { at: now(), sessionId: agent.sessionId } });
+    this.changed(this.store.get(agent.id));
+    return this.view(this.store.get(agent.id));
+  }
+
   // ------------------------------------------------- sessions started elsewhere
 
-  /** Claude Code sessions started outside AI Agent Manager (in a terminal), to continue here. */
+  /** Claude Code sessions started outside AI Agent Manager (in a terminal or the Claude desktop app), 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 });
@@ -1787,7 +1831,7 @@ export class AgentManager extends EventEmitter {
         continue;
       }
       if (s.inUse && !copy) {
-        out.push({ sessionId: s.sessionId, error: 'Still open in a terminal: close it there first, or continue a copy' });
+        out.push({ sessionId: s.sessionId, error: `Still open in ${s.source === 'desktop' ? 'the Claude desktop app' : 'a terminal'}: close it there first, or continue a copy` });
         continue;
       }
       let sessionId = s.sessionId;
@@ -1803,7 +1847,7 @@ export class AgentManager extends EventEmitter {
         engine: 'claude',
         start,
         sessionId,
-        imported: { from: 'terminal', sessionId: s.sessionId, copy: sessionId !== s.sessionId, at: now() },
+        imported: { from: s.source === 'desktop' ? 'desktop' : 'terminal', sessionId: s.sessionId, copy: sessionId !== s.sessionId, at: now() },
       });
       out.push({ sessionId: s.sessionId, agentId: agent.id, name: agent.name });
     }
@@ -2474,7 +2518,8 @@ export class AgentManager extends EventEmitter {
     this.plugins.emit('agent.message', { agent: this.auditView(agent), text, source });
     if (!this.outbox.has(agent.id)) this.outbox.set(agent.id, []);
     this.outbox.get(agent.id).push({ text, source, at: now() });
-    if (!this.runtimes.get(agent.id)?.pty && agent.workdir && agent.status !== 'preparing') this.start(agent.id);
+    // In the Claude desktop app: it waits for Resume here (two places writing one conversation mix it up).
+    if (!this.runtimes.get(agent.id)?.pty && agent.workdir && agent.status !== 'preparing' && !agent.desktop) this.start(agent.id);
     this.changed(agent);
     return this.view(this.store.get(agent.id));
   }

package/src/server.js

@@ -416,6 +416,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   );
   api.post('/agents/:id/start', wrap((req) => manager.start(req.params.id, req.body ?? {})));
   api.post('/agents/:id/stop', wrap((req) => manager.stop(req.params.id)));
+  api.post('/agents/:id/desktop', wrap((req) => manager.openInDesktop(req.params.id)));
   api.post('/agents/:id/refresh', wrap((req) => manager.refresh(req.params.id, { withPrs: true })));
   api.post('/agents/:id/links', wrap((req) => manager.addLink(req.params.id, req.body ?? {})));
   api.delete('/agents/:id/links', wrap((req) => manager.removeLink(req.params.id, req.query)));

package/src/sessions.js

@@ -1,5 +1,5 @@
-// 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;
+// Claude Code sessions started outside AI Agent Manager (a plain `claude` in a terminal, or the
+// Claude desktop app's Code tab), 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';
 import fs from 'node:fs';
@@ -15,6 +15,46 @@ const encode = (p) => {
   return real.replace(/[^a-zA-Z0-9]/g, '-');
 };
 
+/** Where the Claude desktop app keeps its data (its list of Code sessions is under it). */
+const desktopDir = () =>
+  process.env.AGENTMGR_CLAUDE_DESKTOP_DIR ||
+  (process.platform === 'darwin'
+    ? path.join(os.homedir(), 'Library', 'Application Support', 'Claude')
+    : process.platform === 'win32'
+      ? path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'Claude')
+      : path.join(os.homedir(), '.config', 'Claude'));
+
+/**
+ * The Claude desktop app's Code sessions on this computer, by Claude Code session ID: its title
+ * and whether it's archived. Read from the app's own records (claude-code-sessions/<account>/<org>/
+ * local_*.json, each naming its `cliSessionId`); an app that keeps them elsewhere gives none, and
+ * its sessions are still found by their transcripts.
+ */
+export function desktopSessions() {
+  const out = new Map();
+  const root = path.join(desktopDir(), 'claude-code-sessions');
+  const walk = (dir, depth) => {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory() && depth < 3) walk(p, depth + 1);
+      else if (e.isFile() && /^local_.*\.json$/.test(e.name)) {
+        try {
+          const r = JSON.parse(fs.readFileSync(p, 'utf8'));
+          if (typeof r.cliSessionId === 'string') out.set(r.cliSessionId, { title: typeof r.title === 'string' ? r.title : null, archived: Boolean(r.isArchived) });
+        } catch {}
+      }
+    }
+  };
+  walk(root, 0);
+  return out;
+}
+
 /** The first and last `bytes` of a file as JSON records (partial lines dropped). */
 function edges(file, size, bytes = 96 * 1024) {
   const fd = fs.openSync(file, 'r');
@@ -84,7 +124,7 @@ export function runningClaude() {
 }
 
 /**
- * Interactive Claude Code sessions from the last `days`, newest first, leaving out `known`
+ * Interactive Claude Code sessions from the last `days` (terminal and Claude desktop app), newest first, leaving out `known`
  * 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.
@@ -121,6 +161,7 @@ export function scanClaudeSessions({ days = 30, known = new Set(), excludeDir, l
   }
   files.sort((a, b) => b.mtimeMs - a.mtimeMs);
   const running = runningClaude();
+  const desktop = desktopSessions();
   const out = [];
   for (const f of files.slice(0, limit)) {
     let recs;
@@ -132,10 +173,15 @@ export function scanClaudeSessions({ days = 30, known = new Set(), excludeDir, l
     const all = [...recs.head, ...recs.tail];
     const withCwd = all.find((r) => r.cwd);
     if (!withCwd) continue;
-    // Headless runs (claude -p, the SDK) aren't conversations to continue.
-    if (all.some((r) => r.entrypoint && r.entrypoint !== 'cli')) continue;
     const firstAsk = recs.head.map(typed).find(Boolean);
     if (!firstAsk) continue;
+    // Where it was started: a terminal (`cli`), the Claude desktop app (in its list of sessions, or
+    // saying so), an editor, or a program (claude -p, the SDK, built agents), whose runs aren't
+    // conversations to continue.
+    const app = desktop.get(f.id);
+    const entry = all.find((r) => r.entrypoint)?.entrypoint ?? 'cli';
+    const source = app || /desktop/i.test(entry) ? 'desktop' : entry === 'cli' ? 'terminal' : /vscode|jetbrains|ide/i.test(entry) ? 'editor' : null;
+    if (!source) continue;
     const cwd = withCwd.cwd;
     if (excludeDir && (cwd === excludeDir || cwd.startsWith(`${excludeDir}/`))) continue;
     const last = (type, key) => [...all].reverse().find((r) => r.type === type && r[key])?.[key];
@@ -147,7 +193,9 @@ export function scanClaudeSessions({ days = 30, known = new Set(), excludeDir, l
       sessionId: f.id,
       cwd,
       exists: fs.existsSync(cwd),
-      title: last('custom-title', 'customTitle') || last('agent-name', 'agentName') || last('ai-title', 'aiTitle') || last('summary', 'summary') || null,
+      source,
+      archived: app?.archived || undefined,
+      title: app?.title || last('custom-title', 'customTitle') || last('agent-name', 'agentName') || last('ai-title', 'aiTitle') || last('summary', 'summary') || null,
       firstAsk: firstAsk.slice(0, 300),
       lastAsk: lastAsk && lastAsk !== firstAsk ? lastAsk.slice(0, 300) : null,
       branch: branch === 'HEAD' ? null : branch,