ai-agentmanager 1.1.0 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 1.2.1 (2026-10-30)
+
+- **Edit an agent:** **Edit** on an agent changes its name, its request (and can tell the agent about the change), priority, permission mode and model (from its next launch). `agentmgr edit`.
+- **Move an agent to another project:** **✎ Move** next to its project, the Edit dialog, or `agentmgr move <agent> <project>`. Pick any known project, a new project name, or its own repo again. Only where it is listed changes; its code stays in its own repo and branch.
+
+## 1.2.0 (2026-10-30)
+
+- **Assistant:** an always-on session that works on your behalf. Every few minutes it checks Jira (new assignments, comments and mentions), GitHub (review requests, failing checks on your PRs) and Slack with its own tools, and starts agents for new work, or passes the news to the agent already on it. The daemon enforces a daily cap, a cap on its running agents and one agent per Jira key; agents it starts are marked **by assistant**, and Slack alerts can announce them. **Assistant** in the top bar, or `agentmgr assistant`.
+- **Project names** in the agent list are larger and bold, so they stand out from the agents under them.
+
 ## 1.1.0 (2026-10-30)
 
 - **Teams:** give one problem to a team of agents in roles. An analyst writes the analysis and critics challenge it until they agree; an implementer builds it, a tester tests it, and a reviewer approves it or sends it back to the implementer. They hand off through files with a verdict line, which you can read in the team view. The team asks you only at the end (open a PR, keep the branch, or send it back) or when they can't agree within the round limits. **+ New agents → Team**, or `agentmgr team start`.

package/README.md

@@ -76,13 +76,13 @@ Runs on macOS and Linux; on Windows, use WSL2. Requires Node 20+, `git`, and the
 
 ```sh
 npm install -g ai-agentmanager          # the latest release
-npm install -g ai-agentmanager@1.1.0    # or a specific one
+npm install -g ai-agentmanager@1.2.1    # or a specific one
 ```
 
 Or from the repository, at a release tag:
 
 ```sh
-git clone --branch v1.1.0 --depth 1 https://github.com/jdmunta/ai-agentmanager-core.git
+git clone --branch v1.2.1 --depth 1 https://github.com/jdmunta/ai-agentmanager-core.git
 cd ai-agentmanager-core
 npm install
 npm link            # optional: puts `agentmgr` on your PATH
@@ -102,7 +102,7 @@ npm link
 | Installed with | Update |
 | --- | --- |
 | npm | `npm install -g ai-agentmanager@latest` |
-| A clone at a release tag | `git fetch --tags && git checkout v1.1.0 && npm install` (the tag you want) |
+| A clone at a release tag | `git fetch --tags && git checkout v1.2.1 && npm install` (the tag you want) |
 | A clone of `main` | `git pull && npm install` |
 
 **Check your setup.** `agentmgr doctor` checks Node.js, Claude Code and its sign-in, git, `gh`, the data folder, the daemon's port and Chrome, and says how to fix anything missing.
@@ -439,6 +439,17 @@ The sidebar groups agents into projects, shown as a tree:
 - **Ordering.** Projects needing you sort first. Collapsed projects stay collapsed.
 - **CLI.** `agentmgr ls` groups by project too.
 
+### Editing and moving agents
+
+**Edit** on an agent changes its name, its request, priority, permission mode and model. Changing the request updates what AI Agent Manager records (and tracks any new Jira links); tick **Also tell the agent** to send it to the session as well. Permission mode and model apply from its next launch.
+
+To list an agent under another project, use **✎ Move** next to its project (or the Edit dialog) and pick a known project, a new project name, or **Its own repo or folder** to move it back. Only the grouping changes: its code stays in its own worktree and branch.
+
+```bash
+agentmgr edit 3fa2b1 --name login-timeout --priority P1 --intent "Fix the login timeout on slow networks" --tell
+agentmgr move 3fa2b1 @billing        # "" moves it back to its own project
+```
+
 ## Backlog
 
 Queue asks instead of starting them. Use **+ Add** in the Backlog tab, **Queue in backlog** in the New agents dialog, or `agentmgr backlog add`. Each item is one ask, plus where to do it (repo or folder, base branch, project) and a priority from P1 (high) to P3 (low).
@@ -721,6 +732,32 @@ agentmgr leave           # the hub forgets this Mac
 
 **On Railway.** `hub/Dockerfile` builds the hub alone, with no node-pty and no Claude. Set `RAILWAY_DOCKERFILE_PATH=hub/Dockerfile`, `AGENTMGR_HUB_TOKEN`, `AGENTMGR_HUB_URL` (its https address) and, for Google sign-in, the three variables above; add a volume at `/data` so enrollments survive redeploys, and join with the `https://…up.railway.app` address.
 
+## Assistant
+
+An always-on Claude session that works on your behalf. **Assistant** in the top bar (or `agentmgr assistant start`) sets it up. Every 15 minutes the daemon asks it to check for new work, and it starts an agent for each new item, or passes the news to the agent already on it. You don't approve each one; it tells you in its activity log and, with Slack alerts on, in Slack.
+
+| It watches | What it does |
+|---|---|
+| Jira issues newly assigned to you | Starts an agent in the matching project, with the issue link first so the agent is named after the issue (`OPS-7`) |
+| New comments and mentions on your Jira issues | Passes the comment to the agent on that issue (`agentmgr tell`), or starts one if the comment asks for new work |
+| GitHub pull requests waiting for your review | Starts a review agent that drafts the review for you to post |
+| Failing checks on your open pull requests | Tells the agent on that PR to fix it, or starts one |
+| Slack messages to you that ask for work | Starts an agent for clear requests in a known project |
+
+It reads Jira and Slack with the tools your Claude Code already has (no credentials in agentmgr), so connect the Atlassian and Slack MCP servers at user scope, and sign in to `gh`. It runs in `~/.agentmanager/assistant` in `auto` permission mode, so it can run `agentmgr` and `gh` without asking. It never merges, approves, comments or sends messages as you.
+
+The daemon enforces its limits, whatever the session decides: at most 10 new agents a day, at most 5 of its agents running at once, and never a second agent for the same Jira key. Agents it started are marked **by assistant**. It keeps what it has handled in `handled.json` so it never acts twice, and writes `activity.md`, shown in the dialog, with a **Needs you** list for anything it couldn't place. Use **Notes for the assistant** to say which Jira project goes to which repo. Clean up never closes the assistant.
+
+```bash
+agentmgr assistant start                    # set it up, or turn it back on
+agentmgr assistant                          # on or paused, last check, agents it started (--activity for its log)
+agentmgr assistant check                    # check now
+agentmgr assistant set --every 10 --sources jira,comments,reviews,ci --max-per-day 5 --notes "OPS is the @cc repo"
+agentmgr assistant pause                    # stop checking and close the session
+```
+
+Settings live in `config.json` under `"assistant"`. A running assistant reads new watch lists and notes after **Pause** and **Turn on**.
+
 ## Cleaning up old agents
 
 Agents you no longer use keep a session open and a worktree on disk. **Clean up** (in the top bar, or `agentmgr cleanup`) closes agents with no activity for a while and deletes agents that stayed closed long after that. Pick a strategy:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-agentmanager",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "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

@@ -200,7 +200,7 @@ function explainBox(a) {
 const REVIEW_VERDICT = { complete: '✓ Complete', partial: '≈ Partly done', not_done: '✗ Not done' };
 /** The AI judge's review of the work against the intent and brief: button, and the last result once handled. */
 function reviewBox(a) {
-  if (a.kind === 'general') return { button: '', box: '' };
+  if (noRepo(a)) return { button: '', box: '' };
   const r = a.aiReview;
   const button = `<button class="small" data-act="review" ${r?.pending ? 'disabled' : ''}
     title="Check the work against the intent and brief: what is met, missing or risky. A separate one-off model call; runs by itself when the agent says it is done">${r?.pending ? 'Reviewing…' : 'Review with AI'}</button>`;
@@ -429,7 +429,7 @@ function openPlan(agentId) {
 const PLAN_LABEL = { writing: 'being written', review: 'waiting for your review', changes: 'changes requested', approved: 'approved' };
 /** The plan-review row in the brief card: status, open, approve; or the switch to turn review on. */
 function planRow(a) {
-  if (a.kind === 'general') return '';
+  if (noRepo(a)) return '';
   const p = a.planReview;
   if (!p) {
     return a.status === 'done' ? '' : `<div class="plan-row"><button class="small ghost" data-act="plan-on" title="The agent writes an implementation plan and waits for your approval before changing anything">Review its plan first</button></div>`;
@@ -489,7 +489,7 @@ function resultsCard(a) {
 }
 
 function briefPanel(a) {
-  if (a.kind === 'general') return '';
+  if (noRepo(a)) return '';
   const b = a.brief;
   const ex = explainBox(a);
   const rv = reviewBox(a);
@@ -598,12 +598,14 @@ function saveCollapsed() {
 const prioChip = (p, { always = false } = {}) =>
   p === 2 && !always ? '' : `<span class="prio p${p}" title="Priority P${p}">P${p}</span>`;
 
+const noRepo = (a) => a.kind === 'general' || a.kind === 'assistant';
+
 function agentItem(a) {
   const st = statusOf(a);
   const idle = !isActive(a);
   return `<li data-id="${a.id}" class="agent pr${a.priority ?? 2} ${a.id === selectedId ? 'selected' : ''} ${idle ? 'idle' : ''}">
     <div class="line1">${prioChip(a.priority ?? 2)}${a.results?.outcome === 'blocked' ? '<span class="outcome-mark" title="Blocked">⛔</span>' : a.results?.outcome === 'done' ? '<span class="outcome-mark" title="Done">✅</span>' : ''}<span class="name">${esc(a.name)}</span>${flags(a)}<span class="pill ${st}">${pillText(st)}</span></div>
-    <div class="intent">${a.kind === 'general' ? '<span class="tag">general</span> ' : ''}${a.engine && a.engine !== 'claude' ? `<span class="tag engine">${esc(ENGINE_LABEL[a.engine] ?? a.engine)}</span> ` : ''}${esc(a.intent || 'General session')}</div>
+    <div class="intent">${a.kind === 'general' ? '<span class="tag">general</span> ' : a.kind === 'assistant' ? '<span class="tag assistant">assistant</span> ' : a.startedBy ? '<span class="tag assistant" title="Started by the assistant">🤖 by assistant</span> ' : ''}${a.engine && a.engine !== 'claude' ? `<span class="tag engine">${esc(ENGINE_LABEL[a.engine] ?? a.engine)}</span> ` : ''}${esc(a.intent || (a.kind === 'assistant' ? 'Finds new work and starts agents for it' : 'General session'))}</div>
     ${a.status === 'preparing' && a.progress ? `<div class="progress-line">${esc(progressText(a.progress))}</div>` : ''}
     <div class="meta">
       <span class="mono">${a.id}</span>
@@ -652,7 +654,7 @@ function projectGroups(list) {
     const same = byName ? byName.get(g.name).length : out.filter((x) => x.name === g.name).length;
     g.label = same > 1 && g.full ? g.full : g.name;
   }
-  const special = (g) => (g.key === 'general' ? 1 : g.key === 'other' ? 2 : 0);
+  const special = (g) => (g.key === 'assistant' ? -1 : g.key === 'general' ? 1 : g.key === 'other' ? 2 : 0);
   return out.sort(
     (a, b) =>
       special(a) - special(b) ||
@@ -1119,7 +1121,7 @@ for (const root of [$('#inbox-view'), $('#detail-body')]) {
 // ------------------------------------------------------------------ checkpoints and forks
 
 function checkpointsCard(a) {
-  if (a.kind === 'general' || !a.git?.branch) return '';
+  if (noRepo(a) || !a.git?.branch) return '';
   const cps = [...(a.checkpoints ?? [])].reverse();
   const forks = [...agents.values()].filter((x) => x.forkOf?.agentId === a.id);
   return `<div class="card">
@@ -1545,7 +1547,7 @@ function renderDetail() {
             ${[0, 1, 2, 3].map((p) => `<option value="${p}" ${p === (a.priority ?? 2) ? 'selected' : ''}>P${p}</option>`).join('')}
           </select>
           <span class="d-name">${esc(a.name)}</span> <span class="pill ${st}">${pillText(st)}</span>${a.kind === 'general' ? ' <span class="tag">general</span>' : ''}</h2>
-        <p class="intent">${esc(a.intent || (a.kind === 'general' ? 'General session: ask Claude anything in the terminal.' : ''))}</p>
+        <p class="intent">${esc(a.intent || (a.kind === 'general' ? 'General session: ask Claude anything in the terminal.' : a.kind === 'assistant' ? 'Your assistant: it checks for new work every few minutes and starts agents for it. Settings and activity: Assistant in the top bar.' : ''))}</p>
       </div>
       <div class="d-actions">
         ${a.status === 'error' && !a.workdir
@@ -1562,6 +1564,7 @@ function renderDetail() {
         <button data-act="fresh" ${running || a.status === 'preparing' ? 'disabled' : ''} title="Start over with a new session ID (old ones are kept)">New session</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>
         <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>
+        <button data-act="edit" title="Change its name, request, project, priority, permission mode or model">Edit</button>
         <button data-act="refresh" title="Re-scan git, PRs and transcripts">Refresh</button>
         <button data-act="keep" class="${a.keep ? 'on' : ''}" title="${a.keep ? 'Kept: clean up never closes or deletes it. Click to let clean up handle it again' : 'Clean up never closes or deletes an agent marked Keep'}">${a.keep ? '📌 Kept' : 'Keep'}</button>
         <button class="danger" data-act="delete">Delete</button>
@@ -1626,7 +1629,7 @@ function renderDetail() {
         <h3>Workspace</h3>
         <dl class="kv">
           <dt>Folder</dt><dd><code>${esc(a.workdir ?? (a.status === 'preparing' ? 'preparing…' : '—'))}</code>${a.workdir ? copyBtn(a.workdir) : ''}</dd>
-          <dt>Project</dt><dd>${esc(a.projectInfo?.full || a.projectInfo?.name || '—')} <button class="link" data-act="project" title="Group this agent under a different project name">✎</button></dd>
+          <dt>Project</dt><dd>${esc(a.projectInfo?.full || a.projectInfo?.name || '—')} ${noRepo(a) ? '' : '<button class="link" data-act="project" title="Move this agent under another project">✎ Move</button>'}</dd>
           <dt>Repo</dt><dd>${a.repo ? `<code>${esc(a.repo)}</code>` : '—'}</dd>
           <dt>Branch</dt><dd>${a.git?.branch ? `<code>${esc(a.git.branch)}</code>` : '—'}${a.git?.dirtyFiles ? ` <span class="tag">${a.git.dirtyFiles} changed</span>` : ''}</dd>
           <dt>Head</dt><dd>${a.git?.head ? `<code>${esc(a.git.head.sha)}</code> ${esc(a.git.head.subject)}` : '—'}</dd>
@@ -2875,12 +2878,10 @@ $('#detail-body').addEventListener('click', async (e) => {
         term.open(a.id);
       }, 'Moved into the repository');
       break;
-    case 'project': {
-      const name = prompt('Project name for this agent (leave empty to use its repo):', a.project ?? a.projectInfo?.name ?? '');
-      if (name === null) return;
-      act(async () => upsert(await api('PATCH', `/agents/${a.id}`, { project: name })));
-      break;
-    }
+    case 'project':
+      return openEdit(a, 'project');
+    case 'edit':
+      return openEdit(a);
     case 'plan-open':
       return openPlan(a.id);
     case 'plan-on':
@@ -3503,6 +3504,187 @@ $('#cleanup-plan').addEventListener('click', (e) => {
   select(go.dataset.cleanupGoto);
 });
 
+// ------------------------------------------------------------------ edit an agent
+
+let editing = null;
+let enginesCache = null;
+// The project picked in the dialog: "" while it is listed under its own repo or folder.
+const editProject = (a) => (a.projectMove || a.project ? (a.projectInfo?.shortcut ?? '') : '');
+
+async function openEdit(a, focus) {
+  editing = a;
+  const f = $('#edit-form');
+  f.name.value = a.name;
+  f.intent.value = a.intent ?? '';
+  f.tell.checked = false;
+  f.priority.value = String(a.priority ?? 2);
+  f.model.value = a.model ?? '';
+  $('#edit-project-row').hidden = noRepo(a);
+  $('#edit-tell-row').hidden = !a.intent;
+  // Its own repo or folder, every known project, or a new name.
+  f.project.innerHTML = [
+    '<option value="">Its own repo or folder</option>',
+    ...projectsState.map((p) => `<option value="${esc(p.shortcut)}">${esc(p.name)} (@${esc(p.shortcut)})</option>`),
+    '<option value="__new">New project name…</option>',
+  ].join('');
+  f.project.value = editProject(a);
+  $('#edit-newproject-row').hidden = true;
+  f.newProject.value = '';
+  enginesCache ??= await api('GET', '/engines').catch(() => []);
+  const modes = enginesCache.find((e) => e.id === (a.engine ?? 'claude'))?.permissionModes ?? [];
+  f.permissionMode.innerHTML = ['<option value="">As configured</option>', ...modes.map((m) => `<option value="${esc(m)}">${esc(m)}</option>`)].join('');
+  f.permissionMode.value = a.permissionMode ?? '';
+  $('#edit-error').hidden = true;
+  $('#edit-dialog').showModal();
+  (focus === 'project' ? f.project : f.name).focus();
+}
+
+$('#edit-form').project.addEventListener('change', (e) => {
+  $('#edit-newproject-row').hidden = e.target.value !== '__new';
+  if (e.target.value === '__new') $('#edit-form').newProject.focus();
+});
+$('#edit-close').onclick = () => $('#edit-dialog').close();
+$('#edit-form').addEventListener('submit', async (e) => {
+  e.preventDefault();
+  const a = editing;
+  const f = e.target;
+  const patch = {};
+  if (f.name.value.trim() !== a.name) patch.name = f.name.value.trim();
+  if (f.intent.value.trim() !== (a.intent ?? '')) patch.intent = f.intent.value.trim();
+  if (Number(f.priority.value) !== (a.priority ?? 2)) patch.priority = Number(f.priority.value);
+  if ((f.permissionMode.value || null) !== (a.permissionMode ?? null)) patch.permissionMode = f.permissionMode.value || null;
+  if ((f.model.value.trim() || null) !== (a.model ?? null)) patch.model = f.model.value.trim() || null;
+  if (!noRepo(a)) {
+    const target = f.project.value === '__new' ? f.newProject.value.trim() : f.project.value;
+    const was = editProject(a);
+    if (f.project.value === '__new' && !target) {
+      $('#edit-error').textContent = 'Give the new project a name';
+      $('#edit-error').hidden = false;
+      return;
+    }
+    if (target !== was) patch.project = target;
+  }
+  try {
+    if (Object.keys(patch).length) upsert(await api('PATCH', `/agents/${a.id}`, patch));
+    if (patch.intent && f.tell.checked) await api('POST', `/agents/${a.id}/tell`, { text: `The request changed. It is now:\n${patch.intent}` });
+    $('#edit-dialog').close();
+    const relaunch = 'permissionMode' in patch || 'model' in patch;
+    toast(!Object.keys(patch).length ? 'Nothing changed' : `Saved${patch.project !== undefined ? '; moved' : ''}${relaunch ? '. Permission mode and model apply from its next launch' : ''}`);
+  } catch (err) {
+    $('#edit-error').textContent = err.message;
+    $('#edit-error').hidden = false;
+  }
+});
+
+// ------------------------------------------------------------------ assistant
+
+const ASSISTANT_SOURCES = ['jira', 'comments', 'reviews', 'ci', 'slack'];
+let assistantState = null;
+
+function renderAssistantDot() {
+  const a = assistantState;
+  const dot = $('#assistant-dot');
+  dot.hidden = !a?.agentId;
+  if (a) {
+    dot.className = `assistant-dot ${a.on ? (a.busy ? 'busy' : 'on') : 'off'}`;
+    dot.title = a.on ? (a.busy ? 'Checking now' : 'On') : 'Paused';
+  }
+}
+
+async function loadAssistant({ fill = true } = {}) {
+  const a = await api('GET', '/assistant');
+  assistantState = a;
+  renderAssistantDot();
+  const f = $('#assistant-form');
+  if (fill) {
+    for (const k of ASSISTANT_SOURCES) f[`src_${k}`].checked = a.sources.includes(k);
+    f.everyMin.value = a.everyMin;
+    f.maxPerDay.value = a.maxPerDay;
+    f.maxRunning.value = a.maxRunning;
+    f.notes.value = a.notes ?? '';
+  }
+  const state = !a.agentId ? 'Not set up yet. Start it to create its session.' : a.on ? (a.busy ? 'On: checking now.' : 'On.') : 'Paused: not checking.';
+  $('#assistant-status').innerHTML = `<p><b>${esc(state)}</b>
+    ${a.lastCheckAt ? ` Last check ${ago(a.lastCheckAt)}.` : ''}${a.nextAt && a.on ? ` Next ${new Date(a.nextAt) <= new Date() ? 'when it is free' : `at ${new Date(a.nextAt).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}`}.` : ''}
+    ${a.agentId ? ` Started ${a.startedToday} agent${a.startedToday === 1 ? '' : 's'} today, ${a.startedTotal} in all.` : ''}</p>
+    ${a.started.length ? `<ul class="assistant-started">${a.started.slice(0, 8).map((x) => `<li><a href="#${x.id}" data-assistant-goto="${x.id}">${esc(x.name)}</a> <span class="hint">${ago(x.createdAt)} · ${esc(x.intent.slice(0, 90))}</span></li>`).join('')}</ul>` : ''}`;
+  $('#assistant-activity').innerHTML = a.activity ? `<h4>Activity</h4><div class="md">${md(a.activity.split(/\n(?=## )/).reverse().slice(0, 10).join('\n').replace(/([^\n])\n(?=[^\n#\-*])/g, '$1  \n'))}</div>` : a.agentId ? '<p class="hint">No activity yet. Its first check writes here.</p>' : '';
+  $('#assistant-start').hidden = Boolean(a.on);
+  $('#assistant-start').textContent = a.agentId ? 'Turn on' : 'Start';
+  $('#assistant-pause').hidden = !a.on;
+  $('#assistant-check').hidden = !a.on;
+  $('#assistant-open').hidden = !a.agentId;
+  $('#assistant-error').hidden = true;
+  return a;
+}
+
+const assistantPatch = (f) => ({
+  sources: ASSISTANT_SOURCES.filter((k) => f[`src_${k}`].checked),
+  everyMin: Number(f.everyMin.value),
+  maxPerDay: Number(f.maxPerDay.value),
+  maxRunning: Number(f.maxRunning.value),
+  notes: f.notes.value,
+});
+const assistantError = (err) => {
+  $('#assistant-error').textContent = err.message;
+  $('#assistant-error').hidden = false;
+};
+$('#assistant-btn').onclick = async () => {
+  $('#assistant-dialog').showModal();
+  await loadAssistant().catch(assistantError);
+};
+$('#assistant-close').onclick = () => $('#assistant-dialog').close();
+$('#assistant-form').addEventListener('submit', async (e) => {
+  e.preventDefault();
+  try {
+    await api('PUT', '/assistant', assistantPatch(e.target));
+    toast(assistantState?.running ? 'Saved. A running assistant uses the new watch list and notes after Pause and Turn on.' : 'Assistant settings saved');
+    await loadAssistant();
+  } catch (err) {
+    assistantError(err);
+  }
+});
+$('#assistant-start').onclick = async () => {
+  try {
+    if (!assistantState?.agentId) await api('PUT', '/assistant', assistantPatch($('#assistant-form')));
+    await api('POST', '/assistant/start');
+    toast('Assistant on: its first check starts in a moment');
+    await loadAssistant({ fill: false });
+  } catch (err) {
+    assistantError(err);
+  }
+};
+$('#assistant-pause').onclick = async () => {
+  try {
+    await api('POST', '/assistant/pause');
+    await loadAssistant({ fill: false });
+  } catch (err) {
+    assistantError(err);
+  }
+};
+$('#assistant-check').onclick = async () => {
+  try {
+    await api('POST', '/assistant/check');
+    toast('Asked the assistant to check now');
+    await loadAssistant({ fill: false });
+  } catch (err) {
+    assistantError(err);
+  }
+};
+$('#assistant-open').onclick = () => {
+  $('#assistant-dialog').close();
+  if (assistantState?.agentId) select(assistantState.agentId);
+};
+$('#assistant-dialog').addEventListener('click', (e) => {
+  const go = e.target.closest('[data-assistant-goto]');
+  if (!go) return;
+  e.preventDefault();
+  $('#assistant-dialog').close();
+  select(go.dataset.assistantGoto);
+});
+loadAssistant({ fill: false }).catch(() => {});
+setInterval(() => loadAssistant({ fill: false }).catch(() => {}), 60_000);
+
 // ------------------------------------------------------------------ Slack alerts (from this computer)
 
 async function loadAlerts() {

package/public/index.html

@@ -22,6 +22,7 @@
       </div>
       <div class="top-actions">
         <input id="filter" type="search" placeholder="Filter agents" aria-label="Filter agents" />
+        <button id="assistant-btn" title="An always-on session that finds new work and starts agents for it">Assistant <span id="assistant-dot" class="assistant-dot" hidden></span></button>
         <button id="cleanup-btn" title="Close agents idle for a while, and delete old closed ones">Clean up</button>
         <button id="alerts-btn" class="local-only" title="Slack alerts when an agent needs you">Alerts</button>
         <button id="remote-btn" class="local-only" title="Open AI Agent Manager from your phone">Remote access</button>
@@ -383,6 +384,7 @@
           <label class="check"><input type="checkbox" name="ev_stuck" /> seems stuck (same failure, undoing its edits, no progress)</label>
           <label class="check"><input type="checkbox" name="ev_conflict" /> changes the same files as another agent</label>
           <label class="check"><input type="checkbox" name="ev_question" /> asks a question in the inbox</label>
+          <label class="check"><input type="checkbox" name="ev_assistant" /> is started by the assistant for new work</label>
           <label class="check"><input type="checkbox" name="ev_waiting" /> finished its turn and is idle after <input name="waitingDelaySec" type="number" min="0" class="num" />s</label>
           <label class="check"><input type="checkbox" name="skipWhenWatching" /> not while I have its terminal open</label>
           <label class="check"><input type="checkbox" name="includeIntent" /> include the intent text in the message</label>
@@ -399,6 +401,70 @@
       </form>
     </dialog>
 
+    <dialog id="edit-dialog">
+      <form id="edit-form" method="dialog" class="alerts-body">
+        <h2>Edit agent</h2>
+        <label>Name <input name="name" required maxlength="80" /></label>
+        <label>Request <span class="hint">what the agent was asked to do</span>
+          <textarea name="intent" rows="4"></textarea>
+        </label>
+        <label class="check" id="edit-tell-row"><input type="checkbox" name="tell" /> Also tell the agent about the changed request</label>
+        <label id="edit-project-row">Project
+          <select name="project"></select>
+        </label>
+        <label id="edit-newproject-row" hidden>New project name <input name="newProject" maxlength="60" /></label>
+        <div class="row three">
+          <label>Priority
+            <select name="priority"><option value="0">P0 urgent</option><option value="1">P1 high</option><option value="2">P2 normal</option><option value="3">P3 low</option></select>
+          </label>
+          <label>Permission mode <select name="permissionMode"></select></label>
+          <label>Model <input name="model" placeholder="as configured" /></label>
+        </div>
+        <p class="hint" id="edit-hint">Moving changes only where the agent is listed; its code stays in its own repo and branch. Permission mode and model apply from its next launch.</p>
+        <p id="edit-error" class="error" hidden></p>
+        <div class="dialog-actions">
+          <span class="spacer"></span>
+          <button type="button" id="edit-close" class="ghost">Cancel</button>
+          <button class="primary">Save</button>
+        </div>
+      </form>
+    </dialog>
+
+    <dialog id="assistant-dialog">
+      <form id="assistant-form" method="dialog" class="alerts-body">
+        <h2>Assistant</h2>
+        <p class="hint">An always-on Claude session that works on your behalf. Every few minutes it checks for new work with its own Jira, GitHub and Slack tools, and starts an agent for each new item, or passes news to the agent already on it. It never merges, approves, comments or sends messages as you.</p>
+        <div id="assistant-status" class="assistant-status"></div>
+        <fieldset>
+          <legend>Watch</legend>
+          <label class="check"><input type="checkbox" name="src_jira" /> Jira issues newly assigned to me</label>
+          <label class="check"><input type="checkbox" name="src_comments" /> New comments and mentions on my Jira issues (passed to the agent on it)</label>
+          <label class="check"><input type="checkbox" name="src_reviews" /> GitHub pull requests waiting for my review</label>
+          <label class="check"><input type="checkbox" name="src_ci" /> Failing checks on my open pull requests</label>
+          <label class="check"><input type="checkbox" name="src_slack" /> Slack messages to me that ask for work</label>
+        </fieldset>
+        <div class="row three">
+          <label>Check every <span class="hint">minutes</span><input name="everyMin" type="number" min="1" /></label>
+          <label>New agents a day <span class="hint">at most</span><input name="maxPerDay" type="number" min="0" /></label>
+          <label>Running at once <span class="hint">at most</span><input name="maxRunning" type="number" min="0" /></label>
+        </div>
+        <label>Notes for the assistant <span class="hint">e.g. "Jira project OPS is the @cc repo; skip issues labeled design"</span>
+          <textarea name="notes" rows="3"></textarea>
+        </label>
+        <div id="assistant-activity" class="assistant-activity"></div>
+        <p id="assistant-error" class="error" hidden></p>
+        <div class="dialog-actions">
+          <button type="button" id="assistant-start" class="primary">Start</button>
+          <button type="button" id="assistant-check">Check now</button>
+          <button type="button" id="assistant-pause">Pause</button>
+          <button type="button" id="assistant-open" class="ghost">Open its session</button>
+          <span class="spacer"></span>
+          <button type="button" id="assistant-close" class="ghost">Close</button>
+          <button id="assistant-save">Save</button>
+        </div>
+      </form>
+    </dialog>
+
     <dialog id="cleanup-dialog">
       <form id="cleanup-form" method="dialog" class="alerts-body">
         <h2>Clean up old agents</h2>

package/public/style.css

@@ -157,7 +157,7 @@ body.term-max .layout { grid-template-columns: 1fr; }
 .shortcut { flex: none; font: 600 11px/16px var(--mono); padding: 0 6px; border-radius: 4px; background: var(--accent); color: var(--accent-text); cursor: pointer; }
 .bl-head .shortcut { cursor: default; }
 .project-head .caret { width: 12px; color: var(--muted); flex: none; }
-.project-head .pname { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.project-head .pname { font-size: 16px; font-weight: 700; flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .project-head .pcounts { display: flex; gap: 6px; align-items: center; color: var(--muted); font-weight: 500; font-size: 12px; }
 .project-head .prun { color: var(--green); }
 .project-head .pcount { white-space: nowrap; }
@@ -384,6 +384,17 @@ body.remote .local-only { display: none; }
 .alerts-body .check { display: flex; gap: 8px; align-items: center; font-size: 13px; }
 .alerts-body .check input[type=checkbox] { width: auto; }
 .alerts-body .num { width: 64px; padding: 2px 6px; }
+.assistant-dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; margin-left: 4px; vertical-align: middle; background: var(--muted); }
+.assistant-dot.on { background: var(--green); }
+.assistant-dot.busy { background: var(--yellow); }
+.assistant-status { font-size: 13px; }
+.assistant-status p { margin: 4px 0; }
+.assistant-started { margin: 4px 0; padding-left: 18px; font-size: 13px; }
+.assistant-activity { font-size: 13px; max-height: 240px; overflow: auto; }
+.assistant-activity h4 { margin: 8px 0 4px; }
+.assistant-activity .md h1, .assistant-activity .md h2, .assistant-activity .md h3 { font-size: 13px; margin: 10px 0 2px; color: var(--muted); }
+.assistant-activity .md p, .assistant-activity .md ul { margin: 2px 0; }
+.tag.assistant { background: var(--panel-2); }
 .cleanup-plan { font-size: 13px; max-height: 260px; overflow: auto; }
 .cleanup-plan h4 { margin: 8px 0 4px; font-size: 13px; }
 .cleanup-plan ul { margin: 0; padding-left: 18px; }

package/src/assistant.js

@@ -0,0 +1,269 @@
+// The assistant: one always-on session that works on the person's behalf. Every few minutes the
+// daemon asks it to check for new work (newly assigned Jira issues, GitHub review requests,
+// failing checks on the person's PRs, new Jira comments, Slack messages) with its own tools, and
+// it starts agents for that work through agentmgr, or passes news to the agent already on it.
+// The daemon keeps the limits: a daily cap, a cap on its agents running at once, and no second
+// agent for the same issue.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { paths } from './config.js';
+import { leadingJiraKey } from './tracker.js';
+
+export const SOURCES = {
+  jira: 'Jira issues newly assigned to the person',
+  reviews: "GitHub pull requests where the person's review is requested",
+  ci: "the person's own open GitHub pull requests whose checks fail",
+  comments: 'new comments and mentions on Jira issues the person owns',
+  slack: 'Slack messages to the person (direct messages and mentions) that ask for work',
+};
+export const ASSISTANT_DEFAULTS = {
+  everyMin: 15,
+  sources: Object.keys(SOURCES),
+  maxPerDay: 10,
+  maxRunning: 5,
+  permissionMode: 'auto',
+  model: null,
+  notes: '',
+};
+const DAY = 86_400_000;
+const BIN = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'bin', 'agentmgr.js');
+
+const err = (status, message) => Object.assign(new Error(message), { status });
+
+export const assistantDir = () => path.join(paths.home, 'assistant');
+
+/** Settings from config.json's "assistant", with defaults and sane bounds. */
+export function assistantSettings(config = {}) {
+  const c = { ...ASSISTANT_DEFAULTS, ...config.assistant };
+  const n = (v, d, lo, hi) => (Number.isFinite(Number(v)) && Number(v) >= lo ? Math.min(hi, Math.floor(Number(v))) : d);
+  const sources = Array.isArray(c.sources) ? c.sources.filter((s) => SOURCES[s]) : ASSISTANT_DEFAULTS.sources;
+  return {
+    everyMin: n(c.everyMin, ASSISTANT_DEFAULTS.everyMin, 1, 1440),
+    sources,
+    maxPerDay: n(c.maxPerDay, ASSISTANT_DEFAULTS.maxPerDay, 0, 500),
+    maxRunning: n(c.maxRunning, ASSISTANT_DEFAULTS.maxRunning, 0, 100),
+    permissionMode: typeof c.permissionMode === 'string' && c.permissionMode ? c.permissionMode : null,
+    model: typeof c.model === 'string' && c.model ? c.model : null,
+    notes: typeof c.notes === 'string' ? c.notes.slice(0, 4000) : '',
+  };
+}
+
+/** The assistant's standing instructions (appended to its system prompt on every launch). */
+export function assistantPrompt(s, dir, bin = `node ${BIN}`) {
+  const am = bin;
+  const watch = s.sources.map((k) => `- ${SOURCES[k]}`).join('\n');
+  const how = [];
+  if (s.sources.includes('jira')) {
+    how.push(
+      `Jira, new assignments: with your Jira / Atlassian tools, find unresolved issues assigned to the person that were created or assigned since your last check (on the first check, the last 2 days). ` +
+        `For each one you haven't handled, start an agent: ${am} add @<project> "<the issue link> <a one-line summary of what to do>". ` +
+        `Start the request with the issue link: the agent is then named after the issue key, and the daemon refuses a second agent for the same key.`,
+    );
+  }
+  if (s.sources.includes('comments')) {
+    how.push(
+      `Jira, comments and mentions: find new comments on issues the person owns or is mentioned in, since your last check. ` +
+        `If an agent is already working on that issue (its name is the issue key; see ${am} ls --json), pass the comment on: ${am} tell <agent id> "New comment on <key> from <author>: <the comment>". ` +
+        `A comment that asks for new work on an issue with no agent: start one as above. Otherwise just record it.`,
+    );
+  }
+  if (s.sources.includes('reviews')) {
+    how.push(
+      `GitHub reviews: gh search prs --review-requested=@me --state=open --json url,title,repository,updatedAt. ` +
+        `For each pull request you haven't handled, start a review agent in its project: ${am} add @<project> "Review <the PR link>: read the change, check out the branch if needed, and write the review as comments for the person to post. Don't approve, request changes or post anything yourself."`,
+    );
+  }
+  if (s.sources.includes('ci')) {
+    how.push(
+      `Failing checks: gh search prs --author=@me --state=open --json url,title,repository, then gh pr checks <url> for each. ` +
+        `For a pull request with failing checks: if an agent already works on it (${am} ls --json lists each agent's PRs), tell that agent: ${am} tell <agent id> "Checks fail on <PR link>: <which checks>. Find out why and fix it." ` +
+        `Otherwise start one: ${am} add @<project> "Checks fail on <PR link>: find out why and fix it on that branch."`,
+    );
+  }
+  if (s.sources.includes('slack')) {
+    how.push(
+      `Slack: with your Slack tools, read direct messages to the person and messages that mention them, since your last check. ` +
+        `When one clearly asks for work in a known project, start an agent for it and include the message link in the request. Don't reply in Slack; record what you did.`,
+    );
+  }
+  return [
+    `You are the person's assistant inside AI Agent Manager (agentmgr). You run all the time in the background and work on their behalf: you find new work and start agents for it, so the work is under way before they look. You don't do the work yourself.`,
+    `Watch:\n${watch}`,
+    `Each time you get a message starting with "Check now", do one check of every source above, act, record it, and wait for the next message. Don't loop or sleep on your own.`,
+    `How:\n${how.map((h, i) => `${i + 1}. ${h}`).join('\n')}`,
+    `Projects: ${am} project ls shows the projects and their shortcuts. Pick the project whose repository matches the work (the Jira project, the GitHub repository). ` +
+      `If no project fits, use --repo <git URL> when you know the repository; if you don't know where the work belongs, don't start an agent: list it under "Needs you" in the activity file.`,
+    `Limits: the daemon allows at most ${s.maxPerDay} new agents a day and ${s.maxRunning} of yours running at once, and refuses a second agent for the same issue. When ${am} add is refused, don't retry it in this check: record the reason.`,
+    `Memory: keep ${path.join(dir, 'handled.json')} as a JSON object from item keys (a Jira key, a PR URL, "<key>#comment-<id>", a Slack message link) to { "at": time, "action": "started <agent id>" | "told <agent id>" | "skipped: why" }. Read it at the start of each check and add what you handled, so you never act on the same item twice. Keep "lastCheck" in it too.`,
+    `Activity: after each check, append a short entry to ${path.join(dir, 'activity.md')}: a "## <date and time>" heading, then one line per action ("Started OPS-7 (agent 3fa2b1) in @cc: fix the login timeout", "Told 3fa2b1 about a new comment on OPS-7"), and a "Needs you" list for anything you couldn't decide. Write "Nothing new." when nothing came in. AI Agent Manager shows this file to the person.`,
+    `Never merge, approve, close, reassign or comment on anything in Jira, GitHub or Slack, and never send messages as the person. Reading, and starting or telling agents, is all you do.`,
+    s.notes ? `The person's notes for you:\n${s.notes}` : '',
+  ]
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+export class Assistant {
+  constructor({ manager, store, config = {}, log = (m) => console.log(`[agentmgr] ${m}`) }) {
+    this.manager = manager;
+    this.store = store;
+    this.config = config;
+    this.log = log;
+    store.data.assistant ??= {};
+    this.timer = setInterval(() => this.tick(), 30_000);
+    this.timer.unref?.();
+  }
+
+  close() {
+    clearInterval(this.timer);
+  }
+
+  get settings() {
+    return assistantSettings(this.config);
+  }
+
+  get state() {
+    return this.store.data.assistant;
+  }
+
+  /** The assistant agent, if there is one. */
+  agent() {
+    const id = this.state.agentId;
+    const a = id && this.store.get(id);
+    return a?.kind === 'assistant' ? a : null;
+  }
+
+  /** Change settings; kept in config.json by the caller. Running sessions get them on the next launch. */
+  update(patch = {}) {
+    if (patch.sources !== undefined && (!Array.isArray(patch.sources) || patch.sources.some((s) => !SOURCES[s]))) {
+      throw err(400, `sources must be a list of: ${Object.keys(SOURCES).join(', ')}`);
+    }
+    for (const k of ['everyMin', 'maxPerDay', 'maxRunning']) {
+      if (patch[k] !== undefined && !(Number(patch[k]) >= (k === 'everyMin' ? 1 : 0))) throw err(400, `${k} must be ${k === 'everyMin' ? 1 : 0} or more`);
+    }
+    const next = assistantSettings({ assistant: { ...this.config.assistant, ...patch } });
+    this.config.assistant = next;
+    return next;
+  }
+
+  /** Create the assistant if needed and start it; the first check follows once it is ready. */
+  start() {
+    let a = this.agent();
+    if (!a) {
+      const s = this.settings;
+      fs.mkdirSync(assistantDir(), { recursive: true });
+      a = this.manager.create({ kind: 'assistant', name: 'Assistant', permissionMode: s.permissionMode || undefined, model: s.model || undefined, start: true });
+      this.state.agentId = a.id;
+      this.state.nextAt = new Date(Date.now() + 20_000).toISOString();
+      this.store.save();
+      this.log('assistant started');
+      return this.status();
+    }
+    this.state.paused = false;
+    this.state.nextAt ??= new Date(Date.now() + 20_000).toISOString();
+    this.store.save();
+    if (!this.manager.runtimes.get(a.id)?.pty) this.manager.start(a.id);
+    return this.status();
+  }
+
+  /** Stop checking and close the session (it keeps its memory; start resumes it). */
+  async pause() {
+    const a = this.agent();
+    this.state.paused = true;
+    this.store.save();
+    if (a && this.manager.runtimes.get(a.id)?.pty) await this.manager.stop(a.id);
+    return this.status();
+  }
+
+  /** Ask for a check now (queued until the session is idle). */
+  check({ by = 'person' } = {}) {
+    const a = this.agent();
+    if (!a) throw err(409, 'The assistant is not set up yet: start it first');
+    const last = this.state.lastCheckAt;
+    const n = (this.state.checks ?? 0) + 1;
+    const text = `Check now (check ${n}, ${new Date().toISOString()}${last ? `; last check ${last}` : '; first check'}${by === 'person' ? ', asked by the person' : ''}).`;
+    this.manager.tell(a.id, text, { source: 'assistant' });
+    this.state.checks = n;
+    this.state.lastCheckAt = new Date().toISOString();
+    this.state.nextAt = new Date(Date.now() + this.settings.everyMin * 60_000).toISOString();
+    this.store.save();
+    return this.status();
+  }
+
+  /** The scheduler: a check every everyMin minutes while the assistant is on and free. */
+  tick(t = Date.now()) {
+    const a = this.agent();
+    // Paused, or closed by hand: no checks until it is started again.
+    if (!a || this.state.paused || a.desired === 'stopped') return;
+    if (Date.parse(this.state.nextAt ?? 0) > t) return;
+    const rt = this.manager.runtimes.get(a.id);
+    // Busy with the last check, or a message still waiting to be typed in: try again shortly.
+    if (rt?.busy || this.manager.outbox.get(a.id)?.length) return;
+    if (!rt?.pty && a.status === 'preparing') return;
+    try {
+      this.check({ by: 'schedule' });
+    } catch (e) {
+      this.log(`assistant: ${e.message}`);
+    }
+  }
+
+  /** Agents the assistant started. */
+  started() {
+    const a = this.agent();
+    return a ? this.store.list().filter((x) => x.startedBy === a.id) : [];
+  }
+
+  /**
+   * Called before the assistant's own session creates agents: enforces the daily cap, the cap on
+   * its running agents, and one agent per issue. Returns the creation options to add.
+   */
+  admit(callerId, intents, opts = {}) {
+    const a = this.agent();
+    if (!a || callerId !== a.id) return {};
+    const s = this.settings;
+    const mine = this.started();
+    const today = mine.filter((x) => Date.now() - Date.parse(x.createdAt) < DAY).length;
+    if (today + intents.length > s.maxPerDay) throw err(429, `The assistant's limit is ${s.maxPerDay} new agents a day (${today} so far); not started`);
+    const running = mine.filter((x) => this.manager.runtimes.get(x.id)?.pty || x.status === 'preparing').length;
+    if (running + intents.length > s.maxRunning) throw err(429, `The assistant's limit is ${s.maxRunning} of its agents running at once (${running} now); not started`);
+    for (const intent of intents) {
+      const key = opts.name?.trim() || leadingJiraKey(intent);
+      const dup = key && this.store.list().find((x) => x.kind === 'task' && x.name.toLowerCase() === key.toLowerCase());
+      if (dup) throw err(409, `An agent for ${key} already exists: ${dup.name} (${dup.id}); tell it instead`);
+    }
+    return { startedBy: a.id };
+  }
+
+  activity({ chars = 20_000 } = {}) {
+    try {
+      const text = fs.readFileSync(path.join(assistantDir(), 'activity.md'), 'utf8');
+      return text.length > chars ? text.slice(text.indexOf('\n## ', text.length - chars) + 1 || text.length - chars) : text;
+    } catch {
+      return '';
+    }
+  }
+
+  status() {
+    const a = this.agent();
+    const rt = a && this.manager.runtimes.get(a.id);
+    const mine = this.started();
+    return {
+      ...this.settings,
+      agentId: a?.id ?? null,
+      on: Boolean(a && !this.state.paused),
+      running: Boolean(rt?.pty),
+      busy: Boolean(rt?.busy),
+      checks: this.state.checks ?? 0,
+      lastCheckAt: this.state.lastCheckAt ?? null,
+      nextAt: a && !this.state.paused ? (this.state.nextAt ?? null) : null,
+      startedToday: mine.filter((x) => Date.now() - Date.parse(x.createdAt) < DAY).length,
+      startedTotal: mine.length,
+      started: mine
+        .sort((x, y) => y.createdAt.localeCompare(x.createdAt))
+        .slice(0, 20)
+        .map((x) => ({ id: x.id, name: x.name, intent: x.intent, createdAt: x.createdAt })),
+      activity: this.activity(),
+    };
+  }
+}

package/src/cleanup.js

@@ -81,6 +81,7 @@ export class Cleanup {
   /** Why an agent is left alone whatever its age, or null. */
   protectedBy(agent) {
     if (agent.keep) return 'marked Keep';
+    if (agent.kind === 'assistant') return 'the assistant';
     if (agent.status === 'preparing') return 'still setting up';
     const rt = this.manager.runtimes.get(agent.id);
     if (rt?.pty && rt.busy) return 'working';

package/src/cli.js

@@ -451,6 +451,42 @@ export async function main(argv) {
       console.log(`${res.name}: P${res.priority}`);
     });
 
+  program
+    .command('edit')
+    .description("Change an agent's name, request, project, priority, permission mode or model")
+    .argument('<agent>')
+    .option('-n, --name <name>', 'display name')
+    .option('-i, --intent <text>', 'the request as recorded (add --tell to send it to the session too)')
+    .option('--tell', 'with --intent: also tell the agent about the changed request')
+    .option('--project <project>', 'move under this project (shortcut or name); "" for its own repo or folder')
+    .option('--priority <P0-P3>', 'priority')
+    .option('-p, --permission-mode <mode>', 'permission mode, from the next launch ("" for the default)')
+    .option('-m, --model <model>', 'model, from the next launch ("" for the default)')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const patch = Object.fromEntries(
+        [['name', opts.name], ['intent', opts.intent], ['project', opts.project], ['priority', opts.priority], ['permissionMode', opts.permissionMode], ['model', opts.model]].filter(([, v]) => v !== undefined),
+      );
+      if (!Object.keys(patch).length) throw new Error('Nothing to change: give --name, --intent, --project, --priority, --permission-mode or --model');
+      const res = await api('PATCH', `/agents/${a.id}`, patch);
+      if (opts.tell && opts.intent) await api('POST', `/agents/${a.id}/tell`, { text: `The request changed. It is now:\n${opts.intent}` });
+      console.log(`${green('✓')} ${bold(res.name)} ${dim(res.id)}  ${res.projectInfo?.name ?? ''}  P${res.priority}${res.permissionMode ? `  ${res.permissionMode}` : ''}${res.model ? `  ${res.model}` : ''}`);
+      if (patch.permissionMode !== undefined || patch.model !== undefined) console.log(dim('Permission mode and model apply from its next launch.'));
+    });
+
+  program
+    .command('move')
+    .description('Move an agent under another project (shortcut or name); "" moves it back to its own')
+    .argument('<agent>')
+    .argument('<project>')
+    .action(async (ref, project) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const res = await api('PATCH', `/agents/${a.id}`, { project });
+      console.log(`${green('✓')} ${bold(res.name)} is now under ${bold(res.projectInfo?.full || res.projectInfo?.name)}`);
+    });
+
   program
     .command('plan')
     .description('While the workspace is still being prepared, plan the task with Claude and attach')
@@ -1043,6 +1079,68 @@ export async function main(argv) {
       if (c.lastRun) console.log(dim(`\nLast run ${new Date(c.lastRun.at).toLocaleString()} (${c.lastRun.by}): closed ${c.lastRun.closed.length}, deleted ${c.lastRun.deleted.length}`));
     });
 
+  const asCmd = program.command('assistant').description('An always-on session that finds new work (Jira, GitHub, Slack) and starts agents for it');
+  const showAssistant = (a) => {
+    const state = !a.agentId ? dim('not set up (agentmgr assistant start)') : a.on ? green(a.busy ? 'on, checking now' : 'on') : yellow('paused');
+    console.log(`${bold('Assistant')}: ${state}${a.agentId ? dim(`  agent ${a.agentId}`) : ''}`);
+    console.log(`checks every ${a.everyMin} min · watches ${a.sources.join(', ') || 'nothing'} · at most ${a.maxPerDay} new agents a day, ${a.maxRunning} running`);
+    if (a.lastCheckAt) console.log(dim(`last check ${new Date(a.lastCheckAt).toLocaleString()}${a.nextAt ? ` · next ${new Date(a.nextAt).toLocaleTimeString()}` : ''} · started ${a.startedToday} today, ${a.startedTotal} in all`));
+    for (const x of a.started.slice(0, 10)) console.log(`  ${green('+')} ${bold(x.name)} ${dim(x.id)}  ${truncate(x.intent, 70)}`);
+  };
+  asCmd
+    .command('status', { isDefault: true })
+    .description('Show whether it is on, its settings, and the agents it started')
+    .option('--activity', 'also print its activity log')
+    .action(async (opts) => {
+      await daemon();
+      const a = await api('GET', '/assistant');
+      showAssistant(a);
+      if (opts.activity) console.log(`\n${a.activity || dim('No activity yet.')}`);
+    });
+  asCmd
+    .command('start')
+    .description('Set it up (first time) or turn it back on')
+    .action(async () => {
+      await daemon();
+      showAssistant(await api('POST', '/assistant/start'));
+    });
+  asCmd
+    .command('pause')
+    .description('Stop checking and close its session (start resumes it with its memory)')
+    .action(async () => {
+      await daemon();
+      showAssistant(await api('POST', '/assistant/pause'));
+    });
+  asCmd
+    .command('check')
+    .description('Check for new work now')
+    .action(async () => {
+      await daemon();
+      await api('POST', '/assistant/check');
+      console.log(`${green('✓')} asked the assistant to check now`);
+    });
+  asCmd
+    .command('set')
+    .description('Change its settings (they apply from its next launch; pause and start to apply now)')
+    .option('--every <minutes>', 'check this often')
+    .option('--sources <list>', 'comma-separated: jira,comments,reviews,ci,slack')
+    .option('--max-per-day <n>', 'new agents a day, at most')
+    .option('--max-running <n>', 'of its agents running at once, at most')
+    .option('--permission-mode <mode>', 'its own permission mode (default auto, so it can run agentmgr and gh without asking)')
+    .option('--notes <text>', 'standing notes, e.g. which Jira project goes to which repo')
+    .action(async (opts) => {
+      await daemon();
+      const patch = {
+        ...(opts.every ? { everyMin: Number(opts.every) } : {}),
+        ...(opts.sources ? { sources: opts.sources.split(',').map((x) => x.trim()).filter(Boolean) } : {}),
+        ...(opts.maxPerDay ? { maxPerDay: Number(opts.maxPerDay) } : {}),
+        ...(opts.maxRunning ? { maxRunning: Number(opts.maxRunning) } : {}),
+        ...(opts.permissionMode ? { permissionMode: opts.permissionMode } : {}),
+        ...(opts.notes !== undefined ? { notes: opts.notes } : {}),
+      };
+      showAssistant(await api('PUT', '/assistant', patch));
+    });
+
   program
     .command('doctor')
     .description('Check what AI Agent Manager needs on this machine (Node.js, Claude Code, git, gh, the daemon) and how to fix it')
@@ -1459,7 +1557,7 @@ export async function main(argv) {
           i === 0 || proj(agents[i - 1]) !== proj(a) ? bold(truncate(proj(a), 30)) : '',
           a.priority === 0 ? red(bold('P0')) : a.priority === 1 ? red('P1') : a.priority === 3 ? dim('P3') : 'P2',
           a.id,
-          truncate(a.kind === 'general' ? `${a.name} (general)` : a.name, 28),
+          truncate(a.kind === 'general' ? `${a.name} (general)` : a.startedBy ? `${a.name} (assistant)` : a.name, 28),
           statusLabel(a),
           a.git?.branch ?? '',
           String(a.prs.length || ''),

package/src/client.js

@@ -10,7 +10,8 @@ const BIN = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'bin',
 export async function api(method, route, body) {
   const res = await fetch(`${BASE}/api${route}`, {
     method,
-    headers: { 'content-type': 'application/json', 'x-agentmgr': '1' },
+    // From inside an agent's session, say which agent is asking (the assistant's limits use it).
+    headers: { 'content-type': 'application/json', 'x-agentmgr': '1', ...(process.env.AGENTMGR_AGENT_ID ? { 'x-agentmgr-agent': process.env.AGENTMGR_AGENT_ID } : {}) },
     body: body === undefined ? undefined : JSON.stringify(body),
   });
   const data = await res.json().catch(() => ({}));

package/src/manager.js

@@ -46,6 +46,7 @@ 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 { runningClaude, scanClaudeSessions } from './sessions.js';
 import {
   bugFromRef,
@@ -119,9 +120,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
@@ -363,7 +370,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 +521,7 @@ export class AgentManager extends EventEmitter {
     engine,
     sessionId: adopt,
     imported,
+    startedBy,
   }) {
     intent = (intent ?? '').trim();
     const engineDef = engineOf(engine || this.config.engine || DEFAULT_ENGINE);
@@ -524,7 +534,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 +558,11 @@ 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 } : {}),
       name: name?.trim() || jiraKey || slug,
       slug,
       intent,
@@ -687,6 +698,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 +873,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 +891,12 @@ export class AgentManager extends EventEmitter {
       prompts.push(agent.planReview.status === 'approved' ? planApprovedPrompt(file) : planReviewPrompt(file));
     }
     if (planning) prompts.push(planningPrompt(agent));
+    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 });
@@ -1190,8 +1211,28 @@ 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 ('priority' in fields) {
@@ -1199,7 +1240,25 @@ export class AgentManager extends EventEmitter {
       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));
   }
 
@@ -2049,7 +2108,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 +2146,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 +2382,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 +2463,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 +2523,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;

package/src/notify.js

@@ -16,6 +16,7 @@ export const EVENT_DEFAULTS = {
   stuck: true, // going in circles: same failure, undoing its edits, or long stretches without changes
   conflict: true, // changing the same files as another agent in the same repo
   question: true, // asked a question in the decision inbox
+  assistant: true, // the assistant started an agent for new work
 };
 
 // Alerts the AI judge may hold for the digest or drop; the rest are always sent at once.
@@ -264,7 +265,7 @@ export class Notifier {
 
   deliver(kind, agent, what, n, urgency = null) {
     if (!n.enabled || !n.events[kind]) return;
-    const icon = { needsInput: ':raised_hand:', review: ':white_check_mark:', error: ':x:', waiting: ':hourglass_flowing_sand:', blocked: ':no_entry:', stuck: ':repeat:', conflict: ':crossed_swords:', question: ':question:' }[kind];
+    const icon = { needsInput: ':raised_hand:', review: ':white_check_mark:', error: ':x:', waiting: ':hourglass_flowing_sand:', blocked: ':no_entry:', stuck: ':repeat:', conflict: ':crossed_swords:', question: ':question:', assistant: ':robot_face:' }[kind];
     const project = agent.projectInfo?.name ? ` (${agent.projectInfo.name})` : '';
     const link = this.linkFor(agent.id);
     const intent = n.includeIntent && agent.intent ? `\n> ${agent.intent.replace(/\s+/g, ' ').slice(0, 200)}` : '';

package/src/server.js

@@ -11,6 +11,7 @@ import { AgentManager, shellNumber } from './manager.js';
 import { Backlog } from './backlog.js';
 import { Races } from './races.js';
 import { Teams } from './teams.js';
+import { Assistant } from './assistant.js';
 import { Cleanup } from './cleanup.js';
 import { listEngines, registerEngine } from './engines/index.js';
 import { Plugins, pluginSpecs } from './plugins.js';
@@ -59,6 +60,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   const races = new Races({ manager, store });
   const teams = new Teams({ manager, store, config });
   const cleanup = new Cleanup({ manager, store, config, teams });
+  const assistant = new Assistant({ manager, store, config });
   // Alerts link to the phone address when remote access is on, else the local UI.
   const notifier = new Notifier({
     manager,
@@ -177,8 +179,16 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   api.post(
     '/agents',
     wrap((req) => {
-      const { intents, intent, ...opts } = req.body ?? {};
-      return manager.createMany(Array.isArray(intents) ? intents : [intent], opts);
+      const { intents, intent, startedBy, ...opts } = req.body ?? {};
+      if (opts.kind === 'assistant') throw fail(400, 'Start the assistant with POST /assistant/start');
+      const list = (Array.isArray(intents) ? intents : [intent]).map((i) => String(i ?? '').trim()).filter(Boolean);
+      // Agents the assistant's own session starts: its limits apply, and they are marked as its.
+      const extra = assistant.admit(req.headers['x-agentmgr-agent'], list, opts);
+      const created = manager.createMany(list, { ...opts, ...extra });
+      if (extra.startedBy) {
+        for (const a of created) notifier.send('assistant', a, `was started by the assistant: ${a.intent.replace(/\s+/g, ' ').slice(0, 160)}`);
+      }
+      return created;
     }),
   );
   api.post('/general', wrap((req) => manager.createGeneral(req.body ?? {})));
@@ -404,6 +414,15 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   api.delete('/races/:id', wrap((req) => races.remove(req.params.id)));
 
   // Clean up old agents: the strategy and days (kept in config.json), what a run would do, run now.
+  api.get('/assistant', wrap(() => assistant.status()));
+  api.put('/assistant', wrap((req) => {
+    const next = assistant.update(req.body ?? {});
+    saveConfig({ assistant: next });
+    return assistant.status();
+  }));
+  api.post('/assistant/start', wrap(() => assistant.start()));
+  api.post('/assistant/pause', wrap(() => assistant.pause()));
+  api.post('/assistant/check', wrap(() => assistant.check()));
   api.get('/cleanup', wrap(() => cleanup.status()));
   api.put('/cleanup', wrap(async (req) => {
     const next = cleanup.update(req.body ?? {});
@@ -756,6 +775,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     if (closing) return;
     closing = true;
     cleanup.close();
+    assistant.close();
     console.log(`[agentmgr] shutting down (${reason}); closing agents so their sessions are saved`);
     await manager.stopAll({ final: true });
     await manager.flush().catch((err) => console.error(`[agentmgr] final flush failed: ${err.message}`));
@@ -792,6 +812,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     manager,
     teams,
     cleanup,
+    assistant,
     backlog,
     live,
     url: `http://${host}:${port}`,