ai4kanban 0.7.0 → 0.7.1

package/README.md

@@ -65,7 +65,7 @@ akb skill install    # add it, or bring an older copy up to date
 That writes one file into `.claude/skills/kanban/` (Claude Code) and
 `.agents/skills/kanban/` (Codex): `SKILL.md`, a short note telling a coding agent the board
 is here and that `akb` owns it. The board app does the same thing from a button:
-**Configuration → Agent setup**.
+**Configuration → Setup**.
 
 Nothing else is copied in. The flows ship inside the command (`akb guide`), so a newer
 command is newer flows in every project at once — and the command itself stays where npm put
@@ -134,7 +134,7 @@ akb stop 3f2a1b04             # end one
 akb resume 3f2a1b04           # continue one that failed
 ```
 
-Which agent runs them — Claude Code, Codex, Cursor, OpenCode or DeepSeek Harness — and
+Which agent runs them — Claude Code, Codex, Cursor, OpenCode, DeepSeek Harness or ZCode — and
 what it is set to:
 
 ```bash
@@ -153,6 +153,47 @@ An API key is the one thing to leave to the user. Hand them the line rather than
 for them: a key an agent types lands in its transcript and in the shell history, and a
 saved key is never read back.
 
+## Talk to it about the board
+
+Sometimes the answer is a conversation, not a job. `akb chat` opens one about the whole
+board; `akb chat <id>` opens one about that card. It answers, and it does the board work
+you settle on in it.
+
+```bash
+akb chat "what should I build next, and why?"
+akb chat 12 "what is still unclear about this card?"
+akb chat 12 "put this in v1 and drop the last todo"   # it makes the change
+akb chat "start a build on 12"                        # it starts the run
+akb chat 12                   # the conversation so far
+akb chat 12 --clear           # forget it and start fresh
+```
+
+Before opening a fresh conversation, `akb chat` ensures this repo has the kanban skill. The
+first prompt is only the skill invocation and your message: `/kanban …` for Claude Code,
+`$kanban …` for Codex, and `Use the kanban skill: …` for an agent without direct skill-call
+syntax. There is no second chat flow or copied board snapshot; the skill reads the current
+board when it needs it.
+
+The reply arrives as it is written, and the next message lands in the same session — the
+agent still has everything said before, so you can ask a follow-up without explaining your
+project again. Every message is its own command, so the conversation is picked up from any
+terminal and survives closing one. The board's conversation and each card's are separate,
+and both live under `docs/kanban/.chats/`, on your machine and out of git.
+
+From there, chat behaves exactly like using the kanban skill in your coding agent. The skill
+prints the board-specific flow and does the work in the conversation by default; ask for a
+background run when you want another agent to take it independently. If you explicitly say
+which way, that wins.
+
+A change to a card a run is already working on is refused, and the refusal names the card
+and what that run is doing — the same rule that keeps two runs off one card.
+
+A chat is still not a run: it never shows in `akb runs`, never holds a card, and never keeps
+a run off the card it is about.
+
+Only an agent whose command can take a second message into its own session can hold a
+conversation. On any other one, chat says so and names the agents that can.
+
 ## The manual
 
 `akb help runs` is what a coding agent reads: every command it may call — the card work,

package/bin/ai4kanban.mjs

@@ -68,12 +68,23 @@ const PROGRAM = (() => {
   if (/[\\/](_npx|dlx)[\\/]/.test(entry)) return `npx --yes ${NAME}@${VERSION}`
   const base = path.basename(entry).toLowerCase().replace(/\.(cmd|ps1|exe)$/, '')
   if (base === 'akb' || base === NAME) return 'akb'
-  // Relative to where it was typed when that is shorter and still runs — a checkout says
-  // `node cli/bin/ai4kanban.mjs`, which reads inside a sentence; an absolute path doesn't.
-  const near = path.relative(process.cwd(), entry)
-  return `node ${near && !near.startsWith('..') ? near : entry}`
+  return `node ${nearPath(entry)}`
 })()
 
+// How a path is spelled in something a person is meant to paste back.
+//
+// Relative when it is a short hop down from where the command was typed — a checkout says
+// `node cli/bin/ai4kanban.mjs`, which reads inside a sentence and is what the project's own
+// notes spell. Absolute otherwise, and absolute is the safe answer: run from `/`, a
+// relative path is the whole absolute one with its leading slash quietly removed
+// (`node Users/me/…/ai4kanban.mjs`), which runs from that one folder and nowhere else and
+// reads to everyone else like a typo.
+function nearPath(file) {
+  const near = path.relative(process.cwd(), file)
+  const shortHop = near && !near.startsWith('..') && !path.isAbsolute(near) && near.split(/[\\/]/).length <= 3
+  return shortHop ? near : file
+}
+
 // One line, when this copy isn't `akb`, for the text that spells it `akb` throughout — the
 // help, and the flows a `--print` hands over. Cheaper than rewriting either, and it holds
 // for the lines inside them that this command never wrote.
@@ -630,6 +641,9 @@ const RUN_COMMANDS = new Set([
   // Put a spec agent on a card — a named agent that fills one part of its spec (#187).
   'spec',
   'runs',
+  // Talking to the agent about the board, or about one card (#240). Not a run: it holds a
+  // conversation here, in this process, and starts nothing.
+  'chat',
   'log',
   'stop',
   'resume',