@tashks/core 0.1.4 → 0.2.3

package/dist/src/repository.js

@@ -6,8 +6,8 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
 import YAML from "yaml";
-import { Task as TaskSchema, TaskCreateInput as TaskCreateInputSchema, TaskPatch as TaskPatchSchema, WorkLogCreateInput as WorkLogCreateInputSchema, WorkLogEntry as WorkLogEntrySchema, WorkLogPatch as WorkLogPatchSchema, } from "./schema.js";
-import { byUpdatedDescThenTitle, isDueBefore, isStalerThan, isUnblocked, } from "./query.js";
+import { Task as TaskSchema, TaskCreateInput as TaskCreateInputSchema, TaskPatch as TaskPatchSchema, WorkLogCreateInput as WorkLogCreateInputSchema, WorkLogEntry as WorkLogEntrySchema, WorkLogPatch as WorkLogPatchSchema, Project as ProjectSchema, ProjectCreateInput as ProjectCreateInputSchema, ProjectPatch as ProjectPatchSchema, } from "./schema.js";
+import { byUpdatedDescThenTitle, isDueBefore, isStalerThan, isUnblocked, listContexts as listContextsFromTasks, } from "./query.js";
 import { generateTaskId } from "./id.js";
 import { runCreateHooks, runModifyHooks, runNonMutatingHooks, } from "./hooks.js";
 import { buildCompletionRecurrenceTask, buildNextClockRecurrenceTask, isClockRecurrenceDue, } from "./recurrence.js";
@@ -22,11 +22,17 @@ const decodeWorkLogCreateInput = Schema.decodeUnknownSync(WorkLogCreateInputSche
 const decodeWorkLogEntry = Schema.decodeUnknownSync(WorkLogEntrySchema);
 const decodeWorkLogEntryEither = Schema.decodeUnknownEither(WorkLogEntrySchema);
 const decodeWorkLogPatch = Schema.decodeUnknownSync(WorkLogPatchSchema);
+const decodeProject = Schema.decodeUnknownSync(ProjectSchema);
+const decodeProjectEither = Schema.decodeUnknownEither(ProjectSchema);
+const decodeProjectCreateInput = Schema.decodeUnknownSync(ProjectCreateInputSchema);
+const decodeProjectPatch = Schema.decodeUnknownSync(ProjectPatchSchema);
 const toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
 const taskFilePath = (dataDir, id) => join(dataDir, "tasks", `${id}.yaml`);
 const legacyTaskFilePath = (dataDir, id) => join(dataDir, "tasks", `${id}.yml`);
 const workLogFilePath = (dataDir, id) => join(dataDir, "work-log", `${id}.yaml`);
 const legacyWorkLogFilePath = (dataDir, id) => join(dataDir, "work-log", `${id}.yml`);
+const projectFilePath = (dataDir, id) => join(dataDir, "projects", `${id}.yaml`);
+const legacyProjectFilePath = (dataDir, id) => join(dataDir, "projects", `${id}.yml`);
 const dailyHighlightFilePath = (dataDir) => join(dataDir, "daily-highlight.yaml");
 const ensureTasksDir = (dataDir) => Effect.tryPromise({
     try: () => mkdir(join(dataDir, "tasks"), { recursive: true }),
@@ -36,6 +42,10 @@ const ensureWorkLogDir = (dataDir) => Effect.tryPromise({
     try: () => mkdir(join(dataDir, "work-log"), { recursive: true }),
     catch: (error) => `TaskRepository failed to create work-log directory: ${toErrorMessage(error)}`,
 });
+const ensureProjectsDir = (dataDir) => Effect.tryPromise({
+    try: () => mkdir(join(dataDir, "projects"), { recursive: true }),
+    catch: (error) => `TaskRepository failed to create projects directory: ${toErrorMessage(error)}`,
+});
 const writeDailyHighlightToDisk = (dataDir, id) => Effect.tryPromise({
     try: async () => {
         await mkdir(dataDir, { recursive: true });
@@ -214,6 +224,75 @@ const generateNextClockRecurrence = (dataDir, existing, generatedAt) => Effect.g
         : null;
     return { nextTask: result.nextTask, replacedId };
 });
+const readProjectByIdFromDisk = (dataDir, id) => Effect.tryPromise({
+    try: async () => {
+        const candidatePaths = [
+            projectFilePath(dataDir, id),
+            legacyProjectFilePath(dataDir, id),
+        ];
+        for (const path of candidatePaths) {
+            const source = await readFile(path, "utf8").catch((error) => {
+                if (error !== null &&
+                    typeof error === "object" &&
+                    "code" in error &&
+                    error.code === "ENOENT") {
+                    return null;
+                }
+                throw error;
+            });
+            if (source === null) {
+                continue;
+            }
+            const parsed = YAML.parse(source);
+            const project = parseProjectRecord(parsed);
+            if (project === null) {
+                throw new Error(`Invalid project record in ${path}`);
+            }
+            return { path, project };
+        }
+        throw new Error(`Project not found: ${id}`);
+    },
+    catch: (error) => `TaskRepository failed to read project ${id}: ${toErrorMessage(error)}`,
+});
+const readProjectsFromDisk = (dataDir) => Effect.tryPromise({
+    try: async () => {
+        const projectsDir = join(dataDir, "projects");
+        const entries = await readdir(projectsDir, { withFileTypes: true }).catch((error) => {
+            if (error !== null &&
+                typeof error === "object" &&
+                "code" in error &&
+                error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        });
+        const projectFiles = entries
+            .filter((entry) => entry.isFile() &&
+            (entry.name.endsWith(".yaml") || entry.name.endsWith(".yml")))
+            .map((entry) => entry.name);
+        const projects = [];
+        for (const fileName of projectFiles) {
+            const filePath = join(projectsDir, fileName);
+            const source = await readFile(filePath, "utf8");
+            const parsed = YAML.parse(source);
+            const project = parseProjectRecord(parsed);
+            if (project === null) {
+                throw new Error(`Invalid project record in ${filePath}`);
+            }
+            projects.push(project);
+        }
+        return projects;
+    },
+    catch: (error) => `TaskRepository.listProjects failed to read project files: ${toErrorMessage(error)}`,
+});
+const writeProjectToDisk = (path, project) => Effect.tryPromise({
+    try: () => writeFile(path, YAML.stringify(project), "utf8"),
+    catch: (error) => `TaskRepository failed to write project ${project.id}: ${toErrorMessage(error)}`,
+});
+const deleteProjectFromDisk = (path, id) => Effect.tryPromise({
+    try: () => rm(path),
+    catch: (error) => `TaskRepository failed to delete project ${id}: ${toErrorMessage(error)}`,
+});
 const byStartedAtDescThenId = (a, b) => {
     const byStartedAtDesc = b.started_at.localeCompare(a.started_at);
     if (byStartedAtDesc !== 0) {
@@ -223,6 +302,9 @@ const byStartedAtDescThenId = (a, b) => {
 };
 export const applyListTaskFilters = (tasks, filters = {}) => {
     const dueBeforePredicate = filters.due_before !== undefined ? isDueBefore(filters.due_before) : null;
+    const stalePredicate = filters.stale_days !== undefined
+        ? isStalerThan(filters.stale_days, todayIso())
+        : null;
     return tasks
         .filter((task) => {
         if (filters.status !== undefined && task.status !== filters.status) {
@@ -231,7 +313,7 @@ export const applyListTaskFilters = (tasks, filters = {}) => {
         if (filters.area !== undefined && task.area !== filters.area) {
             return false;
         }
-        if (filters.project !== undefined && task.project !== filters.project) {
+        if (filters.project !== undefined && !task.projects.includes(filters.project)) {
             return false;
         }
         if (filters.tags !== undefined &&
@@ -254,10 +336,48 @@ export const applyListTaskFilters = (tasks, filters = {}) => {
         if (filters.unblocked_only === true && !isUnblocked(task, tasks)) {
             return false;
         }
+        if (filters.duration_min !== undefined &&
+            (task.estimated_minutes === null || task.estimated_minutes < filters.duration_min)) {
+            return false;
+        }
+        if (filters.duration_max !== undefined &&
+            (task.estimated_minutes === null || task.estimated_minutes > filters.duration_max)) {
+            return false;
+        }
+        if (filters.context !== undefined &&
+            task.context !== filters.context) {
+            return false;
+        }
+        if (filters.include_templates !== true &&
+            task.is_template === true) {
+            return false;
+        }
+        if (stalePredicate !== null && !stalePredicate(task)) {
+            return false;
+        }
         return true;
     })
         .sort(byUpdatedDescThenTitle);
 };
+export const applyListProjectFilters = (projects, filters = {}) => {
+    return projects
+        .filter((project) => {
+        if (filters.status !== undefined && project.status !== filters.status) {
+            return false;
+        }
+        if (filters.area !== undefined && project.area !== filters.area) {
+            return false;
+        }
+        return true;
+    })
+        .sort((a, b) => {
+        const byUpdatedDesc = b.updated.localeCompare(a.updated);
+        if (byUpdatedDesc !== 0) {
+            return byUpdatedDesc;
+        }
+        return a.title.localeCompare(b.title);
+    });
+};
 export class TaskRepository extends Context.Tag("TaskRepository")() {
 }
 const defaultDataDir = () => {
@@ -266,6 +386,50 @@ const defaultDataDir = () => {
         ? `${home}/.local/share/tashks`
         : ".local/share/tashks";
 };
+export const buildInstanceFromTemplate = (template, overrides) => {
+    const now = new Date().toISOString().slice(0, 10);
+    return decodeTask({
+        id: generateTaskId(overrides?.title ?? template.title),
+        title: overrides?.title ?? template.title,
+        status: overrides?.status ?? "backlog",
+        area: template.area,
+        projects: overrides?.projects
+            ? [...overrides.projects]
+            : [...template.projects],
+        tags: [...template.tags],
+        created: now,
+        updated: now,
+        urgency: template.urgency,
+        energy: template.energy,
+        due: overrides?.due ?? null,
+        context: template.context,
+        subtasks: template.subtasks.map((s) => ({ text: s.text, done: false })),
+        blocked_by: [],
+        estimated_minutes: template.estimated_minutes,
+        actual_minutes: null,
+        completed_at: null,
+        last_surfaced: null,
+        defer_until: overrides?.defer_until ?? null,
+        nudge_count: 0,
+        recurrence: null,
+        recurrence_trigger: "clock",
+        recurrence_strategy: "replace",
+        recurrence_last_generated: null,
+        related: [...template.related],
+        is_template: false,
+        from_template: template.id,
+    });
+};
+const validateNoTemplateRefs = (relatedIds, allTasks) => {
+    const templateIds = allTasks
+        .filter((t) => t.is_template)
+        .map((t) => t.id);
+    const badRefs = relatedIds.filter((id) => templateIds.includes(id));
+    if (badRefs.length > 0) {
+        return Effect.fail(`Cannot reference template(s) in related: ${badRefs.join(", ")}`);
+    }
+    return Effect.void;
+};
 const makeTaskRepositoryLive = (options = {}) => {
     const dataDir = options.dataDir ?? defaultDataDir();
     const hookRuntimeOptions = {
@@ -279,6 +443,10 @@ const makeTaskRepositoryLive = (options = {}) => {
         createTask: (input) => Effect.gen(function* () {
             yield* ensureTasksDir(dataDir);
             const created = createTaskFromInput(input);
+            if (created.related.length > 0) {
+                const allTasks = yield* readTasksFromDisk(dataDir);
+                yield* validateNoTemplateRefs(created.related, allTasks);
+            }
             const taskFromHooks = yield* runCreateHooks(created, hookRuntimeOptions);
             yield* writeTaskToDisk(taskFilePath(dataDir, taskFromHooks.id), taskFromHooks);
             return taskFromHooks;
@@ -286,6 +454,11 @@ const makeTaskRepositoryLive = (options = {}) => {
         updateTask: (id, patch) => Effect.gen(function* () {
             const existing = yield* readTaskByIdFromDisk(dataDir, id);
             const updated = applyTaskPatch(existing.task, patch);
+            if (patch.related !== undefined &&
+                updated.related.length > 0) {
+                const allTasks = yield* readTasksFromDisk(dataDir);
+                yield* validateNoTemplateRefs(updated.related, allTasks);
+            }
             const taskFromHooks = yield* runModifyHooks(existing.task, updated, hookRuntimeOptions);
             yield* writeTaskToDisk(existing.path, taskFromHooks);
             return taskFromHooks;
@@ -319,7 +492,8 @@ const makeTaskRepositoryLive = (options = {}) => {
             const recurringTasks = tasks.filter((task) => task.recurrence !== null &&
                 task.recurrence_trigger === "clock" &&
                 task.status !== "done" &&
-                task.status !== "dropped");
+                task.status !== "dropped" &&
+                !task.is_template);
             const created = [];
             const replaced = [];
             for (const task of recurringTasks) {
@@ -347,6 +521,31 @@ const makeTaskRepositoryLive = (options = {}) => {
             yield* writeDailyHighlightToDisk(dataDir, id);
             return existing.task;
         }),
+        getDailyHighlight: () => Effect.gen(function* () {
+            const source = yield* Effect.tryPromise({
+                try: () => readFile(dailyHighlightFilePath(dataDir), "utf8").catch((error) => {
+                    if (error !== null &&
+                        typeof error === "object" &&
+                        "code" in error &&
+                        error.code === "ENOENT") {
+                        return null;
+                    }
+                    throw error;
+                }),
+                catch: (error) => `TaskRepository failed to read daily highlight: ${toErrorMessage(error)}`,
+            });
+            if (source === null || source.trim().length === 0) {
+                return null;
+            }
+            const parsed = YAML.parse(source);
+            if (parsed === null ||
+                typeof parsed !== "object" ||
+                typeof parsed.id !== "string") {
+                return null;
+            }
+            const result = yield* Effect.catchAll(Effect.map(readTaskByIdFromDisk(dataDir, parsed.id), (r) => r.task), () => Effect.succeed(null));
+            return result;
+        }),
         listStale: (days) => Effect.map(readTasksFromDisk(dataDir), (tasks) => {
             const stalePredicate = isStalerThan(days, todayIso());
             return tasks
@@ -392,12 +591,77 @@ const makeTaskRepositoryLive = (options = {}) => {
             yield* writeWorkLogEntryToDisk(workLogFilePath(dataDir, entry.id), entry);
             return entry;
         }),
+        listProjects: (filters) => Effect.map(readProjectsFromDisk(dataDir), (projects) => applyListProjectFilters(projects, filters)),
+        getProject: (id) => Effect.map(readProjectByIdFromDisk(dataDir, id), (result) => result.project),
+        createProject: (input) => Effect.gen(function* () {
+            yield* ensureProjectsDir(dataDir);
+            const created = createProjectFromInput(input);
+            yield* writeProjectToDisk(projectFilePath(dataDir, created.id), created);
+            return created;
+        }),
+        updateProject: (id, patch) => Effect.gen(function* () {
+            const existing = yield* readProjectByIdFromDisk(dataDir, id);
+            const updated = applyProjectPatch(existing.project, patch);
+            yield* writeProjectToDisk(existing.path, updated);
+            return updated;
+        }),
+        deleteProject: (id) => Effect.gen(function* () {
+            const existing = yield* readProjectByIdFromDisk(dataDir, id);
+            yield* deleteProjectFromDisk(existing.path, id);
+            return { deleted: true };
+        }),
+        importProject: (project) => Effect.gen(function* () {
+            yield* ensureProjectsDir(dataDir);
+            yield* writeProjectToDisk(projectFilePath(dataDir, project.id), project);
+            return project;
+        }),
+        listContexts: () => Effect.map(readTasksFromDisk(dataDir), (tasks) => listContextsFromTasks(tasks)),
+        getRelated: (id) => Effect.gen(function* () {
+            const existing = yield* readTaskByIdFromDisk(dataDir, id);
+            const allTasks = yield* readTasksFromDisk(dataDir);
+            const targetRelated = new Set(existing.task.related);
+            return allTasks.filter((t) => t.id !== id &&
+                (targetRelated.has(t.id) || t.related.includes(id)));
+        }),
+        instantiateTemplate: (templateId, overrides) => Effect.gen(function* () {
+            const existing = yield* readTaskByIdFromDisk(dataDir, templateId);
+            const template = existing.task;
+            if (!template.is_template) {
+                return yield* Effect.fail(`Task ${templateId} is not a template`);
+            }
+            const instance = buildInstanceFromTemplate(template, overrides);
+            const taskFromHooks = yield* runCreateHooks(instance, hookRuntimeOptions);
+            yield* ensureTasksDir(dataDir);
+            yield* writeTaskToDisk(taskFilePath(dataDir, taskFromHooks.id), taskFromHooks);
+            return taskFromHooks;
+        }),
     };
 };
 export const TaskRepositoryLive = (options = {}) => Layer.succeed(TaskRepository, makeTaskRepositoryLive(options));
 export const todayIso = () => new Date().toISOString().slice(0, 10);
+const migrateTaskRecord = (record) => {
+    if (record === null || typeof record !== "object") {
+        return record;
+    }
+    let rec = record;
+    if ("project" in rec && !("projects" in rec)) {
+        const { project, ...rest } = rec;
+        rec = {
+            ...rest,
+            projects: typeof project === "string" ? [project] : [],
+        };
+    }
+    if (!("related" in rec))
+        rec.related = [];
+    if (!("is_template" in rec))
+        rec.is_template = false;
+    if (!("from_template" in rec))
+        rec.from_template = null;
+    return rec;
+};
 export const parseTaskRecord = (record) => {
-    const result = decodeTaskEither(record);
+    const migrated = migrateTaskRecord(record);
+    const result = decodeTaskEither(migrated);
     return Either.isRight(result) ? result.right : null;
 };
 export const parseWorkLogRecord = (record) => {
@@ -414,9 +678,10 @@ export const createTaskFromInput = (input) => {
 export const applyTaskPatch = (task, patch) => {
     const normalizedTask = decodeTask(task);
     const normalizedPatch = decodeTaskPatch(patch);
+    const { from_template: _stripped, ...safePatch } = normalizedPatch;
     return decodeTask({
         ...normalizedTask,
-        ...normalizedPatch,
+        ...safePatch,
         updated: todayIso(),
     });
 };
@@ -428,3 +693,44 @@ export const applyWorkLogPatch = (entry, patch) => {
         ...normalizedPatch,
     });
 };
+export const parseProjectRecord = (record) => {
+    const result = decodeProjectEither(record);
+    return Either.isRight(result) ? result.right : null;
+};
+export const createProjectFromInput = (input) => {
+    const normalizedInput = decodeProjectCreateInput(input);
+    return decodeProject({
+        ...normalizedInput,
+        id: generateTaskId(normalizedInput.title),
+    });
+};
+export const promoteSubtask = (repository, taskId, subtaskIndex) => Effect.gen(function* () {
+    const parent = yield* repository.getTask(taskId);
+    if (parent.is_template) {
+        return yield* Effect.fail("Cannot promote subtasks on a template. Instantiate the template first.");
+    }
+    if (subtaskIndex < 0 || subtaskIndex >= parent.subtasks.length) {
+        return yield* Effect.fail(`Subtask index ${subtaskIndex} is out of range (0..${parent.subtasks.length - 1})`);
+    }
+    const subtask = parent.subtasks[subtaskIndex];
+    const newTask = yield* repository.createTask({
+        title: subtask.text,
+        projects: [...parent.projects],
+        area: parent.area,
+        tags: [...parent.tags],
+        status: subtask.done ? "done" : "backlog",
+        blocked_by: [parent.id],
+    });
+    const updatedSubtasks = parent.subtasks.filter((_, i) => i !== subtaskIndex);
+    yield* repository.updateTask(taskId, { subtasks: updatedSubtasks });
+    return newTask;
+});
+export const applyProjectPatch = (project, patch) => {
+    const normalizedProject = decodeProject(project);
+    const normalizedPatch = decodeProjectPatch(patch);
+    return decodeProject({
+        ...normalizedProject,
+        ...normalizedPatch,
+        updated: todayIso(),
+    });
+};

package/dist/src/schema.d.ts

@@ -1,32 +1,32 @@
 import * as Schema from "effect/Schema";
-export declare const TaskStatus: Schema.Literal<["active", "backlog", "blocked", "done", "dropped", "on-hold"]>;
+export declare const TaskStatus: typeof Schema.String;
 export type TaskStatus = Schema.Schema.Type<typeof TaskStatus>;
-export declare const TaskArea: Schema.Literal<["health", "infrastructure", "work", "personal", "blog", "code", "home", "side-projects"]>;
+export declare const TaskArea: typeof Schema.String;
 export type TaskArea = Schema.Schema.Type<typeof TaskArea>;
-export declare const TaskUrgency: Schema.Literal<["low", "medium", "high", "urgent", "critical"]>;
+export declare const TaskUrgency: typeof Schema.String;
 export type TaskUrgency = Schema.Schema.Type<typeof TaskUrgency>;
-export declare const TaskEnergy: Schema.Literal<["low", "medium", "high"]>;
+export declare const TaskEnergy: typeof Schema.String;
 export type TaskEnergy = Schema.Schema.Type<typeof TaskEnergy>;
 export declare const Subtask: Schema.Struct<{
     text: typeof Schema.String;
     done: typeof Schema.Boolean;
 }>;
 export type Subtask = Schema.Schema.Type<typeof Subtask>;
-export declare const TaskRecurrenceTrigger: Schema.Literal<["clock", "completion"]>;
+export declare const TaskRecurrenceTrigger: typeof Schema.String;
 export type TaskRecurrenceTrigger = Schema.Schema.Type<typeof TaskRecurrenceTrigger>;
-export declare const TaskRecurrenceStrategy: Schema.Literal<["replace", "accumulate"]>;
+export declare const TaskRecurrenceStrategy: typeof Schema.String;
 export type TaskRecurrenceStrategy = Schema.Schema.Type<typeof TaskRecurrenceStrategy>;
 export declare const Task: Schema.Struct<{
     id: typeof Schema.String;
     title: typeof Schema.String;
-    status: Schema.Literal<["active", "backlog", "blocked", "done", "dropped", "on-hold"]>;
-    area: Schema.Literal<["health", "infrastructure", "work", "personal", "blog", "code", "home", "side-projects"]>;
-    project: Schema.NullOr<typeof Schema.String>;
+    status: typeof Schema.String;
+    area: typeof Schema.String;
+    projects: Schema.Array$<typeof Schema.String>;
     tags: Schema.Array$<typeof Schema.String>;
     created: typeof Schema.String;
     updated: typeof Schema.String;
-    urgency: Schema.Literal<["low", "medium", "high", "urgent", "critical"]>;
-    energy: Schema.Literal<["low", "medium", "high"]>;
+    urgency: typeof Schema.String;
+    energy: typeof Schema.String;
     due: Schema.NullOr<typeof Schema.String>;
     context: typeof Schema.String;
     subtasks: Schema.Array$<Schema.Struct<{
@@ -41,21 +41,24 @@ export declare const Task: Schema.Struct<{
     defer_until: Schema.NullOr<typeof Schema.String>;
     nudge_count: typeof Schema.Number;
     recurrence: Schema.NullOr<typeof Schema.String>;
-    recurrence_trigger: Schema.Literal<["clock", "completion"]>;
-    recurrence_strategy: Schema.Literal<["replace", "accumulate"]>;
+    recurrence_trigger: typeof Schema.String;
+    recurrence_strategy: typeof Schema.String;
     recurrence_last_generated: Schema.NullOr<typeof Schema.String>;
+    related: Schema.Array$<typeof Schema.String>;
+    is_template: typeof Schema.Boolean;
+    from_template: Schema.NullOr<typeof Schema.String>;
 }>;
 export type Task = Schema.Schema.Type<typeof Task>;
 export declare const TaskCreateInput: Schema.Struct<{
     title: typeof Schema.String;
-    status: Schema.optionalWith<Schema.Literal<["active", "backlog", "blocked", "done", "dropped", "on-hold"]>, {
-        default: () => "active";
+    status: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
     }>;
-    area: Schema.optionalWith<Schema.Literal<["health", "infrastructure", "work", "personal", "blog", "code", "home", "side-projects"]>, {
-        default: () => "personal";
+    area: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
     }>;
-    project: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
-        default: () => null;
+    projects: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+        default: () => never[];
     }>;
     tags: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
         default: () => never[];
@@ -66,11 +69,11 @@ export declare const TaskCreateInput: Schema.Struct<{
     updated: Schema.optionalWith<typeof Schema.String, {
         default: () => string;
     }>;
-    urgency: Schema.optionalWith<Schema.Literal<["low", "medium", "high", "urgent", "critical"]>, {
-        default: () => "medium";
+    urgency: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
     }>;
-    energy: Schema.optionalWith<Schema.Literal<["low", "medium", "high"]>, {
-        default: () => "medium";
+    energy: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
     }>;
     due: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
         default: () => null;
@@ -108,15 +111,24 @@ export declare const TaskCreateInput: Schema.Struct<{
     recurrence: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
         default: () => null;
     }>;
-    recurrence_trigger: Schema.optionalWith<Schema.Literal<["clock", "completion"]>, {
-        default: () => "clock";
+    recurrence_trigger: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
     }>;
-    recurrence_strategy: Schema.optionalWith<Schema.Literal<["replace", "accumulate"]>, {
-        default: () => "replace";
+    recurrence_strategy: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
     }>;
     recurrence_last_generated: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
         default: () => null;
     }>;
+    related: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+        default: () => never[];
+    }>;
+    is_template: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => false;
+    }>;
+    from_template: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
+        default: () => null;
+    }>;
 }>;
 export type TaskCreateInput = Schema.Schema.Encoded<typeof TaskCreateInput>;
 export declare const TaskPatch: Schema.Struct<{
@@ -126,13 +138,13 @@ export declare const TaskPatch: Schema.Struct<{
     title: Schema.optionalWith<typeof Schema.String, {
         exact: true;
     }>;
-    status: Schema.optionalWith<Schema.Literal<["active", "backlog", "blocked", "done", "dropped", "on-hold"]>, {
+    status: Schema.optionalWith<typeof Schema.String, {
         exact: true;
     }>;
-    area: Schema.optionalWith<Schema.Literal<["health", "infrastructure", "work", "personal", "blog", "code", "home", "side-projects"]>, {
+    area: Schema.optionalWith<typeof Schema.String, {
         exact: true;
     }>;
-    project: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
+    projects: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
         exact: true;
     }>;
     tags: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
@@ -144,10 +156,10 @@ export declare const TaskPatch: Schema.Struct<{
     updated: Schema.optionalWith<typeof Schema.String, {
         exact: true;
     }>;
-    urgency: Schema.optionalWith<Schema.Literal<["low", "medium", "high", "urgent", "critical"]>, {
+    urgency: Schema.optionalWith<typeof Schema.String, {
         exact: true;
     }>;
-    energy: Schema.optionalWith<Schema.Literal<["low", "medium", "high"]>, {
+    energy: Schema.optionalWith<typeof Schema.String, {
         exact: true;
     }>;
     due: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
@@ -186,17 +198,79 @@ export declare const TaskPatch: Schema.Struct<{
     recurrence: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
         exact: true;
     }>;
-    recurrence_trigger: Schema.optionalWith<Schema.Literal<["clock", "completion"]>, {
+    recurrence_trigger: Schema.optionalWith<typeof Schema.String, {
         exact: true;
     }>;
-    recurrence_strategy: Schema.optionalWith<Schema.Literal<["replace", "accumulate"]>, {
+    recurrence_strategy: Schema.optionalWith<typeof Schema.String, {
         exact: true;
     }>;
     recurrence_last_generated: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
         exact: true;
     }>;
+    related: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+        exact: true;
+    }>;
+    is_template: Schema.optionalWith<typeof Schema.Boolean, {
+        exact: true;
+    }>;
+    from_template: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
+        exact: true;
+    }>;
 }>;
 export type TaskPatch = Schema.Schema.Encoded<typeof TaskPatch>;
+export declare const ProjectStatus: typeof Schema.String;
+export type ProjectStatus = Schema.Schema.Type<typeof ProjectStatus>;
+export declare const Project: Schema.Struct<{
+    id: typeof Schema.String;
+    title: typeof Schema.String;
+    status: typeof Schema.String;
+    area: typeof Schema.String;
+    description: typeof Schema.String;
+    tags: Schema.Array$<typeof Schema.String>;
+    created: typeof Schema.String;
+    updated: typeof Schema.String;
+}>;
+export type Project = Schema.Schema.Type<typeof Project>;
+export declare const ProjectCreateInput: Schema.Struct<{
+    title: typeof Schema.String;
+    status: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
+    }>;
+    area: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
+    }>;
+    description: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
+    }>;
+    tags: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+        default: () => string[];
+    }>;
+    created: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
+    }>;
+    updated: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
+    }>;
+}>;
+export type ProjectCreateInput = Schema.Schema.Encoded<typeof ProjectCreateInput>;
+export declare const ProjectPatch: Schema.Struct<{
+    title: Schema.optionalWith<typeof Schema.String, {
+        exact: true;
+    }>;
+    status: Schema.optionalWith<typeof Schema.String, {
+        exact: true;
+    }>;
+    area: Schema.optionalWith<typeof Schema.String, {
+        exact: true;
+    }>;
+    description: Schema.optionalWith<typeof Schema.String, {
+        exact: true;
+    }>;
+    tags: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+        exact: true;
+    }>;
+}>;
+export type ProjectPatch = Schema.Schema.Encoded<typeof ProjectPatch>;
 export declare const WorkLogEntry: Schema.Struct<{
     id: typeof Schema.String;
     task_id: typeof Schema.String;