kankaku 1.1.0 → 1.2.0

package/README.md

@@ -445,7 +445,8 @@ the hub has no credentials — in which case `c`/`s`/`S` do nothing.
 - **Tasks** — a table (time, project, work, cost, prompt) with a
   highlighted row on the left, and a `[ Task ]` detail panel on the right
   showing the selected row's full prompt, client, project, hub task,
-  wall/work/wait time, cost, cache hit and subagent count.
+  wall/work/wait time, cost, cache hit and subagent count. `m` and `M`
+  move (reassign) hub rows (see "Reassigning from the Tasks screen" below).
 - **Catalog** — `[ Clients ]` on the left; the selected client's
   `[ Projects ]`, with open/doing hub task counts, on the right. The
   Clients panel header shows the cache's age and a `(stale)` flag.
@@ -453,6 +454,64 @@ the hub has no credentials — in which case `c`/`s`/`S` do nothing.
   highlighted, and each action's result line shows inside its card while
   it runs and once it settles.
 
+### Reassigning from the Tasks screen
+
+Sync never changes the assignment of a row that is already on the hub
+(it stays create-only, so a reassignment made anywhere is never undone by
+a later sync). The Tasks screen is the explicit way to change it from
+kankaku: with the content zone focused, `m` moves (reassigns) the selected task
+and `M` reassigns every task of the current view (the project filter and
+the today/all scope) whose hub row is on the unassigned client.
+
+Before anything opens, kankaku asks the hub for the rows involved (the
+footer shows `asking the hub…`) and refreshes the catalog. If the hub is
+not configured, rejects the credentials or cannot be reached, the footer
+says so and nothing opens; so does `m` on a task that is not on the hub
+yet (`not on the hub yet — sync first`) and `M` when no task of the view
+is unassigned there.
+
+The picker is a panel over the content zone with its own footer hints:
+
+1. **Client** — the active clients, with the unassigned client last, as
+   `unassigned`.
+2. **Project** — the client's active projects, plus `no project`.
+3. **Task** — the project's tasks that are not done, plus `no task`.
+   Skipped when `no project` was chosen.
+4. **Review** — one line per row, `current → new` by names, the count of
+   rows that will change and what will not be touched. `enter` applies.
+5. **Result** — one line per row (`reassigned`, `unchanged`, or
+   `failed: <reason>`); a failure never stops the remaining rows. `enter`
+   or `esc` returns to the list, which then shows the hub's assignment
+   (`hub …`) in the detail panel next to the local one, for the rows asked
+   about in this session.
+
+`↑`/`↓`/`PageUp`/`PageDown`/`Home`/`End` move inside a step, `enter`
+advances and `esc` (or `←`) goes back one step, closing the picker at the
+first. While the picker is open, the screen's other keys and the app's
+own `esc`/`←`/`Tab`/`1`-`4` are inert; `q` still quits.
+
+What it does and does not do:
+
+- Each changed row gets one `PATCH` of `{ client, project, task }` (an
+  empty relation is sent as `""`). Nothing else is written: not
+  `legacy_client_label`, not any measurement field.
+- The selection is checked against the catalog before any request: the
+  project must belong to the client, the task to the project, all
+  active, the task not done. The picker cannot build an inconsistent
+  choice, and the planner rejects one anyway (the hub itself only checks
+  that each id exists).
+- `M` only ever touches rows that are on the unassigned client on the
+  hub; a row that already has a real assignment is never changed by it.
+  Use `m` on that task to move it deliberately.
+- The local worklog is never rewritten; the Tasks screen keeps showing
+  the local assignment. After a reassignment the hub's assignment is shown
+  next to it for the rows asked about in this session.
+- Tasks that are not on the hub yet must be synced first (Sync screen or
+  `kankaku sync`).
+- The hub keeps no record of who reassigned a row or when. The
+  service account must be allowed to update `task_entries` (the hub's
+  `owner` and `service` roles are).
+
 ## Keys (TUI)
 
 The app has two focus zones — the sidebar and the active screen's own main
@@ -488,9 +547,11 @@ jump to the first/last row.
   (filtered to it), `r` refresh; the Quick actions panel additionally
   takes `c` (refresh catalog), `s` (sync all projects) and `S` (full sync
   all) — one at a time, ignored while another is running.
-- **Tasks** — `a` toggle today/all, `↑`/`↓`/`PageUp`/`PageDown`/`Home`/`End`
-  move the selection, `r` refresh, `esc` clears a project filter set from
-  Dashboard.
+- **Tasks** — `a` toggle today/all,
+  `↑`/`↓`/`PageUp`/`PageDown`/`Home`/`End` move the selection, `r` refresh,
+  `m` move (reassign) the selected task on the hub, `M` move every task of
+  the view that is unassigned on the hub (both open the picker, see above),
+  `esc` clears a project filter set from Dashboard.
 - **Catalog** — `↑`/`↓`/`PageUp`/`PageDown`/`Home`/`End` move the client
   selection, `r` refresh from the hub.
 - **Sync** — `↑`/`↓`/`PageUp`/`PageDown`/`Home`/`End` move the selection,
@@ -502,4 +563,6 @@ The TUI never writes to disk on its own — Dashboard, Tasks and read-only
 Catalog views write nothing at all; Catalog's `refresh`, Sync's
 `s`/`f`/`S` and Dashboard's Quick actions `c`/`s`/`S` write only through
 kankaku's own adapters (`CachedCatalog`, `SyncStateStore`, the hub
-itself), exactly as kankaku's own sync paths do.
+itself), exactly as kankaku's own sync paths do. Tasks' `m`/`M` write
+nothing to disk either (apart from the catalog cache refresh): they change
+the hub's rows only, after the picker's Review step.

package/dist/adapters/hub-reassign.js

@@ -0,0 +1,115 @@
+/**
+ * The hub side of the Tasks screen's reassignment: read the `task_entries`
+ * rows of some kankaku tasks (by `task_id`, in chunks) and PATCH their
+ * `client`/`project`/`task` relations, both through the published
+ * `kankaku-pi/hub` client, so authentication, the 401 re-auth and the
+ * per-request time bound are the client's own. Sync stays create-only:
+ * this is the only path that changes an existing row's assignment, and it
+ * sends nothing but those three relations (never `legacy_client_label`,
+ * never a measurement field).
+ */
+import { PocketBaseClient, PocketBaseError, escapeFilterValue } from "kankaku-pi/hub";
+import { createCatalog } from "./hub.js";
+/** Task ids per lookup request, per the hub contract's guidance (and the sync sink's own chunking). */
+const LOOKUP_CHUNK_SIZE = 30;
+/** Overall bound for `prepare` (row lookups plus the catalog refresh), on top of each request's own time bound. */
+const PREPARE_TIMEOUT_MS = 20_000;
+function relation(value) {
+    return typeof value === "string" ? value : "";
+}
+/**
+ * The hub rows of `taskIds`, keyed by kankaku task id. A task with no row
+ * is simply absent from the map. An empty relation reads `""`. A hub
+ * failure propagates as the client's `PocketBaseError`.
+ */
+export async function fetchHubRows(client, taskIds, options = {}) {
+    const chunkSize = options.chunkSize ?? LOOKUP_CHUNK_SIZE;
+    const rows = new Map();
+    for (let start = 0; start < taskIds.length; start += chunkSize) {
+        const chunk = taskIds.slice(start, start + chunkSize);
+        const filter = chunk.map((taskId) => `task_id="${escapeFilterValue(taskId)}"`).join("||");
+        const items = await client.list("task_entries", { filter, perPage: chunkSize }, options.signal);
+        for (const item of items) {
+            const taskId = item["task_id"];
+            if (typeof taskId !== "string")
+                continue;
+            rows.set(taskId, {
+                rowId: item.id,
+                taskId,
+                clientId: relation(item["client"]),
+                projectId: relation(item["project"]),
+                hubTaskId: relation(item["task"]),
+            });
+        }
+    }
+    return rows;
+}
+/** A short, plain reason for a failed hub call: never a URL, a row id or a stack. */
+export function describeHubError(error) {
+    if (!(error instanceof PocketBaseError))
+        return error instanceof Error ? error.message : String(error);
+    switch (error.kind) {
+        case "auth":
+            return "the hub rejected the credentials";
+        case "timeout":
+            return "the request timed out";
+        case "network":
+            return "the hub is unreachable";
+        case "http":
+            if (error.status === 400)
+                return "the hub rejected the change (400)";
+            if (error.status === 403)
+                return "not allowed to change this row (403)";
+            if (error.status === 404)
+                return "the row no longer exists on the hub (404)";
+            return `the hub answered ${error.status ?? "an error"}`;
+    }
+}
+/**
+ * One `PATCH /api/collections/task_entries/records/<rowId>` per `reassign`
+ * line, body `{ client, project, task }` (`""` for an empty relation).
+ * Rows are sent one after the other; a failure is recorded for its row and
+ * the rest still run. Returns one outcome per `reassign` line, in order.
+ */
+export async function applyReassignment(client, plan) {
+    const outcomes = [];
+    for (const line of plan.lines) {
+        if (line.kind !== "reassign")
+            continue;
+        const body = { client: line.payload.client, project: line.payload.project, task: line.payload.task };
+        try {
+            await client.request("PATCH", `/api/collections/task_entries/records/${encodeURIComponent(line.rowId)}`, body);
+            outcomes.push({ taskId: line.taskId, status: "reassigned" });
+        }
+        catch (error) {
+            outcomes.push({ taskId: line.taskId, status: "failed", reason: describeHubError(error) });
+        }
+    }
+    return outcomes;
+}
+/** Build the {@link ReassignActions} for `credentials`: one client for the row lookups and the PATCHes, the disk-backed catalog for the refresh. */
+export function createReassignActions(credentials, deps) {
+    const client = new PocketBaseClient({ ...credentials, ...(deps.fetch ? { fetch: deps.fetch } : {}) });
+    const catalog = createCatalog(credentials, deps);
+    return {
+        async prepare(taskIds) {
+            const signal = AbortSignal.timeout(PREPARE_TIMEOUT_MS);
+            try {
+                const rows = await fetchHubRows(client, taskIds, { signal });
+                const snapshot = await catalog.refresh(signal);
+                if (snapshot === undefined)
+                    return { ok: false, message: "could not refresh the catalog from the hub" };
+                return { ok: true, rows, catalog: { clients: snapshot.clients, projects: snapshot.projects, tasks: snapshot.tasks ?? [] } };
+            }
+            catch (error) {
+                return { ok: false, message: describeHubError(error) };
+            }
+        },
+        async apply(plan) {
+            const outcomes = await applyReassignment(client, plan);
+            // Task statuses may have moved (opening a task marks it as doing); a failed refresh only leaves the cache as it was.
+            await catalog.refresh().catch(() => undefined);
+            return outcomes;
+        },
+    };
+}

package/dist/cli.js

@@ -11,6 +11,7 @@ import { buildSyncStatusLines, formatCatalogRefreshLines, formatSyncSummaryLines
 import { readTuiConfig } from "./adapters/tui-config.js";
 import { discoverProjects } from "./adapters/project-discovery.js";
 import { readProjectRecords } from "./adapters/worklog-reader.js";
+import { createReassignActions } from "./adapters/hub-reassign.js";
 import { computeProjectSyncStatus, createCatalog, refreshCatalog as refreshCatalogAdapter, resolveHub, syncProject } from "./adapters/hub.js";
 import { readOwnVersion } from "./adapters/app-info.js";
 import { readCarriedVersions } from "./adapters/package-versions.js";
@@ -823,6 +824,21 @@ function catalogScreenDeps(deps) {
         refresh: async () => buildCatalogModel(await refreshCatalogAdapter(catalog), now()),
     };
 }
+/**
+ * Build the Tasks screen's reassignment deps for the interactive app; used
+ * only by `renderApp`. Without hub credentials, `prepare` reports why (the
+ * screen shows it in the footer and opens nothing) and `apply` is never
+ * reached.
+ */
+export function reassignScreenDeps(deps) {
+    const hub = resolveHub({ env: deps.env ?? {}, homeDir: () => deps.homeDir });
+    if (!hub.ok) {
+        const reason = hub.reason;
+        return { prepare: async () => ({ ok: false, message: reason }), apply: async () => [] };
+    }
+    const { now, fetch: fetchOverride } = envDeps(deps);
+    return createReassignActions(hub.credentials, { homeDir: () => deps.homeDir, now, ...(fetchOverride ? { fetch: fetchOverride } : {}) });
+}
 /** Build the Sync screen's `load`/`syncOne`/`syncAll` deps for the interactive app; used only by `renderApp`. */
 function syncScreenDeps(deps, roots) {
     const hub = resolveHub({ env: deps.env ?? {}, homeDir: () => deps.homeDir });
@@ -956,7 +972,7 @@ if (isMain) {
         isTTY: () => process.stdout.isTTY === true,
         prompter: createReadlinePrompter(process.stdin, process.stdout),
         renderApp: (roots, theme, options) => {
-            render(_jsx(ThemeProvider, { theme: theme, children: _jsx(App, { roots: roots, version: readOwnVersion(), loadToday: () => loadDashboard(roots, realDeps), loadTasks: (options) => loadTasks(roots, options), catalog: catalogScreenDeps(realDeps), sync: syncScreenDeps(realDeps, roots), dashboardActions: dashboardActionsDeps(realDeps, roots), wizard: {
+            render(_jsx(ThemeProvider, { theme: theme, children: _jsx(App, { roots: roots, version: readOwnVersion(), loadToday: () => loadDashboard(roots, realDeps), loadTasks: (options) => loadTasks(roots, options), catalog: catalogScreenDeps(realDeps), sync: syncScreenDeps(realDeps, roots), reassign: reassignScreenDeps(realDeps), dashboardActions: dashboardActionsDeps(realDeps, roots), wizard: {
                         facts: gatherWizardFacts(realDeps, options?.claudePluginDir ?? process.env["KANKAKU_CLAUDE_PLUGIN_DIR"]),
                         actions: buildWizardActions(realDeps, options?.claudePluginDir ?? process.env["KANKAKU_CLAUDE_PLUGIN_DIR"]),
                     }, startInWizard: options?.startInWizard }) }), { alternateScreen: true, exitOnCtrlC: true });

package/dist/domain/nav-model.js

@@ -27,6 +27,14 @@ export function clearProjectFilter(state) {
     void projectFilter;
     return rest;
 }
+/** Mark or clear the active screen's modal flow; clearing removes the key, so a state without a modal equals the plain one. */
+export function setModal(state, open) {
+    if (open)
+        return { ...state, modal: true };
+    const { modal, ...rest } = state;
+    void modal;
+    return rest;
+}
 /** Focus the main content zone (e.g. `enter`/`→`/`Tab` from the sidebar). */
 export function focusMain(state) {
     return { ...state, focus: "main" };

package/dist/domain/reassign-model.js

@@ -0,0 +1,101 @@
+/** Why a task is left out of a reassignment plan. User-facing text, shown verbatim. */
+export const NOT_ON_HUB = "not on the hub yet — sync first";
+export const ALREADY_ASSIGNED = "already assigned";
+/** How the catalog's unassigned client is named in every user-facing string. */
+export const UNASSIGNED_LABEL = "unassigned";
+function unassignedClient(clients) {
+    return clients.find((client) => client.unassigned === true);
+}
+/**
+ * `Client`, `Client · Project` or `Client · Project › Task`, by names; the
+ * unassigned client reads `unassigned`, a relation the catalog no longer
+ * knows reads `unknown …`, never an id.
+ */
+export function describeAssignment(assignment, catalog) {
+    const client = catalog.clients.find((candidate) => candidate.id === assignment.clientId);
+    const clientText = assignment.clientId === "" ? "no client" : client === undefined ? "unknown client" : client.unassigned === true ? UNASSIGNED_LABEL : client.name;
+    if (assignment.projectId === "")
+        return clientText;
+    const project = catalog.projects.find((candidate) => candidate.id === assignment.projectId);
+    const projectText = project?.name ?? "unknown project";
+    if (assignment.hubTaskId === "")
+        return `${clientText} · ${projectText}`;
+    const task = catalog.tasks.find((candidate) => candidate.id === assignment.hubTaskId);
+    return `${clientText} · ${projectText} › ${task?.title ?? "unknown task"}`;
+}
+/** The targets whose hub row exists and sits on the catalog's unassigned client: what `M` may touch. */
+export function eligibleForBulk(targets, rows, catalog) {
+    const unassigned = unassignedClient(catalog.clients);
+    if (unassigned === undefined)
+        return [];
+    return targets.filter((target) => rows.get(target.taskId)?.clientId === unassigned.id);
+}
+/** Validate `selection` against the catalog; returns the error message, or `undefined` when it is consistent. */
+function validateSelection(selection, catalog) {
+    const client = catalog.clients.find((candidate) => candidate.id === selection.clientId);
+    if (client === undefined)
+        return "unknown client";
+    if (!client.active)
+        return `client "${client.name}" is not active`;
+    const projectId = selection.projectId ?? "";
+    const hubTaskId = selection.hubTaskId ?? "";
+    if (projectId === "") {
+        return hubTaskId === "" ? undefined : "a task needs a project";
+    }
+    const project = catalog.projects.find((candidate) => candidate.id === projectId);
+    if (project === undefined)
+        return "unknown project";
+    if (!project.active)
+        return `project "${project.name}" is not active`;
+    if (project.clientId !== client.id)
+        return `project "${project.name}" does not belong to client "${client.name}"`;
+    if (hubTaskId === "")
+        return undefined;
+    const task = catalog.tasks.find((candidate) => candidate.id === hubTaskId);
+    if (task === undefined)
+        return "unknown task";
+    if (task.projectId !== project.id)
+        return `task "${task.title}" does not belong to project "${project.name}"`;
+    if (task.status === "done")
+        return `task "${task.title}" is done`;
+    return undefined;
+}
+/**
+ * Turn a destination into one plan line per asked task. The selection is
+ * validated first and rejects the whole plan, so an inconsistent choice
+ * never yields a payload. A task with no hub row is skipped (sync first);
+ * in `bulk` mode a row that is not on the unassigned client is skipped
+ * (`already assigned`); a row that already has exactly the destination is
+ * `unchanged`; the rest are `reassign` lines carrying the relation payload.
+ * Pure: no request is made here.
+ */
+export function planReassignment(input) {
+    const { rows, tasks, catalog, selection, mode } = input;
+    const error = validateSelection(selection, catalog);
+    if (error !== undefined)
+        return { ok: false, error };
+    const payload = { client: selection.clientId, project: selection.projectId ?? "", task: selection.hubTaskId ?? "" };
+    const destination = describeAssignment({ clientId: payload.client, projectId: payload.project, hubTaskId: payload.task }, catalog);
+    const unassigned = unassignedClient(catalog.clients);
+    const lines = tasks.map((target) => {
+        const row = rows.get(target.taskId);
+        if (row === undefined)
+            return { kind: "skipped", taskId: target.taskId, label: target.label, reason: NOT_ON_HUB };
+        if (mode === "bulk" && (unassigned === undefined || row.clientId !== unassigned.id)) {
+            return { kind: "skipped", taskId: target.taskId, label: target.label, reason: ALREADY_ASSIGNED };
+        }
+        if (row.clientId === payload.client && row.projectId === payload.project && row.hubTaskId === payload.task) {
+            return { kind: "unchanged", taskId: target.taskId, label: target.label, at: destination };
+        }
+        return {
+            kind: "reassign",
+            taskId: target.taskId,
+            label: target.label,
+            rowId: row.rowId,
+            from: describeAssignment(row, catalog),
+            to: destination,
+            payload: { ...payload },
+        };
+    });
+    return { ok: true, plan: { mode, destination, lines } };
+}

package/dist/domain/reassign-picker.js

@@ -0,0 +1,258 @@
+import { ALREADY_ASSIGNED, NOT_ON_HUB, UNASSIGNED_LABEL, eligibleForBulk, planReassignment } from "./reassign-model.js";
+/** The id of the "no project" / "no task" option: an empty relation. */
+export const NO_CHOICE = "";
+export function openPicker(input) {
+    return { step: "client", index: 0, ...input };
+}
+function clientLabel(name, unassigned) {
+    return unassigned === true ? UNASSIGNED_LABEL : name;
+}
+/** The selectable options of a choosing step (`client`, `project`, `task`); empty on every other step. */
+export function pickerOptions(state) {
+    const { catalog } = state;
+    if (state.step === "client") {
+        const active = catalog.clients.filter((client) => client.active);
+        const ordered = [...active.filter((client) => client.unassigned !== true), ...active.filter((client) => client.unassigned === true)];
+        return ordered.map((client) => ({ id: client.id, label: clientLabel(client.name, client.unassigned) }));
+    }
+    if (state.step === "project") {
+        const projects = catalog.projects.filter((project) => project.active && project.clientId === state.clientId);
+        return [...projects.map((project) => ({ id: project.id, label: project.name })), { id: NO_CHOICE, label: "no project" }];
+    }
+    if (state.step === "task") {
+        const tasks = catalog.tasks.filter((task) => task.projectId === state.projectId && task.status !== "done");
+        return [...tasks.map((task) => ({ id: task.id, label: task.title })), { id: NO_CHOICE, label: "no task" }];
+    }
+    return [];
+}
+function plural(count, noun) {
+    return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function lines(state) {
+    return state.plan?.ok ? state.plan.plan.lines : [];
+}
+function outcomeFor(state, taskId) {
+    return state.outcomes?.find((outcome) => outcome.taskId === taskId);
+}
+function skippedGroups(planLines) {
+    const groups = [];
+    for (const reason of [ALREADY_ASSIGNED, NOT_ON_HUB]) {
+        const count = planLines.filter((line) => line.kind === "skipped" && line.reason === reason).length;
+        if (count > 0)
+            groups.push({ text: `${count} not touched — ${reason}`, tone: "muted" });
+    }
+    return groups;
+}
+/** The scrolling list of the current step, as display rows. */
+export function pickerRows(state) {
+    if (state.step === "review") {
+        if (state.plan === undefined || !state.plan.ok)
+            return [{ text: `cannot reassign: ${state.plan?.ok === false ? state.plan.error : "no plan"}`, tone: "error" }];
+        const planLines = lines(state);
+        const rows = [];
+        for (const line of planLines) {
+            if (line.kind === "reassign")
+                rows.push({ text: `${line.from} → ${line.to} · ${line.label}` });
+            else if (line.kind === "unchanged")
+                rows.push({ text: `already ${line.at} (unchanged) · ${line.label}`, tone: "muted" });
+        }
+        return [...rows, ...skippedGroups(planLines)];
+    }
+    if (state.step === "result" || state.step === "applying") {
+        const planLines = lines(state);
+        const rows = [];
+        for (const line of planLines) {
+            if (line.kind === "unchanged")
+                rows.push({ text: `unchanged · ${line.label}`, tone: "muted" });
+            if (line.kind !== "reassign")
+                continue;
+            if (state.step === "applying") {
+                rows.push({ text: `sending · ${line.label}` });
+                continue;
+            }
+            const outcome = outcomeFor(state, line.taskId);
+            if (outcome === undefined)
+                rows.push({ text: `failed: no answer from the hub · ${line.label}`, tone: "error" });
+            else if (outcome.status === "reassigned")
+                rows.push({ text: `reassigned · ${line.label}` });
+            else
+                rows.push({ text: `failed: ${outcome.reason} · ${line.label}`, tone: "error" });
+        }
+        return [...rows, ...skippedGroups(planLines)];
+    }
+    return pickerOptions(state).map((option) => ({ text: option.label }));
+}
+/** How many lines the current step's list has (what `moveSelection` clamps to). */
+export function pickerRowCount(state) {
+    return pickerRows(state).length;
+}
+function clamp(value, count) {
+    return Math.min(Math.max(value, 0), Math.max(count - 1, 0));
+}
+/** Move the selection by `delta` lines, clamped to the list (never wraps). */
+export function moveSelection(state, delta) {
+    return { ...state, index: clamp(state.index + delta, pickerRowCount(state)) };
+}
+export function jumpSelection(state, where) {
+    return { ...state, index: where === "first" ? 0 : clamp(Number.MAX_SAFE_INTEGER, pickerRowCount(state)) };
+}
+function withPlan(state) {
+    const selection = {
+        clientId: state.clientId ?? "",
+        ...(state.projectId !== undefined ? { projectId: state.projectId } : {}),
+        ...(state.hubTaskId !== undefined ? { hubTaskId: state.hubTaskId } : {}),
+    };
+    const plan = planReassignment({ rows: state.rows, tasks: state.targets, catalog: state.catalog, selection, mode: state.mode });
+    return { ...state, step: "review", index: 0, plan };
+}
+/**
+ * `enter`: take the selected option and go to the next step, or apply from
+ * review. Returns `undefined` when the picker closes (from `result`); an
+ * empty option list, a rejected plan and the `applying` step leave the
+ * state as it is.
+ */
+export function advance(state) {
+    if (state.step === "result")
+        return undefined;
+    if (state.step === "applying")
+        return state;
+    if (state.step === "review") {
+        if (state.plan === undefined || !state.plan.ok)
+            return state;
+        const hasChanges = state.plan.plan.lines.some((line) => line.kind === "reassign");
+        return hasChanges ? { ...state, step: "applying", index: 0 } : { ...state, step: "result", index: 0, outcomes: [] };
+    }
+    const option = pickerOptions(state)[state.index];
+    if (option === undefined)
+        return state;
+    if (state.step === "client")
+        return { ...state, step: "project", index: 0, clientId: option.id };
+    if (state.step === "project") {
+        if (option.id === NO_CHOICE)
+            return withPlan({ ...state, projectId: undefined });
+        return { ...state, step: "task", index: 0, projectId: option.id };
+    }
+    return withPlan({ ...state, hubTaskId: option.id === NO_CHOICE ? undefined : option.id });
+}
+function without(state, ...keys) {
+    const copy = { ...state };
+    for (const key of keys)
+        delete copy[key];
+    return copy;
+}
+/** Select the option `id` in the list of `state` (used to land on the previous choice when going back). */
+function selecting(state, id) {
+    const index = pickerOptions(state).findIndex((option) => option.id === (id ?? NO_CHOICE));
+    return { ...state, index: Math.max(index, 0) };
+}
+/** `esc`/`←`: go back one step, restoring the previous choice; returns `undefined` when the picker closes (from `client` or `result`). */
+export function back(state) {
+    switch (state.step) {
+        case "client":
+        case "result":
+            return undefined;
+        case "applying":
+            return state;
+        case "project":
+            return selecting(without({ ...state, step: "client" }, "clientId", "projectId", "hubTaskId", "plan"), state.clientId);
+        case "task":
+            return selecting(without({ ...state, step: "project" }, "projectId", "hubTaskId", "plan"), state.projectId);
+        case "review":
+            return state.projectId !== undefined
+                ? selecting(without({ ...state, step: "task" }, "plan"), state.hubTaskId)
+                : selecting(without({ ...state, step: "project" }, "projectId", "hubTaskId", "plan"), undefined);
+    }
+}
+/** The hub answered every PATCH: show the result. */
+export function finishApplying(state, outcomes) {
+    return { ...state, step: "result", index: 0, outcomes };
+}
+const STEP_TITLES = {
+    client: "Client",
+    project: "Project",
+    task: "Task",
+    review: "Review",
+    applying: "Applying",
+    result: "Result",
+};
+export function pickerTitle(state) {
+    return `Reassign · ${STEP_TITLES[state.step]}`;
+}
+function subject(state) {
+    if (state.mode === "single")
+        return `"${state.targets[0]?.label ?? ""}"`;
+    return plural(eligibleForBulk(state.targets, state.rows, state.catalog).length, "unassigned task");
+}
+function chosenClientName(state) {
+    const client = state.catalog.clients.find((candidate) => candidate.id === state.clientId);
+    return client === undefined ? "unknown client" : clientLabel(client.name, client.unassigned);
+}
+/** The two fixed lines above the list: what is being reassigned and what to do or what happened. Always two entries so the layout never shifts. */
+export function pickerHeading(state) {
+    switch (state.step) {
+        case "client":
+            return [`Reassign ${subject(state)}`, "Choose a client"];
+        case "project":
+            return [`Reassign ${subject(state)}`, `${chosenClientName(state)} — choose a project`];
+        case "task": {
+            const project = state.catalog.projects.find((candidate) => candidate.id === state.projectId);
+            return [`Reassign ${subject(state)}`, `${chosenClientName(state)} · ${project?.name ?? "unknown project"} — choose a task`];
+        }
+        case "review": {
+            if (state.plan === undefined || !state.plan.ok)
+                return ["Cannot reassign", ""];
+            const planLines = state.plan.plan.lines;
+            const changes = planLines.filter((line) => line.kind === "reassign").length;
+            const unchanged = planLines.filter((line) => line.kind === "unchanged").length;
+            const skipped = planLines.filter((line) => line.kind === "skipped").length;
+            const detail = [unchanged > 0 ? `${unchanged} unchanged` : "", skipped > 0 ? `${skipped} not touched` : ""].filter((part) => part !== "").join(" · ");
+            return [changes > 0 ? `Move ${plural(changes, "task")} to ${state.plan.plan.destination}` : "Nothing to change", detail];
+        }
+        case "applying":
+            return ["Applying…", "sending the changes to the hub"];
+        case "result": {
+            const planLines = lines(state);
+            const outcomes = state.outcomes ?? [];
+            const done = outcomes.filter((outcome) => outcome.status === "reassigned").length;
+            const failed = planLines.filter((line) => line.kind === "reassign").length - done;
+            const unchanged = planLines.filter((line) => line.kind === "unchanged").length;
+            const skipped = planLines.filter((line) => line.kind === "skipped").length;
+            const headline = [done > 0 ? `${done} reassigned` : "", unchanged > 0 ? `${unchanged} unchanged` : "", failed > 0 ? `${failed} failed` : ""].filter((part) => part !== "").join(" · ");
+            return [headline === "" ? "Nothing changed" : headline, skipped > 0 ? `${skipped} not touched` : ""];
+        }
+    }
+}
+/** The footer key hints for the current step. */
+export function pickerHints(state) {
+    switch (state.step) {
+        case "client":
+            return [
+                { key: "↑↓", label: "move" },
+                { key: "enter", label: "next" },
+                { key: "esc", label: "close" },
+            ];
+        case "project":
+        case "task":
+            return [
+                { key: "↑↓", label: "move" },
+                { key: "enter", label: "next" },
+                { key: "esc", label: "back" },
+            ];
+        case "review":
+            if (state.plan === undefined || !state.plan.ok)
+                return [{ key: "esc", label: "back" }];
+            return [
+                { key: "↑↓", label: "scroll" },
+                { key: "enter", label: "apply" },
+                { key: "esc", label: "back" },
+            ];
+        case "applying":
+            return [{ key: "…", label: "applying, please wait" }];
+        case "result":
+            return [
+                { key: "↑↓", label: "scroll" },
+                { key: "enter", label: "done" },
+                { key: "esc", label: "done" },
+            ];
+    }
+}

package/dist/ports/reassign-actions.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/app.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from "react";
 import { useApp, useInput } from "ink";
-import { INITIAL_NAV_STATE, clearProjectFilter, focusMain, focusSidebar, moveSidebar, openProjectInTasks, screenForKey, switchScreen, } from "../domain/nav-model.js";
+import { INITIAL_NAV_STATE, clearProjectFilter, focusMain, focusSidebar, moveSidebar, openProjectInTasks, screenForKey, setModal, switchScreen, } from "../domain/nav-model.js";
 import { DashboardScreen } from "./dashboard-screen.js";
 import { TasksScreen } from "./tasks-screen.js";
 import { CatalogScreen } from "./catalog-screen.js";
@@ -23,9 +23,12 @@ import { SetupWizard } from "./setup/wizard-screen.js";
  * to it, keeping focus on main; Tasks' own `esc` handling (gated the same
  * way as every other screen key, by its `focused` prop) clears that
  * filter — this hook only predicts whether that will happen, to decide
- * whether it should also move focus.
+ * whether it should also move focus. While the Tasks screen has its
+ * reassignment picker open (`NavState.modal`, reported through its
+ * `onModalChange`), only `q` is handled here: `esc`, `←`, `Tab` and `1`-`4`
+ * belong to the picker, so it can never be left half-way by accident.
  */
-export function App({ roots, version, loadToday, loadTasks, catalog, sync, dashboardActions, wizard, startInWizard }) {
+export function App({ roots, version, loadToday, loadTasks, catalog, sync, dashboardActions, wizard, startInWizard, reassign }) {
     const { exit } = useApp();
     const [nav, setNav] = useState(INITIAL_NAV_STATE);
     const [showWizard, setShowWizard] = useState(startInWizard === true && wizard !== undefined);
@@ -34,6 +37,8 @@ export function App({ roots, version, loadToday, loadTasks, catalog, sync, dashb
             exit();
             return;
         }
+        if (nav.modal === true)
+            return;
         const nextScreen = screenForKey(input);
         if (nextScreen !== undefined) {
             setNav((state) => switchScreen(state, nextScreen));
@@ -70,5 +75,5 @@ export function App({ roots, version, loadToday, loadTasks, catalog, sync, dashb
     if (showWizard && wizard) {
         return _jsx(SetupWizard, { facts: wizard.facts, actions: wizard.actions, onDone: () => setShowWizard(false), onQuit: () => exit(), version: version });
     }
-    return (_jsxs(_Fragment, { children: [nav.screen === "dashboard" && (_jsx(DashboardScreen, { load: loadToday, actions: dashboardActions, roots: roots, version: version, focused: focused, onOpenProject: (project) => setNav((state) => openProjectInTasks(state, project)) })), nav.screen === "tasks" && (_jsx(TasksScreen, { load: loadTasks, roots: roots, version: version, focused: focused, ...(nav.projectFilter !== undefined ? { projectFilter: nav.projectFilter } : {}), onClearFilter: () => setNav((state) => clearProjectFilter(state)) })), nav.screen === "catalog" && _jsx(CatalogScreen, { ...catalog, roots: roots, version: version, focused: focused }), nav.screen === "sync" && _jsx(SyncScreen, { ...sync, roots: roots, version: version, focused: focused })] }));
+    return (_jsxs(_Fragment, { children: [nav.screen === "dashboard" && (_jsx(DashboardScreen, { load: loadToday, actions: dashboardActions, roots: roots, version: version, focused: focused, onOpenProject: (project) => setNav((state) => openProjectInTasks(state, project)) })), nav.screen === "tasks" && (_jsx(TasksScreen, { load: loadTasks, roots: roots, version: version, focused: focused, ...(nav.projectFilter !== undefined ? { projectFilter: nav.projectFilter } : {}), onClearFilter: () => setNav((state) => clearProjectFilter(state)), onModalChange: (open) => setNav((state) => (state.modal === true) === open ? state : setModal(state, open)), ...(reassign !== undefined ? { reassign } : {}) })), nav.screen === "catalog" && _jsx(CatalogScreen, { ...catalog, roots: roots, version: version, focused: focused }), nav.screen === "sync" && _jsx(SyncScreen, { ...sync, roots: roots, version: version, focused: focused })] }));
 }

package/dist/ui/components/table.js

@@ -39,7 +39,7 @@ function rowText(columns, values) {
  * than its column truncates with `…`; `emptyText` renders instead of the
  * body when `rows` is empty.
  */
-export function Table({ columns, rows, rowKey, cell, selectedIndex, emptyText = "no rows", maxRows }) {
+export function Table({ columns, rows, rowKey, cell, selectedIndex, rowColor, emptyText = "no rows", maxRows }) {
     const theme = useTheme();
     const startRef = useRef(0);
     const windowed = maxRows !== undefined && rows.length > maxRows;
@@ -50,6 +50,6 @@ export function Table({ columns, rows, rowKey, cell, selectedIndex, emptyText =
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.muted, children: `  ${rowText(columns, (column) => column.header)}` }), rows.length === 0 ? (_jsx(Text, { color: theme.muted, children: emptyText })) : (_jsxs(_Fragment, { children: [window !== undefined && window.hiddenAbove > 0 && (_jsx(Text, { color: theme.muted, children: `  ↑ ${window.hiddenAbove} more` }, "__indicator-above__")), visibleRows.map((row, index) => {
                         const actualIndex = (window?.start ?? 0) + index;
                         const selected = actualIndex === selectedIndex;
-                        return (_jsx(Text, { backgroundColor: selected ? theme.selectionBg : undefined, children: `${selected ? "› " : "  "}${rowText(columns, (column) => cell(row, column.key))}` }, rowKey(row)));
+                        return (_jsx(Text, { color: rowColor?.(row), backgroundColor: selected ? theme.selectionBg : undefined, children: `${selected ? "› " : "  "}${rowText(columns, (column) => cell(row, column.key))}` }, rowKey(row)));
                     }), window !== undefined && window.hiddenBelow > 0 && (_jsx(Text, { color: theme.muted, children: `  ↓ ${window.hiddenBelow} more` }, "__indicator-below__"))] }))] }));
 }

package/dist/ui/layout.js

@@ -39,7 +39,8 @@ function TabStrip({ items, activeId }) {
  * own panels and scrolling lists to the actual `mainWidth`/`mainHeight`
  * in whichever mode is active.
  */
-export function Layout({ columns, rows, headerLeft, headerRight, sidebarItems, activeId, sidebarStats, keyHints, focus = "sidebar", children }) {
+export function Layout({ columns, rows, headerLeft, headerRight, sidebarItems, activeId, sidebarStats, keyHints, footerNote, focus = "sidebar", children }) {
+    const theme = useTheme();
     const { stdout } = useStdout();
     const width = columns ?? stdout?.columns ?? 80;
     const height = rows ?? stdout?.rows ?? DEFAULT_ROWS;
@@ -50,5 +51,5 @@ export function Layout({ columns, rows, headerLeft, headerRight, sidebarItems, a
     const chromeRows = mode === "collapsed" ? TAB_STRIP_ROWS : mode === "stacked" ? sidebarBlockRows(sidebarItems.length, sidebarStats.length) : 0;
     const mainHeight = Math.max(middleRows - chromeRows, 0);
     const content = children({ mainWidth, mainHeight, mode });
-    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [_jsx(HeaderBar, { left: headerLeft, right: headerRight, width: width }), mode === "collapsed" && (_jsxs(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, children: [_jsx(TabStrip, { items: sidebarItems, activeId: activeId }), _jsx(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, overflow: "hidden", children: content })] })), mode === "stacked" && (_jsxs(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, children: [_jsx(Sidebar, { items: sidebarItems, activeId: activeId, stats: sidebarStats, width: width, focused: sidebarFocused }), _jsx(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, overflow: "hidden", children: content })] })), mode === "wide" && (_jsxs(Box, { flexDirection: "row", flexGrow: 1, minHeight: 0, alignItems: "stretch", children: [_jsx(Sidebar, { items: sidebarItems, activeId: activeId, stats: sidebarStats, width: SIDEBAR_WIDTH, focused: sidebarFocused }), _jsx(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, overflow: "hidden", children: content })] })), _jsx(KeyHints, { hints: keyHints })] }));
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [_jsx(HeaderBar, { left: headerLeft, right: headerRight, width: width }), mode === "collapsed" && (_jsxs(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, children: [_jsx(TabStrip, { items: sidebarItems, activeId: activeId }), _jsx(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, overflow: "hidden", children: content })] })), mode === "stacked" && (_jsxs(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, children: [_jsx(Sidebar, { items: sidebarItems, activeId: activeId, stats: sidebarStats, width: width, focused: sidebarFocused }), _jsx(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, overflow: "hidden", children: content })] })), mode === "wide" && (_jsxs(Box, { flexDirection: "row", flexGrow: 1, minHeight: 0, alignItems: "stretch", children: [_jsx(Sidebar, { items: sidebarItems, activeId: activeId, stats: sidebarStats, width: SIDEBAR_WIDTH, focused: sidebarFocused }), _jsx(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, overflow: "hidden", children: content })] })), footerNote !== undefined ? _jsx(Text, { color: theme.warn, children: footerNote }) : _jsx(KeyHints, { hints: keyHints })] }));
 }

package/dist/ui/reassign-panel.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from "ink";
+import { pickerHeading, pickerRows, pickerTitle } from "../domain/reassign-picker.js";
+import { Panel } from "./components/panel.js";
+import { Table } from "./components/table.js";
+import { useTheme } from "./theme.js";
+/** Rows the panel's own chrome takes (top border line + bottom border) plus the two heading lines and the table's header line. */
+const PICKER_FIXED_ROWS = 2 + 2 + 1;
+/** Columns the panel border (2) and the table's `› ` marker (2) take from the panel width. */
+const PICKER_FIXED_COLUMNS = 4;
+const COLUMN_HEADERS = {
+    client: "client",
+    project: "project",
+    task: "task",
+    review: "change",
+    applying: "sending",
+    result: "result",
+};
+/** How many list lines fit a picker panel of `height` rows (at least one, so a tiny terminal still tracks the selection). */
+export function pickerMaxRows(height) {
+    return Math.max(height - PICKER_FIXED_ROWS, 1);
+}
+/**
+ * The reassignment picker, drawn as one fixed-size `Panel` over the Tasks
+ * screen's content zone: two heading lines, then the current step's list
+ * in a windowed `Table` (the same scrolling and `↑ N more`/`↓ N more`
+ * indicators as every other list). The panel's `height` is fixed by the
+ * caller, so a long list scrolls inside it and never grows the frame.
+ */
+export function ReassignPanel({ state, width, height }) {
+    const theme = useTheme();
+    const [headline, detail] = pickerHeading(state);
+    const rows = pickerRows(state).map((entry, index) => ({ ...entry, key: String(index) }));
+    const textWidth = Math.max(width - PICKER_FIXED_COLUMNS, 1);
+    return (_jsxs(Panel, { title: pickerTitle(state), width: width, height: height, active: true, children: [_jsx(Text, { wrap: "truncate-end", children: headline }), _jsx(Text, { color: theme.muted, wrap: "truncate-end", children: detail === "" ? " " : detail }), _jsx(Table, { columns: [{ key: "text", header: COLUMN_HEADERS[state.step], width: textWidth }], rows: rows, rowKey: (row) => row.key, cell: (row) => row.text, rowColor: (row) => (row.tone === "error" ? theme.error : row.tone === "muted" ? theme.muted : undefined), selectedIndex: state.index, emptyText: "nothing to choose from", maxRows: pickerMaxRows(height) }, state.step)] }));
+}

package/dist/ui/tasks-screen.js

@@ -1,9 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useMemo, useRef, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import { Box, Text, useInput } from "ink";
 import { formatMinutes } from "../domain/today-model.js";
 import { SCREENS, hintsFor } from "../domain/nav-model.js";
 import { wrapText } from "../domain/text-wrap.js";
+import { NOT_ON_HUB, describeAssignment, eligibleForBulk } from "../domain/reassign-model.js";
+import { advance, back, finishApplying, jumpSelection, moveSelection, openPicker, pickerHints, pickerRowCount } from "../domain/reassign-picker.js";
+import { ReassignPanel, pickerMaxRows } from "./reassign-panel.js";
 import { Layout } from "./layout.js";
 import { Panel } from "./components/panel.js";
 import { Table } from "./components/table.js";
@@ -63,7 +66,7 @@ const DETAIL_CHROME_ROWS = 2;
  * `muted` `… N more lines` line instead of letting Ink's own overflow
  * clipping silently swallow the rest with no visible cue.
  */
-function DetailPanel({ row, width, height }) {
+function DetailPanel({ row, hub, width, height }) {
     const theme = useTheme();
     if (row === undefined) {
         return (_jsx(Panel, { title: "Task", width: width, height: height, children: _jsx(Text, { dimColor: true, children: "no task selected" }) }));
@@ -77,6 +80,8 @@ function DetailPanel({ row, width, height }) {
         metaLines.push({ text: `project  ${row.projectName}`, dim: true });
     if (row.hubTaskTitle !== undefined)
         metaLines.push({ text: `task     ${row.hubTaskTitle}`, dim: true });
+    if (hub !== undefined)
+        metaLines.push({ text: `hub      ${hub}`, dim: true });
     metaLines.push({ text: `wall ${formatMinutes(row.wallMs)}   work ${formatMinutes(row.workMs)}   wait ${formatMinutes(row.waitingMs)}`, dim: false });
     metaLines.push({ text: `cost ${formatCost(row.cost)}${row.cacheHit !== undefined ? `   cache hit ${Math.round(row.cacheHit * 100)}%` : ""}`, dim: false });
     metaLines.push({ text: `subagents ${row.subagentCount}`, dim: false });
@@ -86,38 +91,186 @@ function DetailPanel({ row, width, height }) {
     const visiblePromptLines = truncated ? wrappedPrompt.slice(0, Math.max(promptBudget - 1, 0)) : wrappedPrompt.slice(0, promptBudget);
     const hiddenCount = wrappedPrompt.length - visiblePromptLines.length;
     const showIndicator = truncated && promptBudget > 0;
-    return (_jsx(Panel, { title: "Task", width: width, height: height, children: _jsxs(Box, { flexDirection: "column", children: [visiblePromptLines.map((line, index) => (_jsx(Text, { children: line }, `prompt-${index}`))), showIndicator && _jsx(Text, { color: theme.muted, children: `… ${hiddenCount} more lines` }), metaLines.map((line, index) => (_jsx(Text, { dimColor: line.dim, children: line.text }, `meta-${index}`)))] }) }));
+    return (_jsx(Panel, { title: "Task", width: width, height: height, children: _jsxs(Box, { flexDirection: "column", children: [visiblePromptLines.map((line, index) => (_jsx(Text, { children: line }, `prompt-${index}`))), showIndicator && _jsx(Text, { color: theme.muted, children: `… ${hiddenCount} more lines` }), metaLines.map((line, index) => (_jsx(Text, { dimColor: line.dim, wrap: "truncate-end", children: line.text }, `meta-${index}`)))] }) }));
 }
 const KEY_HINTS = [
     { key: "↑↓", label: "select" },
     { key: "a", label: "today/all" },
+    { key: "m", label: "move" },
+    { key: "M", label: "move all" },
     { key: "r", label: "refresh" },
-    { key: "esc", label: "clear filter" },
     { key: "1-4", label: "screens" },
     { key: "q", label: "quit" },
 ];
+/** With a project filter set, `esc` clears it; listed only then, so the footer stays on one line in narrower terminals. */
+const FILTERED_KEY_HINTS = [...KEY_HINTS.slice(0, 5), { key: "esc", label: "clear filter" }, ...KEY_HINTS.slice(5)];
 /** Below this main-content width, the detail panel stacks under the table instead of beside it. */
 const DETAIL_BREAKPOINT = 70;
 /** Rows the `Panel` chrome (top border line + bottom border line) and the `Table`'s own header line take, outside its data rows. */
 const TABLE_CHROME_ROWS = 3;
+/** Footer messages of the reassignment flow. */
+const ASKING_HUB = "asking the hub…";
+const REASSIGN_UNAVAILABLE = "reassignment is not available: no hub connection in this session";
+const NOTHING_UNASSIGNED = "no unassigned tasks on the hub in this view";
+function toTarget(row) {
+    return { taskId: row.id, label: row.prompt };
+}
 /**
  * The Tasks screen: a table of tasks (via `domain/tasks-model.ts`, never
  * reimplemented here) with a `[ Task ]` detail panel for the selected row.
  * `a` toggles today/all, `r` reloads, `↑↓` move the selection. When
  * `projectFilter` is set (via Today's `enter`), the table is restricted to
- * that project and `esc` clears it through `onClearFilter`. Never writes
- * anything to disk.
+ * that project and `esc` clears it through `onClearFilter`.
+ *
+ * `m` moves (reassigns) the selected task on the hub and `M` every task of the
+ * current view that is unassigned there: the screen asks the hub for the
+ * rows involved (`reassign.prepare`, a progress message in the footer
+ * meanwhile), then opens the picker (`domain/reassign-picker.ts`) as a
+ * panel over the content zone. The picker is a modal flow: while it is
+ * open (or the hub is being asked) every other key of the screen is inert.
+ * Nothing is written to disk; the hub is written only by `reassign.apply`,
+ * after the review step.
  */
-export function TasksScreen({ load, roots, version, columns, rows, focused = true, projectFilter, onClearFilter }) {
+export function TasksScreen({ load, roots, version, columns, rows, focused = true, projectFilter, onClearFilter, reassign, onModalChange }) {
     const allRef = useRef(false);
     const [all, setAll] = useState(false);
     const [model, setModel] = useState(() => load({ all: false }));
     const [selected, setSelected] = useState(0);
+    const [picker, setPickerState] = useState(undefined);
+    const pickerRef = useRef(undefined);
+    const [asking, setAsking] = useState(false);
+    const askingRef = useRef(false);
+    const [note, setNote] = useState(undefined);
+    /** The hub's assignment (by names) for the tasks asked about in this session, keyed by kankaku task id. */
+    const [hubAssignments, setHubAssignments] = useState({});
     const visibleRows = useMemo(() => (projectFilter !== undefined ? model.rows.filter((row) => row.project === projectFilter) : model.rows), [model.rows, projectFilter]);
     const maxRowsRef = useRef(0);
+    const pickerRowsRef = useRef(1);
+    const setPicker = (next) => {
+        pickerRef.current = next;
+        setPickerState(next);
+    };
+    const modalOpen = asking || picker !== undefined;
+    useEffect(() => {
+        onModalChange?.(modalOpen);
+    }, [modalOpen]);
+    const rememberHubRows = (found, catalog) => {
+        setHubAssignments((current) => {
+            const next = { ...current };
+            for (const [taskId, hubRow] of found)
+                next[taskId] = describeAssignment(hubRow, catalog);
+            return next;
+        });
+    };
+    const startReassign = (mode) => {
+        if (reassign === undefined) {
+            setNote(REASSIGN_UNAVAILABLE);
+            return;
+        }
+        const chosen = mode === "single" ? [visibleRows[Math.min(selected, Math.max(visibleRows.length - 1, 0))]] : visibleRows;
+        const targets = chosen.filter((row) => row !== undefined).map(toTarget);
+        if (targets.length === 0) {
+            setNote("no tasks to reassign");
+            return;
+        }
+        askingRef.current = true;
+        setAsking(true);
+        setNote(ASKING_HUB);
+        void reassign
+            .prepare(targets.map((target) => target.taskId))
+            .then((prepared) => {
+            if (!prepared.ok) {
+                setNote(prepared.message);
+                return;
+            }
+            rememberHubRows(prepared.rows, prepared.catalog);
+            if (mode === "single" && !prepared.rows.has(targets[0].taskId)) {
+                setNote(NOT_ON_HUB);
+                return;
+            }
+            if (mode === "bulk" && eligibleForBulk(targets, prepared.rows, prepared.catalog).length === 0) {
+                setNote(NOTHING_UNASSIGNED);
+                return;
+            }
+            setNote(undefined);
+            setPicker(openPicker({ mode, catalog: prepared.catalog, targets, rows: prepared.rows }));
+        })
+            .catch((error) => setNote(error instanceof Error ? error.message : String(error)))
+            .finally(() => {
+            askingRef.current = false;
+            setAsking(false);
+        });
+    };
+    const startApply = (state) => {
+        const plan = state.plan;
+        if (reassign === undefined || plan === undefined || !plan.ok)
+            return;
+        const settle = (outcomes) => {
+            const current = pickerRef.current ?? state;
+            setPicker(finishApplying(current, outcomes));
+            setHubAssignments((assignments) => {
+                const next = { ...assignments };
+                for (const line of plan.plan.lines) {
+                    if (line.kind === "reassign" && outcomes.some((outcome) => outcome.taskId === line.taskId && outcome.status === "reassigned"))
+                        next[line.taskId] = line.to;
+                }
+                return next;
+            });
+        };
+        void reassign.apply(plan.plan).then(settle, (error) => {
+            const reason = error instanceof Error ? error.message : String(error);
+            settle(plan.plan.lines.filter((line) => line.kind === "reassign").map((line) => ({ taskId: line.taskId, status: "failed", reason })));
+        });
+    };
+    const handlePickerKey = (current, key) => {
+        if (current.step === "applying")
+            return;
+        const page = Math.max(pickerRowsRef.current, 1);
+        if (key.escape || key.leftArrow) {
+            setPicker(back(current));
+        }
+        else if (key.return) {
+            const next = advance(current);
+            setPicker(next);
+            if (next !== undefined && next.step === "applying" && current.step === "review")
+                startApply(next);
+        }
+        else if (key.downArrow) {
+            setPicker(moveSelection(current, 1));
+        }
+        else if (key.upArrow) {
+            setPicker(moveSelection(current, -1));
+        }
+        else if (key.pageDown) {
+            setPicker(moveSelection(current, page));
+        }
+        else if (key.pageUp) {
+            setPicker(moveSelection(current, -page));
+        }
+        else if (key.home) {
+            setPicker(jumpSelection(current, "first"));
+        }
+        else if (key.end) {
+            setPicker(jumpSelection(current, "last"));
+        }
+    };
     useInput((input, key) => {
+        if (askingRef.current)
+            return;
+        setNote(undefined);
+        const openPickerState = pickerRef.current;
+        if (openPickerState !== undefined) {
+            handlePickerKey(openPickerState, key);
+            return;
+        }
         const lastIndex = Math.max(visibleRows.length - 1, 0);
-        if (input === "a") {
+        if (input === "m") {
+            startReassign("single");
+        }
+        else if (input === "M") {
+            startReassign("bulk");
+        }
+        else if (input === "a") {
             const nextAll = !allRef.current;
             allRef.current = nextAll;
             setAll(nextAll);
@@ -149,7 +302,11 @@ export function TasksScreen({ load, roots, version, columns, rows, focused = tru
             onClearFilter?.();
         }
     }, { isActive: focused });
-    return (_jsx(Layout, { columns: columns, rows: rows, headerLeft: `>_ kankaku ${version}`, headerRight: projectFilter !== undefined ? `filtered: ${projectFilter}` : undefined, sidebarItems: SCREENS, activeId: "tasks", sidebarStats: [`tasks ${visibleRows.length}`, all ? "scope all" : "scope today"], keyHints: hintsFor("tasks", focused ? "main" : "sidebar", KEY_HINTS), focus: focused ? "main" : "sidebar", children: ({ mainWidth, mainHeight }) => {
+    return (_jsx(Layout, { columns: columns, rows: rows, headerLeft: `>_ kankaku ${version}`, headerRight: projectFilter !== undefined ? `filtered: ${projectFilter}` : undefined, sidebarItems: SCREENS, activeId: "tasks", sidebarStats: [`tasks ${visibleRows.length}`, all ? "scope all" : "scope today"], keyHints: picker !== undefined ? pickerHints(picker) : hintsFor("tasks", focused ? "main" : "sidebar", projectFilter !== undefined ? FILTERED_KEY_HINTS : KEY_HINTS), ...(note !== undefined ? { footerNote: note } : {}), focus: focused ? "main" : "sidebar", children: ({ mainWidth, mainHeight }) => {
+            if (picker !== undefined) {
+                pickerRowsRef.current = pickerMaxRows(mainHeight);
+                return _jsx(ReassignPanel, { state: picker, width: mainWidth, height: mainHeight });
+            }
             const wide = mainWidth >= DETAIL_BREAKPOINT;
             const tableWidth = wide ? Math.floor(mainWidth * 0.62) : mainWidth;
             const detailWidth = wide ? Math.max(mainWidth - tableWidth - 1, 1) : mainWidth;
@@ -160,7 +317,7 @@ export function TasksScreen({ load, roots, version, columns, rows, focused = tru
             const maxRows = Math.max(tableHeight - TABLE_CHROME_ROWS, 1);
             maxRowsRef.current = maxRows;
             const table = (_jsx(Panel, { title: "Tasks", width: tableWidth, height: wide ? mainHeight : tableHeight, active: focused, children: _jsx(Table, { columns: taskColumns(tableWidth), rows: visibleRows, rowKey: (row) => row.id, cell: taskCell, selectedIndex: selected, emptyText: "no tasks", maxRows: maxRows }) }));
-            const detail = _jsx(DetailPanel, { row: selectedRow, width: detailWidth, height: detailHeight });
+            const detail = _jsx(DetailPanel, { row: selectedRow, hub: selectedRow !== undefined ? hubAssignments[selectedRow.id] : undefined, width: detailWidth, height: detailHeight });
             return wide ? (_jsxs(Box, { flexDirection: "row", children: [table, _jsx(Box, { width: 1 }), detail] })) : (_jsxs(Box, { flexDirection: "column", children: [table, detail] }));
         } }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kankaku",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Terminal app that shows today's kankaku work across every project on disk",
   "keywords": [
     "pi-package",
@@ -38,8 +38,8 @@
   },
   "dependencies": {
     "ink": "^7.1.1",
-    "kankaku-pi": "^1.1.0",
-    "kankaku-claude": "^1.1.0",
+    "kankaku-pi": "^1.2.0",
+    "kankaku-claude": "^1.2.0",
     "kankaku-hub": "^0.2.0",
     "react": "^19.3.0"
   },

package/vendor/kankaku-pi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kankaku-pi",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "pi extension that records agent work time per prompt, excluding waits for the user, with subagent linkage and task/session views",
   "license": "MIT",
   "author": "soyunninja",