@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/kanboard/src/badges.ts

@@ -0,0 +1,93 @@
+/**
+ * @pi-unipi/kanboard — transcript badges (user-only, never LLM context).
+ *
+ * A successful lead `start` / `finish` / `move <ID> blocked` appends a custom
+ * transcript entry rendered as `▣ UNI-30 started`, `✓ UNI-30 → In Review`,
+ * `⊘ UNI-30 blocked: <comment>`. Custom entries persist for the user but are
+ * outside the LLM context (same mechanism as core's progress bars).
+ */
+
+import type { ExtensionAPI, ThemeColor } from "@earendil-works/pi-coding-agent";
+import { Text, truncateToWidth, type Component } from "@earendil-works/pi-tui";
+
+import { kanboardInvocations } from "./guard.js";
+
+export const BADGE_ENTRY = "unipi:kanboard-badge";
+
+export type BadgeKind = "started" | "finished" | "blocked";
+
+export interface BadgeData {
+	kind: BadgeKind;
+	id: string;
+	/** Short human text (a blocked task carries what is needed). */
+	text?: string;
+}
+
+/** The badge kind a kanboard CLI call produces, or null. */
+export function badgeKindFor(sub: string, args: readonly string[]): BadgeKind | null {
+	if (sub === "start") return "started";
+	if (sub === "finish") return "finished";
+	if (sub === "move" && args.includes("blocked")) return "blocked";
+	return null;
+}
+
+/** Extract a badge from a successful kanboard bash call, or null. */
+export function badgeFromToolCall(toolName: string, input: Record<string, unknown> | undefined, isError: boolean): BadgeData | null {
+	if (isError || (toolName !== "bash" && toolName !== "powershell")) return null;
+	for (const invocation of kanboardInvocations(String(input?.command ?? ""))) {
+		const kind = badgeKindFor(invocation.sub, invocation.args);
+		if (!kind) continue;
+		const id = invocation.args.find((arg) => !arg.startsWith("-"));
+		if (!id) continue;
+		let text: string | undefined;
+		if (kind === "blocked") {
+			const flagIndex = invocation.args.indexOf("--comment");
+			text = flagIndex >= 0 ? (invocation.args[flagIndex + 1] ?? "").replace(/^["']|["']$/g, "") : undefined;
+		}
+		return { kind, id, ...(text !== undefined && text.length > 0 ? { text } : {}) };
+	}
+	return null;
+}
+
+export function badgeText(data: BadgeData): string {
+	if (data.kind === "started") return `▣ ${data.id} started`;
+	if (data.kind === "finished") return `✓ ${data.id} → In Review`;
+	const what = data.text ? `: ${data.text.slice(0, 80)}` : "";
+	return `⊘ ${data.id} blocked${what}`;
+}
+
+function badgeColor(kind: BadgeKind): ThemeColor {
+	if (kind === "started") return "accent";
+	if (kind === "finished") return "success";
+	return "warning";
+}
+
+/** Register the entry renderer (once per extension load; lead only). */
+export function registerBadgeRenderer(pi: ExtensionAPI): void {
+	try {
+		pi.registerEntryRenderer<BadgeData>(BADGE_ENTRY, (entry, _options, theme) => {
+			const data = entry.data;
+			if (!data || typeof data.id !== "string") return undefined;
+			const t = theme as unknown as {
+				fg?: (color: ThemeColor, text: string) => string;
+				bold?: (text: string) => string;
+			};
+			const line = t.fg?.(badgeColor(data.kind), badgeText(data)) ?? badgeText(data);
+			return new Text(t.bold ? t.bold(line) : line, 0, 0);
+		});
+	} catch {
+		// Renderer registration is UI-dependent; skip where unavailable.
+	}
+}
+
+/** Emit a badge for a successful tool result (lead tool_result hook body). */
+export function maybeBadgeToolResult(pi: ExtensionAPI, toolName: string, input: Record<string, unknown> | undefined, isError: boolean, width = 80): Component | null {
+	const badge = badgeFromToolCall(toolName, input, isError);
+	if (!badge) return null;
+	try {
+		pi.appendEntry<BadgeData>(BADGE_ENTRY, badge);
+		return new Text(truncateToWidth(badgeText(badge), width), 0, 0);
+	} catch {
+		return null;
+	}
+}

package/packages/kanboard/src/bin.ts

@@ -80,10 +80,12 @@ export function resolveBinary(env: NodeJS.ProcessEnv = process.env, from?: strin
   if (explicit) {
     return isRunnable(explicit) ? { path: explicit, source: "env" } : null;
   }
-  const packaged = platformPackagePath(from);
-  if (packaged && isRunnable(packaged)) return { path: packaged, source: "platform-package" };
+  // In a source checkout the dev build wins — the platform package can ship a
+  // stale prebuilt binary (seen on coffee: alpha.0 shadowed the debug build).
   const dev = devBuildPath();
   if (dev) return { path: dev, source: "dev-build" };
+  const packaged = platformPackagePath(from);
+  if (packaged && isRunnable(packaged)) return { path: packaged, source: "platform-package" };
   return null;
 }
 

package/packages/kanboard/src/commands.ts

@@ -3,6 +3,7 @@
  * `/unipi:kanboard-add`, `/unipi:kanboard-do`, `/unipi:kanboard-autowork`.
  */
 
+import { boardProgressData } from "./progress.js";
 import { execFile, spawn } from "node:child_process";
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, hostname as osHostname, networkInterfaces, tmpdir, type NetworkInterfaceInfo } from "node:os";
@@ -10,9 +11,11 @@ import { join } from "node:path";
 import { promisify } from "node:util";
 
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
-import { getSettings } from "@pi-unipi/core";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { getSettings, sendHarnessUserMessage } from "@pi-unipi/core";
 
 import { KanboardCliError, type KanboardCli } from "./bin.js";
+import { DEFAULT_DO_TASKS, DEFAULT_DO_WRITES } from "./guard.js";
 import { asProject, asStopResult, asTask, asTaskList, type KanboardTask } from "./shapes.js";
 import { applyLimitEnv, readKanboardSettings, type KanboardSettings } from "./settings.js";
 
@@ -31,21 +34,26 @@ export const HELP = `Kanboard commands
                                         start the board and print its link
   /unipi:kanboard close                 shut the board down
   /unipi:kanboard onboard               register this project
-  /unipi:kanboard status                board, claims and queue
+  /unipi:kanboard status                board and claims
   /unipi:kanboard show [--all]          the board, in chat (lanes + claim order)
   /unipi:kanboard doctor                check the setup
   /unipi:kanboard-add [-p 1-5] <title>  add a task; lines below the title are the description (paste images there)
-  /unipi:kanboard-do <request>          let the agent use the board for this turn
-  /unipi:kanboard-autowork start|stop   work ready tasks chain by chain; stop finishes the current one first
+  /unipi:kanboard-do <request>          grant the agent task slots + a write budget
+  /unipi:kanboard-autowork start|stop   work every ready task in this session; stop just turns the offers off
 Priority -p: 1 none · 2 low · 3 medium · 4 high · 5 urgent`;
 
-export function doText(slug: string, cli: string, request: string, queueMax = 10): string {
-  const limit = queueMax === 0 ? "Todo tasks" : `Todo tasks, at most ${queueMax}`;
-  return `[kanboard] For this request you may use the kanboard skill on project ${slug} (CLI: \`${cli} --actor agent --project ${slug} …\`). Board writes are allowed until this turn ends. You can add tasks, move them between backlog and todo, link, order, note, and edit tasks you created. To have tasks worked, queue them in order with \`queue <IDs>\` (${limit}); the runner starts them one by one after this turn, so do not start the work yourself. If the request is unclear, ask me instead of guessing.
+export function doText(slug: string, cli: string, request: string, slots = DEFAULT_DO_TASKS, writes = DEFAULT_DO_WRITES): string {
+  const s = slots === 1 ? "" : "s";
+  const ws = writes === 1 ? "" : "s";
+  return `[kanboard] For this request you may use the kanboard skill on project ${slug} (CLI: \`${cli} --actor agent --project ${slug} …\`). Budget this session: ${String(slots)} task slot${s} — each \`start\` uses one — and ${String(writes)} board write${ws} (add, edit, link, order, move backlog↔todo, note on tasks you don't hold); /unipi:kanboard-do tops both back up. Always free: reads, and \`finish\`, \`move <ID> blocked --comment\`, \`note\` and \`attach\` on tasks you started. Work the tasks yourself in this session, in whatever mode fits: \`start <ID>\` right before you work it, then \`finish <ID> --comment "<summary>"\` or \`move <ID> blocked --comment "<what you need>"\` — never leave a task you started In Progress. Before starting anything, count the tasks this request needs; if that is more than ${String(slots)}, start nothing — tell me you can do ${String(slots)} now and ask whether to raise the limit (setting kanboard.doTasks) or work in batches. Read a task with \`show <ID>\` before editing or starting it — \`list\` only shows titles and a one-line excerpt. Sidekicks and subagents can read the board but not write it: brief them with the task, then update the board yourself from their report. If the request is unclear, ask me instead of guessing.
 
 Request: ${request}`;
 }
 
+export function autoworkText(slug: string, cli: string): string {
+  return `[kanboard] Autowork on project ${slug} (CLI: \`${cli} --actor agent --project ${slug} …\`): work every ready task on the board, one at a time, in this session — choose any mode yourself (regular, goal, ralph, swarm, graph). No budget limits. Pick with \`next\` or \`list --ready\`; for each: \`show <ID>\`, \`start <ID>\`, work it, then \`finish <ID> --comment "<summary>"\` or \`move <ID> blocked --comment "<what you need>"\`. When you finish one, I'll offer the next ready task. Sidekicks and subagents can read the board but not write it — update the board yourself from their reports.`;
+}
+
 /**
  * Split a command line into words the way a shell would: whitespace separates,
  * a token may start with a quoted span, and a quote inside a word is literal
@@ -184,18 +192,15 @@ export interface CommandDeps {
   settings: () => KanboardSettings;
   /** Reveal the kanboard skill for this session (append-only). */
   revealSkill: (ctx: ExtensionContext | ExtensionCommandContext) => void;
-  /** Autowork: claim-and-run loop (queue first, then claim-next). */
-  work: (ctx: ExtensionContext) => Promise<void>;
-  /** Finish the current task, then stop the loop. */
-  stop: (ctx: ExtensionContext) => void;
-  /** Drain this session's queue after a -do turn (no-op when empty/running). */
-  drainQueue: (ctx: ExtensionContext) => Promise<void>;
-  status: () => { taskId: string | null; mode: string | null; phase: string };
+  /** Autowork on/off (guard budget, monitor, status holder). */
+  setAutowork(on: boolean): void;
   /** The write window opened by -do (read by the tool_call gate). */
   guard: import("./guard.js").WriteGuard;
   /** This session's id (UNIPI_KANBOARD_SESSION / pi-<pid>). */
   session: () => string;
   debug: (line: string) => void;
+  /** Post a user-only progress bar (optional: absent in tests). */
+  progress?: (data: import("@pi-unipi/core").ProgressData) => void;
 }
 
 export interface DaemonInfo {
@@ -407,7 +412,6 @@ export async function ensureDaemon(
         ...process.env,
         UNIPI_KANBOARD_ACTOR: "user",
         UNIPI_KANBOARD_CHAIN_GATE: settings.chainGate,
-        UNIPI_KANBOARD_QUEUE_MAX: String(settings.queueMax),
         UNIPI_KANBOARD_MAX_SESSIONS: String(settings.maxSessions),
       },
     });
@@ -573,15 +577,18 @@ export async function runAdd(deps: CommandDeps, ctx: ExtensionCommandContext, te
     ctx.ui.notify(`kanboard: ${parsed.error} — /unipi:kanboard-add [-p 1-5] [--after ID] [--status backlog|todo] <title>`, "warning");
     return;
   }
-  if (!parsed.title) {
-    ctx.ui.notify("kanboard: add needs a title — /unipi:kanboard-add <title>", "warning");
+  const hasDescription = parsed.description.trim().length > 0;
+  if (!parsed.title && !hasDescription) {
+    ctx.ui.notify("kanboard: add needs a title or a description — /unipi:kanboard-add <title> (lines below are the description)", "warning");
     return;
   }
   if (!(await ensureOnboarded(deps, ctx))) return;
 
   let bodyFile: string | null = null;
   try {
-    const argv = ["add", parsed.title, ...parsed.flags];
+    // A description-only add omits the title positional entirely (the binary
+    // stores an empty title and derives the display title from the body).
+    const argv = ["add", ...(parsed.title ? [parsed.title] : []), ...parsed.flags];
     if (parsed.description) {
       bodyFile = join(mkdtempSync(join(tmpdir(), "kb-add-")), "body.md");
       writeFileSync(bodyFile, parsed.description);
@@ -603,6 +610,55 @@ export async function runAdd(deps: CommandDeps, ctx: ExtensionCommandContext, te
   }
 }
 
+export type CaptureToBacklogResult =
+  | { ok: true; id: string; attachments: number }
+  | { ok: false; reason: string };
+
+/**
+ * Capture editor text as a Backlog task body — the entry point the
+ * input-shortcuts K chord calls through `globalThis.__unipi_kanboard_api`.
+ * No title: the body carries the point (the binary derives the display
+ * title). No prompts: when the folder is not onboarded the capture is
+ * refused with the reason instead.
+ */
+export async function captureToBacklog(
+  deps: CommandDeps,
+  opts: { cwd: string; text: string },
+): Promise<CaptureToBacklogResult> {
+  const client = deps.cli;
+  if (!client) return { ok: false, reason: deps.unavailable ?? "kanboard binary unavailable" };
+  let slug: string | null = null;
+  try {
+    const settings = getSettings("kanboard", opts.cwd) as { slug?: string };
+    slug = typeof settings.slug === "string" && settings.slug.length > 0 ? settings.slug : null;
+  } catch {
+    slug = null;
+  }
+  if (!slug) {
+    return { ok: false, reason: "kanboard is not set up here — run /unipi:kanboard" };
+  }
+  const text = opts.text.trim();
+  if (!text) return { ok: false, reason: "nothing to add" };
+  const attaches = detectFilePaths(text);
+  let bodyFile: string | null = null;
+  try {
+    bodyFile = join(mkdtempSync(join(tmpdir(), "kb-capture-")), "body.md");
+    writeFileSync(bodyFile, text);
+    const argv = ["--project", slug, "add", "--status", "backlog", "--body-file", bodyFile];
+    for (const file of attaches) argv.push("--attach", file);
+    const task = asTask("add", await client.run<unknown>(argv, { cwd: opts.cwd }));
+    deps.debug(`captureToBacklog ${task.id} (${attaches.length} attachments)`);
+    return { ok: true, id: task.id, attachments: attaches.length };
+  } catch (error) {
+    return {
+      ok: false,
+      reason: error instanceof KanboardCliError ? error.message : String(error),
+    };
+  } finally {
+    if (bodyFile) rmSync(join(bodyFile, ".."), { recursive: true, force: true });
+  }
+}
+
 export async function runStatus(deps: CommandDeps, ctx: ExtensionCommandContext | ExtensionContext): Promise<void> {
   const client = deps.cli;
   const lines: string[] = [];
@@ -615,7 +671,10 @@ export async function runStatus(deps: CommandDeps, ctx: ExtensionCommandContext
   const slug = currentSlug();
   if (slug) {
     try {
-      const { tasks, problems } = asTaskList(await client!.run<unknown>(["list"], {}));
+      // --all: the status view counts every lane; the CLI's bare `list`
+      // default (todo/in_progress/blocked/in_review/done) would hide backlog
+      // and cancelled here (UNI-62).
+      const { tasks, problems } = asTaskList(await client!.run<unknown>(["list", "--all"], {}));
       const counts = tasks.reduce<Record<string, number>>((acc, task) => {
         acc[task.status] = (acc[task.status] ?? 0) + 1;
         return acc;
@@ -628,7 +687,9 @@ export async function runStatus(deps: CommandDeps, ctx: ExtensionCommandContext
       if (problems && problems.length > 0) {
         lines.push(`⚠ ${problems.length} task file(s) need repair — unipi-kanboard validate --fix`);
       }
-      // Active claims and this session's queue.
+      const bar = boardProgressData(tasks, slug);
+      if (bar) deps.progress?.(bar);
+      // Active claims of this session.
       const running = tasks.filter((task) => task.status === "in_progress");
       if (running.length > 0) {
         lines.push("claims:");
@@ -640,44 +701,15 @@ export async function runStatus(deps: CommandDeps, ctx: ExtensionCommandContext
           );
         }
       }
-      try {
-        const queue = (await client!.run<unknown>(["queue", "--list"], {
-          extraEnv: { UNIPI_KANBOARD_SESSION: deps.session() },
-        })) as { queue?: string[] };
-        lines.push(`queue (${deps.session()}): ${(queue.queue ?? []).join(" ") || "empty"}`);
-      } catch {
-        lines.push("queue: (unreadable)");
-      }
     } catch {
       lines.push(`project: ${slug} (unreadable board)`);
     }
   } else {
     lines.push("project: not registered here — /unipi:kanboard onboard");
   }
-  const run = deps.status();
-  lines.push(run.taskId ? `runner: ${run.taskId} · ${run.mode} · ${run.phase}` : "runner: idle");
   ctx.ui.notify(lines.join("\n"), "info");
 }
 
-/**
- * After a -do window closed (the first real agent_end), start draining this
- * session's queue when it is non-empty. Returns true when draining started.
- */
-export async function drainQueueAfterDo(deps: CommandDeps, ctx: ExtensionContext): Promise<boolean> {
-  const client = deps.cli;
-  const slug = currentSlug();
-  if (!client || !slug) return false;
-  const queued = await client
-    .run<{ queue?: string[] }>(["queue", "--list"], {
-      extraEnv: { UNIPI_KANBOARD_PROJECT: slug, UNIPI_KANBOARD_SESSION: deps.session() },
-    })
-    .then((payload) => payload.queue ?? [])
-    .catch(() => [] as string[]);
-  if (queued.length === 0) return false;
-  await deps.drainQueue(ctx);
-  return true;
-}
-
 
 /** `doctor`: ✓/✗ lines for the whole setup, posted as a display-only message. */
 export async function runDoctor(deps: CommandDeps, ctx: ExtensionCommandContext, pi: ExtensionAPI): Promise<void> {
@@ -830,6 +862,8 @@ export async function runRotateTokenAction(
 interface ShowTask {
   id: string;
   title: string;
+  /** Derived title (Rust `display_title`) — shown when `title` is empty. */
+  displayTitle?: string;
   status: string;
   priority?: string;
   order?: number;
@@ -855,6 +889,11 @@ const SHOW_EXTRA_LANES: Array<{ id: string; label: string }> = [
 const PRIO_GLYPH: Record<string, string> = { urgent: "⇈", high: "↑", medium: "·", low: "↓", none: " " };
 const PRIO_RANK: Record<string, number> = { urgent: 0, high: 1, medium: 2, low: 3, none: 4 };
 
+/** The title a row shows: the derived one when the raw title is empty. */
+function showTitle(task: ShowTask): string {
+  return task.displayTitle || task.title || "(untitled)";
+}
+
 /** Same ordering as the CLI's claim_sort: priority, then lane order, then id. */
 export function claimOrder(tasks: ShowTask[]): ShowTask[] {
   return [...tasks].sort(
@@ -899,7 +938,7 @@ function laneRows(tasks: ShowTask[], lane: string): ShowRow[] {
         number: `${number}.`,
         id: task.id,
         prio: PRIO_GLYPH[task.priority ?? "none"] ?? " ",
-        title: task.title,
+        title: showTitle(task),
         extra:
           task.ready === false || waits.length > 0
             ? `waits for ${waits.join(", ")}`
@@ -922,7 +961,7 @@ function laneRows(tasks: ShowTask[], lane: string): ShowRow[] {
       branch: "",
       id: task.id,
       prio: PRIO_GLYPH[task.priority ?? "none"] ?? " ",
-      title: task.title,
+      title: showTitle(task),
       extra:
         lane === "in_progress" && task.run?.session
           ? `· ${task.run.session}`
@@ -976,15 +1015,29 @@ export function showRenderer(
         lines.push(theme.fg("accent", lane.label));
         for (const row of laneRows(inLane, lane.id)) {
           const head = `  ${row.branch}${row.number ? `${row.number} ` : ""}${theme.fg("muted", row.id)} ${row.prio} `;
-          // visible length so far, then truncate the title to fit.
-          const prefixLen = 2 + row.branch.length + (row.number ? row.number.length + 1 : 0) + row.id.length + 2;
-          const budget = Math.max(10, width - prefixLen - (row.extra ? row.extra.length + 2 : 0));
-          const title = row.title.length > budget ? `${row.title.slice(0, Math.max(1, budget - 1))}…` : row.title;
-          const extra = row.extra ? `  ${row.tone === "error" ? theme.fg("error", row.extra) : theme.fg("dim", row.extra)}` : "";
-          lines.push(`${head}${title}${extra}`);
+          const styledExtra = row.extra
+            ? `  ${row.tone === "error" ? theme.fg("error", row.extra) : theme.fg("dim", row.extra)}`
+            : "";
+          // Budgets in visible cells (CJK ≈ 2 cells, ANSI = 0 — .length lies on both).
+          // Title takes all the room left after the extra when both fit comfortably,
+          // else it is capped at 10 cells; the extra then takes whatever remains, so a
+          // huge blockedReason is truncated instead of overflowing the terminal (which
+          // hard-crashes pi). Final truncate is the belt-and-braces guarantee.
+          const avail = Math.max(0, width - visibleWidth(head));
+          const extraW = styledExtra ? visibleWidth(styledExtra) : 0;
+          const titleBudget = Math.max(0, avail - extraW >= 10 ? avail - extraW : Math.min(avail, 10));
+          const title = truncateToWidth(row.title, titleBudget, "…");
+          let line = `${head}${title}`;
+          if (styledExtra) {
+            const extraBudget = avail - visibleWidth(title) - 2;
+            if (extraBudget > 0) line += truncateToWidth(styledExtra, extraBudget + 2, "…");
+          }
+          lines.push(line);
         }
       }
-      return lines;
+      // Hard guarantee: a line wider than the terminal hard-crashes pi, so every
+      // emitted line — header and lane labels included — is truncated to `width`.
+      return lines.map((line) => truncateToWidth(line, width));
     },
     invalidate: () => undefined,
   };
@@ -1000,7 +1053,8 @@ async function runShow(deps: CommandDeps, ctx: ExtensionCommandContext, pi: Exte
   const slug = currentSlug()!;
   let tasks: ShowTask[] = [];
   try {
-    const payload = (await client.run(["list", "--json"], { cwd: ctx.cwd })) as { tasks?: ShowTask[] };
+    // --all: this display lists every lane; the CLI bare default hides backlog/cancelled (UNI-62).
+    const payload = (await client.run(["list", "--all", "--json"], { cwd: ctx.cwd })) as { tasks?: ShowTask[] };
     tasks = payload.tasks ?? [];
   } catch (error) {
     ctx.ui.notify(`kanboard: show failed — ${error instanceof KanboardCliError ? error.message : String(error)}`, "error");
@@ -1039,7 +1093,7 @@ const SUB_DESCRIPTIONS: Record<Subcommand, string> = {
   open: "Start the daemon and print the board URL (--host 0.0.0.0|tailscale, --port N)",
   close: "Shut down the board daemon (the web UI goes offline)",
   onboard: "Register this project on the board",
-  status: "Daemon, project counts, claims, queue and the runner state",
+  status: "Daemon, project counts and claims",
   doctor: "Check the whole setup (binary, daemon, project, agent, claims)",
   show: "The board in chat: lanes + claim order (--all adds cancelled/archived)",
 };
@@ -1088,13 +1142,27 @@ export function kanboardCompletions(prefix: string): CompletionItem[] | null {
 /** Live task list for `--after` / `-do` completions, cached ~5s per client. */
 const taskCache = new WeakMap<KanboardCli, { at: number; tasks: ShowTask[] }>();
 
-export async function taskCompletions(deps: CommandDeps, prefix: string, before: string): Promise<CompletionItem[] | null> {
+export interface TaskCompletionOptions {
+  /** Also match task TITLES (default true); false = id prefixes only. */
+  titleSearch?: boolean;
+  /** Row style: "status" = label id, description "<status> — <title>";
+   *  "id-title" = label "<id>  <title>", description "<status>". */
+  rowStyle?: "status" | "id-title";
+}
+
+export async function taskCompletions(
+  deps: CommandDeps,
+  prefix: string,
+  before: string,
+  opts: TaskCompletionOptions = {},
+): Promise<CompletionItem[] | null> {
+  const { titleSearch = true, rowStyle = "status" } = opts;
   const client = deps.cli;
   if (!client) return null;
   let cache = taskCache.get(client);
   if (!cache || Date.now() - cache.at > 5_000) {
     try {
-      const payload = (await client.run(["list", "--json"], { cwd: process.cwd() })) as { tasks?: ShowTask[] };
+      const payload = (await client.run(["list", "--all", "--json"], { cwd: process.cwd() })) as { tasks?: ShowTask[] };
       cache = { at: Date.now(), tasks: payload.tasks ?? [] };
       taskCache.set(client, cache);
     } catch {
@@ -1104,13 +1172,21 @@ export async function taskCompletions(deps: CommandDeps, prefix: string, before:
   const needle = prefix.toLowerCase();
   const items = cache.tasks
     .filter((task) => !["cancelled", "archived"].includes(task.status))
-    .filter((task) => task.id.toLowerCase().startsWith(needle) || task.title.toLowerCase().includes(needle))
+    .filter((task) => task.id.toLowerCase().startsWith(needle) || (titleSearch && showTitle(task).toLowerCase().includes(needle)))
     .slice(0, 12)
-    .map((task) => ({
-      value: fullArgs(before, task.id),
-      label: task.id,
-      description: `${task.status} — ${task.title}`,
-    }));
+    .map((task) =>
+      rowStyle === "id-title"
+        ? {
+            value: fullArgs(before, task.id),
+            label: `${task.id}  ${showTitle(task).slice(0, 64)}`,
+            description: task.status,
+          }
+        : {
+            value: fullArgs(before, task.id),
+            label: task.id,
+            description: `${task.status} — ${showTitle(task)}`,
+          },
+    );
   return items.length > 0 ? items : null;
 }
 
@@ -1186,15 +1262,19 @@ export async function kanboardAddCompletions(deps: CommandDeps, prefix: string):
   return null;
 }
 
-/** /unipi:kanboard-do … — complete a trailing task-id prefix. */
+/** /unipi:kanboard-do … — complete a trailing task-id token; plain prose never matches. */
 export async function kanboardDoCompletions(deps: CommandDeps, prefix: string): Promise<CompletionItem[] | null> {
   const raw = prefix ?? "";
-  const match = /^(.*?)(\S*)$/.exec(raw)!;
-  const before = match[1]!;
-  const token = match[2]!;
-  // Only when the last token looks like a task id prefix (ABC-…).
-  if (!/^[A-Za-z]{2,6}-?[0-9]*$/.test(token) || token.length < 2) return null;
-  return taskCompletions(deps, token, before);
+  const at = raw.lastIndexOf(" ");
+  const before = at === -1 ? "" : raw.slice(0, at + 1);
+  const token = raw.slice(at + 1);
+  // Only a task-id-like tail ("UNI-1", "uni", "UNI-") completes; words that
+  // match no id shape or prefix ("note", "set") yield nothing.
+  if (!/^[A-Za-z]{2,10}-?\d*$/.test(token)) return null;
+  // Title search only when the token looks like a real id prefix (has a digit
+  // or ends with the dash); otherwise id prefixes only.
+  const idLike = /\d/.test(token) || token.endsWith("-");
+  return taskCompletions(deps, token, before, { titleSearch: idLike, rowStyle: "id-title" });
 }
 
 export function registerKanboardCommands(pi: ExtensionAPI, deps: CommandDeps): void {
@@ -1209,7 +1289,14 @@ export function registerKanboardCommands(pi: ExtensionAPI, deps: CommandDeps): v
   }
 
   pi.on("context", (event) => {
-    const hidden = new Set([HELP_CUSTOM_TYPE, DOCTOR_CUSTOM_TYPE, SHOW_CUSTOM_TYPE]);
+    // Monitor notices ride custom ENTRIES (never messages) — this is defense
+    // in depth in case one ever becomes a message.
+    const hidden = new Set([
+      HELP_CUSTOM_TYPE,
+      DOCTOR_CUSTOM_TYPE,
+      SHOW_CUSTOM_TYPE,
+      "unipi:kanboard-notice",
+    ]);
     const filtered = event.messages.filter(
       (message) => !hidden.has((message as { customType?: string }).customType ?? ""),
     );
@@ -1226,7 +1313,18 @@ export function registerKanboardCommands(pi: ExtensionAPI, deps: CommandDeps): v
     // Limits live in the environment; refresh so this bash call inherits the
     // current settings (the spawned CLI reads them).
     applyLimitEnv(deps.settings());
-    const reason = deps.guard.check(command);
+    const reason = await deps.guard.check(command, {
+      ownsClaim: async (id) => {
+        const client = deps.cli;
+        const slug = currentSlug();
+        if (!client || !slug) return false;
+        const task = asTask("show", await client.run([ "show", id, "--json" ], {
+          extraEnv: { UNIPI_KANBOARD_PROJECT: slug, UNIPI_KANBOARD_SESSION: deps.session() },
+        }));
+        const run = task.run as { session?: string } | null | undefined;
+        return task.status === "in_progress" && run?.session === deps.session();
+      },
+    });
     return reason ? { block: true, reason } : undefined;
   });
 
@@ -1250,11 +1348,11 @@ export function registerKanboardCommands(pi: ExtensionAPI, deps: CommandDeps): v
         return;
       }
       if (sub === "work") {
-        ctx.ui.notify("kanboard: use /unipi:kanboard-autowork start to work the queue", "info");
+        ctx.ui.notify("kanboard: use /unipi:kanboard-autowork start to work every ready task in this session", "info");
         return;
       }
       if (sub === "stop") {
-        ctx.ui.notify("kanboard: use /unipi:kanboard-autowork stop to finish the current task and stop", "info");
+        ctx.ui.notify("kanboard: use /unipi:kanboard-autowork stop to turn autowork offers off", "info");
         return;
       }
 
@@ -1303,10 +1401,15 @@ export function registerKanboardCommands(pi: ExtensionAPI, deps: CommandDeps): v
   });
 
   pi.registerCommand("unipi:kanboard-do", {
-    description: "Let the agent use the kanboard for this turn — writes are allowed until the turn ends",
+    description: "Grant the agent kanboard task slots and a write budget (/unipi:kanboard-do <request>; off revokes)",
     getArgumentCompletions: (prefix: string) => kanboardDoCompletions(deps, prefix ?? ""),
     handler: async (args: string, ctx: ExtensionCommandContext) => {
       const request = (args ?? "").trim();
+      if (request.toLowerCase() === "off") {
+        deps.guard.revoke();
+        ctx.ui.notify("kanboard: -do budget revoked — reads stay free", "info");
+        return;
+      }
       if (!request) {
         ctx.ui.notify("kanboard: -do needs a request — /unipi:kanboard-do <what the agent may do on the board>", "warning");
         return;
@@ -1323,9 +1426,19 @@ export function registerKanboardCommands(pi: ExtensionAPI, deps: CommandDeps): v
       const busy = typeof (ctx as unknown as { isIdle?: () => boolean }).isIdle === "function"
         ? !(ctx as unknown as { isIdle: () => boolean }).isIdle!()
         : false;
-      pi.sendUserMessage(doText(slug, client.binary.path, request, deps.settings().queueMax), busy ? { deliverAs: "followUp" } : undefined);
+      const budget = deps.guard.remaining();
+      sendHarnessUserMessage(
+        pi,
+        doText(slug, client.binary.path, request, budget.slots, budget.writes),
+        {
+          source: "Kanboard",
+          title: "Task budget",
+          synopsis: `slots ${String(budget.slots)} · writes ${String(budget.writes)} · user request included`,
+        },
+        busy ? { deliverAs: "followUp" } : undefined,
+      );
       deps.guard.noteSent();
-      deps.debug(`do window open (${slug})`);
+      deps.debug(`do open (${slug}): ${JSON.stringify(deps.guard.remaining())}`);
     },
   });
 
@@ -1343,11 +1456,32 @@ export function registerKanboardCommands(pi: ExtensionAPI, deps: CommandDeps): v
       const sub = (args ?? "").trim().toLowerCase();
       if (sub === "start") {
         if (!(await ensureOnboarded(deps, ctx))) return;
-        await deps.work(ctx as unknown as ExtensionContext);
+        const client = deps.cli;
+        if (!client) {
+          ctx.ui.notify(`kanboard: ${deps.unavailable}`, "warning");
+          return;
+        }
+        const slug = currentSlug()!;
+        deps.revealSkill(ctx);
+        deps.setAutowork(true);
+        deps.guard.setAutowork(true);
+        deps.debug(`autowork on (${slug})`);
+        const busy = typeof (ctx as unknown as { isIdle?: () => boolean }).isIdle === "function"
+          ? !(ctx as unknown as { isIdle: () => boolean }).isIdle!()
+          : false;
+        sendHarnessUserMessage(
+          pi,
+          autoworkText(slug, client.binary.path),
+          { source: "Kanboard", title: "Autowork", synopsis: "no budget limits · user request included" },
+          busy ? { deliverAs: "followUp" } : undefined,
+        );
         return;
       }
       if (sub === "stop") {
-        deps.stop(ctx as unknown as ExtensionContext);
+        deps.setAutowork(false);
+        deps.guard.setAutowork(false);
+        deps.debug("autowork off");
+        ctx.ui.notify("kanboard: autowork off", "info");
         return;
       }
       ctx.ui.notify("kanboard: /unipi:kanboard-autowork start|stop", "warning");