claude-code-kanban 5.1.1 → 5.3.0

package/server.js

@@ -16,6 +16,7 @@ const { isContained } = require('./lib/contain');
 const { resolveScratchSubdir, listScratchDir } = require('./lib/scratch-files');
 const { fileUrlToPath } = require('./lib/file-url');
 const { pluginStatus } = require('./lib/plugin-status');
+const { getAutoCompact } = require('./lib/auto-compact');
 
 const {
   readRecentMessages: _readRecentMessagesUncached,
@@ -38,15 +39,18 @@ const {
 } = require('./lib/parsers');
 const { inlineHtmlAssets, MIME_BY_EXT } = require('./lib/inline-assets');
 const { buildDecision, decisionFileName, isDecisionFile, approvalsFrom, boardRefusal } = require('./lib/approvals');
-const { getClaudeDir, getArgValue, storageNamespace, isDefaultClaudeDir } = require('./lib/claude-dir');
+const { getClaudeDir, getArgValue, storageNamespace, isDefaultClaudeDir, encodeProjectDirName } = require('./lib/claude-dir');
 const { createTerminalService, readTerminalConfig } = require('./lib/terminal');
-const { createDispatchRegistry, formatPreamble, formatDispatchLine, isPeerName } = require('./lib/dispatch');
+const { createProcStats } = require('./lib/proc-stats');
+const { createDispatchRegistry, formatPreamble, formatDispatchLine, isPeerName, DISPATCH_OUTCOME } = require('./lib/dispatch');
 const { createGroupStore, isGroupName, suggestGroupName } = require('./lib/dispatch-groups');
+const { createDispatchedStore, scanTranscripts, pruneSessionDirs, retentionMs } = require('./lib/retention');
+const { createWorktreeStore } = require('./lib/worktrees');
 const { createLinkedDocStore, linkUrl } = require('./lib/linked-docs');
 const { pickFolder } = require('./lib/folder-dialog');
 const { loadSessionCache, saveSessionCache } = require('./lib/session-cache');
 const { countTaskDir } = require('./lib/task-counts');
-const { projectMatcher } = require('./public/project-match');
+const { projectMatcher, normalizeProjectPath } = require('./public/project-match');
 const { getParentVerdict, setParentVerdict } = require('./lib/parent-cache');
 
 if (process.argv.includes("--install") || process.argv.includes("--uninstall")) {
@@ -67,7 +71,8 @@ const PORT = parseInt(getArgValue('port') || process.env.PORT || '3541', 10);
 
 // Mounted before express.json() so a rejected request never buffers a body, and
 // before the /api catch-all so no route escapes the check.
-const net = createNetGuard({ appName: 'Claude Task Kanban' });
+// The board frames the terminal from its other loopback name, so Chrome runs it in its own process.
+const net = createNetGuard({ appName: 'Claude Task Kanban', selfFramedPaths: ['/terminal.html'] });
 app.use(net.hostGuard);
 app.use(net.frameGuard);
 app.use(net.originGuard);
@@ -90,6 +95,8 @@ const AGENT_ACTIVITY_DIR = path.join(CCK_DIR, 'agent-activity');
 const CONTEXT_STATUS_DIR = path.join(CCK_DIR, 'context-status');
 const PINS_FILE = path.join(CCK_DIR, 'pins.json');
 const DISPATCH_GROUPS_FILE = path.join(CCK_DIR, 'dispatch-groups.json');
+const DISPATCHED_FILE = path.join(CCK_DIR, 'dispatched.json');
+const WORKTREES_FILE = path.join(CCK_DIR, 'worktrees.json');
 const LINKED_DOCS_FILE = path.join(CCK_DIR, 'linked-docs.json');
 const SERVER_INFO_FILE = path.join(CCK_DIR, 'server.json');
 const TERMINAL_TOKENS_DIR = path.join(CCK_DIR, 'terminal-tokens');
@@ -200,6 +207,7 @@ const WAITING_RESOLVE_GRACE_MS = 15 * 1000;
 const CTX_CLEANUP_MAX_AGE_MS = 2 * 60 * 60 * 1000;
 const CLEANUP_MAX_AGE_MS = 2 * 24 * 60 * 60 * 1000;
 const CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
+const RETENTION_FIRST_RUN_MS = 5 * 60 * 1000;
 // #endregion
 
 // #region AGENT_ACTIVITY
@@ -286,6 +294,11 @@ function getContextStatus(sessionId, meta) {
   return contextStatusCache.get(sessionId) || (meta?.teamLeaderId ? contextStatusCache.get(meta.teamLeaderId) : null) || null;
 }
 
+function getContextFields(sessionId, meta) {
+  const contextStatus = getContextStatus(sessionId, meta);
+  return { contextStatus, autoCompact: contextStatus ? getAutoCompact(CLAUDE_DIR, meta?.project) : null };
+}
+
 function isAgentFresh(agent) {
   if (isGhostAgent(agent)) return false;
   const ts = agent.updatedAt || agent.startedAt;
@@ -329,33 +342,12 @@ function getGitBranch(cwd) {
   return branch;
 }
 
-// A linked worktree's `.git` is a file holding `gitdir: <main>/.git/worktrees/<name>`, so the
-// main checkout is readable without spawning git. Path shape alone would not do: only some
-// worktrees live under `<repo>/.claude/worktrees/`, the rest sit beside the repo.
-// Cached without a TTL, misses included: a directory cannot turn from an ordinary checkout into
-// a linked worktree without being recreated, and a recreated path is a new cache key.
-const worktreeCache = new Map();
-const WORKTREE_CACHE_MAX = 500;
-const GITDIR_WORKTREE_RE = /^gitdir:\s*(.*)[/\\]\.git[/\\]worktrees[/\\]([^/\\]+)[/\\]?$/;
-
-function resolveWorktree(dir) {
-  if (!dir) return null;
-  if (worktreeCache.has(dir)) return worktreeCache.get(dir);
-
-  let worktree = null;
-  try {
-    // An ordinary checkout's `.git` is a directory, so the read throws EISDIR — that is the
-    // answer, and it costs one syscall instead of a stat followed by a read.
-    const m = GITDIR_WORKTREE_RE.exec(readFileSync(path.join(dir, '.git'), 'utf8').trim());
-    if (m) worktree = { repo: m[1], name: m[2] };
-  } catch (_) {}
-
-  worktreeCache.set(dir, worktree);
-  if (worktreeCache.size > WORKTREE_CACHE_MAX) {
-    worktreeCache.delete(worktreeCache.keys().next().value);
-  }
-  return worktree;
-}
+const worktrees = createWorktreeStore({
+  load: () => {
+    try { return JSON.parse(readFileSync(WORKTREES_FILE, 'utf8')); } catch { return null; }
+  },
+  save: (data) => writeJsonAtomic(WORKTREES_FILE, data),
+});
 
 // Only spawn git when cwd has diverged from the launch project — that's the
 // only case the JSONL value is wrong. Saves N spawns on a typical list build.
@@ -1131,12 +1123,6 @@ function getSessionDisplayName(_sessionId, meta) {
   return null;
 }
 
-// The harness spells a project path into a temp/log dir name by replacing every
-// non-alphanumeric character with a dash, drive colon and separators included.
-function encodeProjectDirName(p) {
-  return p.replace(/[^a-zA-Z0-9]/g, '-');
-}
-
 // Derived by convention, not looked up: the harness creates the dir lazily, so a
 // stat here would report "missing" for every session that has not written a temp
 // file yet — and it would put IO on the session-list hot path. Pure string join.
@@ -1151,7 +1137,7 @@ function getScratchpadDir(id, meta) {
   // harness actually created. Probed only for worktree sessions, and only until one
   // of them exists — before that there is nothing to disambiguate and `byProject`,
   // right for a session started inside the worktree, stands.
-  const wt = resolveWorktree(meta.project);
+  const wt = worktrees.resolve(meta.project);
   if (!wt || existsSync(byProject)) return byProject;
   const byRepo = path.join(SCRATCHPAD_ROOT, encodeProjectDirName(wt.repo), id, 'scratchpad');
   return existsSync(byRepo) ? byRepo : byProject;
@@ -1170,7 +1156,7 @@ function buildSessionObject(id, meta, overrides = {}) {
     cwd: meta.cwd || null,
     description: meta.description || null,
     gitBranch: resolveSessionGitBranch(meta),
-    worktree: resolveWorktree(meta.project),
+    worktree: worktrees.resolve(meta.project),
     customTitle: meta.customTitle || null,
     taskCount: 0,
     completed: 0,
@@ -1191,7 +1177,7 @@ function buildSessionObject(id, meta, overrides = {}) {
     tasksDir: null,
     projectDir: meta.jsonlPath ? path.dirname(meta.jsonlPath) : null,
     scratchpadDir: getScratchpadDir(id, meta),
-    contextStatus: getContextStatus(id, meta),
+    ...getContextFields(id, meta),
     ...getPlanInfo(meta.slug),
     ...getWorkflowInfoSummary(id),
     ...overrides,
@@ -1520,10 +1506,7 @@ app.get('/api/sessions', async (req, res) => {
     // Backfill contextStatus for already-built sessions that are pinned
     for (const pid of pinnedIds) {
       const s = sessionsMap.get(pid);
-      if (s && !s.contextStatus) {
-        const meta = metadata[pid];
-        s.contextStatus = getContextStatus(pid, meta);
-      }
+      if (s && !s.contextStatus) Object.assign(s, getContextFields(pid, metadata[pid]));
     }
 
     // Ensure pinned sessions are in the map even if they weren't discovered
@@ -1572,7 +1555,7 @@ app.get('/api/sessions', async (req, res) => {
     // if the row is missing — that one is not a preference.
     if (projectFilter) {
       const matches = projectMatcher(String(projectFilter));
-      sessions = sessions.filter(s => matches(s.project) || includeIds.has(s.id));
+      sessions = sessions.filter(s => matches(s.project, s.worktree?.repo) || includeIds.has(s.id));
     }
     // The sidebar's 24h filter: projects with any transcript written in the window, so an older
     // session of such a project stays in.
@@ -1644,14 +1627,30 @@ function projectActivity() {
   return activity;
 }
 
-// API: Get distinct project paths with last-modified timestamps
+// API: Get distinct project paths with last-modified timestamps. A linked worktree is folded
+// into its repo, which lists it under `worktrees`; the repo row exists even when only its
+// worktrees have transcripts.
 app.get('/api/projects', (_req, res) => {
   res.setHeader('Cache-Control', 'no-store');
-  const projects = [...projectActivity()]
-    .map(([path, mtime]) => ({
-      path,
-      modifiedAt: mtime ? new Date(mtime).toISOString() : null,
-      ...(isTempPath(path) && { temp: true }),
+  const byRepo = new Map();
+  for (const [project, mtime] of projectActivity()) {
+    const repo = worktrees.resolve(project)?.repo || project;
+    const key = normalizeProjectPath(repo);
+    let row = byRepo.get(key);
+    if (!row) {
+      row = { path: repo, mtime: 0, worktrees: [] };
+      byRepo.set(key, row);
+    }
+    if (repo === project) row.path = project;
+    else row.worktrees.push(project);
+    row.mtime = Math.max(row.mtime, mtime || 0);
+  }
+  const projects = [...byRepo.values()]
+    .map((r) => ({
+      path: r.path,
+      modifiedAt: r.mtime ? new Date(r.mtime).toISOString() : null,
+      ...(isTempPath(r.path) && { temp: true }),
+      ...(r.worktrees.length && { worktrees: r.worktrees.sort() }),
     }))
     .sort((a, b) => a.path.localeCompare(b.path));
   res.json(projects);
@@ -1750,7 +1749,7 @@ app.get('/api/sessions/:sessionId/plan', async (req, res) => {
     if (!existsSync(planPath)) return res.json({ content: null });
 
     const content = await fs.readFile(planPath, 'utf8');
-    res.json({ content, slug });
+    res.json({ content, slug, path: planPath });
   } catch (error) {
     console.error('Error reading plan:', error);
     res.status(500).json({ error: 'Failed to read plan' });
@@ -3292,6 +3291,16 @@ app.get('/api/terminals', (_req, res) => {
   res.json({ sessions: terminal.list() });
 });
 
+const terminalProcStats = createProcStats();
+app.get('/api/terminals/stats', async (_req, res) => {
+  res.setHeader('Cache-Control', 'no-store');
+  const pids = terminal.claudePids();
+  const byPid = await terminalProcStats([process.pid, ...Object.values(pids)]);
+  const terminals = {};
+  for (const [id, pid] of Object.entries(pids)) if (byPid[pid]) terminals[id] = byPid[pid];
+  res.json({ cck: byPid[process.pid] || null, terminals });
+});
+
 app.delete('/api/terminals/:id', (req, res) => {
   const err = terminal.end(req.params.id, req.get('x-terminal-token'));
   if (err === 'auth') return res.status(401).json({ error: 'invalid terminal token' });
@@ -3318,9 +3327,17 @@ app.get('/vendor/xterm/:file', (req, res) => {
 // #endregion
 
 // #region DISPATCH
+const dispatched = createDispatchedStore({
+  load: () => {
+    try { return JSON.parse(readFileSync(DISPATCHED_FILE, 'utf8')); } catch { return null; }
+  },
+  save: (data) => writeJsonAtomic(DISPATCHED_FILE, data),
+});
+
 const dispatches = createDispatchRegistry({
   onSettle: (r) => {
     if (r.parent && r.report) enqueueSessionEvent(topicKey('dispatch', r.parent), formatDispatchLine(r));
+    if (r.session) dispatched.settle(r.session, r.status);
     broadcast({ type: 'dispatch-update' });
   },
 });
@@ -3343,17 +3360,19 @@ const linkedDocs = createLinkedDocStore({
 
 // The board places a session from these alone, so it never has to move it later.
 // `startedBy` lets it follow a starter the user put in a named group, which only the
-// browser knows; it goes once the dispatch settles.
+// browser knows; it goes once the dispatch settles. `dispatched` stays for the card's marker.
 function withDispatchPlacement(sessions) {
   const groups = dispatchGroups.snapshot();
-  const starters = new Map(
-    dispatches.list().filter((r) => r.status === 'running' && r.parent && r.session).map((r) => [r.session, r.parent]),
-  );
-  if (!groups.size && !starters.size) return sessions;
   return sessions.map((s) => {
     const dispatchGroup = groups.get(s.id);
-    const startedBy = starters.get(s.id);
-    return dispatchGroup || startedBy ? { ...s, dispatchGroup, startedBy } : s;
+    const marker = dispatched.get(s.id);
+    if (!dispatchGroup && !marker) return s;
+    return {
+      ...s,
+      dispatchGroup,
+      startedBy: marker?.status === 'running' ? marker.parent || undefined : undefined,
+      dispatched: marker ? { parent: marker.parent, outcome: DISPATCH_OUTCOME[marker.status] } : undefined,
+    };
   });
 }
 
@@ -3377,6 +3396,7 @@ app.post('/api/dispatch', (req, res) => {
     return res.status(started.status).json({ error: started.error });
   }
   dispatches.attach(r.id, { session: started.id, cwd: started.cwd });
+  dispatched.record(started.id, parent);
   // The starter stays where it is: moving it would jump it under the user.
   if (target) dispatchGroups.join(target, [started.id], parent);
   broadcast({ type: 'dispatch-update' });
@@ -3458,7 +3478,14 @@ app.get('/api/tasks/all', async (_req, res) => {
   }
 });
 
-const { enqueueSessionEvent, formatTaskMoved, handleSessionEvents, topicKey } = require('./lib/session-events');
+const {
+  enqueueSessionEvent,
+  formatReviewSubmitted,
+  formatTaskMoved,
+  handleSessionEvents,
+  hasSessionListener,
+  topicKey,
+} = require('./lib/session-events');
 app.get('/api/sessions/:sessionId/events', handleSessionEvents);
 
 // API: Create a task
@@ -3912,6 +3939,102 @@ app.get('/api/file/resolve', async (req, res) => {
 
 // #endregion
 
+// #region REVIEW
+// API: Send review comments on something the board shows (a file preview today) to a
+// session. The source is described, not interpreted, so a new kind of preview needs a
+// client change only. The batch is always written to a file: the doorbell is lossy and
+// carries one line, and the file is what each route points at.
+const REVIEW_DIR = path.join(CCK_DIR, 'reviews');
+const REVIEW_KIND_RE = /^[a-z]{1,20}$/;
+const REVIEW_MAX_COMMENTS = 50;
+const REVIEW_MAX_CHARS = 4000;
+
+function parseReviewBody(body) {
+  const { source, comments } = body || {};
+  if (!source || !REVIEW_KIND_RE.test(source.kind)) throw previewError(400, 'source.kind is required');
+  // The label is pasted into the terminal; an ESC could end bracketed paste and submit text.
+  const label = String(source.label || '')
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: strips control characters on purpose
+    .replace(/[\x00-\x1f\x7f]/g, ' ')
+    .trim()
+    .slice(0, 200);
+  if (!label) throw previewError(400, 'source.label is required');
+  if (!Array.isArray(comments) || !comments.length || comments.length > REVIEW_MAX_COMMENTS) {
+    throw previewError(400, `comments must hold 1 to ${REVIEW_MAX_COMMENTS} items`);
+  }
+  const field = (v, max) => (typeof v === 'string' && v.trim() ? v.trim().replace(/\s+/g, ' ').slice(0, max) : null);
+  // Element and selector are printed inside a markdown code span.
+  const code = (v, max) => field(v, max)?.replace(/`/g, "'") || null;
+  const items = comments.map((c) => ({
+    quote: String(c?.quote || '').trim().slice(0, REVIEW_MAX_CHARS),
+    comment: String(c?.comment || '').trim().slice(0, REVIEW_MAX_CHARS),
+    heading: field(c?.heading, 200),
+    line: Number.isInteger(c?.line) && c.line > 0 ? c.line : null,
+    element: code(c?.element, 300),
+    selector: code(c?.selector, 500),
+  }));
+  if (items.some((c) => !c.comment)) throw previewError(400, 'every comment needs text');
+  return { kind: source.kind, label, path: source.kind === 'file' ? source.path : null, items };
+}
+
+function formatReviewMarkdown(src, items) {
+  const parts = [
+    `# Review of ${src.path || src.label}`,
+    '',
+    `Each comment is the user's instruction about the quoted text.${src.path ? ' A quote missing from the source means the source changed after the review: say so.' : ''}`,
+  ];
+  items.forEach((c, i) => {
+    const where = [c.line && `line ${c.line}`, c.heading && `under "${c.heading}"`].filter(Boolean).join(', ');
+    parts.push('', `## ${i + 1}${where ? ` (${where})` : ''}`, '');
+    if (c.element) parts.push(`Element: \`${c.element}\`${c.selector ? ` at \`${c.selector}\`` : ''}`, '');
+    if (c.quote) parts.push(...c.quote.split(/\r?\n/).map((l) => `> ${l}`), '');
+    parts.push(c.comment);
+  });
+  return `${parts.join('\n')}\n`;
+}
+
+function isWaitingOnUser(sessionId) {
+  const meta = loadSessionMetadata()[sessionId] || {};
+  return !!checkWaitingForUser(path.join(AGENT_ACTIVITY_DIR, sessionId), getSessionLogStat(meta).mtime);
+}
+
+app.post('/api/sessions/:sessionId/review', async (req, res) => {
+  try {
+    const sessionId = req.params.sessionId;
+    if (!isUUID(sessionId)) return res.status(400).json({ error: 'invalid session id' });
+    const src = parseReviewBody(req.body);
+    if (src.kind === 'file') {
+      src.path = resolvePreviewPath(src.path);
+      if (!src.path) return res.status(400).json({ error: 'source.path is required for a file' });
+      await statFileTarget(src.path);
+    }
+
+    const markdown = formatReviewMarkdown(src, src.items);
+    const dir = path.join(REVIEW_DIR, sessionId);
+    await fs.mkdir(dir, { recursive: true });
+    const file = path.join(dir, `${Date.now()}.md`);
+    await fs.writeFile(file, markdown);
+
+    let delivered = null;
+    if (hasSessionListener(sessionId)) {
+      enqueueSessionEvent(sessionId, formatReviewSubmitted(src.items.length, src.label, file));
+      delivered = 'doorbell';
+    } else if (
+      terminal.authorized(req.get('x-terminal-token')) &&
+      terminal.isRunning(sessionId) &&
+      !isWaitingOnUser(sessionId)
+    ) {
+      if (terminal.paste(sessionId, `Address my review comments on ${src.label}: ${file}`)) delivered = 'terminal';
+    }
+    res.json({ delivered, file, markdown });
+  } catch (error) {
+    if (!error.status) console.error('Error in POST /api/sessions/:id/review:', error);
+    res.status(error.status || 500).json({ error: error.message || 'Review failed' });
+  }
+});
+
+// #endregion
+
 // #region SSE
 // SSE endpoint for live updates
 app.get('/api/events', (req, res) => {
@@ -4201,10 +4324,31 @@ async function cleanupAgentActivity() {
   } catch { /* agent-activity dir may not exist */ }
 }
 
+// Dispatch markers, reviews and worktrees: see docs/retention.md.
+async function runRetention() {
+  try {
+    const scan = await scanTranscripts(PROJECTS_DIR);
+    const opts = { known: scan?.ids, maxAgeMs: retentionMs(CLAUDE_DIR) };
+    const markers = dispatched.prune(opts);
+    const reviews = await pruneSessionDirs(REVIEW_DIR, opts);
+    const wts = worktrees.prune(scan?.dirs);
+    if (markers || reviews || wts) {
+      console.log(`[retention] removed ${markers} dispatch markers, ${reviews} reviews, ${wts} worktrees`);
+    }
+  } catch (e) {
+    console.warn('[retention] failed:', e.message);
+  }
+}
+
 cleanupAgentActivity();
 cleanupContextStatus();
 setInterval(cleanupAgentActivity, CLEANUP_INTERVAL_MS);
 setInterval(cleanupContextStatus, 30 * 60 * 1000);
+// Later than the startup scan and prewarm, so the first sweep never competes with them.
+setTimeout(() => {
+  runRetention();
+  setInterval(runRetention, CLEANUP_INTERVAL_MS);
+}, RETENTION_FIRST_RUN_MS);
 
 // Warm the metadata + loop-info caches in the background so the first user
 // request lands warm. The cheap-probe in /api/sessions skips per-session

package/skill-guides/dispatch.md

@@ -2,7 +2,7 @@
 
 A dispatch is one Claude Code session that cck starts for a task, in its embedded terminal. It is an ordinary session, not a child: it shows in the sidebar like any other, and the user can open its terminal at any time.
 
-A dispatch is **fire-and-forget** by default: you hand the task off, and the user watches it in the sidebar. Add `--report` only when you need the outcome back: the user asked you to collect it, or your next step depends on it.
+A dispatch **reports back** by default: start it with `--report` and `--peer`, then collect and verify the outcome (With `--report`, below). When the user's request says `--no-report`, it is **fire-and-forget**: start it with neither flag (Fire-and-forget, below). `--no-report` lives only in the user's request; `dispatch start` has no such flag.
 
 ## Write the spec
 
@@ -19,12 +19,12 @@ Dispatch when the task can run on its own. Do the work yourself when it is small
 ## Start
 
 ```bash
-claude-code-kanban dispatch start --cwd <dir> --spec-file <spec.md> --name <name> --group <group> --peer <your-peer> [--report] --json
+claude-code-kanban dispatch start --cwd <dir> --spec-file <spec.md> --name <name> --group <group> --peer <your-peer> --report --json
 ```
 
 `claude-code-kanban help dispatch start` lists every flag (model, worktree, and the rest). `project list` shows the folders `--cwd` accepts. How to choose the values:
 
-- `--peer` is your own peer name: the first line of `ListAgents` ("This session is `<name>`"). Pass it whenever you have the `ListAgents` tool. cck then tells the started session to ask you with `SendMessage` instead of failing on a question. See [Peer](#peer).
+- `--peer` is your own peer name: the first line of `ListAgents` ("This session is `<name>`"). Pass it when you have the `ListAgents` tool. cck then tells the started session to ask you with `SendMessage` instead of failing on a question. See [Peer](#peer).
 - `--spec-file` over `--spec` for anything longer than a line: no shell quoting.
 - `--name` is what the user sees in the sidebar. Kebab-case, saying what the session does: `fix-login-redirect`, not `task-1`.
 - `--group` names the effort, in kebab-case (`auth-refactor`), and shows the new session under that sidebar group. This session stays where it is. Pass it on your first dispatch; later dispatches join the same group without it. A group goes away when its sessions end, unless the user pins a member or keeps the group.
@@ -32,13 +32,13 @@ claude-code-kanban dispatch start --cwd <dir> --spec-file <spec.md> --name <name
 
 ## Fire-and-forget
 
-Tell the user the session name, its group, and the dispatch id, then carry on with your own work or end your turn. The user follows the dispatch in the sidebar. With `--peer`, its questions still reach you as new turns.
+The started session gets the task alone and does not know your session exists. Tell the user the session name, its group, and the dispatch id. Your part ends with that message: the user follows the dispatch in the sidebar, and asks you when they want it checked.
 
 ## With `--report`
 
 The started session settles with one report, `succeeded` or `failed`, or as `exited` when its terminal ends first. Start every independent dispatch first, then collect. Two channels, use either or both:
 
-- **Inbox:** this skill armed it. Lines `cck:1 dispatch.<status> <id> ...` arrive on their own while you keep working.
+- **Inbox:** this skill armed it. Lines `[kanban board] Dispatch <id> (session <uuid>) ...` arrive on their own while you keep working.
 - **Wait:** block until one settles.
 
 ```bash