claude-code-kanban 5.4.0 → 6.0.0

package/public/style.css

@@ -7075,6 +7075,105 @@ select.form-input option:checked {
   color: var(--text-muted);
   align-self: center;
 }
+
+.scratchpad-header {
+  position: relative;
+}
+
+.scratchpad-title-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.scratchpad-emoji-btn {
+  width: 32px;
+  height: 32px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 18px;
+  line-height: 1;
+  color: var(--text-muted);
+  background: var(--bg-elevated);
+  border: 1px dashed var(--border);
+  border-radius: 8px;
+  cursor: pointer;
+}
+
+.scratchpad-emoji-btn.set {
+  border-style: solid;
+  border-color: var(--accent);
+}
+
+.scratchpad-emoji-btn:hover {
+  border-color: var(--accent);
+}
+
+.scratchpad-emoji-btn[hidden] {
+  display: none;
+}
+
+.scratchpad-emoji-picker {
+  display: none;
+  position: absolute;
+  top: 40px;
+  left: 0;
+  z-index: 5;
+  width: 300px;
+  padding: 10px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  box-shadow: 0 10px 30px rgba(0, 0, 0, 0.35);
+  outline: none;
+}
+
+.scratchpad-emoji-picker.open {
+  display: block;
+}
+
+.scratchpad-emoji-grid {
+  display: grid;
+  gap: 2px;
+}
+
+.scratchpad-emoji-grid button {
+  padding: 4px 0;
+  font-size: 18px;
+  background: none;
+  border: 0;
+  border-radius: 6px;
+  cursor: pointer;
+}
+
+.scratchpad-emoji-grid button:hover,
+.scratchpad-emoji-grid button.kb {
+  background: var(--bg-hover);
+}
+
+.scratchpad-emoji-grid button.cur {
+  background: var(--accent-dim);
+}
+
+.scratchpad-emoji-row {
+  display: flex;
+  gap: 6px;
+  margin-top: 8px;
+}
+
+.scratchpad-emoji-row .form-input {
+  flex: 1;
+  min-width: 0;
+  padding: 5px 8px;
+  font-size: 13px;
+}
+
+.scratchpad-badge.has-emoji {
+  font-size: 13px;
+  line-height: 18px;
+  padding: 0 5px;
+}
 /* #endregion */
 
 /* #region STORAGE_MANAGER */

package/server.js

@@ -43,11 +43,11 @@ const { buildDecision, decisionFileName, isDecisionFile, approvalsFrom, boardRef
 const { getClaudeDir, getArgValue, storageNamespace, isDefaultClaudeDir, encodeProjectDirName } = require('./lib/claude-dir');
 const { createTerminalService, readTerminalConfig } = require('./lib/terminal');
 const { createProcStats } = require('./lib/proc-stats');
-const { createDispatchRegistry, formatPreamble, formatDispatchLine, isPeerName, DISPATCH_OUTCOME } = require('./lib/dispatch');
+const { createDispatchRegistry } = 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 { readGitBranch } = require('./lib/git-branch');
+const { readGitBranch, sessionGitBranch } = require('./lib/git-branch');
 const { createLinkedDocStore, linkUrl } = require('./lib/linked-docs');
 const { pickFolder } = require('./lib/folder-dialog');
 const { loadSessionCache, saveSessionCache } = require('./lib/session-cache');
@@ -343,15 +343,6 @@ const worktrees = createWorktreeStore({
   save: (data) => writeJsonAtomic(WORKTREES_FILE, data),
 });
 
-// Only look up the branch when cwd has diverged from the launch project — that's
-// the only case the JSONL value is wrong.
-function resolveSessionGitBranch(meta) {
-  if (meta.cwd && meta.project && meta.cwd !== meta.project) {
-    return getGitBranch(meta.cwd) || meta.gitBranch || null;
-  }
-  return meta.gitBranch || null;
-}
-
 function getSessionLogStat(meta) {
   if (!meta.jsonlPath) return { mtime: null, hasMessages: false };
   try {
@@ -1168,6 +1159,7 @@ function buildSessionObject(id, meta, overrides = {}) {
   const logStat = overrides._logStat || getSessionLogStat(meta);
   const logMtime = logStat.mtime;
   const logAge = logMtime ? Date.now() - logMtime : Infinity;
+  const worktree = worktrees.resolve(meta.project);
   return {
     id,
     name: getSessionDisplayName(id, meta),
@@ -1176,8 +1168,8 @@ function buildSessionObject(id, meta, overrides = {}) {
     project: meta.project || null,
     cwd: meta.cwd || null,
     description: meta.description || null,
-    gitBranch: resolveSessionGitBranch(meta),
-    worktree: worktrees.resolve(meta.project),
+    gitBranch: sessionGitBranch(meta, !!worktree, getGitBranch),
+    worktree,
     customTitle: meta.customTitle || null,
     taskCount: 0,
     completed: 0,
@@ -1631,6 +1623,30 @@ app.get('/api/sessions/search', (req, res) => {
   res.json(hits.slice(0, SESSION_SEARCH_MAX).map((h) => h.id));
 });
 
+app.get('/api/sessions/known', (_req, res) => {
+  res.setHeader('Cache-Control', 'no-store');
+  try {
+    const known = new Map();
+    for (const [id, meta] of Object.entries(loadSessionMetadata())) {
+      known.set(id, { id, project: meta.project || null, name: getSessionDisplayName(id, meta) });
+    }
+    const add = (id, project = null) => {
+      if (!known.has(id)) known.set(id, { id, project, name: null });
+    };
+    for (const dir of [TASKS_DIR, AGENT_ACTIVITY_DIR]) {
+      if (!existsSync(dir)) continue;
+      for (const d of readdirSync(dir, { withFileTypes: true })) if (d.isDirectory()) add(d.name);
+    }
+    for (const map of Object.values(loadAllTaskMaps().listToSessions)) {
+      for (const [id, info] of Object.entries(map)) add(id, info.project || null);
+    }
+    res.json([...known.values()]);
+  } catch (error) {
+    console.error('Error listing known sessions:', error);
+    res.status(500).json({ error: 'Failed to list known sessions' });
+  }
+});
+
 function isTempPath(p) {
   const rel = path.relative(TEMP_ROOT, p);
   return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
@@ -3276,7 +3292,9 @@ const terminal = createTerminalService({
   isAllowedFolder,
   liveSessions: () => loadLiveSessions(true),
   onChange: () => broadcast({ type: 'terminals-update', ids: terminal.list().map((t) => t.id) }),
-  onExit: (id) => dispatches.sessionExited(id),
+  onExit: (id) => {
+    if (dispatches.remove(id)) broadcast({ type: 'dispatch-update' });
+  },
 });
 
 let folderDialogOpen = false;
@@ -3346,13 +3364,7 @@ const dispatched = createDispatchedStore({
   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' });
-  },
-});
+const dispatches = createDispatchRegistry();
 
 const dispatchGroups = createGroupStore({
   load: () => {
@@ -3371,8 +3383,6 @@ 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. `dispatched` stays for the card's marker.
 function withDispatchPlacement(sessions) {
   const groups = dispatchGroups.snapshot();
   return sessions.map((s) => {
@@ -3382,56 +3392,35 @@ function withDispatchPlacement(sessions) {
     return {
       ...s,
       dispatchGroup,
-      startedBy: marker?.status === 'running' ? marker.parent || undefined : undefined,
-      dispatched: marker ? { parent: marker.parent, outcome: DISPATCH_OUTCOME[marker.status] } : undefined,
+      dispatched: marker ? { parent: marker.parent } : undefined,
     };
   });
 }
 
 // Starting a session needs the terminal token, as the browser does; the CLI reads it from
-// TERMINAL_TOKEN_FILE. The child gets only its dispatch capability through the preamble.
+// TERMINAL_TOKEN_FILE. The started session never holds it.
 app.post('/api/dispatch', (req, res) => {
   if (!terminal.authorized(req.get('x-terminal-token'))) return res.status(401).json({ error: 'invalid terminal token' });
-  const { cwd, spec, name, model, worktree, parent, group, report, peer } = req.body || {};
+  const { cwd, spec, name, model, worktree, parent, group, claudeArgs } = req.body || {};
   if (typeof spec !== 'string' || !spec.trim()) return res.status(400).json({ error: 'spec is required' });
-  if (peer != null && !isPeerName(peer)) return res.status(400).json({ error: 'peer must be a peer name as ListAgents prints it' });
   if (parent != null && !(typeof parent === 'string' && isUUID(parent))) return res.status(400).json({ error: 'invalid parent' });
   if (group != null && !isGroupName(group)) {
     return res.status(400).json({ error: `group must be kebab-case, e.g. ${suggestGroupName(group) || 'my-group'}` });
   }
-  const target = group || (parent && dispatchGroups.groupOf(parent)) || null;
-  const r = dispatches.create({ parent, name, spec: spec.trim(), report: report === true, peer, group: target, worktree });
-  const env = { CCK_DISPATCH_ID: r.id, ...(parent && { PARENT_SESSION_ID: parent }) };
-  const started = terminal.startNew({ cwd, name, model, worktree, prompt: formatPreamble(r) }, env);
-  if (started.error) {
-    dispatches.discard(r.id);
-    return res.status(started.status).json({ error: started.error });
-  }
-  dispatches.attach(r.id, { session: started.id, cwd: started.cwd });
+  const started = terminal.startNew({ cwd, name, model, worktree, prompt: spec.trim(), extraArgs: claudeArgs });
+  if (started.error) return res.status(started.status).json({ error: started.error });
+  dispatches.add({ session: started.id, parent, cwd: started.cwd, name, group: group || null, worktree });
   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);
+  if (group) dispatchGroups.join(group, [started.id]);
   broadcast({ type: 'dispatch-update' });
-  res.status(201).json({ dispatch: r.id, session: started.id, cwd: started.cwd, group: target });
+  res.status(201).json({ session: started.id, cwd: started.cwd, group: group || null });
 });
 
-app.post('/api/dispatch/:id/done', (req, res) => {
-  const { cap, outcome, summary } = req.body || {};
-  const err = dispatches.settle(req.params.id, cap, outcome, summary);
-  if (err) return res.status(err.status).json({ error: err.error });
-  res.status(204).end();
-});
-
-app.get('/api/dispatch', async (req, res) => {
+app.get('/api/dispatch', (req, res) => {
   res.setHeader('Cache-Control', 'no-store');
-  const ids = typeof req.query.ids === 'string' && req.query.ids ? req.query.ids.split(',') : null;
   const parent = typeof req.query.parent === 'string' && req.query.parent ? req.query.parent : null;
-  // res, not req: a GET's request stream can close before the response is sent.
-  const out = await dispatches.wait({ ids, parent }, req.query.wait, (stop) => {
-    res.on('close', stop);
-    return () => res.off('close', stop);
-  });
-  if (!res.writableEnded) res.json(out);
+  res.json({ running: dispatches.list({ parent }) });
 });
 // #endregion
 
@@ -3496,7 +3485,6 @@ const {
   formatTaskMoved,
   handleSessionEvents,
   hasSessionListener,
-  topicKey,
 } = require('./lib/session-events');
 app.get('/api/sessions/:sessionId/events', handleSessionEvents);
 

package/skill-guides/dispatch.md

@@ -1,73 +1,35 @@
 # Dispatch guide
 
-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 a plain Claude Code session that cck starts in its embedded terminal, with your spec as the first message. It is an ordinary session: it shows in the sidebar, its card links back to you, and the user can open its terminal at any time. cck only starts 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.
+## Spec
 
-## Write the spec
+The started session sees only the spec, not this conversation, so the spec carries everything it needs.
 
-The started session sees only the spec, not this conversation, so every spec is self-contained. Name:
-
-- **Target:** the files, component, or environment in scope.
-- **Change:** the concrete result to produce.
-- **Constraints:** invariants and do-not-touch boundaries.
-- **Ownership:** what it may edit. Two dispatches edit the same files only when each runs in its own `--worktree`.
-- **Acceptance:** the test, output, or evidence that proves it is done.
-
-Dispatch when the task can run on its own. Do the work yourself when it is small or needs context from this conversation that you cannot write down.
+cck sends nothing back. To hear from the session, the spec tells it to `SendMessage` you and names you. Your name is auto-assigned (e.g. `claude-code-hub-06`); `ListAgents` prints it as "This session is <name>".
 
 ## 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> --json -- <claude args>
 ```
 
-`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 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.
-- The result holds the `dispatch` id and the `session` id.
-
-## Fire-and-forget
+- `--name` is the sidebar name and the session's peer name. Kebab-case and unique: `fix-login-redirect`.
+- `--group` names the effort in kebab-case (`auth-refactor`) and shows the session under that sidebar group. Pass it on every dispatch that belongs to the effort; a dispatch without it goes to its project.
+- `--spec-file` keeps a long spec out of shell quoting.
+- Everything after `--` goes to `claude` as it is: any flag in `claude --help`, e.g. `-- --permission-mode auto --add-dir ../shared`. Keep each value one shell word of plain characters (no quotes, `%` or control characters); long text belongs in the spec. cck owns the session id, name, model and worktree, so pass those with its own flags.
+- After a cck restart the terminal comes back with `claude --resume <id>` alone, so the args after `--` apply to the first run only.
+- The result holds the `session` id.
 
-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.
+`claude-code-kanban help dispatch start` lists cck's flags (`--model`, `--worktree` and more); `claude --help` lists the ones you can pass after `--`.
 
-## With `--report`
+## Messages and status
 
-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 `[kanban board] Dispatch <id> (session <uuid>) ...` arrive on their own while you keep working.
-- **Wait:** block until one settles.
-
-```bash
-claude-code-kanban dispatch wait [<id>...] --timeout 15m --json
-```
+A message from the session arrives here as a new turn. Reply with `SendMessage` to its name.
 
-Call it again with the ids still running (`help dispatch wait` has the output fields). A timeout is a checkpoint: the session may still be working. Look before you act:
+A crashed session sends nothing. To learn when one ends, `SendMessage` it with `notify_when_idle: true`, or look:
 
 ```bash
-claude-code-kanban dispatch list --json
+claude-code-kanban dispatch list --json            # still running in cck's terminal
 claude-code-kanban session peek <session-id> --limit 20
 ```
-
-A dispatch still `running` is still working; retry only after a `failed` report or an `exited` one.
-
-The summary is the started session's own claim. Verify it (run the tests, read the diff), then give the user each dispatch's outcome, the summary, and what you checked. Done when every `--report` dispatch has settled and each summary is verified.
-
-## Peer
-
-A dispatch is a Claude Code peer under its `--name`, so `SendMessage` reaches it and it reaches you. The peer channel carries the conversation. The report carries the record: only `dispatch done` settles a dispatch, ends `dispatch wait`, and shows in the sidebar.
-
-- **Answer questions.** A question or a finding from the dispatch arrives as a new turn. Answer it yourself, or ask the user when the decision is theirs, then send the answer back.
-- **Steer.** Send a short, self-contained message to the dispatch's name. It arrives between the receiver's steps, never inside a subagent or a running workflow.
-- **Limits.** A session in another permission mode can hold a message until its user approves it, so anything the result depends on goes in the report. A dispatch that restarts ends as `exited` and cannot report, so its result comes back as a message.
-
-## If you are the started session
-
-Your prompt begins with `[cck dispatch <id>]` and holds your instructions: the peer to ask, and with a report the exact `dispatch done` command. Follow them. Without that line, the prompt is the task alone.
-
-- Ask the peer with `SendMessage` when you need a decision or find something that changes the task, and keep working on what does not depend on the answer.
-- The summary is three sentences: what changed, what you found, what remains. Use `--summary-file` if it needs quotes.
-- After you report, a message from the peer is a new request: answer it.