kankaku 1.0.2 → 1.2.0

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/domain/setup-wizard.js

@@ -5,8 +5,9 @@
  * callers (`src/ui/setup/*`, `src/cli.tsx`) read the real files and pass
  * plain facts in via `WizardFacts`, exactly like `domain/setup-plan.ts`.
  */
+import { shouldWriteCredentials } from "./local-hub-model.js";
 import { detectAgents } from "./setup-plan.js";
-/** The local hub's fixed port for the wizard's `install locally` review line and `install-local-hub` action — mirrors `hub-manager/install.ts#DEFAULT_HUB_PORT`. */
+/** The local hub's default port, where the wizard's port field starts looking for a free one - mirrors `hub-manager/install.ts#DEFAULT_HUB_PORT`. */
 export const DEFAULT_HUB_PORT = 8090;
 /**
  * Shorten `path` for display by replacing a leading `homeDir` with `~`.
@@ -31,7 +32,7 @@ function clearError(errors, key) {
     delete rest[key];
     return rest;
 }
-const HUB_ERROR_KEYS = ["url", "email", "password", "ownerEmail", "ownerPassword"];
+const HUB_ERROR_KEYS = ["url", "email", "password", "ownerEmail", "ownerPassword", "port"];
 function clearHubErrors(errors) {
     return HUB_ERROR_KEYS.reduce((acc, key) => clearError(acc, key), errors);
 }
@@ -50,6 +51,7 @@ export function createWizardState(facts) {
             password: facts.hub.password ?? "",
             ownerEmail: "",
             ownerPassword: "",
+            port: String(facts.hub.localPort ?? DEFAULT_HUB_PORT),
         },
         roots: facts.roots.current ?? facts.roots.defaultRoots,
         errors: {},
@@ -68,6 +70,17 @@ export function setHubMode(state, mode) {
 export function setHubField(state, field, value) {
     return { ...state, hub: { ...state.hub, [field]: value }, errors: clearError(state.errors, field) };
 }
+/** The local hub port as a number when `text` is digits only within 1024-65535, otherwise `undefined`. */
+export function parseHubPort(text) {
+    if (!/^\d+$/.test(text))
+        return undefined;
+    const port = Number(text);
+    return port >= 1024 && port <= 65535 ? port : undefined;
+}
+/** Flags `port` as occupied (`port N is in use`), found by the probe the Hub step runs before advancing; editing the port field clears it. */
+export function setHubPortInUse(state, port) {
+    return { ...state, errors: { ...state.errors, port: `port ${port} is in use` } };
+}
 export function setHubHealth(state, ok) {
     return { ...state, hub: { ...state.hub, healthOk: ok } };
 }
@@ -96,6 +109,8 @@ function validateHub(hub) {
             errors.ownerEmail = "enter a valid email";
         if (hub.ownerPassword.trim() === "")
             errors.ownerPassword = "enter a password";
+        if (parseHubPort(hub.port) === undefined)
+            errors.port = "enter a port between 1024 and 65535";
         return errors;
     }
     return {};
@@ -140,8 +155,12 @@ export function planFromWizard(state, facts) {
         }
     }
     else if (state.hub.mode === "local") {
-        const url = `http://127.0.0.1:${DEFAULT_HUB_PORT}`;
-        actions.push({ kind: "install-local-hub", file: url, label: `install a local hub at ${url}` });
+        const url = `http://127.0.0.1:${parseHubPort(state.hub.port) ?? DEFAULT_HUB_PORT}`;
+        const existingUrl = facts.hub.credentialsPresent ? facts.hub.url : undefined;
+        const note = shouldWriteCredentials(existingUrl, url)
+            ? "sync credentials → the local hub"
+            : `sync credentials stay on ${existingUrl} (switch later with kankaku hub use)`;
+        actions.push({ kind: "install-local-hub", file: url, label: `install a local hub at ${url}`, note });
     }
     const sameRoots = facts.roots.current !== undefined && arraysEqual(facts.roots.current, state.roots);
     if (!sameRoots) {

package/dist/domain/version-info.js

@@ -0,0 +1,5 @@
+/** Pure text for `kankaku --version`. No I/O: `adapters/package-versions.ts` reads the versions. */
+/** `kankaku <version>`, then one indented line per carried package: its version, or `not found`. */
+export function formatVersionLines(ownVersion, carried) {
+    return [`kankaku ${ownVersion}`, ...carried.map(({ name, version }) => `  ${name} ${version ?? "not found"}`)];
+}

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/setup/wizard-screen.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from "react";
 import { Box, Text, useInput, useStdout } from "ink";
-import { DEFAULT_HUB_PORT, applyResult, back, createWizardState, hintsForStep, next, planFromWizard, setHubField, setHubHealth, setHubMode, setRoots, shortenHome, toggleAgent, } from "../../domain/setup-wizard.js";
+import { DEFAULT_HUB_PORT, applyResult, back, createWizardState, hintsForStep, next, parseHubPort, planFromWizard, setHubField, setHubHealth, setHubMode, setHubPortInUse, setRoots, shortenHome, toggleAgent, } from "../../domain/setup-wizard.js";
 import { HeaderBar } from "../components/header-bar.js";
 import { KeyHints } from "../components/key-hints.js";
 import { Panel } from "../components/panel.js";
@@ -111,11 +111,27 @@ export function SetupWizard({ facts, actions, onDone, onQuit, version, columns,
     const [healthChecking, setHealthChecking] = useState(false);
     const [rootsText, setRootsText] = useState(() => state.roots.join(", "));
     const applyStartedRef = useRef(false);
+    const portTouchedRef = useRef(false);
     useEffect(() => {
         if (state.step === "hub")
             setHubFocus(0);
     }, [state.step]);
-    const hubFieldCount = state.hub.mode === "existing" ? 4 : state.hub.mode === "local" ? 3 : 1;
+    // Prefill the local hub's port with the first free one from the default upwards, unless an install already recorded its own or the user got there first.
+    useEffect(() => {
+        if (facts.hub.localPort !== undefined)
+            return;
+        let cancelled = false;
+        void actions.suggestPort(DEFAULT_HUB_PORT).then((port) => {
+            if (cancelled || port === undefined || portTouchedRef.current)
+                return;
+            setState((s) => setHubField(s, "port", String(port)));
+        });
+        return () => {
+            cancelled = true;
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const hubFieldCount = state.hub.mode === "existing" ? 4 : state.hub.mode === "local" ? 4 : 1;
     const textInputFocused = state.step === "roots" || (state.step === "hub" && hubFocus >= 1 && hubFocus < hubFieldCount);
     useEffect(() => {
         if (state.step !== "apply" || applyStartedRef.current)
@@ -140,6 +156,14 @@ export function SetupWizard({ facts, actions, onDone, onQuit, version, columns,
                 onDone();
                 return;
             }
+            if (state.step === "hub" && state.hub.mode === "local") {
+                // A valid port is probed before advancing; an existing install's own port is ours and is never probed.
+                const port = parseHubPort(state.hub.port);
+                if (port !== undefined && port !== facts.hub.localPort) {
+                    void actions.isPortFree(port).then((free) => setState((s) => (free ? next(s, facts) : setHubPortInUse(s, port))));
+                    return;
+                }
+            }
             setState((s) => next(s, facts));
             return;
         }
@@ -172,8 +196,11 @@ export function SetupWizard({ facts, actions, onDone, onQuit, version, columns,
     const height = rows ?? stdout?.rows ?? DEFAULT_ROWS;
     const mainWidth = width;
     const mainHeight = Math.max(height - HEADER_ROWS - FOOTER_ROWS, 0);
-    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [_jsx(HeaderBar, { left: `>_ kankaku setup${version ? ` ${version}` : ""}`, width: width }), _jsx(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, children: _jsxs(Panel, { title: panelTitle(state), width: mainWidth, height: mainHeight, active: true, children: [state.step === "agents" && (_jsx(Checklist, { items: agentChecklistItems(state.agents, state.selected, facts.homeDir), cursor: agentCursor, onToggle: (id) => setState((s) => toggleAgent(s, id)), onMove: (delta) => setAgentCursor((c) => Math.min(Math.max(c + delta, 0), state.agents.length - 1)), focused: true })), state.step === "hub" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Radio, { options: HUB_MODE_OPTIONS, value: state.hub.mode, onChange: (mode) => setState((s) => setHubMode(s, mode)), focused: hubFocus === 0 }), state.hub.mode === "existing" && (_jsxs(Box, { flexDirection: "column", children: [["url", "email", "password"].map((field, index) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: `${field}: ` }), _jsx(TextInput, { value: state.hub[field], onChange: (value) => setState((s) => setHubField(s, field, value)), masked: field === "password", focused: hubFocus === index + 1 })] }, field))), state.errors.url && _jsx(Text, { color: theme.error, children: state.errors.url }), state.errors.email && _jsx(Text, { color: theme.error, children: state.errors.email }), state.errors.password && _jsx(Text, { color: theme.error, children: state.errors.password }), _jsx(Text, { children: `[ check ] c   ${healthLine(state.hub.healthOk, healthChecking)}` })] })), state.hub.mode === "local" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: `will install and run at http://127.0.0.1:${DEFAULT_HUB_PORT}` }), _jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: "owner email: " }), _jsx(TextInput, { value: state.hub.ownerEmail, onChange: (value) => setState((s) => setHubField(s, "ownerEmail", value)), focused: hubFocus === 1 })] }), _jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: "owner password: " }), _jsx(TextInput, { value: state.hub.ownerPassword, onChange: (value) => setState((s) => setHubField(s, "ownerPassword", value)), masked: true, focused: hubFocus === 2 })] }), state.errors.ownerEmail && _jsx(Text, { color: theme.error, children: state.errors.ownerEmail }), state.errors.ownerPassword && _jsx(Text, { color: theme.error, children: state.errors.ownerPassword })] }))] })), state.step === "roots" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "project roots (comma-separated):" }), _jsx(TextInput, { value: rootsText, onChange: (value) => {
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [_jsx(HeaderBar, { left: `>_ kankaku setup${version ? ` ${version}` : ""}`, width: width }), _jsx(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, children: _jsxs(Panel, { title: panelTitle(state), width: mainWidth, height: mainHeight, active: true, children: [state.step === "agents" && (_jsx(Checklist, { items: agentChecklistItems(state.agents, state.selected, facts.homeDir), cursor: agentCursor, onToggle: (id) => setState((s) => toggleAgent(s, id)), onMove: (delta) => setAgentCursor((c) => Math.min(Math.max(c + delta, 0), state.agents.length - 1)), focused: true })), state.step === "hub" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Radio, { options: HUB_MODE_OPTIONS, value: state.hub.mode, onChange: (mode) => setState((s) => setHubMode(s, mode)), focused: hubFocus === 0 }), state.hub.mode === "existing" && (_jsxs(Box, { flexDirection: "column", children: [["url", "email", "password"].map((field, index) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: `${field}: ` }), _jsx(TextInput, { value: state.hub[field], onChange: (value) => setState((s) => setHubField(s, field, value)), masked: field === "password", focused: hubFocus === index + 1 })] }, field))), state.errors.url && _jsx(Text, { color: theme.error, children: state.errors.url }), state.errors.email && _jsx(Text, { color: theme.error, children: state.errors.email }), state.errors.password && _jsx(Text, { color: theme.error, children: state.errors.password }), _jsx(Text, { children: `[ check ] c   ${healthLine(state.hub.healthOk, healthChecking)}` })] })), state.hub.mode === "local" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: `will install and run at http://127.0.0.1:${parseHubPort(state.hub.port) ?? DEFAULT_HUB_PORT}` }), _jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: "owner email: " }), _jsx(TextInput, { value: state.hub.ownerEmail, onChange: (value) => setState((s) => setHubField(s, "ownerEmail", value)), focused: hubFocus === 1 })] }), _jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: "owner password: " }), _jsx(TextInput, { value: state.hub.ownerPassword, onChange: (value) => setState((s) => setHubField(s, "ownerPassword", value)), masked: true, focused: hubFocus === 2 })] }), _jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: "port: " }), _jsx(TextInput, { value: state.hub.port, onChange: (value) => {
+                                                        portTouchedRef.current = true;
+                                                        setState((s) => setHubField(s, "port", value.replace(/\D/g, "")));
+                                                    }, focused: hubFocus === 3 })] }), state.errors.ownerEmail && _jsx(Text, { color: theme.error, children: state.errors.ownerEmail }), state.errors.ownerPassword && _jsx(Text, { color: theme.error, children: state.errors.ownerPassword }), state.errors.port && _jsx(Text, { color: theme.error, children: state.errors.port })] }))] })), state.step === "roots" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "project roots (comma-separated):" }), _jsx(TextInput, { value: rootsText, onChange: (value) => {
                                         setRootsText(value);
                                         setState((s) => setRoots(s, value));
-                                    }, focused: true }), state.errors.roots && _jsx(Text, { color: theme.error, children: state.errors.roots })] })), state.step === "review" && (_jsx(Table, { columns: reviewColumns(mainWidth), rows: state.plan, rowKey: (row) => `${row.kind}-${row.file}`, cell: reviewCell, emptyText: "nothing to change" })), state.step === "apply" && (_jsxs(Box, { flexDirection: "column", children: [state.results.map((result, index) => (_jsx(Text, { children: applyResultLine(result) }, `${result.action.kind}-${index}`))), state.results.length < state.plan.length && _jsx(Text, { dimColor: true, children: "applying\u2026" })] })), state.step === "done" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: `setup complete: ${state.results.length} change(s) applied` }), _jsx(Text, { dimColor: true, children: "enter open dashboard" })] }))] }) }), _jsx(KeyHints, { hints: hints })] }));
+                                    }, focused: true }), state.errors.roots && _jsx(Text, { color: theme.error, children: state.errors.roots })] })), state.step === "review" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Table, { columns: reviewColumns(mainWidth), rows: state.plan, rowKey: (row) => `${row.kind}-${row.file}`, cell: reviewCell, emptyText: "nothing to change" }), state.plan.map((action) => action.note !== undefined && _jsx(Text, { children: action.note }, `note-${action.kind}-${action.file}`))] })), state.step === "apply" && (_jsxs(Box, { flexDirection: "column", children: [state.results.map((result, index) => (_jsx(Text, { children: applyResultLine(result) }, `${result.action.kind}-${index}`))), state.results.length < state.plan.length && _jsx(Text, { dimColor: true, children: "applying\u2026" })] })), state.step === "done" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: `setup complete: ${state.results.length} change(s) applied` }), _jsx(Text, { dimColor: true, children: "enter open dashboard" })] }))] }) }), _jsx(KeyHints, { hints: hints })] }));
 }