@pi-unipi/kanboard 3.0.0-alpha.0 → 3.0.0-alpha.10

package/README.md

@@ -39,20 +39,28 @@ not allowed to write:
 
 1. `claim-next --session <sid> --pid <ppid> --host <host> --gate <chainGate>` —
    nothing ready → `Nothing ready (N waiting on deps, M blocked)`.
-2. **jev picks the mode** (one `choice` call over title + body ≤2000 chars):
-   `direct` (small clear change) · `plan` (needs an approved plan) · `goal`
-   (multi-turn objective with verification). jev null → `direct`; the choice is
-   logged to `~/.unipi/logs/kanboard.log` with `UNIPI_DEBUG_KANBOARD=1`.
+2. **The task's labels decide how it runs** (`edit <ID> --strategy
+   none|goal|ralph|swarm|graph` and `--plan yes|no`; `auto`/unset = jev picks).
+   jev gets one `choice` call with only the unset questions (title + body
+   ≤2000 chars): strategy criteria none/goal/ralph/swarm/graph + plan yes/no.
+   jev null → `none` + no plan; the decision is logged to
+   `~/.unipi/logs/kanboard.log` with `UNIPI_DEBUG_KANBOARD=1`.
 3. `set-run --mode`, then the task goes to the agent as a user message: title,
    body, last 10 activity entries, each dependency with its status and last note,
    and the rules (block with a comment to ask a question; never write
    `in_review`/`done`/`cancelled`; work only on this task).
-   - **plan** → plan mode is entered through workflow's `unipi:plan-enter` runner
-     first; approval stays interactive; a discarded plan releases the task to Todo
-     with `plan discarded`.
+   - **plan=yes** → plan mode is entered through workflow's `unipi:plan-enter`
+     runner first; approval stays interactive; a discarded plan releases the
+     task to Todo with `plan discarded`. The chosen strategy applies to the
+     work turn after approval (deferred until `planModeChanged`).
    - **goal** → long-horizon's `unipi:goal-start` runner starts a goal with the
      task as the objective; the goal id is recorded with `set-run --goal` and
      completion is read back with `unipi:goal-status`.
+   - **swarm / graph** → long-horizon's `unipi:lh-explicit` runner sets the
+     explicit mode for the work turn.
+   - **ralph** → `unipi:ralph-start` starts the checklist loop (task title +
+     body as the checklist file); with no `- [ ]` items or a failed start it
+     falls back to goal, then none.
 4. Run end (a `/plan` settle after the last `agent_end`, once the agent reports
    idle with no queued messages): the task is re-read — if the agent blocked it,
    that is respected and reported (`▣ UNI-12 blocked: <comment>`) and the loop
@@ -65,7 +73,7 @@ not allowed to write:
    stale are dropped with a notice), falls back to `claim-next` while autowork
    is on, and stops when nothing is ready. The event loop is never blocked.
 
-Footer: `▣ UNI-12 · direct` while a task runs. The claimed task is persisted with
+Footer: `▣ UNI-12 · <strategy>[ +plan]` while a task runs. The claimed task is persisted with
 `pi.appendEntry("unipi:kanboard-runner", …)`, so `/reload` or a resume offers to
 resume it or releases it to Todo.
 

package/index.ts

@@ -22,6 +22,8 @@ import {
   initUnipiDirs,
   registerCommandRunner,
   getSettings,
+  appendProgress,
+  registerProgressRenderer,
 } from "@pi-unipi/core";
 
 import { openCli, type KanboardCli } from "./src/bin.js";
@@ -69,6 +71,7 @@ export default function (pi: ExtensionAPI) {
       return status?.phase === "running" ? status.taskId : null;
     },
     () => readKanboardSettings().turnAddLimit,
+    () => readKanboardSettings().doCredits,
   );
   const sessionId = (): string => process.env.UNIPI_KANBOARD_SESSION ?? `pi-${process.pid}`;
 
@@ -101,6 +104,7 @@ export default function (pi: ExtensionAPI) {
       guard,
       session: sessionId,
       debug,
+      progress: (data) => appendProgress(pi, data),
     }) as CommandDeps;
 
   const revealSkill = (ctx: ExtensionContext | { cwd?: string }): void => {
@@ -133,6 +137,7 @@ export default function (pi: ExtensionAPI) {
     return true;
   };
 
+  registerProgressRenderer(pi);
   registerKanboardCommands(pi, buildDeps());
 
   registerCommandRunner(ACTION_OPEN, async (ctx) => {
@@ -158,6 +163,9 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.on("session_start", async (_event, ctx) => {
+    // Kanboard's own ambient children (summaries, --list-models) get this env:
+    // they must not re-sync the runtime or spawn a daemon.
+    if (process.env.UNIPI_KANBOARD_CHILD) return;
     initUnipiDirs();
     if (attach(ctx as unknown as ExtensionContext)) {
       const deps = buildDeps();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pi-unipi/kanboard",
-  "version": "3.0.0-alpha.0",
-  "description": "Kanboard v3 \u2014 deferred-work board: CLI/daemon bridge, task runner and skill",
+  "version": "3.0.0-alpha.10",
+  "description": "Kanboard v3 — deferred-work board: CLI/daemon bridge, task runner and skill",
   "type": "module",
   "main": "index.ts",
   "license": "MIT",
@@ -31,10 +31,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0-alpha.0"
+    "@pi-unipi/core": "3.0.0-alpha.10"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.86.0",
+    "@earendil-works/pi-coding-agent": "^0.87.1",
     "typebox": "^1.1.38"
   },
   "pi": {
@@ -48,10 +48,10 @@
     "themes": []
   },
   "optionalDependencies": {
-    "@pi-unipi/kanboard-linux-x64": "3.0.0-alpha.0",
-    "@pi-unipi/kanboard-linux-arm64": "3.0.0-alpha.0",
-    "@pi-unipi/kanboard-darwin-x64": "3.0.0-alpha.0",
-    "@pi-unipi/kanboard-darwin-arm64": "3.0.0-alpha.0",
-    "@pi-unipi/kanboard-win32-x64": "3.0.0-alpha.0"
+    "@pi-unipi/kanboard-linux-x64": "3.0.0-alpha.10",
+    "@pi-unipi/kanboard-linux-arm64": "3.0.0-alpha.10",
+    "@pi-unipi/kanboard-darwin-x64": "3.0.0-alpha.10",
+    "@pi-unipi/kanboard-darwin-arm64": "3.0.0-alpha.10",
+    "@pi-unipi/kanboard-win32-x64": "3.0.0-alpha.10"
   }
 }

package/skills/kanboard/SKILL.md

@@ -26,6 +26,8 @@ be on `PATH`):
 <binary> --actor agent --project <slug> attach <ID> <file> --note "<what it shows>"
 <binary> --actor agent --project <slug> attachments <ID>
 <binary> --actor agent --project <slug> edit <ID> --title|--body|--labels …   # only tasks you created, while in backlog/todo
+<binary> --actor agent --project <slug> edit <ID> --strategy none|goal|ralph|swarm|graph|auto  # how the runner works it (auto/unset = jev decides)
+<binary> --actor agent --project <slug> edit <ID> --plan yes|no|auto        # plan+approve first (auto/unset = jev decides)
 <binary> --actor agent --project <slug> move <ID> blocked --comment "<what you need>"
 <binary> --actor agent --project <slug> link <ID> --after <DEP>
 <binary> --actor agent --project <slug> unlink <ID> --after <DEP>
@@ -35,7 +37,10 @@ be on `PATH`):
 ```
 
 `--json` gives machine-readable output for every subcommand (task objects carry
-`ready`, `waitingFor`, `depsStatus` and `staleness`).
+`ready`, `waitingFor`, `depsStatus`, `staleness`, `strategy` and `plan`).
+
+`list`/`search` show a one-line body excerpt; read a task's full description with
+`show <ID>` before editing, linking or queueing it.
 
 `settings show` reads the pi runtime and effective limits; `settings set`
 and `rotate-token` are user-only — the agent is refused.
@@ -69,9 +74,10 @@ lists them — read the files there directly if you need one.
    your turn ends; claiming them yourself loses the summary and the review step.
 3. **Never cancel.** If a task should be dropped, block it with
    `move <ID> blocked --comment "suggest cancel: <why>"` and let the user decide.
-4. **To ask the user something, block the task and stop**: `move <ID> blocked
-   --comment "<exactly what you need>"`. The answer arrives as a comment the next
-   time the task is claimed.
+4. **Follow the blocking rule in your task prompt**: by default work
+   autonomously and record assumptions with `note <ID> "assumed: <what/why>"`;
+   block (with a comment saying exactly what you need) only when you truly
+   cannot continue — `move <ID> blocked --comment "<what you need>"`.
 5. **Work only on the task you were given.** Follow-up work goes to the board as
    a new task in Backlog (`add "<title>"`), optionally `link <new> --after <ID>`.
    A session holds one claim at a time, and at most `maxSessions` (default 2)

package/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/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";
@@ -39,9 +40,9 @@ export const HELP = `Kanboard commands
   /unipi:kanboard-autowork start|stop   work ready tasks chain by chain; stop finishes the current one first
 Priority -p: 1 none · 2 low · 3 medium · 4 high · 5 urgent`;
 
-export function doText(slug: string, cli: string, request: string, queueMax = 10): string {
+export function doText(slug: string, cli: string, request: string, queueMax = 10, credits = 0): 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.
+  return `[kanboard] For this request you may use the kanboard skill on project ${slug} (CLI: \`${cli} --actor agent --project ${slug} …\`). You have ${credits} write credit${credits === 1 ? "" : "s"} remaining this session — each board write (add, move, edit, note, link, order, queue) costs 1, reads are free; /unipi:kanboard-do tops the credits back up. 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. Read a task with \`show <ID>\` before editing, linking or queueing it — \`list\` only shows titles and a one-line excerpt. To choose how a task is worked, label it with \`edit <ID> --strategy none|goal|ralph|swarm|graph\` and \`--plan yes|no\`; leave it unset to let the runner decide. If the request is unclear, ask me instead of guessing.
 
 Request: ${request}`;
 }
@@ -196,6 +197,8 @@ export interface CommandDeps {
   /** 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 {
@@ -628,6 +631,8 @@ 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`);
       }
+      const bar = boardProgressData(tasks, slug);
+      if (bar) deps.progress?.(bar);
       // Active claims and this session's queue.
       const running = tasks.filter((task) => task.status === "in_progress");
       if (running.length > 0) {
@@ -781,26 +786,23 @@ export async function runStopDaemon(deps: CommandDeps, ctx: ExtensionCommandCont
 
 /**
  * Tell the daemon how to run pi for summaries: `piCommand` (this process's
- * argv minus flags) and `models` (the user's available list, the whitelist the
- * Settings dialog may pick from). Runs on session start and on `open`.
+ * argv minus flags). The daemon owns the model catalog itself now — it runs
+ * `piCommand --list-models` with the same ambient runtime as the summarizer.
+ * Runs on session start and on `open`; skipped inside kanboard's own child
+ * sessions (UNIPI_KANBOARD_CHILD) so the summarizer never rewrites the file.
  */
 export async function syncPiRuntime(
   deps: CommandDeps,
   ctx: ExtensionCommandContext | ExtensionContext,
 ): Promise<void> {
   const client = deps.cli;
-  if (!client) return;
+  if (!client || process.env.UNIPI_KANBOARD_CHILD) return;
   // argv[1] is the pi script when node runs it; a compiled binary has none.
   // Keep it when it exists on disk (the coffee bin/pi shim has no extension).
   const script = process.argv[1];
   const argv = [process.execPath, ...(script && existsSync(script) ? [script] : [])];
-  const models =
-    (ctx as { modelRegistry?: { getAvailable?: () => Array<{ provider: string; id: string }> } })
-      .modelRegistry?.getAvailable?.()
-      .map((model) => `${model.provider}/${model.id}`) ?? [];
   try {
     await client.run<unknown>(["settings", "set", "pi-command", JSON.stringify(argv)], {});
-    await client.run<unknown>(["settings", "set", "models", JSON.stringify(models)], {});
   } catch (error) {
     deps.debug(`pi runtime sync failed: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -1091,7 +1093,21 @@ 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);
@@ -1107,13 +1123,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 && task.title.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}  ${task.title.slice(0, 64)}`,
+            description: task.status,
+          }
+        : {
+            value: fullArgs(before, task.id),
+            label: task.id,
+            description: `${task.status} — ${task.title}`,
+          },
+    );
   return items.length > 0 ? items : null;
 }
 
@@ -1189,15 +1213,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 {
@@ -1306,10 +1334,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 kanboard write credits to the agent (/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: write credits 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;
@@ -1326,9 +1359,12 @@ 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);
+      pi.sendUserMessage(
+        doText(slug, client.binary.path, request, deps.settings().queueMax, deps.guard.remaining()),
+        busy ? { deliverAs: "followUp" } : undefined,
+      );
       deps.guard.noteSent();
-      deps.debug(`do window open (${slug})`);
+      deps.debug(`do credits open (${slug}): ${deps.guard.remaining()} remaining`);
     },
   });
 

package/src/guard.ts

@@ -9,8 +9,8 @@
 
 import { tokenizeArgs } from "./commands.js";
 
-export const WRITE_BLOCK_REASON =
-  "kanboard board writes are only allowed during /unipi:kanboard-do or a runner task";
+export const DEFAULT_DO_CREDITS = 10;
+export const WRITE_CREDITS_USED_UP = "kanboard write credits used up — run /unipi:kanboard-do to reload";
 export const addCapReason = (limit: number): string => `at most ${limit} new tasks per turn`;
 /** @deprecated tests should read the limit through the guard's getter instead. */
 export const ADD_CAP = 20;
@@ -80,35 +80,55 @@ export function isReadonly(invocation: KanboardInvocation): boolean {
 }
 
 export interface WriteGuard {
-  /** Open the window for a `/unipi:kanboard-do` turn. */
+  /** Grant / top up the session's write credits to N (kanboard.doCredits). */
   open(): void;
+  /** Revoke remaining credits (/unipi:kanboard-do off). */
+  revoke(): void;
+  /** Credits left this session. */
+  remaining(): number;
   /** Arm the agent_end closer right after the -do prompt was sent. */
   noteSent(): void;
-  /**
-   * A window opened by -do closes on the first agent_end that isn't the
-   * pre-send echo (>150ms after noteSent). Returns true when it just closed.
-   */
+  /** Credits persist across turns; this only closes the -do window label. */
   onAgentEnd(): boolean;
   /** null when the command is allowed; otherwise the block reason. */
   check(command: string): string | null;
 }
 
 /**
- * The window is open during a -do turn (`doOpen`) or while the runner has a
- * task in phase `running`. `runnerTask` returns that task's id (null when the
- * runner is not running one) — the `add` counter resets whenever the running
- * task changes, so autowork/queue drains get a fresh 20 per task.
+ * Writes cost session credits (one per write subcommand in the command line);
+ * reads are free and never blocked. A runner task keeps unlimited access
+ * (still add-capped). Credits persist across turns and follow-up questions
+ * until spent; /unipi:kanboard-do tops up to N without stacking past N.
  */
-export function createWriteGuard(runnerTask: () => string | null, addLimit: () => number = () => ADD_CAP): WriteGuard {
+export function createWriteGuard(
+  runnerTask: () => string | null,
+  addLimit: () => number = () => ADD_CAP,
+  doCredits: () => number = () => DEFAULT_DO_CREDITS,
+): WriteGuard {
+  let credits = 0;
   let doOpen = false;
   let sentAt = 0;
   let adds = 0;
   let lastTask: string | null = null;
+  const countAdd = (invocation: KanboardInvocation): string | null => {
+    if (invocation.sub !== "add") return null;
+    adds += 1;
+    const limit = addLimit();
+    return limit > 0 && adds > limit ? addCapReason(limit) : null;
+  };
   return {
     open() {
-      doOpen = true;
+      credits = Math.max(credits, Math.max(0, doCredits()));
       adds = 0;
       lastTask = null;
+      doOpen = true;
+    },
+    revoke() {
+      credits = 0;
+      doOpen = false;
+    },
+    remaining() {
+      return credits;
     },
     noteSent() {
       sentAt = Date.now();
@@ -130,12 +150,15 @@ export function createWriteGuard(runnerTask: () => string | null, addLimit: () =
       }
       for (const invocation of invocations) {
         if (isReadonly(invocation)) continue;
-        if (!(doOpen || task !== null)) return WRITE_BLOCK_REASON;
-        if (invocation.sub === "add") {
-          adds += 1;
-          const limit = addLimit();
-          if (limit > 0 && adds > limit) return addCapReason(limit);
+        if (task !== null) {
+          const cap = countAdd(invocation);
+          if (cap) return cap;
+          continue;
         }
+        if (credits <= 0) return WRITE_CREDITS_USED_UP;
+        credits -= 1;
+        const cap = countAdd(invocation);
+        if (cap) return cap;
       }
       return null;
     },

package/src/progress.ts

@@ -0,0 +1,27 @@
+/**
+ * Board progress bar (user-only entry):
+ *   ▣ Board · unipi  ██████████▒▒░░░░░░░░  5/10 tasks  1 blocked
+ * Solid = in review + done, shade = in progress, light = todo + blocked.
+ * Backlog, cancelled and archived tasks are outside the bar.
+ */
+
+import type { ProgressData } from "@pi-unipi/core";
+
+const COUNTED = new Set(["todo", "in_progress", "in_review", "done", "blocked"]);
+
+export function boardProgressData(tasks: ReadonlyArray<{ status: string }>, slug: string): ProgressData | undefined {
+  const counted = tasks.filter((t) => COUNTED.has(t.status));
+  if (counted.length === 0) return undefined;
+  const n = (s: string) => counted.filter((t) => t.status === s).length;
+  const blocked = n("blocked");
+  return {
+    icon: "▣",
+    label: slug ? `Board · ${slug}` : "Board",
+    done: n("in_review") + n("done"),
+    active: n("in_progress"),
+    total: counted.length,
+    unit: "tasks",
+    detail: blocked > 0 ? `${String(blocked)} blocked` : undefined,
+    color: "success",
+  };
+}

package/src/runner.ts

@@ -7,9 +7,11 @@
  * (spec principle 2).
  */
 
+import { appendProgress } from "@pi-unipi/core";
+import { boardProgressData } from "./progress.js";
 import { hostname as osHostname } from "node:os";
 import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
-import { callCommandRunner, readJudgeJevSettings, askJev, UNIPI_EVENTS } from "@pi-unipi/core";
+import { callCommandRunner, resolveDecisionModel, askJev, registerCompactionContext, UNIPI_EVENTS } from "@pi-unipi/core";
 
 import { KanboardCliError, type KanboardCli } from "./bin.js";
 import {
@@ -26,7 +28,10 @@ import { applyLimitEnv, type KanboardSettings } from "./settings.js";
 
 export const RUNNER_ENTRY = "unipi:kanboard-runner";
 
-export type RunMode = "direct" | "plan" | "goal";
+export type RunMode = "none" | "plan" | "goal" | "ralph" | "swarm" | "graph";
+
+/** Work strategy = the long-horizon modes; `direct` maps to `none`. */
+export type Strategy = "none" | "goal" | "ralph" | "swarm" | "graph";
 
 export type { KanboardTask, KanboardActivity, KanboardRun };
 
@@ -35,6 +40,10 @@ interface RunnerState {
   task: KanboardTask | null;
   mode: RunMode;
   goalId: string | null;
+  /** Plan-first flag for the current task (requested by label or jev). */
+  planning: boolean;
+  /** Strategy held back until plan approval (set on planModeChanged). */
+  pendingStrategy: Strategy | null;
   endsSinceSend: number;
   stopAfterCurrent: boolean;
   /** Autowork: keep claiming ready tasks after each finish (queue first). */
@@ -47,6 +56,8 @@ interface RunnerState {
   consumedText: string;
   /** When the current task's prompt was sent (ms). */
   sentAt: number;
+  /** Last ctx seen — needed to apply a deferred strategy on plan approval. */
+  lastCtx: ExtensionContext | undefined;
 }
 
 export interface RunnerDeps {
@@ -74,23 +85,34 @@ export interface Runner {
 
 /**
  * The askJev question the runner asks for mode choice, as a standalone export
- * so probes and tests exercise exactly what chooseMode sends.
+ * so probes and tests exercise exactly what chooseStrategy sends.
+ */
+const STRATEGY_CRITERIA: Record<Strategy, string> = {
+  none: "A well-scoped change one pass can finish and check.",
+  goal: "One objective that needs iterating until it is verifiably done (tests, checks).",
+  ralph: "An enumerable checklist of similar chores worked item by item.",
+  swarm: "Several independent parts that can be worked in parallel, then combined.",
+  graph: "Dependent steps where later work needs earlier results.",
+};
+
+type StrategyQuestion = { type: "choice"; instructions: string; criteria: Record<string, string> };
+
+/**
+ * The askJev questions the runner asks per claimed task — only for the fields
+ * the task left unset (`strategy`/`plan` labels win; `auto` = jev decides).
+ * Exported so probes and tests exercise exactly what chooseStrategy sends.
  */
-export function modeQuestion(task: KanboardTask): {
+export function strategyQuestion(task: KanboardTask): {
   state: string;
-  questions: { mode: { type: "choice"; instructions: string; criteria: Record<string, string> } };
+  questions: { strategy: StrategyQuestion };
 } {
   return {
     state: `${task.title}\n\n${(task.body ?? "").slice(0, 2000)}`,
     questions: {
-      mode: {
+      strategy: {
         type: "choice",
-        instructions: "How should this task be executed?",
-        criteria: {
-          direct: "A small, clear change — just do it",
-          plan: "Multi-file or design choices; needs a plan approved first",
-          goal: "A large multi-step objective that needs many turns and verification",
-        },
+        instructions: "Which work strategy should run this task?",
+        criteria: { ...STRATEGY_CRITERIA },
       },
     },
   };
@@ -102,8 +124,10 @@ export function createRunner(deps: RunnerDeps): Runner {
   const state: RunnerState = {
     phase: "idle",
     task: null,
-    mode: "direct",
+    mode: "none",
     goalId: null,
+    planning: false,
+    pendingStrategy: null,
     endsSinceSend: 0,
     stopAfterCurrent: false,
     autowork: false,
@@ -112,6 +136,7 @@ export function createRunner(deps: RunnerDeps): Runner {
     lastText: "",
     consumedText: "",
     sentAt: 0,
+    lastCtx: undefined,
   };
 
   const setStatus = (ctx: ExtensionContext, text?: string): void => {
@@ -122,7 +147,8 @@ export function createRunner(deps: RunnerDeps): Runner {
     }
   };
 
-  const describe = (): string => (state.task ? `▣ ${state.task.id} · ${state.mode}` : "▣ idle");
+  const describe = (): string =>
+    state.task ? `▣ ${state.task.id} · ${state.mode}${state.planning ? " +plan" : ""}` : "▣ idle";
 
   const persist = (phase: string): void => {
     pi.appendEntry(RUNNER_ENTRY, {
@@ -220,15 +246,36 @@ export function createRunner(deps: RunnerDeps): Runner {
     }
   }
 
-  // ── mode choice (jev) ─────────────────────────────────────────────────────
+  // ── strategy choice (labels win; jev decides the unset) ───────────────────
 
-  async function chooseMode(task: KanboardTask): Promise<RunMode> {
-    const settings = readJudgeJevSettings(cwd);
-    const answers = await askJev({ ...modeQuestion(task), settings, env: process.env });
-    const choice = answers?.mode?.choice;
-    const mode: RunMode = choice === "plan" || choice === "goal" ? choice : "direct";
-    deps.debug(`mode ${task.id}: jev answered ${JSON.stringify(choice ?? null)} → ${mode}`);
-    return mode;
+  async function chooseStrategy(task: KanboardTask): Promise<{ strategy: Strategy; plan: boolean }> {
+    // Labels win; the board defaults fill the gaps; jev only picks a strategy
+    // when both leave it on auto. Plan is never a jev question.
+    const board = deps.settings();
+    const labelled = typeof task.strategy === "string" && (task.strategy as string) !== "auto" ? (task.strategy as Strategy) : undefined;
+    const plan: boolean = typeof task.plan === "boolean" ? task.plan : board.defaultPlan === true;
+    // Jev routing is enabled only by defaultStrategy "auto"; disabled = the
+    // board default runs, no jev call at all.
+    const jevRouting = board.defaultStrategy === "auto";
+    let strategy: Strategy | undefined = labelled;
+    if (strategy === undefined && !jevRouting) {
+      strategy = board.defaultStrategy as Strategy;
+    }
+    let jevAnswer: string | null = null;
+    let jevConfidence: number | null = null;
+    if (strategy === undefined && jevRouting) {
+      const settings = resolveDecisionModel(cwd, "kanboard");
+      const answers = await askJev({ ...strategyQuestion(task), settings, env: process.env });
+      jevAnswer = answers?.strategy?.choice ?? null;
+      jevConfidence = typeof answers?.strategy?.confidence === "number" ? answers.strategy.confidence : null;
+      // Same confidence gate as the long-horizon judge: a missing or low
+      // confidence abstains to "none".
+      const accepted =
+        jevAnswer !== null && jevAnswer in STRATEGY_CRITERIA && (jevConfidence ?? -1) >= board.jevThreshold;
+      strategy = accepted ? (jevAnswer as Strategy) : "none";
+    }
+    deps.debug(`strategy ${task.id}: label=${labelled ?? "-"} board=${board.defaultStrategy}/${board.defaultPlan ? "plan" : "no-plan"} jev answered ${JSON.stringify(jevAnswer)} confidence=${jevConfidence ?? "-"}/${board.jevThreshold} → ${strategy}${plan ? "+plan" : ""}`);
+    return { strategy: strategy ?? "none", plan };
   }
 
   // ── prompting ─────────────────────────────────────────────────────────────
@@ -240,7 +287,7 @@ export function createRunner(deps: RunnerDeps): Runner {
       .map((entry) => `- ${entry.at} [${entry.actor}] ${entry.text}`)
       .join("\n");
     const byId = new Map(all.map((candidate) => [candidate.id, candidate]));
-    const deps = (task.deps ?? [])
+    const depLines = (task.deps ?? [])
       .map((id) => {
         const dep = byId.get(id);
         if (!dep) return `- ${id}: (missing)`;
@@ -258,16 +305,25 @@ export function createRunner(deps: RunnerDeps): Runner {
       activity || "(none)",
       "",
       "## Dependencies",
-      deps || "(none)",
+      depLines || "(none)",
       "",
       ...attachmentSection(task),
       "## Rules",
       `Work only on this task (${task.id}).`,
       `Use the board CLI through its absolute path and always pass the actor and project:`,
       `  ${binary} --actor agent --project ${project()} <command>`,
-      `If you need information or a decision from the user, run:`,
-      `  ${binary} --actor agent --project ${project()} move ${task.id} blocked --comment "<what you need>"`,
-      "and stop — the runner will hand the task back when the user answers.",
+      ...(deps.settings().blocking === "ask"
+        ? [
+            `If you need information or a decision from the user, run:`,
+            `  ${binary} --actor agent --project ${project()} move ${task.id} blocked --comment "<what you need>"`,
+            "and stop — the runner will hand the task back when the user answers.",
+          ]
+        : [
+            "Work autonomously. If something is unclear, make the most reasonable assumption, record it with",
+            `  \`note ${task.id} "assumed: <what and why>"\`, and continue. Block only when you truly cannot continue —`,
+            "missing credentials or access, a destructive or irreversible decision, or a contradiction in the",
+            `  task — with \`${binary} --actor agent --project ${project()} move ${task.id} blocked --comment "<what you need>"\`, then stop.`,
+          ]),
       `Do not move the task to in_review or done and do not cancel it: the runner writes those when your turn ends.`,
       `You may add notes with \`note ${task.id} "<text>"\`, link follow-up work with \`add\`, and reorder with \`order\`.`,
       `To show evidence (a screenshot, a log, a report), attach it: \`attach ${task.id} <file> --note "<what it shows>"\`.`,
@@ -277,6 +333,7 @@ export function createRunner(deps: RunnerDeps): Runner {
   // ── the loop ──────────────────────────────────────────────────────────────
 
   async function startTask(ctx: ExtensionContext): Promise<boolean> {
+    state.lastCtx = ctx;
     let claimed: KanboardTask | null;
     let claim: KanboardClaim;
     try {
@@ -298,6 +355,8 @@ export function createRunner(deps: RunnerDeps): Runner {
     state.task = claimed;
     state.endsSinceSend = 0;
     state.planOutcome = null;
+    state.planning = false;
+    state.pendingStrategy = null;
     state.lastText = "";
     try {
       return await runClaimedTask(ctx, claimed);
@@ -338,13 +397,16 @@ export function createRunner(deps: RunnerDeps): Runner {
     state.goalId = null;
     state.phase = "running";
 
-    let mode: RunMode = "direct";
+    let strategy: Strategy = "none";
+    let plan = false;
     try {
-      mode = await chooseMode(claimed);
+      ({ strategy, plan } = await chooseStrategy(claimed));
     } catch (error) {
-      deps.debug(`mode choice failed: ${error instanceof Error ? error.message : String(error)}`);
+      deps.debug(`strategy choice failed: ${error instanceof Error ? error.message : String(error)}`);
     }
-    state.mode = mode;
+    // mode = the strategy that actually runs the work turn (plan rides alongside).
+    state.mode = strategy;
+    state.planning = plan;
 
     const all = await cli
       .run<unknown>(["list"], { extraEnv: { UNIPI_KANBOARD_PROJECT: project() } })
@@ -354,67 +416,173 @@ export function createRunner(deps: RunnerDeps): Runner {
         return [] as KanboardTask[];
       });
 
-    // Record the mode (and the goal id once it exists) on the task itself.
-    await cli
-      .run(["set-run", claimed.id, "--mode", mode], { extraEnv: { UNIPI_KANBOARD_PROJECT: project() } })
-      .catch((error) => deps.debug(`set-run failed: ${error instanceof Error ? error.message : String(error)}`));
-
-    if (mode === "plan") {
+    if (plan) {
       const started = await callCommandRunner<{ ok?: boolean; reason?: string }>("unipi:plan-enter", ctx);
       if (!started.found || !started.result?.ok) {
         ctx.ui.notify(
-          `kanboard: plan mode unavailable (${started.result?.reason ?? "workflow not loaded"}) — running direct`,
+          `kanboard: plan mode unavailable (${started.result?.reason ?? "workflow not loaded"}) — running without a plan`,
           "warning",
         );
-        state.mode = "direct";
+        state.planning = false;
       }
     }
-    if (state.mode === "goal") {
+    if (state.planning) {
+      // The strategy applies to the WORK turn after approval — apply it on
+      // planModeChanged, not now (setExplicit would be consumed by the plan turn).
+      state.pendingStrategy = strategy;
+    } else {
+      await applyStrategy(ctx, claimed, strategy);
+    }
+
+    persist("running");
+    setStatus(ctx, describe());
+    ctx.ui.notify(`▣ ${claimed.id} · ${state.mode}${state.planning ? " +plan" : ""} — ${claimed.title}`, "info");
+
+    const prompt = renderPrompt(claimed, all);
+    const busy = typeof ctx.isIdle === "function" ? !ctx.isIdle() : false;
+    state.sentAt = Date.now();
+    pi.sendUserMessage(prompt, busy ? { deliverAs: "followUp" } : undefined);
+    return true;
+  }
+
+  /** Latest [parked goal: …] marker from the task's release comments, if any. */
+  async function parkedGoalFromNotes(taskId: string): Promise<string | null> {
+    try {
+      const shown = asTask(
+        "show",
+        await runCli<unknown>(["show", taskId], { extraEnv: { UNIPI_KANBOARD_PROJECT: project() } }),
+      );
+      const matches = (shown.activity ?? [])
+        .map((entry) => entry.text.match(/\[parked goal: ([\w-]+)\]/)?.[1])
+        .filter((goal): goal is string => typeof goal === "string");
+      return matches.at(-1) ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Wire the chosen strategy for the work turn; falls back toward "none". */
+  async function applyStrategy(ctx: ExtensionContext, task: KanboardTask, strategy: Strategy): Promise<void> {
+    const setRun = (mode: RunMode, goal?: string): void => {
+      void cli
+        .run(
+          ["set-run", task.id, "--mode", mode, ...(goal ? ["--goal", goal] : [])],
+          { extraEnv: { UNIPI_KANBOARD_PROJECT: project() } },
+        )
+        .catch((error) => deps.debug(`set-run failed: ${error instanceof Error ? error.message : String(error)}`));
+    };
+    const goalStart = async (): Promise<boolean> => {
+      // A goal parked for THIS task (interrupted/released earlier) resumes
+      // instead of starting fresh; a stale id falls through to goal-start.
+      const priorGoal = task.run?.goal ?? (await parkedGoalFromNotes(task.id));
+      if (priorGoal) {
+        const resumed = await callCommandRunner<{ ok?: boolean; reason?: string }>(
+          "unipi:goal-resume",
+          ctx,
+          { goalId: priorGoal },
+        );
+        if (resumed.found && resumed.result?.ok) {
+          state.goalId = priorGoal;
+          state.mode = "goal";
+          setRun("goal", priorGoal);
+          return true;
+        }
+      }
       const started = await callCommandRunner<{ ok?: boolean; goalId?: string; reason?: string }>(
         "unipi:goal-start",
         ctx,
-        { objective: `${claimed.title} — ${(claimed.body ?? "").slice(0, 400)}`.trim() },
+        { objective: `${task.title} — ${(task.body ?? "").slice(0, 400)}`.trim() },
       );
       if (started.found && started.result?.ok && started.result.goalId) {
         state.goalId = started.result.goalId;
-        await cli
-          .run(["set-run", claimed.id, "--mode", "goal", "--goal", state.goalId], {
-            extraEnv: { UNIPI_KANBOARD_PROJECT: project() },
-          })
-          .catch(() => undefined);
-      } else {
+        state.mode = "goal";
+        setRun("goal", state.goalId);
+        return true;
+      }
+      return false;
+    };
+    switch (strategy) {
+      case "none":
+        state.mode = "none";
+        setRun("none");
+        return;
+      case "goal":
+        if (await goalStart()) return;
+        ctx.ui.notify(`kanboard: goal unavailable — running without a strategy`, "warning");
+        state.mode = "none";
+        setRun("none");
+        return;
+      case "swarm":
+      case "graph": {
+        const started = await callCommandRunner<{ ok?: boolean; reason?: string }>(
+          "unipi:lh-explicit",
+          ctx,
+          { mode: strategy },
+        );
+        if (started.found && started.result?.ok) {
+          state.mode = strategy;
+          setRun(strategy);
+          return;
+        }
         ctx.ui.notify(
-          `kanboard: goal mode unavailable (${started.result?.reason ?? "long-horizon not loaded"}) — running direct`,
+          `kanboard: ${strategy} unavailable (${started.result?.reason ?? "long-horizon not loaded"}) — running without a strategy`,
           "warning",
         );
-        state.mode = "direct";
+        state.mode = "none";
+        setRun("none");
+        return;
       }
-    }
+      case "ralph": {
+        const body = task.body ?? "";
+        const started = await callCommandRunner<{ ok?: boolean; reason?: string }>(
+          "unipi:ralph-start",
+          ctx,
+          { name: task.id, content: `${task.title}
 
-    persist("running");
-    setStatus(ctx, describe());
-    ctx.ui.notify(`▣ ${claimed.id} · ${state.mode} — ${claimed.title}`, "info");
+${body}`.trim() },
+        );
+        if (started.found && started.result?.ok) {
+          state.mode = "ralph";
+          setRun("ralph");
+          return;
+        }
+        ctx.ui.notify(
+          `kanboard: ralph unavailable (${started.result?.reason ?? "no checklist items"}) — falling back to goal`,
+          "warning",
+        );
+        if (await goalStart()) return;
+        ctx.ui.notify(`kanboard: goal unavailable — running without a strategy`, "warning");
+        state.mode = "none";
+        setRun("none");
+        return;
+      }
+    }
+  }
 
-    const prompt = renderPrompt(claimed, all);
-    const busy = typeof ctx.isIdle === "function" ? !ctx.isIdle() : false;
-    state.sentAt = Date.now();
-    pi.sendUserMessage(prompt, busy ? { deliverAs: "followUp" } : undefined);
-    return true;
+  /** User-only board bar after each finished task. Best-effort. */
+  async function postBoardProgress(): Promise<void> {
+    try {
+      const { tasks } = asTaskList(await runCli<unknown>(["list"], { extraEnv: { UNIPI_KANBOARD_PROJECT: project() } }));
+      const bar = boardProgressData(tasks, project());
+      if (bar) appendProgress(pi, bar);
+    } catch (error) {
+      deps.debug(`board progress failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
 
   /** Ask the goal engine whether the goal reached a terminal state. */
-  async function goalStatus(): Promise<{ status: string; objective?: string } | null> {
-    const looked = await callCommandRunner<{ found?: boolean; status?: string; objective?: string }>(
+  async function goalStatus(): Promise<{ status: string; reason?: string; objective?: string } | null> {
+    const looked = await callCommandRunner<{ found?: boolean; status?: string; reason?: string; objective?: string }>(
       "unipi:goal-status",
       undefined,
       { goalId: state.goalId },
     );
     if (!looked.found || !looked.result?.found || !looked.result.status) return null;
-    return { status: looked.result.status, objective: looked.result.objective };
+    return { status: looked.result.status, reason: looked.result.reason, objective: looked.result.objective };
   }
 
   function planStillActive(): boolean {
-    return state.mode === "plan" && state.planOutcome === null;
+    return state.planning && state.planOutcome === null;
   }
 
   async function finishTask(ctx: ExtensionContext, outcome: "in_review" | "todo" | "blocked", comment: string): Promise<void> {
@@ -426,21 +594,57 @@ export function createRunner(deps: RunnerDeps): Runner {
         "show",
         await runCli<unknown>(["show", task.id], { extraEnv: { UNIPI_KANBOARD_PROJECT: project() } }),
       );
-      if (value.status === "blocked") {
+      // The user moved the task out from under the runner (done/cancelled/
+      // backlog): stop its goal, leave the board alone.
+      const movedAway = ["done", "cancelled", "backlog"].includes(value.status);
+      if (movedAway && state.goalId) {
+        await callCommandRunner("unipi:goal-stop", ctx, { goalId: state.goalId });
+      }
+      // A still-drivable goal is parked so re-claiming this task resumes it.
+      // The id rides the release comment (activity survives; the run block
+      // does not — release clears it).
+      let parkedMarker = "";
+      if (!movedAway && state.mode === "goal" && state.goalId) {
+        const paused = await callCommandRunner<{ ok?: boolean; reason?: string }>(
+          "unipi:goal-pause",
+          ctx,
+          { goalId: state.goalId },
+        );
+        if (paused.found && paused.result?.ok) {
+          deps.debug(`goal ${state.goalId} parked for ${task.id}`);
+          parkedMarker = ` [parked goal: ${state.goalId}]`;
+        }
+      }
+      if (movedAway) {
+        // The user's move stands — no release, just reset the runner.
+        ctx.ui.notify(`▣ ${task.id} was moved to ${value.status} outside the runner — goal stopped`, "warning");
+      } else if (value.status === "blocked") {
         const note = (value.activity ?? []).slice(-1)[0]?.text ?? "blocked";
         ctx.ui.notify(`▣ ${task.id} blocked: ${note}`, "warning");
       } else if (outcome === "in_review") {
-        await runCli(["release", task.id, "--to", "in_review", "--comment", comment], {
+        await runCli(["release", task.id, "--to", "in_review", "--comment", comment + parkedMarker], {
           extraEnv: { UNIPI_KANBOARD_PROJECT: project() },
         });
         const first = comment.split("\n")[0]?.slice(0, 120) ?? "";
         ctx.ui.notify(`✓ ${task.id} → In Review: ${first}`, "info");
       } else {
-        await runCli(["release", task.id, "--to", outcome, "--comment", comment], {
+        await runCli(["release", task.id, "--to", outcome, "--comment", comment + parkedMarker], {
           extraEnv: { UNIPI_KANBOARD_PROJECT: project() },
         });
         ctx.ui.notify(`↩ ${task.id} → ${outcome === "todo" ? "Todo" : "Blocked"}: ${comment.slice(0, 120)}`, "warning");
       }
+      if (movedAway) {
+        state.consumedText = state.lastText.trim();
+        state.task = null;
+        state.goalId = null;
+        state.endsSinceSend = 0;
+        state.phase = "idle";
+        persist("idle");
+        setStatus(ctx, state.stopAfterCurrent ? undefined : describe());
+        await postBoardProgress();
+        await continueLoop(ctx);
+        return;
+      }
     } catch (error) {
       ctx.ui.notify(
         `kanboard: could not release ${task.id} — ${error instanceof KanboardCliError ? error.message : String(error)}`,
@@ -454,6 +658,7 @@ export function createRunner(deps: RunnerDeps): Runner {
     state.phase = "idle";
     persist("idle");
     setStatus(ctx, state.stopAfterCurrent ? undefined : describe());
+    await postBoardProgress();
 
     await continueLoop(ctx);
   }
@@ -577,6 +782,14 @@ export function createRunner(deps: RunnerDeps): Runner {
     return false;
   }
 
+  // Compaction summaries lead with the task in flight, so the agent keeps its
+  // task id and rules even when the original task prompt is summarized away.
+  registerCompactionContext("kanboard", () =>
+    state.phase === "running" && state.task
+      ? kanboardCompactionBrief(state.task, state.mode, cli.binary.path, project(), deps.settings().blocking)
+      : null,
+  );
+
   return {
     async work(ctx: ExtensionContext): Promise<void> {
       if (state.phase !== "idle") {
@@ -646,9 +859,14 @@ export function createRunner(deps: RunnerDeps): Runner {
     onPlanModeChanged(payload: unknown): void {
       const active = (payload as { active?: boolean } | undefined)?.active;
       const reason = (payload as { reason?: string } | undefined)?.reason;
-      if (active === false && state.mode === "plan") {
+      if (active === false && state.planning && state.planOutcome === null) {
         state.planOutcome = reason === "discarded" ? "discarded" : "approved";
         deps.debug(`plan mode left: ${state.planOutcome}`);
+        // Strategy applies to the work turn after approval.
+        if (state.planOutcome === "approved" && state.pendingStrategy && state.task && state.lastCtx) {
+          void applyStrategy(state.lastCtx, state.task, state.pendingStrategy);
+        }
+        state.pendingStrategy = null;
       }
     },
 
@@ -683,7 +901,9 @@ export function createRunner(deps: RunnerDeps): Runner {
       );
       if (resume) {
         state.task = task;
-        state.mode = claimed.mode ?? "direct";
+        // Old session entries may still say "direct" — it maps to "none".
+        const restored = (claimed.mode as string | undefined) === "direct" ? "none" : (claimed.mode ?? "none");
+        state.mode = restored;
         state.goalId = claimed.goalId ?? null;
         state.phase = "running";
         state.endsSinceSend = 0;
@@ -729,19 +949,26 @@ export function createRunner(deps: RunnerDeps): Runner {
       deps.debug("settle deferred: plan mode still active");
       return;
     }
-    if (state.mode === "plan" && state.planOutcome === "discarded") {
+    if (state.planning && state.planOutcome === "discarded") {
       await finishTask(ctx, "todo", "plan discarded");
       return;
     }
     if (state.mode === "goal" && state.goalId) {
       const goal = await goalStatus();
-      if (goal && goal.status !== "complete") {
-        if (["failed", "blocked", "stalled", "abandoned", "budget_exhausted"].includes(goal.status)) {
-          await finishTask(ctx, "todo", `goal ${goal.status}`);
+      if (goal) {
+        // A user-stopped goal is NOT success: the task goes back to Todo.
+        if (goal.status === "complete" && goal.reason === "complete(user_requested)") {
+          await finishTask(ctx, "todo", "goal stopped by user");
+          return;
+        }
+        if (goal.status !== "complete") {
+          if (["failed", "blocked", "stalled", "abandoned", "budget_exhausted"].includes(goal.status)) {
+            await finishTask(ctx, "todo", `goal ${goal.status}`);
+            return;
+          }
+          deps.debug(`settle deferred: goal ${goal.status}`);
           return;
         }
-        deps.debug(`settle deferred: goal ${goal.status}`);
-        return;
       }
     }
 
@@ -778,6 +1005,27 @@ export function createDebugLog(env: NodeJS.ProcessEnv = process.env): (line: str
   };
 }
 
+/** Active-work text for compaction summaries (see core registerCompactionContext). */
+export function kanboardCompactionBrief(
+  task: KanboardTask,
+  mode: string | null,
+  binary: string,
+  project: string,
+  blocking: string,
+): string {
+  const body = (task.body ?? "").replace(/\s+/g, " ").trim();
+  const cli = `${binary} --actor agent --project ${project}`;
+  return [
+    `Kanboard task ${task.id} "${task.title}" is in progress${mode && mode !== "none" ? ` (strategy: ${mode})` : ""} — work only on this task.`,
+    body ? `Task: ${body.length > 600 ? `${body.slice(0, 599)}…` : body}` : "",
+    `Board CLI: ${cli} <command>  (e.g. \`show ${task.id}\` for the full task, \`note ${task.id} "<text>"\`).`,
+    blocking === "ask"
+      ? `If you need the user: \`${cli} move ${task.id} blocked --comment "<what you need>"\`, then stop.`
+      : `Work autonomously; block (\`move ${task.id} blocked --comment "…"\`) only when you truly cannot continue.`,
+    "Do not move the task to in_review or done — the runner does that when your turn ends.",
+  ].filter(Boolean).join("\n");
+}
+
 export function registerPlanEventListener(pi: ExtensionAPI, runner: Runner): void {
   pi.events.on(UNIPI_EVENTS.PLAN_MODE_CHANGED, (payload: unknown) => runner.onPlanModeChanged(payload));
 }

package/src/settings.ts

@@ -2,7 +2,7 @@
  * @pi-unipi/kanboard — settings (hub section "Kanboard").
  */
 
-import { getSettings, registerCommandRunner, registerSettings, setSettings } from "@pi-unipi/core";
+import { getSettings, registerCommandRunner, registerSettings, setSettings, decisionModelSection, DEFAULT_DECISION_OVERRIDE } from "@pi-unipi/core";
 
 export type ChainGate = "in_review" | "done";
 
@@ -31,6 +31,17 @@ export interface KanboardSettings {
   maxSessions: number;
   /** `add` calls allowed per -do/runner window (0 = unlimited). */
   turnAddLimit: number;
+  /** Write credits a /unipi:kanboard-do grants (each board write costs 1). */
+  doCredits: number;
+  /** Strategy for unlabelled tasks ("auto" = jev decides, gated by `jevThreshold`). */
+  defaultStrategy: "auto" | "none" | "goal" | "ralph" | "swarm" | "graph";
+  /** Confidence floor for jev's strategy answer; below it (or missing) the task runs "none". */
+  jevThreshold: number;
+  /** Plan-first for unlabelled tasks (jev is never asked about plan). */
+  defaultPlan: boolean;
+  /** Whether a blocked-by-confusion task may ask the user (ask) or must
+   *  assume-and-note (avoid, the default). */
+  blocking: "avoid" | "ask";
 }
 
 export const DEFAULT_SETTINGS: KanboardSettings = {
@@ -46,6 +57,11 @@ export const DEFAULT_SETTINGS: KanboardSettings = {
   queueMax: 10,
   maxSessions: 2,
   turnAddLimit: 20,
+  doCredits: 10,
+  defaultStrategy: "none",
+  jevThreshold: 0.8,
+  defaultPlan: false,
+  blocking: "avoid",
 };
 
 export const KANBOARD_NAMESPACE = "kanboard";
@@ -59,7 +75,7 @@ export function registerKanboardSettings(): void {
   registerSettings({
     namespace: KANBOARD_NAMESPACE,
     label: "Kanboard",
-    defaults: DEFAULT_SETTINGS as unknown as Record<string, unknown>,
+    defaults: { ...DEFAULT_SETTINGS, decisionModel: DEFAULT_DECISION_OVERRIDE } as unknown as Record<string, unknown>,
     schema: [
       {
         title: "Kanboard",
@@ -103,11 +119,63 @@ export function registerKanboardSettings(): void {
           { key: "queueMax", type: "number", label: "-do queue limit", min: 0, zeroLabel: "unlimited", description: "Tasks a session may queue for the runner" },
           { key: "maxSessions", type: "number", label: "Sessions working at once (per project)", min: 1, description: "Distinct sessions holding in_progress tasks" },
           { key: "turnAddLimit", type: "number", label: "New tasks per turn", min: 0, zeroLabel: "unlimited", description: "`add` calls allowed per -do turn or runner task" },
+          { key: "doCredits", type: "number", label: "-do write credits", min: 0, zeroLabel: "off", description: "Write credits a /unipi:kanboard-do grants; each board write costs 1, reads are free" },
+        ],
+      },
+      {
+        title: "Task defaults",
+        description: "What the runner does when a task carries no label",
+        fields: [
+          {
+            key: "defaultStrategy",
+            type: "enum",
+            label: "Default strategy",
+            options: [
+              { value: "auto", label: "Auto (jev decides, gated by confidence)" },
+              { value: "none", label: "none (one-pass change)" },
+              { value: "goal", label: "goal (iterate until verifiably done)" },
+              { value: "ralph", label: "ralph (checklist of similar chores)" },
+              { value: "swarm", label: "swarm (parallel parts)" },
+              { value: "graph", label: "graph (dependent steps)" },
+            ],
+            description: "Strategy for tasks without a --strategy label; auto = jev decides, gated by the confidence threshold",
+          },
+          {
+            key: "jevThreshold",
+            type: "number",
+            label: "Jev confidence threshold",
+            min: 0.01,
+            max: 1,
+            description: "Below this jev's strategy answer abstains → none (0-1)",
+          },
+          {
+            key: "defaultPlan",
+            type: "boolean",
+            label: "Plan first by default",
+            description: "Unlabelled tasks get a plan+approval turn before work (jev is never asked)",
+          },
+          {
+            key: "blocking",
+            type: "enum",
+            label: "Blocking",
+            options: [
+              { value: "avoid", label: "Avoid — work autonomously, note assumptions" },
+              { value: "ask", label: "Ask — block the task to ask the user" },
+            ],
+            description: "What a confused runner task may do; avoid = assume-and-note, only block on true impossibles",
+          },
+        ],
+      },
+      {
+        title: "Board",
+        description: "Daemon, tokens and links",
+        fields: [
           { key: "open", type: "action", label: "Open board…", description: "Start the daemon and print the URL", command: ACTION_OPEN },
           { key: "stopDaemon", type: "action", label: "Stop daemon", description: "Terminate the running kanboard daemon", command: ACTION_STOP_DAEMON },
           { key: "rotateToken", type: "action", label: "Rotate access token", description: "Drop the persistent token; a fresh one mints on the next daemon start", command: ACTION_ROTATE_TOKEN },
         ],
       },
+      decisionModelSection({ title: "Strategy — Decision model" }),
     ],
   });
 }
@@ -130,6 +198,18 @@ export function readKanboardSettings(cwd: string = process.cwd()): KanboardSetti
     queueMax: typeof raw.queueMax === "number" && raw.queueMax >= 0 ? raw.queueMax : DEFAULT_SETTINGS.queueMax,
     maxSessions: typeof raw.maxSessions === "number" && raw.maxSessions >= 1 ? raw.maxSessions : DEFAULT_SETTINGS.maxSessions,
     turnAddLimit: typeof raw.turnAddLimit === "number" && raw.turnAddLimit >= 0 ? raw.turnAddLimit : DEFAULT_SETTINGS.turnAddLimit,
+    doCredits: typeof raw.doCredits === "number" && raw.doCredits >= 0 ? raw.doCredits : DEFAULT_SETTINGS.doCredits,
+    defaultStrategy:
+      typeof raw.defaultStrategy === "string" &&
+      ["auto", "none", "goal", "ralph", "swarm", "graph"].includes(raw.defaultStrategy)
+        ? (raw.defaultStrategy as KanboardSettings["defaultStrategy"])
+        : DEFAULT_SETTINGS.defaultStrategy,
+    jevThreshold:
+      typeof raw.jevThreshold === "number" && raw.jevThreshold > 0 && raw.jevThreshold <= 1
+        ? raw.jevThreshold
+        : DEFAULT_SETTINGS.jevThreshold,
+    defaultPlan: raw.defaultPlan === true,
+    blocking: raw.blocking === "ask" ? "ask" : "avoid",
   };
 }