@pi-unipi/kanboard 3.0.0-alpha.2 → 3.0.0-alpha.4

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";
@@ -101,6 +103,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 +136,7 @@ export default function (pi: ExtensionAPI) {
     return true;
   };
 
+  registerProgressRenderer(pi);
   registerKanboardCommands(pi, buildDeps());
 
   registerCommandRunner(ACTION_OPEN, async (ctx) => {

package/package.json

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

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";
@@ -41,7 +42,7 @@ 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.
+  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. 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) {

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,27 @@ export function createRunner(deps: RunnerDeps): Runner {
     }
   }
 
-  // ── mode choice (jev) ─────────────────────────────────────────────────────
-
-  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;
+  // ── strategy choice (labels win; jev decides the unset) ───────────────────
+
+  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;
+    let strategy: Strategy | undefined = labelled;
+    if (strategy === undefined && board.defaultStrategy !== "auto") {
+      strategy = board.defaultStrategy as Strategy;
+    }
+    let jevAnswer: string | null = null;
+    if (strategy === undefined) {
+      const settings = resolveDecisionModel(cwd, "kanboard");
+      const answers = await askJev({ ...strategyQuestion(task), settings, env: process.env });
+      jevAnswer = answers?.strategy?.choice ?? null;
+      strategy = jevAnswer !== null && jevAnswer in STRATEGY_CRITERIA ? (jevAnswer as Strategy) : "none";
+    }
+    deps.debug(`strategy ${task.id}: label=${labelled ?? "-"} board=${board.defaultStrategy}/${board.defaultPlan ? "plan" : "no-plan"} jev answered ${JSON.stringify(jevAnswer)} → ${strategy}${plan ? "+plan" : ""}`);
+    return { strategy, plan };
   }
 
   // ── prompting ─────────────────────────────────────────────────────────────
@@ -240,7 +278,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 +296,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 +324,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 +346,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 +388,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,52 +407,126 @@ 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;
+  }
+
+  /** 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> => {
       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: ${strategy} unavailable (${started.result?.reason ?? "long-horizon not loaded"}) — running without a strategy`,
+          "warning",
+        );
+        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}
+
+${body}`.trim() },
+        );
+        if (started.found && started.result?.ok) {
+          state.mode = "ralph";
+          setRun("ralph");
+          return;
+        }
         ctx.ui.notify(
-          `kanboard: goal mode unavailable (${started.result?.reason ?? "long-horizon not loaded"}) — running direct`,
+          `kanboard: ralph unavailable (${started.result?.reason ?? "no checklist items"}) — falling back to goal`,
           "warning",
         );
-        state.mode = "direct";
+        if (await goalStart()) return;
+        ctx.ui.notify(`kanboard: goal unavailable — running without a strategy`, "warning");
+        state.mode = "none";
+        setRun("none");
+        return;
       }
     }
+  }
 
-    persist("running");
-    setStatus(ctx, describe());
-    ctx.ui.notify(`▣ ${claimed.id} · ${state.mode} — ${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;
+  /** 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. */
@@ -414,7 +541,7 @@ export function createRunner(deps: RunnerDeps): Runner {
   }
 
   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> {
@@ -454,6 +581,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 +705,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 +782,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 +824,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,7 +872,7 @@ 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;
     }
@@ -778,6 +921,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,13 @@ export interface KanboardSettings {
   maxSessions: number;
   /** `add` calls allowed per -do/runner window (0 = unlimited). */
   turnAddLimit: number;
+  /** Strategy for unlabelled tasks ("auto" = jev decides). */
+  defaultStrategy: "auto" | "none" | "goal" | "ralph" | "swarm" | "graph";
+  /** 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 +53,9 @@ export const DEFAULT_SETTINGS: KanboardSettings = {
   queueMax: 10,
   maxSessions: 2,
   turnAddLimit: 20,
+  defaultStrategy: "auto",
+  defaultPlan: false,
+  blocking: "avoid",
 };
 
 export const KANBOARD_NAMESPACE = "kanboard";
@@ -59,7 +69,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 +113,54 @@ 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" },
+        ],
+      },
+      {
+        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)" },
+              { 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",
+          },
+          {
+            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 +183,13 @@ 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,
+    defaultStrategy:
+      typeof raw.defaultStrategy === "string" &&
+      ["auto", "none", "goal", "ralph", "swarm", "graph"].includes(raw.defaultStrategy)
+        ? (raw.defaultStrategy as KanboardSettings["defaultStrategy"])
+        : DEFAULT_SETTINGS.defaultStrategy,
+    defaultPlan: raw.defaultPlan === true,
+    blocking: raw.blocking === "ask" ? "ask" : "avoid",
   };
 }