kankaku 1.0.2 → 1.2.0

package/dist/adapters/setup/json-writer.js

@@ -59,10 +59,15 @@ export function backupOnce(filePath) {
     if (sourceIsOwnerOnly)
         tightenBestEffort(backupPath);
 }
-/** Write `value` as 2-space-indented JSON to `filePath` via tmp file + rename, creating the parent directory when missing. */
-export function writeJsonAtomic(filePath, value, dirMode) {
+/**
+ * Write `value` as 2-space-indented JSON to `filePath` via tmp file + rename,
+ * creating the parent directory when missing. With `fileMode` the temp file
+ * is created with that mode from the first byte, so a secret is never
+ * readable through a wider mode, not even for the instant before a chmod.
+ */
+export function writeJsonAtomic(filePath, value, dirMode, fileMode) {
     mkdirSync(dirname(filePath), dirMode !== undefined ? { recursive: true, mode: dirMode } : { recursive: true });
     const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tmp, JSON.stringify(value, null, 2));
+    writeFileSync(tmp, JSON.stringify(value, null, 2), fileMode !== undefined ? { mode: fileMode } : {});
     renameSync(tmp, filePath);
 }

package/dist/cli.js

@@ -11,8 +11,11 @@ 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";
+import { formatVersionLines } from "./domain/version-info.js";
 import { buildCatalogModel } from "./domain/catalog-model.js";
 import { buildTodayRows, formatTodayLines } from "./domain/today-model.js";
 import { buildDashboardModel } from "./domain/dashboard-model.js";
@@ -21,6 +24,7 @@ import { buildTasksModel } from "./domain/tasks-model.js";
 import { buildSyncRows } from "./domain/sync-model.js";
 import { DEFAULT_THEME, ThemeProvider, resolveTheme } from "./ui/theme.js";
 import { detectAgents, formatDoctorLines, formatSetupPlanLines, planSetup } from "./domain/setup-plan.js";
+import { parseHubPort } from "./domain/setup-wizard.js";
 import { readAgentFacts } from "./adapters/setup/agents.js";
 import { addKankakuPackage, removeKankakuPackage } from "./adapters/setup/pi.js";
 import { removeClaudeIntegration, writeClaudeIntegration } from "./adapters/setup/claude.js";
@@ -31,11 +35,13 @@ import { tuiConfigPath, writeTuiConfig } from "./adapters/setup/tui-config.js";
 import { installLocalHub } from "./adapters/setup/local-hub.js";
 import { createChildProcessRunner } from "./adapters/setup/child-process-runner.js";
 import { createReadlinePrompter } from "./adapters/setup/readline-prompter.js";
-import { hubLayout, parseHubConfig } from "./domain/local-hub-model.js";
+import { describeSyncTarget, hubLayout, parseHubConfig } from "./domain/local-hub-model.js";
 import { hubLogs, hubStatus, installHub, startHub, stopHub, upgradeHub } from "./adapters/hub-manager/install.js";
 import { isAlive, readPid, startDetached } from "./adapters/hub-manager/process.js";
 import { locateHubPackage } from "./adapters/hub-manager/package.js";
-const USAGE = "usage: kankaku [today|tasks [--all]|catalog [refresh]|sync [status|all] [--project <dir>]|setup [--yes] [--dry-run] [--from-checkout <dir>] [--claude-plugin-dir <dir>]|doctor|hub install [--port N] [--owner-email E] [--owner-password P]|hub start|hub stop|hub status|hub upgrade|hub logs [-n N]] [--roots a,b] [--theme name]\n";
+import { useLocalHub } from "./adapters/hub-manager/credentials.js";
+import { firstFreePort, isPortFree, realPortBinder } from "./adapters/hub-manager/port-probe.js";
+const USAGE = "usage: kankaku [--version|-v|version|today|tasks [--all]|catalog [refresh]|sync [status|all] [--project <dir>]|setup [--yes] [--dry-run] [--from-checkout <dir>] [--claude-plugin-dir <dir>]|doctor|hub install [--port N] [--owner-email E] [--owner-password P]|hub use|hub start|hub stop|hub status|hub upgrade|hub logs [-n N]] [--roots a,b] [--theme name]\n";
 /** Load today's model for `roots`: discover projects, read their worklogs, build rows. */
 export function loadToday(roots) {
     const projects = discoverProjects(roots);
@@ -267,19 +273,23 @@ async function runDoctorCommand(deps, claudePluginOverride) {
  * with no network call — the hub's health is checked interactively, from
  * the wizard's own Hub step, never upfront.
  */
-function gatherWizardFacts(deps, claudePluginOverride) {
+export function gatherWizardFacts(deps, claudePluginOverride) {
     const agentFacts = readAgentFacts(deps.homeDir, claudePluginOverride);
     const hubResolution = resolveHub({ env: deps.env ?? {}, homeDir: () => deps.homeDir });
     const credPath = credentialsPath(deps.homeDir);
-    const hub = hubResolution.ok
-        ? {
-            credentialsPresent: true,
-            url: hubResolution.credentials.url,
-            email: hubResolution.credentials.email,
-            password: hubResolution.credentials.password,
-            credentialsPath: credPath,
-        }
-        : { credentialsPresent: false, url: undefined, email: undefined, password: undefined, credentialsPath: credPath };
+    const localPort = localHubPort(deps);
+    const hub = {
+        ...(hubResolution.ok
+            ? {
+                credentialsPresent: true,
+                url: hubResolution.credentials.url,
+                email: hubResolution.credentials.email,
+                password: hubResolution.credentials.password,
+                credentialsPath: credPath,
+            }
+            : { credentialsPresent: false, url: undefined, email: undefined, password: undefined, credentialsPath: credPath }),
+        ...(localPort !== undefined ? { localPort } : {}),
+    };
     const tuiPath = tuiConfigPath(deps.homeDir);
     const roots = {
         current: existsSync(tuiPath) ? readTuiConfig(deps.homeDir, deps.cwd).roots : undefined,
@@ -303,6 +313,7 @@ function buildHubManagerDeps(deps) {
         platform: process.platform,
         arch: process.arch,
         isAlive: (pid) => isAlive(pid),
+        portBinder: realPortBinder,
         ...deps.hubManager,
     };
 }
@@ -330,8 +341,10 @@ async function performLocalHubInstallFromCheckout(checkout, deps) {
  * `--claude-plugin-dir`/`KANKAKU_CLAUDE_PLUGIN_DIR` — see
  * `runCli`/`resolveClaudePluginOverride`), never from wizard state.
  * `install-local-hub` runs the real `hub-manager/install.ts#installHub`
- * (which writes `accounts.json` and `~/.kankaku/credentials.json`
- * itself), reporting every install step in the result detail. Never
+ * (which writes `accounts.json` and `service.json`, and
+ * `~/.kankaku/credentials.json` only when none exists or it already
+ * points at the local hub), reporting every install step in the result
+ * detail - the `sync credentials` step with its own explanation. Never
  * throws: any adapter failure becomes an `"error"` outcome instead.
  */
 async function applyWizardAction(action, state, deps, claudePluginOverride) {
@@ -363,8 +376,8 @@ async function applyWizardAction(action, state, deps, claudePluginOverride) {
                 return { action, outcome: result.changed ? "wrote" : "unchanged" };
             }
             case "install-local-hub": {
-                const report = await installHub({ ownerEmail: state.hub.ownerEmail, ownerPassword: state.hub.ownerPassword }, buildHubManagerDeps(deps));
-                const detail = report.steps.map((step) => `${step.step}: ${step.outcome}`).join("; ");
+                const report = await installHub({ port: parseHubPort(state.hub.port), ownerEmail: state.hub.ownerEmail, ownerPassword: state.hub.ownerPassword }, buildHubManagerDeps(deps));
+                const detail = report.steps.map((step) => `${step.step}: ${step.outcome}${step.step === "sync credentials" && step.detail ? ` (${step.detail})` : ""}`).join("; ");
                 if (!report.ok)
                     return { action, outcome: "error", detail };
                 return { action, outcome: "started", detail: `${detail} — running at ${report.url}` };
@@ -401,11 +414,17 @@ function announceCommands(deps, result) {
     for (const file of result.foreign)
         deps.stdout(`skipped ${file} (not a kankaku command)`);
 }
+/** The binder for the wizard's port probe: the real one, unless a test injected another through `CliDeps.hubManager`. */
+function portBinderFor(deps) {
+    return deps.hubManager?.portBinder ?? realPortBinder;
+}
 /** Build the setup wizard's `WizardActions` for the interactive app: every write goes through the same real `adapters/setup/*` writers `kankaku setup --yes` uses. Used only by `renderApp`. */
 export function buildWizardActions(deps, claudePluginOverride) {
     return {
         apply: (action, state) => applyWizardAction(action, state, deps, claudePluginOverride),
         checkHealth: (url) => checkHubHealth(url, { fetch: deps.fetch }),
+        isPortFree: (port) => isPortFree(port, portBinderFor(deps)),
+        suggestPort: (from) => firstFreePort(from, 20, portBinderFor(deps)),
     };
 }
 /** `--claude-plugin-dir <dir>`'s value when given, else `KANKAKU_CLAUDE_PLUGIN_DIR`; `undefined` resolves to the bundled `kankaku-claude` package (see `adapters/setup/claude-plugin.ts#locateClaudePlugin`). */
@@ -444,6 +463,28 @@ function formatHubStatusLine(status, pocketbaseVersion, pbDataBytes) {
     const pbPart = pocketbaseVersion ? ` (PocketBase ${pocketbaseVersion})` : "";
     return `local hub: ${label}${status.version ? ` ${status.version}` : ""}${pbPart} at ${status.url} · pb_data ${formatBytes(pbDataBytes)}`;
 }
+/** The URL this machine's sync resolves to (`resolveHub`: environment first, then `~/.kankaku/credentials.json`), or `undefined` when none is configured. */
+function syncCredentialsUrl(deps) {
+    const hub = resolveHub({ env: deps.env ?? {}, homeDir: () => deps.homeDir });
+    return hub.ok ? hub.credentials.url : undefined;
+}
+/** The installed local hub's port from `hub.json`, or `undefined` when it is not installed (or `hub.json` is unreadable). */
+function localHubPort(deps) {
+    const layout = hubLayout(deps.homeDir);
+    if (!existsSync(layout.hubJson))
+        return undefined;
+    try {
+        return parseHubConfig(JSON.parse(readFileSync(layout.hubJson, "utf8"))).port;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The installed local hub's URL, or `undefined` when it is not installed. */
+function localHubUrl(deps) {
+    const port = localHubPort(deps);
+    return port === undefined ? undefined : `http://127.0.0.1:${port}`;
+}
 /** `-n <count>`'s value, defaulting to 50 when absent or not a positive integer. */
 function logCountFlag(args) {
     const index = args.indexOf("-n");
@@ -454,12 +495,13 @@ function flagValue(args, flag) {
     const index = args.indexOf(flag);
     return index === -1 ? undefined : args[index + 1];
 }
+/** `--port`'s value: `undefined` when the flag is absent, `NaN` when it is present but not a whole number between 1 and 65535. */
 function portFlag(args) {
     const raw = flagValue(args, "--port");
     if (raw === undefined)
-        return undefined;
+        return args.includes("--port") ? Number.NaN : undefined;
     const value = Number(raw);
-    return Number.isInteger(value) && value > 0 ? value : undefined;
+    return Number.isInteger(value) && value >= 1 && value <= 65535 ? value : Number.NaN;
 }
 /** Print every `HubActionReport` step, one per line (`<step>: <outcome> (<detail>)`), and the resulting URL when present. */
 function printHubReport(deps, report) {
@@ -482,6 +524,12 @@ async function runHubCommand(args, deps) {
     const [sub, ...rest] = args;
     const hubDeps = buildHubManagerDeps(deps);
     if (sub === "install") {
+        const port = portFlag(rest);
+        if (Number.isNaN(port)) {
+            deps.stderr("kankaku hub install: --port must be a whole number between 1 and 65535\n");
+            deps.exit(1);
+            return;
+        }
         let ownerEmail = flagValue(rest, "--owner-email");
         let ownerPassword = flagValue(rest, "--owner-password");
         if ((ownerEmail === undefined || ownerPassword === undefined) && (deps.isTTY?.() ?? false) && deps.prompter) {
@@ -493,7 +541,7 @@ async function runHubCommand(args, deps) {
             deps.exit(1);
             return;
         }
-        const report = await installHub({ port: portFlag(rest), ownerEmail, ownerPassword }, hubDeps);
+        const report = await installHub({ port, ownerEmail, ownerPassword }, hubDeps);
         printHubReport(deps, report);
         if (!report.ok)
             deps.exit(1);
@@ -524,6 +572,19 @@ async function runHubCommand(args, deps) {
             }
         }
         deps.stdout(formatHubStatusLine(status, pocketbaseVersion, dirSizeBytes(layout.pbData)));
+        deps.stdout(`sync: ${describeSyncTarget(syncCredentialsUrl(deps), localHubUrl(deps))}`);
+        return;
+    }
+    if (sub === "use") {
+        const result = useLocalHub(deps.homeDir);
+        if (!result.ok) {
+            deps.stderr(`kankaku hub use: ${result.error}\n`);
+            deps.exit(1);
+            return;
+        }
+        deps.stdout(result.changed
+            ? `sync now points at ${result.url} (was ${result.previousUrl ?? "not configured"})`
+            : `sync credentials: unchanged (already points at ${result.url})`);
         return;
     }
     if (sub === "upgrade") {
@@ -708,6 +769,10 @@ export async function runCli(argv, deps) {
         deps.renderApp(roots, theme, { startInWizard });
         return;
     }
+    if (command === "--version" || command === "-v" || command === "version") {
+        deps.stdout(formatVersionLines(readOwnVersion(), readCarriedVersions(deps.resolvePackage)).join("\n"));
+        return;
+    }
     if (command === "today") {
         const model = loadToday(roots);
         deps.stdout(formatTodayLines(model.rows, model.total).join("\n"));
@@ -759,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 });
@@ -892,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/local-hub-model.js

@@ -101,6 +101,7 @@ export function hubLayout(homeDir) {
         currentFile: joinPath(root, "current"),
         hubJson: joinPath(root, "hub.json"),
         accountsJson: joinPath(root, "accounts.json"),
+        serviceJson: joinPath(root, "service.json"),
         pidFile: joinPath(root, "pid"),
         logFile: joinPath(root, "hub.log"),
     };
@@ -177,3 +178,42 @@ export function generatePassword(randomBytes, length = 24) {
     }
     return password;
 }
+/** Narrows `json` to a `ServiceAccount` (three non-empty strings), or `undefined` when it is anything else. */
+export function parseServiceAccount(json) {
+    if (!json || typeof json !== "object" || Array.isArray(json))
+        return undefined;
+    const record = json;
+    const { url, email, password } = record;
+    if (typeof url !== "string" || url === "" || typeof email !== "string" || email === "" || typeof password !== "string" || password === "")
+        return undefined;
+    return { url, email, password };
+}
+function hostAndPort(url) {
+    try {
+        const parsed = new URL(url);
+        const host = parsed.hostname === "localhost" ? "127.0.0.1" : parsed.hostname;
+        return `${parsed.protocol}//${host}:${parsed.port}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether two hub URLs name the same scheme, host and port (`localhost` and `127.0.0.1` are the same host; a trailing slash or path is ignored). An unparsable URL never matches. */
+export function sameHubUrl(a, b) {
+    const left = hostAndPort(a);
+    return left !== undefined && left === hostAndPort(b);
+}
+/** Install may write `~/.kankaku/credentials.json` only when none exists, or when it already points at this local hub. */
+export function shouldWriteCredentials(existingUrl, localUrl) {
+    return existingUrl === undefined || sameHubUrl(existingUrl, localUrl);
+}
+/** The `sync credentials` step's detail when install leaves `credentials.json` alone. */
+export function credentialsKeptDetail(existingUrl) {
+    return `this machine syncs to ${existingUrl}; run 'kankaku hub use' to switch to the local hub`;
+}
+/** Where this machine's sync points, for `kankaku hub status`: `local hub`, the other hub's URL, or `not configured`. */
+export function describeSyncTarget(credentialsUrl, localUrl) {
+    if (credentialsUrl === undefined)
+        return "not configured";
+    return localUrl !== undefined && sameHubUrl(credentialsUrl, localUrl) ? "local hub" : credentialsUrl;
+}

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 } };
+}