diff --git a/README.md b/README.md
index 7baf2bd..a0f4189 100644
--- a/README.md
+++ b/README.md
@@ -268,7 +268,7 @@ Idempotent: `<!-- aio-id: {workUnitId} -->` on the parent and `<!-- aio-id: {wor
 
 `## Issue tracking` is attached on **every** agent start while a tree (or last issue) exists, so building stays on the board — not a one-shot addendum. Persist with `git add issues/`. Do not `gh issue create`.
 
-Issues sync to the existing ktui board **Spectrum Web Co** via the `ktui` CLI. Agent tools come from MCP `ktui mcp --start-server` (tool `mcp__ktui_ktui`). This plugin's `.mcp.json` starts that server; no `--scope`.
+Issues sync to the existing ktui board **Spectrum Web Co** via the `ktui` CLI. The plugin moves the current work-unit cards Ready → Doing when the agent starts and Doing → Done on terminal `agent_end` (`willContinue !== true`). Mid-run `turn_end` events do not complete the cards. Agent tools come from MCP `ktui mcp --start-server` (tool `mcp__ktui_ktui`). This plugin's `.mcp.json` starts that server; no `--scope`.
 
 OMP shows a themed kanban widget above the editor plus a `/kanban` overlay. That overlay is **not** the real Textual TUI — run `ktui` in another terminal for that. See **TUI chrome**.
 
diff --git a/src/index.ts b/src/index.ts
index 3aea375..f57be0d 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -30,7 +30,7 @@ import {
 import { resolveGithub } from "./issues/github.ts";
 import { defaultKtuiRunner } from "./issues/kanban.ts";
 import { ensureRepo, listIssues } from "./issues/tissue.ts";
-import { refreshSnapshot, syncAllIssues, trackThoughtGraph, trackUpliftedPrompt } from "./issues/track.ts";
+import { createBoardLaneController, isTerminalAgentEnd, refreshSnapshot, syncAllIssues, trackThoughtGraph, trackUpliftedPrompt } from "./issues/track.ts";
 import { registerIssueTools } from "./issues/tools.ts";
 import { importedSkillCount } from "./skills/import.ts";
 import type { GraphSyncResult, IssueTrackState, SyncResult } from "./issues/types.ts";
@@ -171,10 +171,21 @@ export default function allInOne(pi: ExtensionAPI): void {
 	};
 	const issueState: IssueTrackState = { enabled: config.issues.enabled };
 	const run = defaultKtuiRunner(config.issues.ktuiBin);
+	let hudCtx: ExtensionContext | undefined;
 	let lastResult: UpliftResult | undefined;
 	let injectAddendum = false;
 	let injectIssueAddendum = false;
 	let issueTree: GraphSyncResult | undefined;
+	const boardLanes = createBoardLaneController({
+		run,
+		boardName: () => config.issues.boardName,
+		enabled: () => issueState.enabled,
+		tree: () => issueTree,
+		last: () => issueState.last,
+		onMoved: async () => {
+			if (hudCtx) await refreshHud(hudCtx);
+		},
+	});
 	let sessionCwd = process.cwd();
 	const thinkState = { enabled: config.think.enabled };
 	let lastGraph: ThoughtGraph | undefined;
@@ -804,6 +815,7 @@ export default function allInOne(pi: ExtensionAPI): void {
 	});
 
 	pi.on("session_start", async (event, ctx) => {
+		hudCtx = ctx;
 		sessionCwd = ctx.cwd;
 		applyFlag();
 		lsp.setCwd(ctx.cwd);
@@ -892,6 +904,7 @@ export default function allInOne(pi: ExtensionAPI): void {
 	});
 
 	pi.on("input", async (event, ctx) => {
+		hudCtx = ctx;
 		const idle = typeof ctx.isIdle === "function" ? ctx.isIdle() : true;
 		const decision = decideUplift(
 			{
@@ -1015,6 +1028,7 @@ export default function allInOne(pi: ExtensionAPI): void {
 	});
 
 	pi.on("before_agent_start", (event) => {
+		boardLanes.onAgentStart();
 		let lspDigest = "";
 		if (config.lsp.enabled) {
 			try {
@@ -1120,7 +1134,13 @@ export default function allInOne(pi: ExtensionAPI): void {
 	});
 
 
-	pi.on("turn_end", () => {
+	pi.on("agent_end", (event, ctx) => {
+		if (ctx) hudCtx = ctx;
+		if (isTerminalAgentEnd(event)) boardLanes.onAgentEnd();
+	});
+
+	pi.on("turn_end", (event, ctx) => {
+		if (ctx) hudCtx = ctx;
 		try {
 			const digest = lsp.shouldInjectParent();
 			if (digest) injectLspNote(pi, digest);
diff --git a/src/issues/kanban.test.ts b/src/issues/kanban.test.ts
index df2bbad..1116ab1 100644
--- a/src/issues/kanban.test.ts
+++ b/src/issues/kanban.test.ts
@@ -7,6 +7,8 @@ import {
 	listBoards,
 	listCategories,
 	listTasks,
+	moveTasksToLane,
+	resolveLaneColumn,
 	syncIssue,
 } from "./kanban.ts";
 
@@ -211,3 +213,133 @@ describe("boardSnapshot", () => {
 		expect(snapshot?.tasks).toHaveLength(3);
 	});
 });
+
+const NAMED_COLUMN_JSON = JSON.stringify([
+	{ column_id: 10, name: "Ready", visible: true, position: 1, board_id: 1 },
+	{ column_id: 20, name: "Doing", visible: true, position: 2, board_id: 1 },
+	{ column_id: 30, name: "Done", visible: true, position: 3, board_id: 1 },
+]);
+
+const POSITION_COLUMN_JSON = JSON.stringify([
+	{ column_id: 4, name: "Backlog", visible: true, position: 1, board_id: 1 },
+	{ column_id: 5, name: "Wip", visible: true, position: 2, board_id: 1 },
+	{ column_id: 6, name: "Complete", visible: true, position: 3, board_id: 1 },
+]);
+
+describe("resolveLaneColumn", () => {
+	test("resolves by name when ids are not 1/2/3", async () => {
+		const run = mockRunner((argv) => {
+			if (argv[0] === "column" && argv[1] === "list") return { stdout: NAMED_COLUMN_JSON };
+			throw new Error(`unexpected ${argv.join(" ")}`);
+		});
+		expect(await resolveLaneColumn(run, 1, "ready")).toBe(10);
+		expect(await resolveLaneColumn(run, 1, "doing")).toBe(20);
+		expect(await resolveLaneColumn(run, 1, "done")).toBe(30);
+	});
+
+	test("returns undefined when names are not Ready/Doing/Done", async () => {
+		const run = mockRunner((argv) => {
+			if (argv[0] === "column" && argv[1] === "list") return { stdout: POSITION_COLUMN_JSON };
+			throw new Error(`unexpected ${argv.join(" ")}`);
+		});
+		expect(await resolveLaneColumn(run, 1, "ready")).toBeUndefined();
+		expect(await resolveLaneColumn(run, 1, "doing")).toBeUndefined();
+		expect(await resolveLaneColumn(run, 1, "done")).toBeUndefined();
+	});
+
+	test("does not resolve done to Archive by position", async () => {
+		const run = mockRunner((argv) => {
+			if (argv[0] === "column" && argv[1] === "list") {
+				return {
+					stdout: JSON.stringify([
+						{ column_id: 1, name: "Backlog", visible: true, position: 1, board_id: 1 },
+						{ column_id: 2, name: "Wip", visible: true, position: 2, board_id: 1 },
+						{ column_id: 3, name: "Archive", visible: true, position: 3, board_id: 1 },
+					]),
+				};
+			}
+			throw new Error(`unexpected ${argv.join(" ")}`);
+		});
+		expect(await resolveLaneColumn(run, 1, "done")).toBeUndefined();
+	});
+});
+
+describe("moveTasksToLane", () => {
+	function laneRunner(opts: {
+		columns?: string;
+		tasks?: unknown;
+		moveCode?: number;
+		moveThrow?: boolean;
+		runThrow?: boolean;
+	} = {}) {
+		return mockRunner((argv) => {
+			if (opts.runThrow) throw new Error("ktui exploded");
+			if (argv[0] === "board" && argv[1] === "list") return { stdout: BOARD_JSON };
+			if (argv[0] === "board" && argv[1] === "activate") return {};
+			if (argv[0] === "column" && argv[1] === "list") {
+				return { stdout: opts.columns ?? COLUMN_JSON };
+			}
+			if (argv[0] === "task" && argv[1] === "list") {
+				const tasks = opts.tasks ?? [];
+				return { stdout: typeof tasks === "string" ? tasks : JSON.stringify(tasks) };
+			}
+			if (argv[0] === "task" && argv[1] === "move") {
+				if (opts.moveThrow) throw new Error("ktui exploded");
+				return { code: opts.moveCode ?? 0 };
+			}
+			throw new Error(`unexpected ${argv.join(" ")}`);
+		});
+	}
+
+	test("emits task move argv for Ready to Doing", async () => {
+		const run = laneRunner({
+			tasks: [{ task_id: 9, title: "A", column: 1, description: "tissue:a" }],
+		});
+		await expect(moveTasksToLane(run, [9], "doing")).resolves.toEqual({ moved: 1, skipped: 0 });
+		expect(run.calls).toContainEqual(["task", "move", "9", "2"]);
+	});
+
+	test("skips tasks already in the target lane", async () => {
+		const run = laneRunner({
+			tasks: [{ task_id: 9, title: "A", column: 2, description: "tissue:a" }],
+		});
+		await expect(moveTasksToLane(run, [9], "doing")).resolves.toEqual({ moved: 0, skipped: 1 });
+		expect(run.calls.some((argv) => argv[0] === "task" && argv[1] === "move")).toBe(false);
+	});
+
+	test("skips missing task ids", async () => {
+		const run = laneRunner({
+			tasks: [{ task_id: 9, title: "A", column: 1, description: "tissue:a" }],
+		});
+		await expect(moveTasksToLane(run, [99], "doing")).resolves.toEqual({ moved: 0, skipped: 1 });
+		expect(run.calls.some((argv) => argv[0] === "task" && argv[1] === "move")).toBe(false);
+	});
+
+	test("makes no ktui calls for empty ids", async () => {
+		const run = laneRunner({ runThrow: true });
+		await expect(moveTasksToLane(run, [], "doing")).resolves.toEqual({ moved: 0, skipped: 0 });
+		expect(run.calls).toHaveLength(0);
+	});
+
+	test("never throws when the runner throws or move is nonzero", async () => {
+		const throwing = laneRunner({ runThrow: true });
+		await expect(moveTasksToLane(throwing, [9], "doing")).resolves.toEqual({
+			moved: 0,
+			skipped: 1,
+			reason: "ktui exploded",
+		});
+
+		const failed = laneRunner({
+			tasks: [{ task_id: 9, title: "A", column: 1, description: "tissue:a" }],
+			moveCode: 2,
+		});
+		await expect(moveTasksToLane(failed, [9], "doing")).resolves.toEqual({ moved: 0, skipped: 1 });
+
+		const moveThrows = laneRunner({
+			tasks: [{ task_id: 9, title: "A", column: 1, description: "tissue:a" }],
+			moveThrow: true,
+		});
+		await expect(moveTasksToLane(moveThrows, [9], "doing")).resolves.toEqual({ moved: 0, skipped: 1 });
+	});
+});
+
diff --git a/src/issues/kanban.ts b/src/issues/kanban.ts
index d79b97f..f223d43 100644
--- a/src/issues/kanban.ts
+++ b/src/issues/kanban.ts
@@ -289,3 +289,68 @@ export async function boardSnapshot(
 		return undefined;
 	}
 }
+
+export type BoardLane = "ready" | "doing" | "done";
+
+export async function resolveLaneColumn(
+	run: KtuiRunner,
+	boardId: number,
+	lane: BoardLane,
+): Promise<number | undefined> {
+	const columns = await listColumns(run, boardId);
+	return columns.find((column) => column.name.trim().toLowerCase() === lane)?.column_id;
+}
+
+export async function moveTask(run: KtuiRunner, taskId: number, columnId: number): Promise<boolean> {
+	try {
+		const result = await run(["task", "move", String(taskId), String(columnId)]);
+		return result.code === 0;
+	} catch {
+		return false;
+	}
+}
+
+export async function moveTasksToLane(
+	run: KtuiRunner,
+	taskIds: number[],
+	lane: BoardLane,
+	boardName?: string,
+): Promise<{ moved: number; skipped: number; reason?: string }> {
+	const ids: number[] = [];
+	const seen = new Set<number>();
+	for (const id of taskIds) {
+		if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
+		seen.add(id);
+		ids.push(id);
+	}
+	if (ids.length === 0) return { moved: 0, skipped: 0 };
+
+	try {
+		const { boardId } = await ensureBoard(run, boardName ?? DEFAULT_BOARD_NAME);
+		await run(["board", "activate", String(boardId)]).catch(() => undefined);
+
+		const columnId = await resolveLaneColumn(run, boardId, lane);
+		if (columnId === undefined) {
+			return { moved: 0, skipped: ids.length, reason: "lane column unresolved" };
+		}
+
+		const tasks = await listTasks(run, boardId);
+		const byId = new Map(tasks.map((task) => [task.task_id, task]));
+		let moved = 0;
+		let skipped = 0;
+		for (const id of ids) {
+			const task = byId.get(id);
+			if (!task || task.column === columnId) {
+				skipped += 1;
+				continue;
+			}
+			if (await moveTask(run, id, columnId)) moved += 1;
+			else skipped += 1;
+		}
+		return { moved, skipped };
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		return { moved: 0, skipped: ids.length, reason };
+	}
+}
+
diff --git a/src/issues/track.test.ts b/src/issues/track.test.ts
index 3793ec4..af6009f 100644
--- a/src/issues/track.test.ts
+++ b/src/issues/track.test.ts
@@ -4,8 +4,18 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { ThoughtGraph } from "../think/types.ts";
 import type { KtuiRunner } from "./kanban.ts";
-import { refreshSnapshot, syncAllIssues, trackThoughtGraph, trackUpliftedPrompt, workUnitId } from "./track.ts";
-import { DEFAULT_BOARD_NAME } from "./types.ts";
+import {
+	advanceTrackedIssues,
+	createBoardLaneController,
+	isTerminalAgentEnd,
+	refreshSnapshot,
+	syncAllIssues,
+	trackedTaskIds,
+	trackThoughtGraph,
+	trackUpliftedPrompt,
+	workUnitId,
+} from "./track.ts";
+import { DEFAULT_BOARD_NAME, type GraphSyncResult, type SyncResult } from "./types.ts";
 
 const tempDirs: string[] = [];
 
@@ -166,8 +176,15 @@ function graphOfThree(): ThoughtGraph {
 function boardRunner(): KtuiRunner & { calls: string[][]; tasks: Array<{ task_id: number; title: string; column: number; description: string }> } {
 	const tasks: Array<{ task_id: number; title: string; column: number; description: string }> = [];
 	let nextId = 1;
+	const columns = [
+		{ column_id: 1, name: "Ready", visible: true, position: 1, board_id: 1 },
+		{ column_id: 2, name: "Doing", visible: true, position: 2, board_id: 1 },
+		{ column_id: 3, name: "Done", visible: true, position: 3, board_id: 1 },
+	];
 	const run = mockRunner((argv) => {
 		if (argv[0] === "board" && argv[1] === "list") return { stdout: BOARD_JSON };
+		if (argv[0] === "board" && argv[1] === "activate") return { stdout: "" };
+		if (argv[0] === "column" && argv[1] === "list") return { stdout: JSON.stringify(columns) };
 		if (argv[0] === "task" && argv[1] === "list") {
 			return { stdout: tasks.length > 0 ? JSON.stringify(tasks) : "No tasks created yet." };
 		}
@@ -177,6 +194,13 @@ function boardRunner(): KtuiRunner & { calls: string[][]; tasks: Array<{ task_id
 			tasks.push({ task_id: taskId, title: String(argv[2]), column: 1, description: desc });
 			return { stdout: `Created task \`${argv[2]}\` with task_id = ${taskId}.` };
 		}
+		if (argv[0] === "task" && argv[1] === "move") {
+			const taskId = Number(argv[2]);
+			const columnId = Number(argv[3]);
+			const task = tasks.find((item) => item.task_id === taskId);
+			if (task) task.column = columnId;
+			return { stdout: "" };
+		}
 		throw new Error(`unexpected ${argv.join(" ")}`);
 	});
 	return Object.assign(run, { tasks });
@@ -269,3 +293,184 @@ describe("trackThoughtGraph", () => {
 		expect(result.children).toHaveLength(0);
 	});
 });
+
+function fakeSync(taskId: number | null): SyncResult {
+	return {
+		issue: { id: "i", title: "t", description: "", path: "", fileName: "" },
+		taskId,
+		boardId: 1,
+		categoryId: null,
+		created: false,
+		skipped: false,
+	};
+}
+
+describe("trackedTaskIds", () => {
+	test("dedupes parent+children+last and ignores null/0", () => {
+		const tree: GraphSyncResult = {
+			workUnitId: "unit",
+			parent: fakeSync(10),
+			children: [fakeSync(11), fakeSync(10), fakeSync(null), fakeSync(0)],
+		};
+		expect(trackedTaskIds(tree, fakeSync(12))).toEqual([10, 11, 12]);
+		expect(trackedTaskIds(tree, fakeSync(10))).toEqual([10, 11]);
+		expect(trackedTaskIds(undefined, fakeSync(0))).toEqual([]);
+		expect(trackedTaskIds(undefined, fakeSync(null))).toEqual([]);
+		expect(trackedTaskIds()).toEqual([]);
+	});
+});
+
+describe("advanceTrackedIssues", () => {
+	test("doing moves all tree task ids to column 2", async () => {
+		const root = tmp();
+		const run = boardRunner();
+		const tree = await trackThoughtGraph({
+			root,
+			original: "Ship the widget",
+			graph: graphOfThree(),
+			run,
+			boardName: DEFAULT_BOARD_NAME,
+		});
+		const ids = trackedTaskIds(tree);
+		expect(ids).toHaveLength(4);
+		const result = await advanceTrackedIssues({
+			run,
+			boardName: DEFAULT_BOARD_NAME,
+			lane: "doing",
+			tree,
+		});
+		expect(result.moved).toBe(4);
+		for (const id of ids) {
+			expect(run.tasks.find((task) => task.task_id === id)?.column).toBe(2);
+		}
+	});
+
+	test("never throws", async () => {
+		const result = await advanceTrackedIssues({
+			run: async () => {
+				throw new Error("ktui exploded");
+			},
+			boardName: DEFAULT_BOARD_NAME,
+			lane: "doing",
+			last: fakeSync(1),
+		});
+		expect(result.moved).toBe(0);
+		expect(result.skipped).toBe(1);
+		expect(result.reason).toBe("ktui exploded");
+	});
+});
+
+describe("isTerminalAgentEnd", () => {
+	test("absent and false are terminal; true is a continuation", () => {
+		expect(isTerminalAgentEnd({})).toBe(true);
+		expect(isTerminalAgentEnd({ willContinue: false })).toBe(true);
+		expect(isTerminalAgentEnd({ willContinue: true })).toBe(false);
+	});
+});
+
+describe("createBoardLaneController", () => {
+	test("onAgentStart then onAgentEnd moves doing before done", async () => {
+		const root = tmp();
+		const run = boardRunner();
+		const tree = await trackThoughtGraph({
+			root,
+			original: "Ship the widget",
+			graph: graphOfThree(),
+			run,
+			boardName: DEFAULT_BOARD_NAME,
+		});
+		const controller = createBoardLaneController({
+			run,
+			boardName: () => DEFAULT_BOARD_NAME,
+			enabled: () => true,
+			tree: () => tree,
+			last: () => undefined,
+		});
+		controller.onAgentStart();
+		await controller.pending();
+		for (const id of trackedTaskIds(tree)) {
+			expect(run.tasks.find((task) => task.task_id === id)?.column).toBe(2);
+		}
+		controller.onAgentEnd();
+		await controller.pending();
+		for (const id of trackedTaskIds(tree)) {
+			expect(run.tasks.find((task) => task.task_id === id)?.column).toBe(3);
+		}
+		const moves = run.calls.filter((argv) => argv[0] === "task" && argv[1] === "move");
+		const lastDoing = moves.reduce((idx, argv, i) => (argv[3] === "2" ? i : idx), -1);
+		const firstDone = moves.findIndex((argv) => argv[3] === "3");
+		expect(lastDoing).toBeGreaterThanOrEqual(0);
+		expect(firstDone).toBeGreaterThan(lastDoing);
+	});
+
+	test("onAgentEnd without onAgentStart does not move tasks", async () => {
+		const root = tmp();
+		const run = boardRunner();
+		const tree = await trackThoughtGraph({
+			root,
+			original: "Ship the widget",
+			graph: graphOfThree(),
+			run,
+			boardName: DEFAULT_BOARD_NAME,
+		});
+		const controller = createBoardLaneController({
+			run,
+			boardName: () => DEFAULT_BOARD_NAME,
+			enabled: () => true,
+			tree: () => tree,
+			last: () => undefined,
+		});
+		controller.onAgentEnd();
+		await controller.pending();
+		expect(run.calls.filter((argv) => argv[0] === "task" && argv[1] === "move")).toHaveLength(0);
+		for (const task of run.tasks) expect(task.column).toBe(1);
+	});
+
+	test("enabled false makes no ktui calls", async () => {
+		const run = mockRunner(() => {
+			throw new Error("unexpected ktui");
+		});
+		const controller = createBoardLaneController({
+			run,
+			boardName: () => DEFAULT_BOARD_NAME,
+			enabled: () => false,
+			tree: () => undefined,
+			last: () => fakeSync(9),
+		});
+		controller.onAgentStart();
+		controller.onAgentEnd();
+		await controller.pending();
+		expect(run.calls).toHaveLength(0);
+	});
+
+	test("continuation agent_end leaves cards in doing until terminal", async () => {
+		const root = tmp();
+		const run = boardRunner();
+		const tree = await trackThoughtGraph({
+			root,
+			original: "Ship the widget",
+			graph: graphOfThree(),
+			run,
+			boardName: DEFAULT_BOARD_NAME,
+		});
+		const controller = createBoardLaneController({
+			run,
+			boardName: () => DEFAULT_BOARD_NAME,
+			enabled: () => true,
+			tree: () => tree,
+			last: () => undefined,
+		});
+		controller.onAgentStart();
+		await controller.pending();
+		if (isTerminalAgentEnd({ willContinue: true })) controller.onAgentEnd();
+		await controller.pending();
+		for (const id of trackedTaskIds(tree)) {
+			expect(run.tasks.find((task) => task.task_id === id)?.column).toBe(2);
+		}
+		if (isTerminalAgentEnd({ willContinue: false })) controller.onAgentEnd();
+		await controller.pending();
+		for (const id of trackedTaskIds(tree)) {
+			expect(run.tasks.find((task) => task.task_id === id)?.column).toBe(3);
+		}
+	});
+});
diff --git a/src/issues/track.ts b/src/issues/track.ts
index c6d4d8e..a389fda 100644
--- a/src/issues/track.ts
+++ b/src/issues/track.ts
@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
 import { writeFileSync } from "node:fs";
 import type { ThoughtGraph, ThoughtNode } from "../think/types.ts";
-import type { KtuiRunner } from "./kanban.ts";
-import { boardSnapshot, syncIssue } from "./kanban.ts";
+import type { BoardLane, KtuiRunner } from "./kanban.ts";
+import { boardSnapshot, moveTasksToLane, syncIssue } from "./kanban.ts";
 import { createIssue, ensureRepo, formatIssueBody, issueLinks, listIssues, parseIssueFile } from "./tissue.ts";
 import type { BoardSnapshot, GithubAssoc, GraphSyncResult, SyncResult, TissueIssue } from "./types.ts";
 
@@ -293,3 +293,84 @@ export async function syncAllIssues(
 	}
 	return results;
 }
+
+export function trackedTaskIds(tree?: GraphSyncResult, last?: SyncResult): number[] {
+	const ids: number[] = [];
+	const seen = new Set<number>();
+	const candidates: Array<number | null | undefined> = [];
+	if (tree) {
+		candidates.push(tree.parent.taskId);
+		for (const child of tree.children) candidates.push(child.taskId);
+	}
+	if (last) candidates.push(last.taskId);
+	for (const taskId of candidates) {
+		if (taskId == null || !Number.isFinite(taskId) || taskId <= 0 || seen.has(taskId)) continue;
+		seen.add(taskId);
+		ids.push(taskId);
+	}
+	return ids;
+}
+
+export async function advanceTrackedIssues(opts: {
+	run: KtuiRunner;
+	boardName: string;
+	lane: BoardLane;
+	tree?: GraphSyncResult;
+	last?: SyncResult;
+}): Promise<{ moved: number; skipped: number; reason?: string }> {
+	try {
+		return await moveTasksToLane(opts.run, trackedTaskIds(opts.tree, opts.last), opts.lane, opts.boardName);
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		return { moved: 0, skipped: 0, reason };
+	}
+}
+
+export function isTerminalAgentEnd(event: { willContinue?: boolean }): boolean {
+	return event.willContinue !== true;
+}
+
+export function createBoardLaneController(opts: {
+	run: KtuiRunner;
+	boardName: () => string;
+	enabled: () => boolean;
+	tree: () => GraphSyncResult | undefined;
+	last: () => SyncResult | undefined;
+	onMoved?: () => void | Promise<void>;
+}): {
+	onAgentStart: () => void;
+	onAgentEnd: () => void;
+	pending: () => Promise<void>;
+} {
+	let agentRan = false;
+	let chain: Promise<void> = Promise.resolve();
+
+	const enqueue = (lane: BoardLane): void => {
+		chain = chain
+			.then(async () => {
+				await advanceTrackedIssues({
+					run: opts.run,
+					boardName: opts.boardName(),
+					lane,
+					tree: opts.tree(),
+					last: opts.last(),
+				});
+				await opts.onMoved?.();
+			})
+			.catch(() => {});
+	};
+
+	return {
+		onAgentStart: () => {
+			if (!opts.enabled()) return;
+			agentRan = true;
+			enqueue("doing");
+		},
+		onAgentEnd: () => {
+			if (!agentRan) return;
+			agentRan = false;
+			enqueue("done");
+		},
+		pending: () => chain,
+	};
+}