@todu/pi-extensions 0.1.0

package/dist/extension/register-commands.js

@@ -0,0 +1,1214 @@
+import path from "node:path";
+import { BorderedLoader, DynamicBorder } from "@mariozechner/pi-coding-agent";
+import { Container, SelectList, Text } from "@mariozechner/pi-tui";
+import { browseTasks } from "../flows/browse-tasks.js";
+import { commentOnTask } from "../flows/comment-on-task.js";
+import { createTask } from "../flows/create-task.js";
+import { showTaskDetail } from "../flows/show-task-detail.js";
+import { updateTask } from "../flows/update-task.js";
+import { getDefaultToduTaskServiceRuntime } from "../services/todu/default-task-service.js";
+import { createTaskBrowseFilterState } from "../services/task-browse-filter-store.js";
+import { createRepoContextService } from "../services/repo-context.js";
+import { createTaskDetailActionItems, createTaskDetailViewModel, formatTaskPriorityLabel, formatTaskStatusLabel, } from "../ui/components/task-detail.js";
+import { createTaskListItem } from "../ui/components/task-list.js";
+import { formatHabitTable } from "../ui/components/habit-table.js";
+import { createTaskLoaderViewModel } from "../ui/components/loaders.js";
+import { taskPriorityOptions, taskStatusOptions, } from "../ui/components/task-settings.js";
+import { getDefaultCurrentTaskContextController } from "./current-task-context.js";
+import { getDefaultTaskBrowseFilterContextController, } from "./task-browse-filter-context.js";
+const DEFAULT_TASK_BROWSE_FILTER_STATE = createTaskBrowseFilterState();
+const createTasksCommandHandler = (dependencies = {}) => {
+    const getTaskService = dependencies.getTaskService ?? (() => getDefaultToduTaskServiceRuntime().ensureConnected());
+    const getTaskBrowseFilterController = () => dependencies.taskBrowseFilterController ?? getDefaultTaskBrowseFilterContextController();
+    const editTaskBrowseFilters = dependencies.editTaskBrowseFilters ?? showTaskBrowseFilterMode;
+    const resolveDefaultProject = dependencies.resolveDefaultProject ?? resolveDefaultProjectFromRepo;
+    const loadTasks = dependencies.loadTasks ?? loadTasksWithLoader;
+    const showTaskBrowseView = dependencies.showTaskBrowseView ?? selectTaskBrowseViewAction;
+    const showEmptyState = dependencies.showEmptyState ?? showEmptyTasksState;
+    const setCurrentTask = dependencies.setCurrentTask ??
+        ((ctx, task) => getDefaultCurrentTaskContextController().setCurrentTask(ctx, task));
+    const openTaskDetail = dependencies.openTaskDetail ??
+        ((ctx, taskService, taskId) => openSelectedTaskDetail(ctx, taskService, taskId, {
+            setCurrentTask,
+            showTaskDetailView: dependencies.showTaskDetailView,
+            selectTaskStatus: dependencies.selectTaskStatus,
+            selectTaskPriority: dependencies.selectTaskPriority,
+            editTaskComment: dependencies.editTaskComment,
+        }));
+    return async (_args, ctx) => {
+        if (!ctx.hasUI) {
+            process.stderr.write("/tasks requires interactive mode\n");
+            return;
+        }
+        try {
+            const taskBrowseFilterController = getTaskBrowseFilterController();
+            await taskBrowseFilterController.restoreFromBranch(ctx);
+            const taskService = await getTaskService();
+            let mode;
+            if (taskBrowseFilterController.getState().hasSavedFilter) {
+                mode = "view";
+            }
+            else {
+                const defaultState = await resolveDefaultTaskBrowseFilterState(taskService, resolveDefaultProject);
+                await taskBrowseFilterController.setState(ctx, defaultState);
+                mode = "view";
+            }
+            while (true) {
+                if (mode === "filter") {
+                    const filterEditResult = await editTaskBrowseFilters(ctx, taskService, taskBrowseFilterController.getState());
+                    if (filterEditResult.status === "cancelled") {
+                        ctx.ui.notify("Task browse cancelled", "info");
+                        return;
+                    }
+                    await taskBrowseFilterController.setState(ctx, filterEditResult.filterState);
+                    mode = "view";
+                    continue;
+                }
+                const filterState = taskBrowseFilterController.getState();
+                const taskFilter = createTaskFilterFromBrowseState(filterState);
+                const filterSummary = formatTaskBrowseFilterSummary(filterState);
+                const loadedTasks = await loadTasks(ctx, taskService, taskFilter, filterSummary);
+                if (loadedTasks.status === "cancelled") {
+                    ctx.ui.notify("Task browse cancelled", "info");
+                    return;
+                }
+                if (loadedTasks.status === "error") {
+                    ctx.ui.notify(loadedTasks.message, "error");
+                    return;
+                }
+                if (loadedTasks.tasks.length === 0) {
+                    const emptyAction = await showEmptyState(ctx, filterState);
+                    if (emptyAction === "change-filters") {
+                        mode = "filter";
+                        continue;
+                    }
+                    if (emptyAction === "clear-filters") {
+                        await taskBrowseFilterController.setState(ctx, createSavedTaskBrowseFilterState());
+                        continue;
+                    }
+                    return;
+                }
+                const browseViewResult = await showTaskBrowseView(ctx, loadedTasks.tasks, filterState);
+                if (browseViewResult.status === "closed") {
+                    ctx.ui.notify("Task browse cancelled", "info");
+                    return;
+                }
+                if (browseViewResult.status === "change-filters") {
+                    mode = "filter";
+                    continue;
+                }
+                if (browseViewResult.status === "clear-filters") {
+                    await taskBrowseFilterController.setState(ctx, createSavedTaskBrowseFilterState());
+                    continue;
+                }
+                await openTaskDetail(ctx, taskService, browseViewResult.taskId);
+                return;
+            }
+        }
+        catch (error) {
+            ctx.ui.notify(formatTasksCommandError(error, "Failed to browse tasks"), "error");
+        }
+    };
+};
+const createTaskCommandHandler = (dependencies = {}) => {
+    const getTaskService = dependencies.getTaskService ?? (() => getDefaultToduTaskServiceRuntime().ensureConnected());
+    const getCurrentTaskId = dependencies.getCurrentTaskId ??
+        (() => getDefaultCurrentTaskContextController().getState().currentTaskId);
+    const setCurrentTask = dependencies.setCurrentTask ??
+        ((ctx, task) => getDefaultCurrentTaskContextController().setCurrentTask(ctx, task));
+    const openTaskDetail = dependencies.openTaskDetail ??
+        ((ctx, taskService, taskId) => openTaskDetailHub(ctx, taskService, taskId, {
+            setCurrentTask,
+            showTaskDetailView: dependencies.showTaskDetailView,
+            selectTaskStatus: dependencies.selectTaskStatus,
+            selectTaskPriority: dependencies.selectTaskPriority,
+            editTaskComment: dependencies.editTaskComment,
+        }));
+    return async (args, ctx) => {
+        if (!ctx.hasUI) {
+            process.stderr.write("/task requires interactive mode\n");
+            return;
+        }
+        const requestedTaskId = resolveRequestedTaskId(args, getCurrentTaskId());
+        if (!requestedTaskId) {
+            ctx.ui.notify("No task selected. Run /tasks or pass a task ID.", "warning");
+            return;
+        }
+        try {
+            const taskService = await getTaskService();
+            await openTaskDetail(ctx, taskService, requestedTaskId);
+        }
+        catch (error) {
+            ctx.ui.notify(formatTasksCommandError(error, "Failed to open task detail"), "error");
+        }
+    };
+};
+const createTaskClearCommandHandler = (dependencies = {}) => {
+    const getCurrentTaskId = dependencies.getCurrentTaskId ??
+        (() => getDefaultCurrentTaskContextController().getState().currentTaskId);
+    const clearCurrentTask = dependencies.clearCurrentTask ??
+        ((ctx) => getDefaultCurrentTaskContextController().clearCurrentTask(ctx));
+    return async (_args, ctx) => {
+        const currentTaskId = getCurrentTaskId();
+        if (!currentTaskId) {
+            if (ctx.hasUI) {
+                ctx.ui.notify("No current task to clear", "info");
+                return;
+            }
+            process.stdout.write("No current task to clear\n");
+            return;
+        }
+        try {
+            await clearCurrentTask(ctx);
+            if (ctx.hasUI) {
+                ctx.ui.notify("Cleared current task", "info");
+                return;
+            }
+            process.stdout.write("Cleared current task\n");
+        }
+        catch (error) {
+            if (ctx.hasUI) {
+                ctx.ui.notify(formatTasksCommandError(error, "Failed to clear current task"), "error");
+                return;
+            }
+            process.stderr.write(`${formatTasksCommandError(error, "Failed to clear current task")}\n`);
+        }
+    };
+};
+const createTaskNewCommandHandler = (dependencies = {}) => {
+    const getTaskService = dependencies.getTaskService ?? (() => getDefaultToduTaskServiceRuntime().ensureConnected());
+    const promptTaskTitle = dependencies.promptTaskTitle ?? promptRequiredTaskTitle;
+    const selectTaskProject = dependencies.selectTaskProject ?? selectProjectForTaskCreation;
+    const editTaskExplanation = dependencies.editTaskExplanation ?? editNewTaskExplanation;
+    const confirmTaskAuthoring = dependencies.confirmTaskAuthoring ?? confirmTaskAuthoringHelp;
+    const requestTaskAuthoringAssistance = dependencies.requestTaskAuthoringAssistance;
+    const setCurrentTask = dependencies.setCurrentTask ??
+        ((ctx, task) => getDefaultCurrentTaskContextController().setCurrentTask(ctx, task));
+    const openTaskDetail = dependencies.openTaskDetail ??
+        ((ctx, taskService, taskId) => openTaskDetailHub(ctx, taskService, taskId, {
+            setCurrentTask,
+            showTaskDetailView: dependencies.showTaskDetailView,
+            selectTaskStatus: dependencies.selectTaskStatus,
+            selectTaskPriority: dependencies.selectTaskPriority,
+            editTaskComment: dependencies.editTaskComment,
+        }));
+    return async (_args, ctx) => {
+        if (!ctx.hasUI) {
+            process.stderr.write("/task-new requires interactive mode\n");
+            return;
+        }
+        const title = await promptTaskTitle(ctx);
+        if (!title) {
+            ctx.ui.notify("Task creation cancelled", "info");
+            return;
+        }
+        let taskService;
+        try {
+            taskService = await getTaskService();
+        }
+        catch (error) {
+            ctx.ui.notify(formatTasksCommandError(error, "Failed to start task creation"), "error");
+            return;
+        }
+        let projectSelection;
+        try {
+            projectSelection = await selectTaskProject(ctx, taskService);
+        }
+        catch (error) {
+            ctx.ui.notify(formatTasksCommandError(error, "Failed to load projects"), "error");
+            return;
+        }
+        if (projectSelection.status === "unavailable") {
+            ctx.ui.notify("No projects available for new tasks", "warning");
+            return;
+        }
+        if (projectSelection.status === "cancelled") {
+            ctx.ui.notify("Task creation cancelled", "info");
+            return;
+        }
+        let explanationInput;
+        try {
+            explanationInput = await editTaskExplanation(ctx, title);
+        }
+        catch (error) {
+            ctx.ui.notify(formatTasksCommandError(error, "Failed to collect task explanation"), "error");
+            return;
+        }
+        if (explanationInput === undefined) {
+            ctx.ui.notify("Task creation cancelled", "info");
+            return;
+        }
+        const initialDraft = {
+            title,
+            description: normalizeOptionalTaskDescription(explanationInput),
+            projectName: projectSelection.project.name,
+        };
+        let finalDraft = {
+            title: initialDraft.title,
+            description: initialDraft.description,
+        };
+        let wantsTaskAuthoringHelp;
+        try {
+            wantsTaskAuthoringHelp = await confirmTaskAuthoring(ctx, initialDraft);
+        }
+        catch (error) {
+            ctx.ui.notify(formatTasksCommandError(error, "Failed to confirm task authoring"), "error");
+            return;
+        }
+        if (wantsTaskAuthoringHelp) {
+            if (!requestTaskAuthoringAssistance) {
+                ctx.ui.notify("Task authoring assistance is unavailable", "error");
+                return;
+            }
+            let authoredDraft;
+            try {
+                authoredDraft = await requestTaskAuthoringAssistance(ctx, initialDraft);
+            }
+            catch (error) {
+                ctx.ui.notify(formatTasksCommandError(error, "Failed to complete task authoring"), "error");
+                return;
+            }
+            if (!authoredDraft) {
+                ctx.ui.notify("Task creation cancelled", "info");
+                return;
+            }
+            const authoredTitle = authoredDraft.title.trim();
+            if (authoredTitle.length === 0) {
+                ctx.ui.notify("Task authoring returned an empty title", "error");
+                return;
+            }
+            finalDraft = {
+                title: authoredTitle,
+                description: normalizeOptionalTaskDescription(authoredDraft.description ?? ""),
+            };
+        }
+        let createdTask;
+        try {
+            createdTask = await createTask({ taskService }, {
+                title: finalDraft.title,
+                projectId: projectSelection.project.id,
+                description: finalDraft.description,
+            });
+        }
+        catch (error) {
+            ctx.ui.notify(formatTasksCommandError(error, "Failed to create task"), "error");
+            return;
+        }
+        ctx.ui.notify(`Created task ${createdTask.title}`, "info");
+        try {
+            await openTaskDetail(ctx, taskService, createdTask.id);
+        }
+        catch (error) {
+            ctx.ui.notify(formatTasksCommandError(error, `Created task ${createdTask.title} but failed to open task detail`), "error");
+        }
+    };
+};
+const createHabitsCommandHandler = (dependencies = {}) => {
+    const getHabitService = dependencies.getHabitService ??
+        (() => getDefaultToduTaskServiceRuntime().ensureHabitServiceConnected());
+    return async (_args, ctx) => {
+        if (!ctx.hasUI) {
+            process.stderr.write("/habits requires interactive mode\n");
+            return;
+        }
+        try {
+            let habits = [];
+            let loadError = null;
+            await ctx.ui.custom((tui, theme, _keybindings, done) => {
+                const loader = new BorderedLoader(tui, theme, "Loading habits...");
+                loader.onAbort = () => done();
+                void getHabitService()
+                    .then((habitService) => habitService.listHabitsWithStreaks())
+                    .then((result) => {
+                    habits = result;
+                    done();
+                })
+                    .catch((error) => {
+                    loadError = formatTasksCommandError(error, "Failed to load habits");
+                    done();
+                });
+                return loader;
+            });
+            if (loadError) {
+                ctx.ui.notify(loadError, "error");
+                return;
+            }
+            if (habits.length === 0) {
+                ctx.ui.notify("No habits found", "info");
+                return;
+            }
+            const table = formatHabitTable(habits);
+            await ctx.ui.custom((_tui, theme, _keybindings, done) => {
+                const container = new Container();
+                container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+                container.addChild(new Text(theme.fg("accent", theme.bold("Habits")), 1, 0));
+                container.addChild(new Text(table, 1, 1));
+                container.addChild(new Text(theme.fg("dim", "esc close"), 1, 0));
+                container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+                return {
+                    render: (width) => container.render(width),
+                    invalidate: () => container.invalidate(),
+                    handleInput: (data) => {
+                        if (data === "\x1b" || data === "q") {
+                            done();
+                        }
+                    },
+                };
+            });
+        }
+        catch (error) {
+            ctx.ui.notify(formatTasksCommandError(error, "Failed to show habits"), "error");
+        }
+    };
+};
+const registerCommands = (pi, dependencies = {}) => {
+    getDefaultCurrentTaskContextController(pi);
+    getDefaultTaskBrowseFilterContextController(pi);
+    pi.registerCommand("tasks", {
+        description: "Browse and filter todu tasks",
+        handler: createTasksCommandHandler(dependencies),
+    });
+    pi.registerCommand("task", {
+        description: "Show the current task or a specific task by ID",
+        handler: createTaskCommandHandler(dependencies),
+    });
+    pi.registerCommand("task-clear", {
+        description: "Clear the current task context",
+        handler: createTaskClearCommandHandler(dependencies),
+    });
+    pi.registerCommand("task-new", {
+        description: "Create a new todu task",
+        handler: createTaskNewCommandHandler({
+            ...dependencies,
+            requestTaskAuthoringAssistance: dependencies.requestTaskAuthoringAssistance ??
+                ((ctx, draft) => requestTaskAuthoringAssistance(pi, ctx, draft)),
+        }),
+    });
+    pi.registerCommand("habits", {
+        description: "Show habits with streak and today status",
+        handler: createHabitsCommandHandler(dependencies),
+    });
+};
+const loadTasksWithLoader = async (ctx, taskService, filter, filterSummary) => ctx.ui.custom((tui, theme, _keybindings, done) => {
+    const loader = new BorderedLoader(tui, theme, createTaskLoaderViewModel(`Loading tasks · ${filterSummary}`).label);
+    let settled = false;
+    const settle = (result) => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        done(result);
+    };
+    loader.onAbort = () => settle({ status: "cancelled" });
+    void browseTasks({ taskService }, filter)
+        .then((tasks) => {
+        settle({ status: "loaded", tasks });
+    })
+        .catch((error) => {
+        settle({
+            status: "error",
+            message: formatTasksCommandError(error, "Failed to load filtered tasks"),
+        });
+    });
+    return loader;
+});
+const showTaskBrowseFilterMode = async (ctx, taskService, currentState) => {
+    const projects = [...(await taskService.listProjects())].sort((left, right) => left.name.localeCompare(right.name));
+    let draftState = createTaskBrowseFilterState({
+        ...currentState,
+        hasSavedFilter: true,
+    });
+    while (true) {
+        const action = await selectTaskBrowseFilterModeAction(ctx, draftState, projects);
+        if (!action) {
+            return { status: "cancelled" };
+        }
+        if (action === "apply") {
+            return { status: "saved", filterState: draftState };
+        }
+        if (action === "reset") {
+            draftState = createSavedTaskBrowseFilterState();
+            continue;
+        }
+        if (action === "status") {
+            const nextStatus = await selectOptionalTaskSettingFromList(ctx, {
+                title: "Filter by status",
+                options: createTaskBrowseStatusOptions(),
+                currentValue: draftState.status,
+                currentLabel: formatTaskBrowseStatusFilterLabel(draftState.status),
+                actionLabel: "status filter",
+            });
+            if (nextStatus !== undefined) {
+                draftState = createTaskBrowseFilterState({
+                    ...draftState,
+                    hasSavedFilter: true,
+                    status: nextStatus,
+                });
+            }
+            continue;
+        }
+        if (action === "priority") {
+            const nextPriority = await selectOptionalTaskSettingFromList(ctx, {
+                title: "Filter by priority",
+                options: createTaskBrowsePriorityOptions(),
+                currentValue: draftState.priority,
+                currentLabel: formatTaskBrowsePriorityFilterLabel(draftState.priority),
+                actionLabel: "priority filter",
+            });
+            if (nextPriority !== undefined) {
+                draftState = createTaskBrowseFilterState({
+                    ...draftState,
+                    hasSavedFilter: true,
+                    priority: nextPriority,
+                });
+            }
+            continue;
+        }
+        const nextProject = await selectTaskBrowseProjectFilter(ctx, projects, draftState.projectId);
+        if (nextProject !== undefined) {
+            draftState = createTaskBrowseFilterState({
+                ...draftState,
+                hasSavedFilter: true,
+                projectId: nextProject.projectId,
+                projectName: nextProject.projectName,
+            });
+        }
+    }
+};
+const selectTaskBrowseViewAction = async (ctx, tasks, filterState) => {
+    const items = [
+        {
+            value: "action:change-filters",
+            label: "Change filters",
+            description: "Edit status, priority, or project filters",
+        },
+        {
+            value: "action:clear-filters",
+            label: "Clear filters",
+            description: "Reset all filters to Any",
+        },
+        ...tasks.map((task) => ({
+            ...createTaskListItem(task),
+            value: `task:${task.id}`,
+        })),
+    ];
+    return ctx.ui.custom((tui, theme, _keybindings, done) => {
+        const container = new Container();
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        container.addChild(new Text(theme.fg("accent", theme.bold("Browse Tasks")), 1, 0));
+        container.addChild(new Text(theme.fg("muted", `Filters: ${formatTaskBrowseFilterSummary(filterState)}`), 1, 0));
+        const selectList = new SelectList(items, Math.min(items.length, 12), {
+            selectedPrefix: (text) => theme.fg("accent", text),
+            selectedText: (text) => theme.fg("accent", text),
+            description: (text) => theme.fg("muted", text),
+            scrollInfo: (text) => theme.fg("dim", text),
+            noMatch: (text) => theme.fg("warning", text),
+        });
+        selectList.onSelect = (item) => {
+            const value = item.value;
+            if (value === "action:change-filters") {
+                done({ status: "change-filters" });
+                return;
+            }
+            if (value === "action:clear-filters") {
+                done({ status: "clear-filters" });
+                return;
+            }
+            done({ status: "selected", taskId: value.replace(/^task:/, "") });
+        };
+        selectList.onCancel = () => done({ status: "closed" });
+        container.addChild(selectList);
+        container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc close"), 1, 0));
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        return {
+            render: (width) => container.render(width),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => {
+                selectList.handleInput(data);
+                tui.requestRender();
+            },
+        };
+    });
+};
+const showEmptyTasksState = async (ctx, filterState) => ctx.ui.custom((_tui, theme, _keybindings, done) => {
+    const items = [
+        {
+            value: "change-filters",
+            label: "Change filters",
+            description: "Adjust the current task filters",
+        },
+        {
+            value: "clear-filters",
+            label: "Clear filters",
+            description: "Reset all filters to Any",
+        },
+        {
+            value: "close",
+            label: "Close",
+            description: "Exit task browsing",
+        },
+    ];
+    const container = new Container();
+    container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+    container.addChild(new Text(theme.fg("accent", theme.bold("Browse Tasks")), 1, 0));
+    container.addChild(new Text(theme.fg("muted", `No tasks match the current filters: ${formatTaskBrowseFilterSummary(filterState)}`), 1, 1));
+    const selectList = new SelectList(items, items.length, {
+        selectedPrefix: (text) => theme.fg("accent", text),
+        selectedText: (text) => theme.fg("accent", text),
+        description: (text) => theme.fg("muted", text),
+        scrollInfo: (text) => theme.fg("dim", text),
+        noMatch: (text) => theme.fg("warning", text),
+    });
+    selectList.onSelect = (item) => done(item.value);
+    selectList.onCancel = () => done("close");
+    container.addChild(selectList);
+    container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc close"), 1, 0));
+    container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+    return {
+        render: (width) => container.render(width),
+        invalidate: () => container.invalidate(),
+        handleInput: (data) => {
+            selectList.handleInput(data);
+            _tui.requestRender();
+        },
+    };
+});
+const selectTaskBrowseFilterModeAction = async (ctx, filterState, projects) => {
+    const items = [
+        {
+            value: "status",
+            label: `Status: ${formatTaskBrowseStatusFilterLabel(filterState.status)}`,
+            description: "Choose a status filter or Any",
+        },
+        {
+            value: "priority",
+            label: `Priority: ${formatTaskBrowsePriorityFilterLabel(filterState.priority)}`,
+            description: "Choose a priority filter or Any",
+        },
+        {
+            value: "project",
+            label: `Project: ${formatTaskBrowseProjectFilterLabel(filterState.projectId, projects.find((project) => project.id === filterState.projectId)?.name ??
+                filterState.projectName)}`,
+            description: "Choose a project filter or Any",
+        },
+        {
+            value: "apply",
+            label: "View tasks",
+            description: `Open the filtered list (${formatTaskBrowseFilterSummary(filterState)})`,
+        },
+        {
+            value: "reset",
+            label: "Reset filters",
+            description: "Set status, priority, and project back to Any",
+        },
+    ];
+    return ctx.ui.custom((tui, theme, _keybindings, done) => {
+        const container = new Container();
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        container.addChild(new Text(theme.fg("accent", theme.bold("Task Filters")), 1, 0));
+        container.addChild(new Text(theme.fg("muted", "Set the filters to use when browsing tasks."), 1, 0));
+        const selectList = new SelectList(items, items.length, {
+            selectedPrefix: (text) => theme.fg("accent", text),
+            selectedText: (text) => theme.fg("accent", text),
+            description: (text) => theme.fg("muted", text),
+            scrollInfo: (text) => theme.fg("dim", text),
+            noMatch: (text) => theme.fg("warning", text),
+        });
+        selectList.onSelect = (item) => done(item.value);
+        selectList.onCancel = () => done(null);
+        container.addChild(selectList);
+        container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc cancel"), 1, 0));
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        return {
+            render: (width) => container.render(width),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => {
+                selectList.handleInput(data);
+                tui.requestRender();
+            },
+        };
+    });
+};
+const selectOptionalTaskSettingFromList = async (ctx, options) => {
+    const items = options.options.map((option) => ({
+        value: option.value ?? "__any__",
+        label: option.label,
+        description: option.value === options.currentValue
+            ? `${option.label} (current)`
+            : `Set ${options.actionLabel} to ${option.label}`,
+    }));
+    return ctx.ui.custom((tui, theme, _keybindings, done) => {
+        const container = new Container();
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        container.addChild(new Text(theme.fg("accent", theme.bold(options.title)), 1, 0));
+        container.addChild(new Text(theme.fg("muted", `Current ${options.actionLabel}: ${options.currentLabel}`), 1, 0));
+        const selectList = new SelectList(items, items.length, {
+            selectedPrefix: (text) => theme.fg("accent", text),
+            selectedText: (text) => theme.fg("accent", text),
+            description: (text) => theme.fg("muted", text),
+            scrollInfo: (text) => theme.fg("dim", text),
+            noMatch: (text) => theme.fg("warning", text),
+        });
+        selectList.onSelect = (item) => {
+            const selectedValue = item.value === "__any__" ? null : item.value;
+            done(selectedValue);
+        };
+        selectList.onCancel = () => done(undefined);
+        container.addChild(selectList);
+        container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc cancel"), 1, 0));
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        return {
+            render: (width) => container.render(width),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => {
+                selectList.handleInput(data);
+                tui.requestRender();
+            },
+        };
+    });
+};
+const selectTaskBrowseProjectFilter = async (ctx, projects, currentProjectId) => {
+    const nextProjectId = await selectOptionalTaskSettingFromList(ctx, {
+        title: "Filter by project",
+        options: [
+            { label: "Any", value: null },
+            ...projects.map((project) => ({
+                label: project.name,
+                value: project.id,
+            })),
+        ],
+        currentValue: currentProjectId,
+        currentLabel: formatTaskBrowseProjectFilterLabel(currentProjectId, projects.find((project) => project.id === currentProjectId)?.name ?? null),
+        actionLabel: "project filter",
+    });
+    if (nextProjectId === undefined) {
+        return undefined;
+    }
+    return {
+        projectId: nextProjectId,
+        projectName: nextProjectId
+            ? (projects.find((project) => project.id === nextProjectId)?.name ?? nextProjectId)
+            : null,
+    };
+};
+const createTaskBrowseStatusOptions = () => [
+    { label: "Any", value: null },
+    ...taskStatusOptions,
+];
+const createTaskBrowsePriorityOptions = () => [
+    { label: "Any", value: null },
+    ...taskPriorityOptions,
+];
+const createSavedTaskBrowseFilterState = (overrides = {}) => createTaskBrowseFilterState({
+    hasSavedFilter: true,
+    ...overrides,
+});
+const createTaskFilterFromBrowseState = (filterState) => ({
+    statuses: filterState.status ? [filterState.status] : undefined,
+    priorities: filterState.priority ? [filterState.priority] : undefined,
+    projectId: filterState.projectId ?? undefined,
+});
+const formatTaskBrowseFilterSummary = (filterState) => [
+    `Status ${formatTaskBrowseStatusFilterLabel(filterState.status)}`,
+    `Priority ${formatTaskBrowsePriorityFilterLabel(filterState.priority)}`,
+    `Project ${formatTaskBrowseProjectFilterLabel(filterState.projectId, filterState.projectName)}`,
+].join(" • ");
+const formatTaskBrowseStatusFilterLabel = (status) => status ? formatTaskStatusLabel(status) : "Any";
+const formatTaskBrowsePriorityFilterLabel = (priority) => priority ? formatTaskPriorityLabel(priority) : "Any";
+const formatTaskBrowseProjectFilterLabel = (projectId, projectName) => {
+    if (!projectId) {
+        return "Any";
+    }
+    return projectName ?? projectId;
+};
+const promptRequiredTaskTitle = async (ctx) => {
+    while (true) {
+        const title = await ctx.ui.input("New task title", "What needs to be done?");
+        if (title === undefined) {
+            return null;
+        }
+        const trimmedTitle = title.trim();
+        if (trimmedTitle.length > 0) {
+            return trimmedTitle;
+        }
+        ctx.ui.notify("Task title is required", "warning");
+    }
+};
+const selectProjectForTaskCreation = async (ctx, taskService) => {
+    const projects = [...(await taskService.listProjects())].sort((left, right) => left.name.localeCompare(right.name));
+    if (projects.length === 0) {
+        return { status: "unavailable" };
+    }
+    const selectedProjectId = await selectProjectFromList(ctx, projects);
+    if (!selectedProjectId) {
+        return { status: "cancelled" };
+    }
+    const selectedProject = projects.find((project) => project.id === selectedProjectId);
+    if (!selectedProject) {
+        return { status: "cancelled" };
+    }
+    return {
+        status: "selected",
+        project: selectedProject,
+    };
+};
+const selectProjectFromList = async (ctx, projects) => {
+    const items = projects.map((project) => ({
+        value: project.id,
+        label: project.name,
+        description: `${project.status} • ${project.priority} • ${project.id}`,
+    }));
+    return ctx.ui.custom((tui, theme, _keybindings, done) => {
+        const container = new Container();
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        container.addChild(new Text(theme.fg("accent", theme.bold("Select Project")), 1, 0));
+        container.addChild(new Text(theme.fg("muted", "Choose the project for the new task."), 1, 0));
+        const selectList = new SelectList(items, Math.min(items.length, 10), {
+            selectedPrefix: (text) => theme.fg("accent", text),
+            selectedText: (text) => theme.fg("accent", text),
+            description: (text) => theme.fg("muted", text),
+            scrollInfo: (text) => theme.fg("dim", text),
+            noMatch: (text) => theme.fg("warning", text),
+        });
+        selectList.onSelect = (item) => done(item.value);
+        selectList.onCancel = () => done(null);
+        container.addChild(selectList);
+        container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc cancel"), 1, 0));
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        return {
+            render: (width) => container.render(width),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => {
+                selectList.handleInput(data);
+                tui.requestRender();
+            },
+        };
+    });
+};
+const editNewTaskExplanation = async (ctx, taskTitle) => ctx.ui.editor(`Explain the task in your own words (optional) · ${taskTitle}`, "");
+const confirmTaskAuthoringHelp = async (ctx, draft) => ctx.ui.confirm("Task authoring", `Do you want help with task authoring before creating ${draft.title} in ${draft.projectName}?`);
+const requestTaskAuthoringAssistance = async (pi, ctx, draft) => {
+    let pendingError = null;
+    const result = await ctx.ui.custom((tui, theme, _keybindings, done) => {
+        const loader = new BorderedLoader(tui, theme, `Refining task draft · ${draft.title}`);
+        let settled = false;
+        const settle = (value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            done(value);
+        };
+        loader.onAbort = () => settle(null);
+        const commandArgs = ["--mode", "json", "--print", "--no-session", "--no-extensions"];
+        if (ctx.model) {
+            commandArgs.push("--model", `${ctx.model.provider}/${ctx.model.id}`);
+        }
+        commandArgs.push(buildTaskAuthoringSkillPrompt(draft));
+        void pi
+            .exec("pi", commandArgs, { signal: loader.signal, timeout: 120_000 })
+            .then((execResult) => {
+            if (execResult.code !== 0) {
+                const errorOutput = [execResult.stderr, execResult.stdout]
+                    .map((value) => value.trim())
+                    .find(Boolean);
+                throw new Error(errorOutput ?? `Task authoring subprocess failed with exit code ${execResult.code}`);
+            }
+            settle(parseTaskAuthoringResponse(extractAssistantTextFromJsonOutput(execResult.stdout)));
+        })
+            .catch((error) => {
+            if (loader.signal.aborted) {
+                settle(null);
+                return;
+            }
+            pendingError =
+                error instanceof Error ? error : new Error("Task authoring subprocess failed");
+            settle(null);
+        });
+        return loader;
+    });
+    if (pendingError) {
+        throw pendingError;
+    }
+    return result;
+};
+const buildTaskAuthoringSkillPrompt = (draft) => {
+    const explanation = draft.description ?? "(none provided)";
+    return [
+        "/skill:task-authoring",
+        "This is a task authoring request.",
+        "Use task authoring to turn the following rough draft into a finalized task title and markdown description.",
+        "Do not ask follow-up questions. Use only the information provided below.",
+        "Return the result in this exact format:",
+        "Title: <title>",
+        "",
+        "<markdown description>",
+        "",
+        "The title should be 60 characters or fewer.",
+        "",
+        `Project: ${draft.projectName}`,
+        `Draft title: ${draft.title}`,
+        "User explanation:",
+        explanation,
+    ].join("\n");
+};
+const extractAssistantTextFromJsonOutput = (output) => {
+    const lines = output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        let event;
+        try {
+            event = JSON.parse(lines[index] ?? "");
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(event) || event.type !== "message_end" || !isRecord(event.message)) {
+            continue;
+        }
+        const { message } = event;
+        if (message.role !== "assistant" || !Array.isArray(message.content)) {
+            continue;
+        }
+        const text = message.content
+            .filter((block) => isRecord(block) && block.type === "text" && typeof block.text === "string")
+            .map((block) => block.text)
+            .join("\n")
+            .trim();
+        if (text.length > 0) {
+            return text;
+        }
+    }
+    throw new Error("Task authoring did not return a response");
+};
+const parseTaskAuthoringResponse = (responseText) => {
+    const jsonResult = parseTaskAuthoringJsonResponse(responseText);
+    if (jsonResult) {
+        return jsonResult;
+    }
+    const formattedResult = parseTaskAuthoringFormattedResponse(responseText);
+    if (formattedResult) {
+        return formattedResult;
+    }
+    throw new Error("Task authoring did not return a recognizable title and description");
+};
+const parseTaskAuthoringJsonResponse = (responseText) => {
+    const rawJson = extractJsonObject(responseText);
+    if (!rawJson) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(rawJson);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(parsed)) {
+        return null;
+    }
+    const title = parsed.title;
+    if (typeof title !== "string" || title.trim().length === 0) {
+        return null;
+    }
+    const description = parsed.description;
+    if (description !== null && description !== undefined && typeof description !== "string") {
+        return null;
+    }
+    return {
+        title: title.trim(),
+        description: typeof description === "string" ? normalizeOptionalTaskDescription(description) : null,
+    };
+};
+const parseTaskAuthoringFormattedResponse = (responseText) => {
+    const normalizedText = responseText.replace(/\r\n/g, "\n").trim();
+    if (normalizedText.length === 0) {
+        return null;
+    }
+    const titleMatch = normalizedText.match(/^Title:\s*(.+)$/im);
+    if (titleMatch?.[1]) {
+        const title = titleMatch[1].trim();
+        const description = normalizedText
+            .slice((titleMatch.index ?? 0) + titleMatch[0].length)
+            .replace(/^\s*Description:\s*/i, "")
+            .trim();
+        if (title.length === 0) {
+            return null;
+        }
+        return {
+            title,
+            description: normalizeOptionalTaskDescription(description),
+        };
+    }
+    const firstLineBreak = normalizedText.indexOf("\n");
+    if (firstLineBreak < 0) {
+        return null;
+    }
+    const title = normalizedText.slice(0, firstLineBreak).trim();
+    const description = normalizedText.slice(firstLineBreak + 1).trim();
+    if (title.length === 0 || description.length === 0) {
+        return null;
+    }
+    if (title.startsWith("#")) {
+        return null;
+    }
+    return {
+        title,
+        description: normalizeOptionalTaskDescription(description),
+    };
+};
+const extractJsonObject = (value) => {
+    const trimmedValue = value.trim();
+    if (trimmedValue.startsWith("{") && trimmedValue.endsWith("}")) {
+        return trimmedValue;
+    }
+    const fencedMatch = trimmedValue.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+    if (fencedMatch?.[1]) {
+        return fencedMatch[1].trim();
+    }
+    const firstBraceIndex = trimmedValue.indexOf("{");
+    const lastBraceIndex = trimmedValue.lastIndexOf("}");
+    if (firstBraceIndex < 0 || lastBraceIndex <= firstBraceIndex) {
+        return null;
+    }
+    return trimmedValue.slice(firstBraceIndex, lastBraceIndex + 1);
+};
+const normalizeOptionalTaskDescription = (description) => {
+    const trimmedDescription = description.trim();
+    return trimmedDescription.length > 0 ? trimmedDescription : null;
+};
+const openSelectedTaskDetail = async (ctx, taskService, taskId, dependencies) => {
+    const task = await showTaskDetail({ taskService }, taskId);
+    if (!task) {
+        ctx.ui.notify("Selected task no longer exists", "warning");
+        return;
+    }
+    await openTaskDetailHub(ctx, taskService, taskId, dependencies);
+};
+const openTaskDetailHub = async (ctx, taskService, taskId, dependencies) => {
+    const showTaskDetailView = dependencies.showTaskDetailView ?? selectTaskDetailAction;
+    const selectStatus = dependencies.selectTaskStatus ?? selectTaskStatusFromList;
+    const selectPriority = dependencies.selectTaskPriority ?? selectTaskPriorityFromList;
+    const editComment = dependencies.editTaskComment ?? editTaskComment;
+    while (true) {
+        const task = await showTaskDetail({ taskService }, taskId);
+        if (!task) {
+            ctx.ui.notify("Selected task no longer exists", "warning");
+            return;
+        }
+        const action = await showTaskDetailView(ctx, task);
+        if (!action) {
+            return;
+        }
+        if (action === "pickup") {
+            await dependencies.setCurrentTask(ctx, task);
+            ctx.ui.setEditorText(`pickup task ${task.id}`);
+            ctx.ui.notify(`Prepared pickup workflow for ${task.title}`, "info");
+            return;
+        }
+        if (action === "set-current") {
+            await dependencies.setCurrentTask(ctx, task);
+            ctx.ui.notify(`Current task set to ${task.title}`, "info");
+            continue;
+        }
+        if (action === "update-status") {
+            const nextStatus = await selectStatus(ctx, task);
+            if (!nextStatus || nextStatus === task.status) {
+                continue;
+            }
+            try {
+                const updatedTask = await updateTask({ taskService }, {
+                    taskId: task.id,
+                    status: nextStatus,
+                });
+                await syncCurrentTaskIfFocused(ctx, updatedTask, dependencies.setCurrentTask);
+                ctx.ui.notify(`Updated ${task.title} to ${nextStatus}`, "info");
+            }
+            catch (error) {
+                ctx.ui.notify(formatTasksCommandError(error, "Failed to update task status"), "error");
+            }
+            continue;
+        }
+        if (action === "update-priority") {
+            const nextPriority = await selectPriority(ctx, task);
+            if (!nextPriority || nextPriority === task.priority) {
+                continue;
+            }
+            try {
+                const updatedTask = await updateTask({ taskService }, {
+                    taskId: task.id,
+                    priority: nextPriority,
+                });
+                await syncCurrentTaskIfFocused(ctx, updatedTask, dependencies.setCurrentTask);
+                ctx.ui.notify(`Updated ${task.title} priority to ${nextPriority}`, "info");
+            }
+            catch (error) {
+                ctx.ui.notify(formatTasksCommandError(error, "Failed to update task priority"), "error");
+            }
+            continue;
+        }
+        const commentContent = await editComment(ctx, task);
+        if (!commentContent || commentContent.trim().length === 0) {
+            continue;
+        }
+        await commentOnTask({ taskService }, {
+            taskId: task.id,
+            content: commentContent.trim(),
+        });
+        const refreshedTask = await showTaskDetail({ taskService }, task.id);
+        if (refreshedTask) {
+            await syncCurrentTaskIfFocused(ctx, refreshedTask, dependencies.setCurrentTask);
+        }
+        ctx.ui.notify(`Added comment to ${task.title}`, "info");
+    }
+};
+const selectTaskDetailAction = async (ctx, task) => {
+    const viewModel = createTaskDetailViewModel(task);
+    const actionItems = createTaskDetailActionItems(task);
+    return ctx.ui.custom((tui, theme, _keybindings, done) => {
+        const container = new Container();
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        container.addChild(new Text(theme.fg("accent", theme.bold(viewModel.title)), 1, 0));
+        container.addChild(new Text(theme.fg("muted", viewModel.body), 1, 0));
+        container.addChild(new Text(theme.fg("accent", theme.bold("Quick actions")), 1, 0));
+        const selectList = new SelectList(actionItems, actionItems.length, {
+            selectedPrefix: (text) => theme.fg("accent", text),
+            selectedText: (text) => theme.fg("accent", text),
+            description: (text) => theme.fg("muted", text),
+            scrollInfo: (text) => theme.fg("dim", text),
+            noMatch: (text) => theme.fg("warning", text),
+        });
+        selectList.onSelect = (item) => done(item.value);
+        selectList.onCancel = () => done(null);
+        container.addChild(selectList);
+        container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc close"), 1, 0));
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        return {
+            render: (width) => container.render(width),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => {
+                selectList.handleInput(data);
+                tui.requestRender();
+            },
+        };
+    });
+};
+const selectTaskStatusFromList = async (ctx, task) => selectTaskSettingFromList(ctx, {
+    title: `Update status · ${task.title}`,
+    options: taskStatusOptions,
+    currentValue: task.status,
+    currentLabel: formatTaskStatusLabel(task.status),
+    actionLabel: "status",
+});
+const selectTaskPriorityFromList = async (ctx, task) => selectTaskSettingFromList(ctx, {
+    title: `Update priority · ${task.title}`,
+    options: taskPriorityOptions,
+    currentValue: task.priority,
+    currentLabel: formatTaskPriorityLabel(task.priority),
+    actionLabel: "priority",
+});
+const selectTaskSettingFromList = async (ctx, options) => {
+    const items = options.options.map((option) => ({
+        value: option.value,
+        label: option.label,
+        description: option.value === options.currentValue
+            ? `${option.label} (current)`
+            : `Set ${options.actionLabel} to ${option.label}`,
+    }));
+    return ctx.ui.custom((tui, theme, _keybindings, done) => {
+        const container = new Container();
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        container.addChild(new Text(theme.fg("accent", theme.bold(options.title)), 1, 0));
+        container.addChild(new Text(theme.fg("muted", `Current ${options.actionLabel}: ${options.currentLabel}`), 1, 0));
+        const selectList = new SelectList(items, items.length, {
+            selectedPrefix: (text) => theme.fg("accent", text),
+            selectedText: (text) => theme.fg("accent", text),
+            description: (text) => theme.fg("muted", text),
+            scrollInfo: (text) => theme.fg("dim", text),
+            noMatch: (text) => theme.fg("warning", text),
+        });
+        selectList.onSelect = (item) => done(item.value);
+        selectList.onCancel = () => done(null);
+        container.addChild(selectList);
+        container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc cancel"), 1, 0));
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        return {
+            render: (width) => container.render(width),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => {
+                selectList.handleInput(data);
+                tui.requestRender();
+            },
+        };
+    });
+};
+const editTaskComment = async (ctx, task) => {
+    const content = await ctx.ui.editor(`Add comment · ${task.title}`, "");
+    return content ?? null;
+};
+const syncCurrentTaskIfFocused = async (ctx, task, setCurrentTask) => {
+    const currentTaskId = getFocusedTaskId();
+    if (currentTaskId !== task.id) {
+        return;
+    }
+    await setCurrentTask(ctx, task);
+};
+const getFocusedTaskId = () => {
+    try {
+        return getDefaultCurrentTaskContextController().getState().currentTaskId;
+    }
+    catch {
+        return null;
+    }
+};
+const resolveRequestedTaskId = (args, currentTaskId) => {
+    const trimmedArgs = args.trim();
+    return trimmedArgs.length > 0 ? trimmedArgs : currentTaskId;
+};
+const resolveDefaultTaskBrowseFilterState = async (taskService, resolveDefaultProject) => {
+    const project = await resolveDefaultProject(taskService).catch(() => null);
+    return createTaskBrowseFilterState({
+        hasSavedFilter: true,
+        status: "active",
+        priority: "high",
+        projectId: project?.projectId ?? null,
+        projectName: project?.projectName ?? null,
+    });
+};
+const resolveDefaultProjectFromRepo = async (taskService, repoContextService = createRepoContextService()) => {
+    const projects = await taskService.listProjects();
+    if (projects.length === 0) {
+        return null;
+    }
+    const repoResult = await repoContextService.resolveRepository();
+    let candidateName = null;
+    if (repoResult.kind === "resolved") {
+        const targetRef = repoResult.repository.targetRef;
+        const repoName = targetRef.includes("/") ? targetRef.split("/").pop() : targetRef;
+        candidateName = repoName;
+    }
+    if (!candidateName) {
+        candidateName = path.basename(process.cwd());
+    }
+    if (!candidateName) {
+        return null;
+    }
+    const match = matchProjectByName(projects, candidateName);
+    return match ? { projectId: match.id, projectName: match.name } : null;
+};
+const matchProjectByName = (projects, candidateName) => {
+    const normalized = candidateName.toLowerCase();
+    return (projects.find((project) => project.name.toLowerCase() === normalized) ??
+        projects.find((project) => project.name.toLowerCase().replace(/[\s_-]+/g, "-") === normalized.replace(/[\s_-]+/g, "-")) ??
+        null);
+};
+const isRecord = (value) => typeof value === "object" && value !== null;
+const formatTasksCommandError = (error, prefix) => {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return `${prefix}: ${error.message}`;
+    }
+    return prefix;
+};
+export { createHabitsCommandHandler, createTaskClearCommandHandler, createTaskCommandHandler, createTaskNewCommandHandler, createTasksCommandHandler, createSavedTaskBrowseFilterState, createTaskFilterFromBrowseState, DEFAULT_TASK_BROWSE_FILTER_STATE, editTaskComment, formatTaskBrowseFilterSummary, formatTasksCommandError, loadTasksWithLoader, matchProjectByName, openSelectedTaskDetail, openTaskDetailHub, registerCommands, resolveDefaultProjectFromRepo, resolveDefaultTaskBrowseFilterState, resolveRequestedTaskId, selectTaskBrowseViewAction, selectTaskDetailAction, selectTaskPriorityFromList, selectTaskStatusFromList, showEmptyTasksState, showTaskBrowseFilterMode, syncCurrentTaskIfFocused, };