@scardis/omnifocus-mcp 0.1.0

package/src/tools/dropTask.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema, TaskDetail } from "../schemas/index.js";
+
+const dropTaskSchema = z.object({
+  id: IdSchema.describe("The task's id.primaryKey"),
+});
+
+export type DropTaskInput = z.infer<typeof dropTaskSchema>;
+
+export async function dropTaskHandler(
+  input: DropTaskInput
+): Promise<z.infer<typeof TaskDetail>> {
+  const raw = await runSnippet("drop_task", { id: input.id });
+  return TaskDetail.parse(raw);
+}
+
+export const dropTaskTool = {
+  name: "drop_task",
+  description: "Mark a task dropped by its stable ID. Returns the updated task detail.",
+  inputSchema: dropTaskSchema,
+  handler: dropTaskHandler,
+} as const;

package/src/tools/editFolder.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { EditFolderInput, FolderDetail } from "../schemas/index.js";
+
+export type EditFolderInputType = z.infer<typeof EditFolderInput>;
+
+export async function editFolderHandler(
+  input: EditFolderInputType
+): Promise<z.infer<typeof FolderDetail>> {
+  const raw = await runSnippet("edit_folder", input);
+  return FolderDetail.parse(raw);
+}
+
+export const editFolderTool = {
+  name: "edit_folder",
+  description: "Rename an existing OmniFocus folder by its ID.",
+  inputSchema: EditFolderInput,
+  handler: editFolderHandler,
+} as const;

package/src/tools/editProject.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { EditProjectInput, ProjectDetail } from "../schemas/index.js";
+
+export type EditProjectInputType = z.infer<typeof EditProjectInput>;
+
+export async function editProjectHandler(
+  input: EditProjectInputType
+): Promise<z.infer<typeof ProjectDetail>> {
+  const raw = await runSnippet("edit_project", input);
+  return ProjectDetail.parse(raw);
+}
+
+export const editProjectTool = {
+  name: "edit_project",
+  description:
+    "Edit an existing project. Only provided fields are changed. Pass null for deferDate, dueDate, or reviewInterval to clear them. When tagIds is provided it replaces the full tag set.",
+  inputSchema: EditProjectInput,
+  handler: editProjectHandler,
+} as const;

package/src/tools/editTag.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { EditTagInput, TagDetail } from "../schemas/index.js";
+
+export type EditTagInputType = z.infer<typeof EditTagInput>;
+
+export async function editTagHandler(
+  input: EditTagInputType
+): Promise<z.infer<typeof TagDetail>> {
+  const raw = await runSnippet("edit_tag", input);
+  return TagDetail.parse(raw);
+}
+
+export const editTagTool = {
+  name: "edit_tag",
+  description:
+    "Edit an existing OmniFocus tag. Provide id plus any combination of name (rename) and status (active/onHold/dropped).",
+  inputSchema: EditTagInput,
+  handler: editTagHandler,
+} as const;

package/src/tools/editTask.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { EditTaskInput, TaskDetail } from "../schemas/index.js";
+
+export type EditTaskInputType = z.infer<typeof EditTaskInput>;
+
+export async function editTaskHandler(
+  input: EditTaskInputType
+): Promise<z.infer<typeof TaskDetail>> {
+  const raw = await runSnippet("edit_task", input);
+  return TaskDetail.parse(raw);
+}
+
+export const editTaskTool = {
+  name: "edit_task",
+  description:
+    "Edit an existing task by its stable ID. Only fields included in the call are changed; omitted fields are left unchanged. When tagIds is provided it replaces the full tag set. Pass null for deferDate, dueDate, or estimatedMinutes to clear those fields.",
+  inputSchema: EditTaskInput,
+  handler: editTaskHandler,
+} as const;

package/src/tools/getFolder.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema, FolderDetail } from "../schemas/index.js";
+
+export const getFolderSchema = z.object({
+  id: IdSchema.describe("The folder's id.primaryKey"),
+});
+
+export type GetFolderInput = z.infer<typeof getFolderSchema>;
+
+export async function getFolderHandler(
+  input: GetFolderInput
+): Promise<z.infer<typeof FolderDetail>> {
+  const raw = await runSnippet("get_folder", { id: input.id });
+  return FolderDetail.parse(raw);
+}
+
+export const getFolderTool = {
+  name: "get_folder",
+  description:
+    "Get full detail for a folder by its stable ID. Returns path, parentId, status, child folder IDs, and immediate project IDs.",
+  inputSchema: getFolderSchema,
+  handler: getFolderHandler,
+} as const;

package/src/tools/getProject.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema, ProjectDetail } from "../schemas/index.js";
+
+export const getProjectSchema = z.object({
+  id: IdSchema.describe("The project's id.primaryKey"),
+});
+
+export type GetProjectInput = z.infer<typeof getProjectSchema>;
+
+export async function getProjectHandler(
+  input: GetProjectInput
+): Promise<z.infer<typeof ProjectDetail>> {
+  const raw = await runSnippet("get_project", { id: input.id });
+  return ProjectDetail.parse(raw);
+}
+
+export const getProjectTool = {
+  name: "get_project",
+  description:
+    "Get full detail for a project by its stable ID. Returns note, folder path, status, type, dates, review metadata, and tag IDs.",
+  inputSchema: getProjectSchema,
+  handler: getProjectHandler,
+} as const;

package/src/tools/getTag.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema, TagDetail } from "../schemas/index.js";
+
+export const getTagSchema = z.object({
+  id: IdSchema.describe("The tag's id.primaryKey"),
+});
+
+export type GetTagInput = z.infer<typeof getTagSchema>;
+
+export async function getTagHandler(
+  input: GetTagInput
+): Promise<z.infer<typeof TagDetail>> {
+  const raw = await runSnippet("get_tag", { id: input.id });
+  return TagDetail.parse(raw);
+}
+
+export const getTagTool = {
+  name: "get_tag",
+  description:
+    "Get full detail for a tag by its stable ID. Returns path, parentId, status, and child tag IDs.",
+  inputSchema: getTagSchema,
+  handler: getTagHandler,
+} as const;

package/src/tools/getTask.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema, TaskDetail } from "../schemas/index.js";
+
+export const getTaskSchema = z.object({
+  id: IdSchema.describe("The task's id.primaryKey"),
+});
+
+export type GetTaskInput = z.infer<typeof getTaskSchema>;
+
+export async function getTaskHandler(
+  input: GetTaskInput
+): Promise<z.infer<typeof TaskDetail>> {
+  const raw = await runSnippet("get_task", { id: input.id });
+  return TaskDetail.parse(raw);
+}
+
+export const getTaskTool = {
+  name: "get_task",
+  description:
+    "Get full detail for a task by its stable ID. Returns note, status, flagged, defer/due/completion dates, estimated minutes, container info, tag IDs, and parentTaskId (null for top-level tasks, set to the parent task's ID for subtasks).",
+  inputSchema: getTaskSchema,
+  handler: getTaskHandler,
+} as const;

package/src/tools/index.ts

@@ -0,0 +1,85 @@
+export { listProjectsTool } from "./listProjects.js";
+export { getProjectTool } from "./getProject.js";
+export { listFoldersTool } from "./listFolders.js";
+export { getFolderTool } from "./getFolder.js";
+export { listTasksTool } from "./listTasks.js";
+export { getTaskTool } from "./getTask.js";
+export { listTagsTool } from "./listTags.js";
+export { getTagTool } from "./getTag.js";
+export { resolveNameTool } from "./resolveName.js";
+export { createTaskTool } from "./createTask.js";
+export { editTaskTool } from "./editTask.js";
+export { completeTaskTool } from "./completeTask.js";
+export { dropTaskTool } from "./dropTask.js";
+export { deleteTaskTool } from "./deleteTask.js";
+export { createProjectTool } from "./createProject.js";
+export { editProjectTool } from "./editProject.js";
+export { completeProjectTool } from "./completeProject.js";
+export { dropProjectTool } from "./dropProject.js";
+export { deleteProjectTool } from "./deleteProject.js";
+export { createFolderTool } from "./createFolder.js";
+export { editFolderTool } from "./editFolder.js";
+export { deleteFolderTool } from "./deleteFolder.js";
+export { createTagTool } from "./createTag.js";
+export { editTagTool } from "./editTag.js";
+export { deleteTagTool } from "./deleteTag.js";
+export { moveTaskTool } from "./moveTask.js";
+export { moveProjectTool } from "./moveProject.js";
+
+import { listProjectsTool } from "./listProjects.js";
+import { getProjectTool } from "./getProject.js";
+import { listFoldersTool } from "./listFolders.js";
+import { getFolderTool } from "./getFolder.js";
+import { listTasksTool } from "./listTasks.js";
+import { getTaskTool } from "./getTask.js";
+import { listTagsTool } from "./listTags.js";
+import { getTagTool } from "./getTag.js";
+import { resolveNameTool } from "./resolveName.js";
+import { createTaskTool } from "./createTask.js";
+import { editTaskTool } from "./editTask.js";
+import { completeTaskTool } from "./completeTask.js";
+import { dropTaskTool } from "./dropTask.js";
+import { deleteTaskTool } from "./deleteTask.js";
+import { createProjectTool } from "./createProject.js";
+import { editProjectTool } from "./editProject.js";
+import { completeProjectTool } from "./completeProject.js";
+import { dropProjectTool } from "./dropProject.js";
+import { deleteProjectTool } from "./deleteProject.js";
+import { createFolderTool } from "./createFolder.js";
+import { editFolderTool } from "./editFolder.js";
+import { deleteFolderTool } from "./deleteFolder.js";
+import { createTagTool } from "./createTag.js";
+import { editTagTool } from "./editTag.js";
+import { deleteTagTool } from "./deleteTag.js";
+import { moveTaskTool } from "./moveTask.js";
+import { moveProjectTool } from "./moveProject.js";
+
+export const allTools = [
+  listProjectsTool,
+  getProjectTool,
+  listFoldersTool,
+  getFolderTool,
+  listTasksTool,
+  getTaskTool,
+  listTagsTool,
+  getTagTool,
+  resolveNameTool,
+  createTaskTool,
+  editTaskTool,
+  completeTaskTool,
+  dropTaskTool,
+  deleteTaskTool,
+  createProjectTool,
+  editProjectTool,
+  completeProjectTool,
+  dropProjectTool,
+  deleteProjectTool,
+  createFolderTool,
+  editFolderTool,
+  deleteFolderTool,
+  createTagTool,
+  editTagTool,
+  deleteTagTool,
+  moveTaskTool,
+  moveProjectTool,
+] as const;

package/src/tools/listFolders.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { FolderSummary, ListFoldersFilter } from "../schemas/index.js";
+
+export const listFoldersSchema = z.object({
+  filter: ListFoldersFilter.optional().describe(
+    "Optional filter. When status is provided, only folders with that status are returned. When omitted, all folders (active and dropped) are returned."
+  ),
+  limit: z.number().int().positive().optional().describe(
+    "Maximum number of folders to return. Defaults to 200."
+  ),
+});
+
+export type ListFoldersInput = z.infer<typeof listFoldersSchema>;
+
+export async function listFoldersHandler(
+  input: ListFoldersInput
+): Promise<z.infer<typeof FolderSummary>[]> {
+  const raw = await runSnippet("list_folders", {
+    filter: input.filter,
+    limit: input.limit,
+  });
+  return z.array(FolderSummary).parse(raw);
+}
+
+export const listFoldersTool = {
+  name: "list_folders",
+  description:
+    "List folders in OmniFocus. By default, all folders (active and dropped) are returned. Optional filter.status ('active' | 'dropped') restricts to that status. Results are capped at limit (default 200). Each folder includes id, name, full path (ancestors joined with ▸), parentId, and status.",
+  inputSchema: listFoldersSchema,
+  handler: listFoldersHandler,
+} as const;

package/src/tools/listProjects.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { ProjectSummary, ListProjectsFilter } from "../schemas/index.js";
+
+export const listProjectsSchema = z.object({
+  filter: ListProjectsFilter.optional().describe(
+    "Optional filters. All fields combine as AND. When status is omitted, done and dropped projects are excluded by default."
+  ),
+  limit: z.number().int().positive().optional().describe(
+    "Maximum number of projects to return. Defaults to 100."
+  ),
+});
+
+export type ListProjectsInput = z.infer<typeof listProjectsSchema>;
+
+export async function listProjectsHandler(
+  input: ListProjectsInput
+): Promise<z.infer<typeof ProjectSummary>[]> {
+  const raw = await runSnippet("list_projects", {
+    filter: input.filter,
+    limit: input.limit,
+  });
+  return z.array(ProjectSummary).parse(raw);
+}
+
+export const listProjectsTool = {
+  name: "list_projects",
+  description:
+    "List projects in OmniFocus. By default, done and dropped projects are excluded — pass filter.status to override. Optional filter fields: status (array of status strings), folderId (restricts to that folder's subtree), flagged (boolean). Results are capped at limit (default 100). Each project includes folderId and flagged in addition to id, name, folderPath, status, and type.",
+  inputSchema: listProjectsSchema,
+  handler: listProjectsHandler,
+} as const;

package/src/tools/listTags.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { TagSummary, ListTagsFilter } from "../schemas/index.js";
+
+export const listTagsSchema = z.object({
+  filter: ListTagsFilter.optional().describe(
+    "Optional filter. When status is provided, only tags with that status are returned. When omitted, all tags (active, onHold, and dropped) are returned."
+  ),
+  limit: z.number().int().positive().optional().describe(
+    "Maximum number of tags to return. Defaults to 200."
+  ),
+});
+
+export type ListTagsInput = z.infer<typeof listTagsSchema>;
+
+export async function listTagsHandler(
+  input: ListTagsInput
+): Promise<z.infer<typeof TagSummary>[]> {
+  const raw = await runSnippet("list_tags", {
+    filter: input.filter,
+    limit: input.limit,
+  });
+  return z.array(TagSummary).parse(raw);
+}
+
+export const listTagsTool = {
+  name: "list_tags",
+  description:
+    "List tags in OmniFocus. By default, all tags (active, onHold, and dropped) are returned. Optional filter.status ('active' | 'onHold' | 'dropped') restricts to that status. Results are capped at limit (default 200). Each tag includes id, name, full path (ancestors joined with ▸), parentId, and status.",
+  inputSchema: listTagsSchema,
+  handler: listTagsHandler,
+} as const;

package/src/tools/listTasks.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema, TaskSummary, ListTasksFilter } from "../schemas/index.js";
+
+const ScopeSchema = z
+  .object({
+    projectId: IdSchema.optional(),
+    folderId: IdSchema.optional(),
+    inbox: z.literal(true).optional(),
+    all: z.literal(true).optional(),
+  })
+  .refine(
+    (s) => {
+      const keys = [s.projectId, s.folderId, s.inbox, s.all].filter(
+        (v) => v !== undefined
+      );
+      return keys.length === 1;
+    },
+    {
+      message:
+        "Exactly one of projectId, folderId, inbox, or all must be provided",
+    }
+  );
+
+export const listTasksSchema = z.object({
+  scope: ScopeSchema.describe(
+    "Exactly one of: projectId (string), folderId (string), inbox (true), or all (true)"
+  ),
+  filter: ListTasksFilter.optional().describe(
+    "Optional filters. All fields combine as AND. When status is omitted, complete and dropped tasks are excluded by default."
+  ),
+  limit: z.number().int().positive().optional().describe(
+    "Maximum number of tasks to return. Defaults to 200."
+  ),
+});
+
+export type ListTasksInput = z.infer<typeof listTasksSchema>;
+
+export async function listTasksHandler(
+  input: ListTasksInput
+): Promise<z.infer<typeof TaskSummary>[]> {
+  const raw = await runSnippet("list_tasks", {
+    scope: input.scope,
+    filter: input.filter,
+    limit: input.limit,
+  });
+  return z.array(TaskSummary).parse(raw);
+}
+
+export const listTasksTool = {
+  name: "list_tasks",
+  description:
+    "List tasks in OmniFocus within a scope. Provide exactly one of: projectId (tasks in a project), folderId (tasks across all projects in a folder), inbox (inbox tasks), or all (every task). By default, complete and dropped tasks are excluded — pass filter.status to override. Optional filter fields: flagged (boolean), status (array of status strings), tagId (string), dueBeforeDate (ISO datetime). Results are capped at limit (default 200). Each returned task includes dueDate and tagIds.",
+  inputSchema: listTasksSchema,
+  handler: listTasksHandler,
+} as const;

package/src/tools/moveProject.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { MoveProjectInput, ProjectSummary } from "../schemas/index.js";
+
+export type MoveProjectInputType = z.infer<typeof MoveProjectInput>;
+
+export async function moveProjectHandler(
+  input: MoveProjectInputType
+): Promise<z.infer<typeof ProjectSummary>> {
+  const raw = await runSnippet("move_project", input);
+  return ProjectSummary.parse(raw);
+}
+
+export const moveProjectTool = {
+  name: "move_project",
+  description:
+    "Move a project to a different folder or to the top level. Pass folderId as a string to move into a folder, or null to move to the top level. Throws a not-found error if either ID does not exist.",
+  inputSchema: MoveProjectInput,
+  handler: moveProjectHandler,
+} as const;

package/src/tools/moveTask.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { MoveTaskInput, TaskSummary } from "../schemas/index.js";
+
+export type MoveTaskInputType = z.infer<typeof MoveTaskInput>;
+
+export async function moveTaskHandler(
+  input: MoveTaskInputType
+): Promise<z.infer<typeof TaskSummary>> {
+  const raw = await runSnippet("move_task", input);
+  return TaskSummary.parse(raw);
+}
+
+export const moveTaskTool = {
+  name: "move_task",
+  description:
+    "Move a task to a different project (making it a top-level task) or make it a subtask of another task. Exactly one of projectId or parentTaskId must be provided. Throws a not-found error if any ID does not exist.",
+  inputSchema: MoveTaskInput,
+  handler: moveTaskHandler,
+} as const;

package/src/tools/resolveName.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { EntityType, ResolveCandidate } from "../schemas/index.js";
+
+export const resolveNameSchema = z.object({
+  type: EntityType.describe(
+    "The entity type to search: task, project, folder, tag, or perspective"
+  ),
+  query: z.string().min(1).describe("Exact name to search for"),
+  scope: z
+    .string()
+    .optional()
+    .describe(
+      'Optional path prefix to narrow results, e.g. "Work ▸ Clients"'
+    ),
+});
+
+export type ResolveNameInput = z.infer<typeof resolveNameSchema>;
+
+export async function resolveNameHandler(
+  input: ResolveNameInput
+): Promise<z.infer<typeof ResolveCandidate>[]> {
+  const raw = await runSnippet("resolve_name", {
+    type: input.type,
+    query: input.query,
+    scope: input.scope ?? null,
+  });
+  return z.array(ResolveCandidate).parse(raw);
+}
+
+export const resolveNameTool = {
+  name: "resolve_name",
+  description:
+    "Resolve an entity name to its stable ID(s). Returns ALL matches — never silently picks one. If multiple candidates are returned, ask the user or caller to disambiguate using the path field before proceeding with a write operation.",
+  inputSchema: resolveNameSchema,
+  handler: resolveNameHandler,
+} as const;

package/test/integration/completeProject.int.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestFolder, cleanupTestFolder, createTestProject, type TestFixture } from "./fixtures.js";
+import { ProjectDetail } from "../../src/schemas/index.js";
+
+describe("complete_project (integration)", () => {
+  let fixture: TestFixture;
+  let projectId: string;
+
+  beforeAll(async () => {
+    fixture = await createTestFolder();
+    projectId = await createTestProject(fixture.folderId, "CompleteProject Test Project");
+  });
+
+  afterAll(async () => {
+    await cleanupTestFolder(fixture.folderId);
+  });
+
+  it("marks project complete and returns status done", async () => {
+    const raw = await runSnippet("complete_project", { id: projectId });
+    const project = ProjectDetail.parse(raw);
+    expect(project.status).toBe("done");
+    expect(project.completionDate).not.toBeNull();
+  });
+});

package/test/integration/completeTask.int.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestFolder, cleanupTestFolder, createTestProject, type TestFixture } from "./fixtures.js";
+import { TaskDetail } from "../../src/schemas/index.js";
+
+describe("complete_task (integration)", () => {
+  let fixture: TestFixture;
+  let taskId: string;
+
+  beforeAll(async () => {
+    fixture = await createTestFolder();
+    const projectId = await createTestProject(fixture.folderId, "CompleteTask Test Project");
+    const taskRaw = await runSnippet("create_task", {
+      name: "Task to complete",
+      projectId,
+    });
+    taskId = TaskDetail.parse(taskRaw).id;
+  });
+
+  afterAll(async () => {
+    await cleanupTestFolder(fixture.folderId);
+  });
+
+  it("marks task complete and returns status complete", async () => {
+    const raw = await runSnippet("complete_task", { id: taskId });
+    const task = TaskDetail.parse(raw);
+    expect(task.status).toBe("complete");
+    expect(task.completionDate).not.toBeNull();
+  });
+});

package/test/integration/createFolder.int.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { cleanupTestFolder } from "./fixtures.js";
+import { FolderDetail } from "../../src/schemas/index.js";
+
+describe("create_folder (integration)", () => {
+  const createdFolderIds: string[] = [];
+
+  afterAll(async () => {
+    for (const id of createdFolderIds) {
+      await cleanupTestFolder(id);
+    }
+  });
+
+  it("creates a top-level folder and returns stable id", async () => {
+    const name = `__mcp_test_folder_${Date.now()}__`;
+    const raw = await runSnippet("create_folder", { name });
+    const folder = FolderDetail.parse(raw);
+    expect(folder.id).toBeTruthy();
+    expect(folder.name).toBe(name);
+    expect(folder.parentId).toBeNull();
+    expect(folder.path).toBe(name);
+    createdFolderIds.push(folder.id);
+  });
+
+  it("creates a nested folder with correct path and parentId", async () => {
+    const parentName = `__mcp_test_parent_${Date.now()}__`;
+    const parentRaw = await runSnippet("create_folder", { name: parentName });
+    const parent = FolderDetail.parse(parentRaw);
+    createdFolderIds.push(parent.id);
+
+    const childRaw = await runSnippet("create_folder", {
+      name: "Child",
+      parentFolderId: parent.id,
+    });
+    const child = FolderDetail.parse(childRaw);
+    expect(child.parentId).toBe(parent.id);
+    expect(child.path).toContain(parentName);
+    expect(child.path).toContain("Child");
+  });
+
+  it("returns not-found error for invalid parentFolderId", async () => {
+    await expect(
+      runSnippet("create_folder", { name: "X", parentFolderId: "nonexistent-id-xyz" })
+    ).rejects.toSatisfy((e: unknown) => {
+      const err = e as Record<string, unknown>;
+      return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+    });
+  });
+});