@todu/pi-extensions 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Erik Craddock
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+# todu-pi-extensions
+
+`todu-pi-extensions` is a pi package that adds todu-focused commands, tools, and TUI workflows to [pi](https://pi.dev). It is the pi-side integration layer for working with tasks from [todu](https://github.com/evcraddock/todu) without leaving the agent.
+
+Today the package is focused on task browsing, task detail, task creation, and task updates inside pi.
+
+## How it fits together
+
+- [pi](https://pi.dev) is the host coding agent and extension runtime.
+- [todu](https://github.com/evcraddock/todu) is the task backend and CLI.
+- `todu-pi-extensions` connects pi to todu.
+- [todu-workflow](https://github.com/evcraddock/todu-workflow) is an optional companion project with higher-level workflow skills and policies.
+
+`todu-workflow` is not a hard dependency. You can use this package by itself, use it alongside `todu-workflow`, or build your own workflow on top of pi and todu.
+
+## Prerequisites
+
+Install these first:
+
+- [pi via pi.dev](https://pi.dev)
+- [todu via github.com/evcraddock/todu](https://github.com/evcraddock/todu)
+- Node.js 20+
+- npm
+- [overmind](https://github.com/DarthSim/overmind) for the local dev environment
+
+## Install the extension
+
+Install the packaged npm release:
+
+```bash
+pi install npm:@todu/pi-extensions
+```
+
+Install project-local instead of globally:
+
+```bash
+pi install -l npm:@todu/pi-extensions
+```
+
+Install from git when testing an unpublished revision:
+
+```bash
+pi install git:github.com/evcraddock/todu-pi-extensions
+```
+
+Install from a local checkout while developing:
+
+```bash
+npm install
+npm run build
+pi install /path/to/todu-pi-extensions
+```
+
+Local path installs load `dist/index.js`, not `src/index.ts`. Rebuild after source changes so pi picks up the packaged output instead of live source files.
+
+After installation, reload pi if it is already running.
+
+## Basic usage
+
+Use the extension inside pi with commands such as:
+
+- `/tasks` to browse and filter tasks
+- `/task` to inspect the current task or a task by ID
+- `/task-new` to create a task
+- `/task-clear` to clear the current task context
+
+The package also exposes agent tools for structured task operations such as listing tasks, showing task details, and creating or updating tasks.
+
+## Work on this project
+
+```bash
+npm install
+make dev
+```
+
+`make dev` starts the local dev environment, including the isolated todu daemon used by this repository.
+
+Useful commands:
+
+```bash
+make check
+make pre-pr
+make dev-cli CMD="task list"
+make help
+```
+
+## Release
+
+Tag a version that matches `package.json` and let GitHub Actions publish `@todu/pi-extensions` to npm and attach the package tarball to the GitHub release. The workflow expects `NPM_TOKEN` to be configured in the repository secrets.
+
+The isolated dev daemon keeps its state under `.dev/` so local development does not touch your normal todu data.
+
+## License
+
+MIT

package/dist/domain/habit.d.ts

@@ -0,0 +1,38 @@
+export type HabitId = string;
+export interface HabitSummary {
+    id: HabitId;
+    title: string;
+    projectId: string;
+    projectName: string | null;
+    schedule: string;
+    timezone: string;
+    startDate: string;
+    endDate: string | null;
+    nextDue: string;
+    paused: boolean;
+}
+export interface HabitDetail extends HabitSummary {
+    description: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface HabitStreak {
+    current: number;
+    longest: number;
+    completedToday: boolean;
+    totalCheckins: number;
+}
+export interface HabitCheckResult {
+    habitId: HabitId;
+    date: string;
+    completed: boolean;
+    streak?: HabitStreak;
+}
+export interface HabitSummaryWithStreak extends HabitSummary {
+    streak: HabitStreak | null;
+}
+export interface HabitFilter {
+    paused?: boolean;
+    projectId?: string;
+    query?: string;
+}

package/dist/domain/habit.js

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

package/dist/domain/note.d.ts

@@ -0,0 +1,21 @@
+export type NoteId = string;
+export type NoteEntityType = "task" | "project" | "habit";
+export interface NoteSummary {
+    id: NoteId;
+    content: string;
+    author: string;
+    entityType: NoteEntityType | null;
+    entityId: string | null;
+    tags: string[];
+    createdAt: string;
+}
+export interface NoteFilter {
+    entityType?: NoteEntityType;
+    entityId?: string;
+    tag?: string;
+    author?: string;
+    from?: string;
+    to?: string;
+    journal?: boolean;
+    timezone?: string;
+}

package/dist/domain/note.js

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

package/dist/domain/recurring.d.ts

@@ -0,0 +1,29 @@
+import type { TaskPriority } from "./task";
+export type RecurringId = string;
+export type RecurringMissPolicy = "accumulate" | "rollForward";
+export interface RecurringTemplateSummary {
+    id: RecurringId;
+    title: string;
+    projectId: string;
+    projectName: string | null;
+    priority: TaskPriority;
+    schedule: string;
+    timezone: string;
+    startDate: string;
+    endDate: string | null;
+    nextDue: string;
+    missPolicy: RecurringMissPolicy;
+    paused: boolean;
+}
+export interface RecurringTemplateDetail extends RecurringTemplateSummary {
+    description: string | null;
+    labels: string[];
+    skippedDates: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RecurringFilter {
+    paused?: boolean;
+    projectId?: string;
+    query?: string;
+}

package/dist/domain/recurring.js

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

package/dist/domain/task-actions.d.ts

@@ -0,0 +1,24 @@
+import type { TaskId, TaskPriority, TaskStatus } from "./task";
+export type TaskFlowId = "browse-tasks" | "show-task-detail" | "create-task" | "update-task" | "comment-on-task" | "pick-current-task";
+export interface SetCurrentTaskAction {
+    kind: "set-current";
+    taskId: TaskId;
+}
+export interface UpdateTaskStatusAction {
+    kind: "update-status";
+    taskId: TaskId;
+    status: TaskStatus;
+}
+export interface UpdateTaskPriorityAction {
+    kind: "update-priority";
+    taskId: TaskId;
+    priority: TaskPriority;
+}
+export interface CommentOnTaskAction {
+    kind: "comment";
+    taskId: TaskId;
+}
+export interface CreateTaskAction {
+    kind: "create";
+}
+export type TaskAction = SetCurrentTaskAction | UpdateTaskStatusAction | UpdateTaskPriorityAction | CommentOnTaskAction | CreateTaskAction;

package/dist/domain/task-actions.js

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

package/dist/domain/task.d.ts

@@ -0,0 +1,50 @@
+export type TaskId = string;
+export type ProjectId = string;
+export type TaskCommentId = string;
+export type TaskStatus = "active" | "inprogress" | "waiting" | "done" | "cancelled";
+export type TaskPriority = "low" | "medium" | "high";
+export interface ProjectSummary {
+    id: ProjectId;
+    name: string;
+    status: "active" | "done" | "cancelled";
+    priority: TaskPriority;
+    description: string | null;
+}
+export interface TaskComment {
+    id: TaskCommentId;
+    taskId: TaskId;
+    content: string;
+    author: string;
+    createdAt: string;
+}
+export interface TaskSummary {
+    id: TaskId;
+    title: string;
+    status: TaskStatus;
+    priority: TaskPriority;
+    projectId: ProjectId | null;
+    projectName: string | null;
+    labels: string[];
+}
+export interface TaskDetail extends TaskSummary {
+    description: string | null;
+    comments: TaskComment[];
+}
+export type TaskSortField = "priority" | "dueDate" | "createdAt" | "updatedAt" | "title";
+export type TaskSortDirection = "asc" | "desc";
+export interface TaskFilter {
+    projectId?: ProjectId | null;
+    statuses?: TaskStatus[];
+    priorities?: TaskPriority[];
+    query?: string;
+    from?: string;
+    to?: string;
+    updatedFrom?: string;
+    updatedTo?: string;
+    label?: string;
+    overdue?: boolean;
+    today?: boolean;
+    sort?: TaskSortField;
+    sortDirection?: TaskSortDirection;
+    timezone?: string;
+}

package/dist/domain/task.js

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

package/dist/extension/current-task-context.d.ts

@@ -0,0 +1,26 @@
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { TaskDetail, TaskId } from "../domain/task";
+import { type TaskSessionStore } from "../services/task-session-store";
+import { type ToduTaskServiceRuntime } from "../services/todu/default-task-service";
+declare const CURRENT_TASK_STATUS_KEY = "todu-current-task";
+declare const CURRENT_TASK_WIDGET_KEY = "todu-current-task";
+export interface CurrentTaskContextState {
+    currentTaskId: TaskId | null;
+    currentTask: TaskDetail | null;
+}
+export interface CurrentTaskContextController {
+    getState(): CurrentTaskContextState;
+    restoreFromBranch(ctx: ExtensionContext): Promise<void>;
+    setCurrentTask(ctx: ExtensionContext, task: TaskDetail | null): Promise<void>;
+    clearCurrentTask(ctx: ExtensionContext): Promise<void>;
+    handleDataChanged(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export interface CreateCurrentTaskContextControllerDependencies {
+    runtime?: Pick<ToduTaskServiceRuntime, "client" | "ensureConnected">;
+    taskSessionStore?: TaskSessionStore;
+}
+declare const createCurrentTaskContextController: (pi: Pick<ExtensionAPI, "appendEntry">, dependencies?: CreateCurrentTaskContextControllerDependencies) => CurrentTaskContextController;
+declare const getDefaultCurrentTaskContextController: (pi?: Pick<ExtensionAPI, "appendEntry">) => CurrentTaskContextController;
+declare const resetDefaultCurrentTaskContextController: () => Promise<void>;
+export { createCurrentTaskContextController, CURRENT_TASK_STATUS_KEY, CURRENT_TASK_WIDGET_KEY, getDefaultCurrentTaskContextController, resetDefaultCurrentTaskContextController, };

package/dist/extension/current-task-context.js

@@ -0,0 +1,140 @@
+import { createInMemoryTaskSessionStore, persistTaskSessionState, restoreTaskSessionState, } from "../services/task-session-store.js";
+import { getDefaultToduTaskServiceRuntime, } from "../services/todu/default-task-service.js";
+import { createCurrentTaskWidgetViewModel } from "../ui/widgets/current-task-widget.js";
+const CURRENT_TASK_STATUS_KEY = "todu-current-task";
+const CURRENT_TASK_WIDGET_KEY = "todu-current-task";
+const createCurrentTaskContextController = (pi, dependencies = {}) => {
+    const runtime = dependencies.runtime ?? getDefaultToduTaskServiceRuntime();
+    const taskSessionStore = dependencies.taskSessionStore ?? createInMemoryTaskSessionStore();
+    let currentTask = null;
+    let activeContext = null;
+    let dataChangedSubscription = null;
+    let subscribePromise = null;
+    const updateAmbientUi = (ctx) => {
+        if (!ctx.hasUI) {
+            return;
+        }
+        const { currentTaskId } = taskSessionStore.getState();
+        if (!currentTaskId && !currentTask) {
+            ctx.ui.setStatus(CURRENT_TASK_STATUS_KEY, undefined);
+            ctx.ui.setWidget(CURRENT_TASK_WIDGET_KEY, undefined);
+            return;
+        }
+        const viewModel = createCurrentTaskWidgetViewModel(currentTask, currentTaskId);
+        ctx.ui.setWidget(CURRENT_TASK_WIDGET_KEY, [viewModel.title, viewModel.subtitle]);
+        if (currentTask) {
+            ctx.ui.setStatus(CURRENT_TASK_STATUS_KEY, `${currentTask.id} • ${currentTask.title}`);
+            return;
+        }
+        ctx.ui.setStatus(CURRENT_TASK_STATUS_KEY, currentTaskId ?? undefined);
+    };
+    const ensureDataChangedSubscription = async () => {
+        if (dataChangedSubscription) {
+            return;
+        }
+        if (subscribePromise) {
+            await subscribePromise;
+            return;
+        }
+        subscribePromise = runtime.client
+            .on("data.changed", () => {
+            void controller.handleDataChanged();
+        })
+            .then((subscription) => {
+            dataChangedSubscription = subscription;
+            return subscription;
+        })
+            .finally(() => {
+            subscribePromise = null;
+        });
+        await subscribePromise;
+    };
+    const refreshCurrentTask = async (ctx) => {
+        const { currentTaskId } = taskSessionStore.getState();
+        if (!currentTaskId) {
+            currentTask = null;
+            updateAmbientUi(ctx);
+            return;
+        }
+        try {
+            const taskService = await runtime.ensureConnected();
+            const task = await taskService.getTask(currentTaskId);
+            if (!task || isTerminalCurrentTaskStatus(task.status)) {
+                currentTask = null;
+                taskSessionStore.clearCurrentTask();
+                persistTaskSessionState(pi.appendEntry, taskSessionStore.getState());
+                updateAmbientUi(ctx);
+                return;
+            }
+            currentTask = task;
+            updateAmbientUi(ctx);
+        }
+        catch {
+            currentTask = null;
+            updateAmbientUi(ctx);
+        }
+    };
+    const controller = {
+        getState: () => ({
+            currentTaskId: taskSessionStore.getState().currentTaskId,
+            currentTask,
+        }),
+        async restoreFromBranch(ctx) {
+            activeContext = ctx;
+            taskSessionStore.replaceState(restoreTaskSessionState(ctx.sessionManager.getBranch()));
+            if (taskSessionStore.getState().currentTaskId) {
+                await ensureDataChangedSubscription();
+            }
+            await refreshCurrentTask(ctx);
+        },
+        async setCurrentTask(ctx, task) {
+            activeContext = ctx;
+            currentTask = task;
+            if (task) {
+                taskSessionStore.setCurrentTask(task.id);
+                await ensureDataChangedSubscription();
+            }
+            else {
+                taskSessionStore.clearCurrentTask();
+            }
+            persistTaskSessionState(pi.appendEntry, taskSessionStore.getState());
+            updateAmbientUi(ctx);
+        },
+        async clearCurrentTask(ctx) {
+            await controller.setCurrentTask(ctx, null);
+        },
+        async handleDataChanged() {
+            if (!activeContext) {
+                return;
+            }
+            await refreshCurrentTask(activeContext);
+        },
+        async dispose() {
+            dataChangedSubscription?.unsubscribe();
+            dataChangedSubscription = null;
+            subscribePromise = null;
+            activeContext = null;
+            currentTask = null;
+        },
+    };
+    return controller;
+};
+let defaultCurrentTaskContextController = null;
+const getDefaultCurrentTaskContextController = (pi) => {
+    if (!defaultCurrentTaskContextController) {
+        if (!pi) {
+            throw new Error("Current task context controller has not been initialized");
+        }
+        defaultCurrentTaskContextController = createCurrentTaskContextController(pi);
+    }
+    return defaultCurrentTaskContextController;
+};
+const isTerminalCurrentTaskStatus = (status) => status === "done" || status === "cancelled";
+const resetDefaultCurrentTaskContextController = async () => {
+    if (!defaultCurrentTaskContextController) {
+        return;
+    }
+    await defaultCurrentTaskContextController.dispose();
+    defaultCurrentTaskContextController = null;
+};
+export { createCurrentTaskContextController, CURRENT_TASK_STATUS_KEY, CURRENT_TASK_WIDGET_KEY, getDefaultCurrentTaskContextController, resetDefaultCurrentTaskContextController, };

package/dist/extension/register-commands.d.ts

@@ -0,0 +1,114 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { ProjectSummary, TaskDetail, TaskFilter, TaskId, TaskPriority, TaskStatus, TaskSummary } from "../domain/task";
+import type { HabitService } from "../services/habit-service";
+import type { TaskService } from "../services/task-service";
+import type { TaskBrowseFilterState } from "../services/task-browse-filter-store";
+import { type TaskDetailActionKind } from "../ui/components/task-detail";
+import { type TaskBrowseFilterContextController } from "./task-browse-filter-context";
+declare const DEFAULT_TASK_BROWSE_FILTER_STATE: TaskBrowseFilterState;
+interface LoadedTasksResult {
+    status: "loaded";
+    tasks: TaskSummary[];
+}
+interface CancelledTasksResult {
+    status: "cancelled";
+}
+interface ErrorTasksResult {
+    status: "error";
+    message: string;
+}
+type TaskBrowseLoadResult = LoadedTasksResult | CancelledTasksResult | ErrorTasksResult;
+type SelectTaskProjectResult = {
+    status: "selected";
+    project: ProjectSummary;
+} | {
+    status: "cancelled";
+} | {
+    status: "unavailable";
+};
+interface TaskAuthoringDraft {
+    title: string;
+    description: string | null;
+    projectName: string;
+}
+interface TaskAuthoringResult {
+    title: string;
+    description: string | null;
+}
+type EditTaskBrowseFiltersResult = {
+    status: "saved";
+    filterState: TaskBrowseFilterState;
+} | {
+    status: "cancelled";
+};
+type TaskBrowseViewResult = {
+    status: "selected";
+    taskId: TaskId;
+} | {
+    status: "change-filters";
+} | {
+    status: "clear-filters";
+} | {
+    status: "closed";
+};
+type EmptyTaskBrowseAction = "change-filters" | "clear-filters" | "close";
+export interface ResolveDefaultProjectResult {
+    projectId: string;
+    projectName: string;
+}
+export interface RegisterCommandDependencies {
+    getTaskService?: () => Promise<TaskService>;
+    getHabitService?: () => Promise<HabitService>;
+    resolveDefaultProject?: (taskService: TaskService) => Promise<ResolveDefaultProjectResult | null>;
+    getCurrentTaskId?: () => TaskId | null;
+    clearCurrentTask?: (ctx: ExtensionCommandContext) => Promise<void>;
+    promptTaskTitle?: (ctx: ExtensionCommandContext) => Promise<string | null>;
+    selectTaskProject?: (ctx: ExtensionCommandContext, taskService: TaskService) => Promise<SelectTaskProjectResult>;
+    editTaskExplanation?: (ctx: ExtensionCommandContext, taskTitle: string) => Promise<string | undefined>;
+    confirmTaskAuthoring?: (ctx: ExtensionCommandContext, draft: TaskAuthoringDraft) => Promise<boolean>;
+    requestTaskAuthoringAssistance?: (ctx: ExtensionCommandContext, draft: TaskAuthoringDraft) => Promise<TaskAuthoringResult | null>;
+    taskBrowseFilterController?: TaskBrowseFilterContextController;
+    editTaskBrowseFilters?: (ctx: ExtensionCommandContext, taskService: TaskService, currentState: TaskBrowseFilterState) => Promise<EditTaskBrowseFiltersResult>;
+    loadTasks?: (ctx: ExtensionCommandContext, taskService: TaskService, filter: TaskFilter, filterSummary: string) => Promise<TaskBrowseLoadResult>;
+    showTaskBrowseView?: (ctx: ExtensionCommandContext, tasks: TaskSummary[], filterState: TaskBrowseFilterState) => Promise<TaskBrowseViewResult>;
+    showEmptyState?: (ctx: ExtensionCommandContext, filterState: TaskBrowseFilterState) => Promise<EmptyTaskBrowseAction>;
+    setCurrentTask?: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<void>;
+    showTaskDetailView?: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<TaskDetailActionKind | null>;
+    selectTaskStatus?: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<TaskStatus | null>;
+    selectTaskPriority?: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<TaskPriority | null>;
+    editTaskComment?: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<string | null>;
+    openTaskDetail?: (ctx: ExtensionCommandContext, taskService: TaskService, taskId: TaskId) => Promise<void>;
+}
+declare const createTasksCommandHandler: (dependencies?: RegisterCommandDependencies) => ((args: string, ctx: ExtensionCommandContext) => Promise<void>);
+declare const createTaskCommandHandler: (dependencies?: RegisterCommandDependencies) => ((args: string, ctx: ExtensionCommandContext) => Promise<void>);
+declare const createTaskClearCommandHandler: (dependencies?: RegisterCommandDependencies) => ((args: string, ctx: ExtensionCommandContext) => Promise<void>);
+declare const createTaskNewCommandHandler: (dependencies?: RegisterCommandDependencies) => ((args: string, ctx: ExtensionCommandContext) => Promise<void>);
+declare const createHabitsCommandHandler: (dependencies?: RegisterCommandDependencies) => ((args: string, ctx: ExtensionCommandContext) => Promise<void>);
+declare const registerCommands: (pi: ExtensionAPI, dependencies?: RegisterCommandDependencies) => void;
+declare const loadTasksWithLoader: (ctx: ExtensionCommandContext, taskService: TaskService, filter: TaskFilter, filterSummary: string) => Promise<TaskBrowseLoadResult>;
+declare const showTaskBrowseFilterMode: (ctx: ExtensionCommandContext, taskService: TaskService, currentState: TaskBrowseFilterState) => Promise<EditTaskBrowseFiltersResult>;
+declare const selectTaskBrowseViewAction: (ctx: ExtensionCommandContext, tasks: TaskSummary[], filterState: TaskBrowseFilterState) => Promise<TaskBrowseViewResult>;
+declare const showEmptyTasksState: (ctx: ExtensionCommandContext, filterState: TaskBrowseFilterState) => Promise<EmptyTaskBrowseAction>;
+declare const createSavedTaskBrowseFilterState: (overrides?: Partial<TaskBrowseFilterState>) => TaskBrowseFilterState;
+declare const createTaskFilterFromBrowseState: (filterState: TaskBrowseFilterState) => TaskFilter;
+declare const formatTaskBrowseFilterSummary: (filterState: TaskBrowseFilterState) => string;
+interface OpenTaskDetailDependencies {
+    setCurrentTask: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<void>;
+    showTaskDetailView?: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<TaskDetailActionKind | null>;
+    selectTaskStatus?: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<TaskStatus | null>;
+    selectTaskPriority?: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<TaskPriority | null>;
+    editTaskComment?: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<string | null>;
+}
+declare const openSelectedTaskDetail: (ctx: ExtensionCommandContext, taskService: TaskService, taskId: TaskId, dependencies: OpenTaskDetailDependencies) => Promise<void>;
+declare const openTaskDetailHub: (ctx: ExtensionCommandContext, taskService: TaskService, taskId: TaskId, dependencies: OpenTaskDetailDependencies) => Promise<void>;
+declare const selectTaskDetailAction: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<TaskDetailActionKind | null>;
+declare const selectTaskStatusFromList: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<TaskStatus | null>;
+declare const selectTaskPriorityFromList: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<TaskPriority | null>;
+declare const editTaskComment: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<string | null>;
+declare const syncCurrentTaskIfFocused: (ctx: ExtensionCommandContext, task: TaskDetail, setCurrentTask: (ctx: ExtensionCommandContext, task: TaskDetail) => Promise<void>) => Promise<void>;
+declare const resolveRequestedTaskId: (args: string, currentTaskId: TaskId | null) => TaskId | null;
+declare const resolveDefaultTaskBrowseFilterState: (taskService: TaskService, resolveDefaultProject: (taskService: TaskService) => Promise<ResolveDefaultProjectResult | null>) => Promise<TaskBrowseFilterState>;
+declare const resolveDefaultProjectFromRepo: (taskService: TaskService, repoContextService?: import("../services/repo-context").RepoContextService) => Promise<ResolveDefaultProjectResult | null>;
+declare const matchProjectByName: (projects: ProjectSummary[], candidateName: string) => ProjectSummary | null;
+declare const formatTasksCommandError: (error: unknown, prefix: string) => string;
+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, };