omnifocus-mcp-enhanced 1.6.11 → 1.7.0

package/README.md

@@ -44,6 +44,7 @@ Want to see where the project is heading next? See the [roadmap](docs/roadmap/20
 
 ## 🆕 Latest Release
 
+- **v1.7.0** - Added OmniFocus 4.7+ repeat rule support via `set_repetition_rule` (ICS rule strings, schedule type, anchor date, catch-up, end date, repetition count), mutually exclusive tag support via `exclusiveTags` on add/edit tools, and improved planned-date editing tests.
 - **v1.6.10** - Fixed Inbox task completion via `edit_item`, fixed AppleScript special-character handling for apostrophes/backslashes, fixed JSON result escaping for special characters, and clarified `batch_add_items` / `mcporter` usage with working examples.
 - **v1.6.9** - Added task attachment support: `get_task_by_id` now lists attachment metadata, `dump_database` exports attachment/link metadata, and new `read_task_attachment` returns image attachments as MCP image content when possible.
 - **v1.6.8** - Added stable task move support via `move_task` and `edit_item` (`newProjectId/newProjectName/newParentTaskId/newParentTaskName/moveToInbox`) with duplicate-name protection and cycle-prevention checks.
@@ -66,6 +67,8 @@ Want to see where the project is heading next? See the [roadmap](docs/roadmap/20
 - **🔄 Full CRUD Operations** - Create, read, update, delete tasks and projects
 - **📅 Time Management** - Due, defer, planned dates, estimates, and scheduling
 - **🏷️ Advanced Tagging** - Tag-based filtering with exact/partial matching
+- **🚫 Mutually Exclusive Tags** - Automatically respects exclusive tag groups when applying tags
+- **🔁 Repeat Rules** - Full OmniFocus 4.7+ repetition support (ICS rules, schedule type, anchor date, catch-up, end date, count)
 - **🤖 AI Integration** - Seamless Claude AI integration for intelligent workflows
 - **🖼️ Attachment-Aware Reads** - Surface note attachments and linked files before deciding whether AI should inspect them
 

package/README.zh.md

@@ -40,6 +40,7 @@ OmniFocus 本身已经很强了，但它大多数时候仍然是一个需要你
 
 ## 🆕 最新版本
 
+- **v1.7.0** - 新增 OmniFocus 4.7+ 重复规则支持（`set_repetition_rule`：ICS 规则、重复方式、锚定日期、自动追平、结束日期、重复次数），新增互斥标签支持（`exclusiveTags`），并补全计划日期编辑测试。
 - **v1.6.10** - 修复 `edit_item` 无法完成 Inbox 任务的问题，修复 AppleScript 对单引号/反斜杠等特殊字符的处理，修复特殊字符导致的 JSON 返回解析失败，并补充 `batch_add_items` / `mcporter` 的可直接运行示例与说明。
 - **v1.6.9** - 新增任务附件支持：`get_task_by_id` 会返回附件元信息，`dump_database` 导出附件/链接元信息，并新增 `read_task_attachment`，可在支持时直接把图片附件作为 MCP 图片内容返回。
 - **v1.6.6** - 新增 Planned Date（计划日期）全链路支持：创建/编辑/读取/过滤/排序/导出，包含 `plannedDate` / `newPlannedDate`。
@@ -61,6 +62,8 @@ OmniFocus 本身已经很强了，但它大多数时候仍然是一个需要你
 - **🔄 完整 CRUD 操作** - 创建、读取、更新、删除任务和项目
 - **📅 时间管理** - 截止日期、推迟日期、计划日期、估时和计划
 - **🏷️ 高级标签** - 基于标签的精确/模糊匹配过滤
+- **🚫 互斥标签** - 应用标签时自动遵守互斥标签组规则
+- **🔁 重复规则** - 完整支持 OmniFocus 4.7+ 重复任务（ICS 规则、重复方式、锚定日期、自动追平、结束日期、重复次数）
 - **🤖 AI 集成** - 与 Claude AI 无缝集成，实现智能工作流
 - **🖼️ 附件感知读取** - 先暴露备注附件和链接文件的元信息，再决定是否让 AI 继续查看附件内容
 

package/dist/omnifocustypes.js

@@ -18,6 +18,17 @@ export var Task;
         RepetitionMethod[RepetitionMethod["Fixed"] = 2] = "Fixed";
         RepetitionMethod[RepetitionMethod["None"] = 3] = "None";
     })(RepetitionMethod = Task.RepetitionMethod || (Task.RepetitionMethod = {}));
+    let RepetitionScheduleType;
+    (function (RepetitionScheduleType) {
+        RepetitionScheduleType[RepetitionScheduleType["Regularly"] = 0] = "Regularly";
+        RepetitionScheduleType[RepetitionScheduleType["FromCompletion"] = 1] = "FromCompletion";
+    })(RepetitionScheduleType = Task.RepetitionScheduleType || (Task.RepetitionScheduleType = {}));
+    let AnchorDateKey;
+    (function (AnchorDateKey) {
+        AnchorDateKey[AnchorDateKey["DeferDate"] = 0] = "DeferDate";
+        AnchorDateKey[AnchorDateKey["DueDate"] = 1] = "DueDate";
+        AnchorDateKey[AnchorDateKey["PlannedDate"] = 2] = "PlannedDate";
+    })(AnchorDateKey = Task.AnchorDateKey || (Task.AnchorDateKey = {}));
 })(Task || (Task = {}));
 export var Project;
 (function (Project) {

package/dist/server.js

@@ -13,6 +13,7 @@ import * as batchRemoveItemsTool from './tools/definitions/batchRemoveItems.js';
 import * as getTaskByIdTool from './tools/definitions/getTaskById.js';
 import * as readTaskAttachmentTool from './tools/definitions/readTaskAttachment.js';
 import * as getTodayCompletedTasksTool from './tools/definitions/getTodayCompletedTasks.js';
+import * as setRepetitionRuleTool from './tools/definitions/setRepetitionRule.js';
 // Import perspective tools
 import * as getInboxTasksTool from './tools/definitions/getInboxTasks.js';
 import * as getFlaggedTasksTool from './tools/definitions/getFlaggedTasks.js';
@@ -41,6 +42,7 @@ server.tool("batch_remove_items", "Remove multiple tasks or projects from OmniFo
 server.tool("get_task_by_id", "Get information about a specific task by ID or name", getTaskByIdTool.schema.shape, getTaskByIdTool.handler);
 server.tool("read_task_attachment", "Read a task attachment reported by get_task_by_id. Images are returned as MCP image content when possible.", readTaskAttachmentTool.schema.shape, readTaskAttachmentTool.handler);
 server.tool("get_today_completed_tasks", "Get tasks completed today - view today's accomplishments", getTodayCompletedTasksTool.schema.shape, getTodayCompletedTasksTool.handler);
+server.tool("set_repetition_rule", "Set, update, or clear the repeat rule on a task. Supports ICS rule strings, schedule type, anchor date, catch-up, end date, and repetition count.", setRepetitionRuleTool.schema.shape, setRepetitionRuleTool.handler);
 // Register perspective tools
 server.tool("get_inbox_tasks", "Get tasks from OmniFocus inbox perspective", getInboxTasksTool.schema.shape, getInboxTasksTool.handler);
 server.tool("get_flagged_tasks", "Get flagged tasks from OmniFocus with optional project filtering", getFlaggedTasksTool.schema.shape, getFlaggedTasksTool.handler);

package/dist/tools/definitions/addOmniFocusTask.js

@@ -9,6 +9,7 @@ export const schema = z.object({
     flagged: z.boolean().optional().describe("Whether the task is flagged or not"),
     estimatedMinutes: z.number().optional().describe("Estimated time to complete the task, in minutes"),
     tags: z.array(z.string()).optional().describe("Tags to assign to the task"),
+    exclusiveTags: z.boolean().optional().describe("Respect mutually exclusive tag groups when applying tags (default: true). When a tag belongs to an exclusive group, sibling tags from that group are removed."),
     projectName: z.string().optional().describe("The name of the project to add the task to (will add to inbox if not specified)"),
     parentTaskId: z.string().optional().describe("The ID of the parent task to create this task as a subtask"),
     parentTaskName: z.string().optional().describe("The name of the parent task to create this task as a subtask (alternative to parentTaskId)")
@@ -39,10 +40,13 @@ export async function handler(args, extra) {
             let plannedDateText = args.plannedDate
                 ? ` planned for ${new Date(args.plannedDate).toLocaleDateString()}`
                 : "";
+            let exclusivityText = result.removedSiblings && result.removedSiblings.length > 0
+                ? `\nRemoved mutually exclusive tags: ${result.removedSiblings.join(', ')}`
+                : "";
             return {
                 content: [{
                         type: "text",
-                        text: `✅ Task "${args.name}" created successfully ${locationText}${dueDateText}${plannedDateText}${tagText}.\n\nid: ${result.taskId}`
+                        text: `✅ Task "${args.name}" created successfully ${locationText}${dueDateText}${plannedDateText}${tagText}.\n\nid: ${result.taskId}${exclusivityText}`
                     }]
             };
         }

package/dist/tools/definitions/addProject.js

@@ -9,6 +9,7 @@ export const schema = z.object({
     flagged: z.boolean().optional().describe("Whether the project is flagged or not"),
     estimatedMinutes: z.number().optional().describe("Estimated time to complete the project, in minutes"),
     tags: z.array(z.string()).optional().describe("Tags to assign to the project"),
+    exclusiveTags: z.boolean().optional().describe("Respect mutually exclusive tag groups when applying tags (default: true). When a tag belongs to an exclusive group, sibling tags from that group are removed."),
     folderName: z.string().optional().describe("The name of the folder to add the project to (will add to root if not specified)"),
     sequential: z.boolean().optional().describe("Whether tasks in the project should be sequential (default: false)")
 });
@@ -33,10 +34,13 @@ export async function handler(args, extra) {
             let sequentialText = args.sequential
                 ? " (sequential)"
                 : " (parallel)";
+            let exclusivityText = result.removedSiblings && result.removedSiblings.length > 0
+                ? `\nRemoved mutually exclusive tags: ${result.removedSiblings.join(', ')}`
+                : "";
             return {
                 content: [{
                         type: "text",
-                        text: `✅ Project "${args.name}" created successfully ${locationText}${dueDateText}${plannedDateText}${tagText}${sequentialText}.\n\nid: ${result.projectId}`
+                        text: `✅ Project "${args.name}" created successfully ${locationText}${dueDateText}${plannedDateText}${tagText}${sequentialText}.\n\nid: ${result.projectId}${exclusivityText}`
                     }]
             };
         }

package/dist/tools/definitions/editItem.js

@@ -17,6 +17,7 @@ export const schema = z.object({
     addTags: z.array(z.string()).optional().describe("Tags to add to the task"),
     removeTags: z.array(z.string()).optional().describe("Tags to remove from the task"),
     replaceTags: z.array(z.string()).optional().describe("Tags to replace all existing tags with"),
+    exclusiveTags: z.boolean().optional().describe("Respect mutually exclusive tag groups when adding/replacing tags (default: true). When a tag belongs to an exclusive group, sibling tags from that group are removed."),
     newProjectId: z.string().optional().describe("For tasks: move task to this project ID"),
     newProjectName: z.string().optional().describe("For tasks: move task to this project name (errors on duplicate names)"),
     newParentTaskId: z.string().optional().describe("For tasks: move task under this parent task ID"),
@@ -48,10 +49,13 @@ export async function handler(args, extra) {
             if (result.changedProperties) {
                 changedText = ` (${result.changedProperties})`;
             }
+            let exclusivityText = result.removedSiblings && result.removedSiblings.length > 0
+                ? `\nRemoved mutually exclusive tags: ${result.removedSiblings.join(', ')}`
+                : "";
             return {
                 content: [{
                         type: "text",
-                        text: `✅ ${itemTypeLabel} "${result.name}" updated successfully${changedText}.`
+                        text: `✅ ${itemTypeLabel} "${result.name}" updated successfully${changedText}.${exclusivityText}`
                     }]
             };
         }

package/dist/tools/definitions/plannedDateSchemas.test.js

@@ -74,3 +74,28 @@ test('filter_tasks schema supports planned date filters and sorting', () => {
     assert.equal(parsed.plannedBefore, '2026-02-20');
     assert.equal(parsed.sortBy, 'plannedDate');
 });
+test('add_omnifocus_task schema preserves exclusiveTags', () => {
+    const parsed = addTaskSchema.parse({
+        name: 'Task with exclusive tags',
+        tags: ['High', 'Work'],
+        exclusiveTags: false
+    });
+    assert.equal(parsed.exclusiveTags, false);
+});
+test('add_project schema preserves exclusiveTags', () => {
+    const parsed = addProjectSchema.parse({
+        name: 'Project with exclusive tags',
+        tags: ['High'],
+        exclusiveTags: true
+    });
+    assert.equal(parsed.exclusiveTags, true);
+});
+test('edit_item schema preserves exclusiveTags', () => {
+    const parsed = editItemSchema.parse({
+        itemType: 'task',
+        id: 'abc',
+        addTags: ['High'],
+        exclusiveTags: true
+    });
+    assert.equal(parsed.exclusiveTags, true);
+});

package/dist/tools/definitions/setRepetitionRule.js

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { setRepetitionRule } from '../primitives/setRepetitionRule.js';
+export const schema = z.object({
+    taskId: z.string().describe('The ID of the task to modify'),
+    ruleString: z
+        .string()
+        .optional()
+        .describe('ICS recurrence rule string, e.g. FREQ=WEEKLY;INTERVAL=2. Defaults to FREQ=WEEKLY.'),
+    scheduleType: z
+        .enum(['Regularly', 'FromCompletion'])
+        .optional()
+        .describe('How the next occurrence is scheduled. Regularly repeats from assigned dates; FromCompletion repeats after completion.'),
+    anchorDateKey: z
+        .enum(['DueDate', 'DeferDate', 'PlannedDate'])
+        .optional()
+        .describe('Which date property is advanced when the task repeats.'),
+    catchUpAutomatically: z
+        .boolean()
+        .optional()
+        .describe('When true, missed occurrences are skipped and the next future occurrence is created.'),
+    endDate: z
+        .string()
+        .optional()
+        .describe('ISO date string for when the repetition ends. Encoded into the rule as UNTIL=.'),
+    count: z
+        .number()
+        .optional()
+        .describe('Number of repetitions after which the rule ends. Encoded into the rule as COUNT=.'),
+    clear: z
+        .boolean()
+        .optional()
+        .describe('Set to true to remove the repetition rule from the task.'),
+});
+export async function handler(args, extra) {
+    try {
+        const result = await setRepetitionRule({
+            taskId: args.taskId,
+            ruleString: args.ruleString,
+            scheduleType: args.scheduleType,
+            anchorDateKey: args.anchorDateKey,
+            catchUpAutomatically: args.catchUpAutomatically,
+            endDate: args.endDate,
+            count: args.count,
+            clear: args.clear,
+        });
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to set repetition rule: ${result.error || 'Unknown error'}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (result.cleared) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Repetition rule cleared successfully.',
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Repetition rule set successfully.\nRule: ${result.ruleString}\nSchedule: ${result.scheduleType}\nAnchor: ${result.anchorDateKey}\nCatch up automatically: ${result.catchUpAutomatically}`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error setting repetition rule: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/definitions/setRepetitionRule.test.js

@@ -0,0 +1,42 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { schema } from './setRepetitionRule.js';
+test('set_repetition_rule schema requires taskId', () => {
+    assert.throws(() => schema.parse({}));
+});
+test('set_repetition_rule schema accepts minimal valid input', () => {
+    const parsed = schema.parse({ taskId: 'abc123' });
+    assert.equal(parsed.taskId, 'abc123');
+});
+test('set_repetition_rule schema accepts full repetition config', () => {
+    const parsed = schema.parse({
+        taskId: 'abc123',
+        ruleString: 'FREQ=WEEKLY;INTERVAL=2',
+        scheduleType: 'FromCompletion',
+        anchorDateKey: 'PlannedDate',
+        catchUpAutomatically: true,
+        endDate: '2026-12-31T23:59:59.000Z',
+        count: 10,
+    });
+    assert.equal(parsed.ruleString, 'FREQ=WEEKLY;INTERVAL=2');
+    assert.equal(parsed.scheduleType, 'FromCompletion');
+    assert.equal(parsed.anchorDateKey, 'PlannedDate');
+    assert.equal(parsed.catchUpAutomatically, true);
+    assert.equal(parsed.count, 10);
+});
+test('set_repetition_rule schema rejects invalid scheduleType', () => {
+    assert.throws(() => schema.parse({
+        taskId: 'abc123',
+        scheduleType: 'Sometimes',
+    }));
+});
+test('set_repetition_rule schema rejects invalid anchorDateKey', () => {
+    assert.throws(() => schema.parse({
+        taskId: 'abc123',
+        anchorDateKey: 'StartDate',
+    }));
+});
+test('set_repetition_rule schema accepts clear flag', () => {
+    const parsed = schema.parse({ taskId: 'abc123', clear: true });
+    assert.equal(parsed.clear, true);
+});

package/dist/tools/primitives/addOmniFocusTask.js

@@ -2,6 +2,7 @@ import { executeAppleScript } from '../../utils/scriptExecution.js';
 import { appleScriptDateCode } from '../../utils/dateFormatter.js';
 import { buildAppleScriptJsonHelpers } from '../../utils/appleScriptJson.js';
 import { escapeAppleScriptString } from '../../utils/appleScriptString.js';
+import { applyTagsExclusive } from './applyTagsExclusive.js';
 export function buildTagAssignmentScript(tags, targetVar) {
     if (!tags || tags.length === 0) {
         return '';
@@ -149,11 +150,28 @@ export async function addOmniFocusTask(params) {
         // Parse the result
         try {
             const result = JSON.parse(stdout);
-            // Return the result
+            if (!result.success) {
+                return {
+                    success: false,
+                    error: result.error
+                };
+            }
+            const taskId = result.taskId;
+            const tags = params.tags || [];
+            const exclusiveTags = params.exclusiveTags !== false;
+            // If tags were applied and exclusivity is enabled, enforce mutually exclusive groups.
+            if (taskId && tags.length > 0 && exclusiveTags) {
+                const exclusivityResult = await applyTagsExclusive(taskId, tags, 'add');
+                return {
+                    success: true,
+                    taskId,
+                    removedSiblings: exclusivityResult.removedSiblings,
+                    missingTags: exclusivityResult.missing,
+                };
+            }
             return {
-                success: result.success,
-                taskId: result.taskId,
-                error: result.error
+                success: true,
+                taskId,
             };
         }
         catch (parseError) {

package/dist/tools/primitives/addProject.js

@@ -2,6 +2,7 @@ import { executeAppleScript } from '../../utils/scriptExecution.js';
 import { appleScriptDateCode } from '../../utils/dateFormatter.js';
 import { buildAppleScriptJsonHelpers } from '../../utils/appleScriptJson.js';
 import { escapeAppleScriptString } from '../../utils/appleScriptString.js';
+import { applyTagsExclusive } from './applyTagsExclusive.js';
 /**
  * Generate pure AppleScript for project creation
  */
@@ -99,11 +100,28 @@ export async function addProject(params) {
         // Parse the result
         try {
             const result = JSON.parse(stdout);
-            // Return the result
+            if (!result.success) {
+                return {
+                    success: false,
+                    error: result.error
+                };
+            }
+            const projectId = result.projectId;
+            const tags = params.tags || [];
+            const exclusiveTags = params.exclusiveTags !== false;
+            // If tags were applied and exclusivity is enabled, enforce mutually exclusive groups.
+            if (projectId && tags.length > 0 && exclusiveTags) {
+                const exclusivityResult = await applyTagsExclusive(projectId, tags, 'add');
+                return {
+                    success: true,
+                    projectId,
+                    removedSiblings: exclusivityResult.removedSiblings,
+                    missingTags: exclusivityResult.missing,
+                };
+            }
             return {
-                success: result.success,
-                projectId: result.projectId,
-                error: result.error
+                success: true,
+                projectId,
             };
         }
         catch (parseError) {

package/dist/tools/primitives/applyTagsExclusive.js

@@ -0,0 +1,37 @@
+import { executeOmniFocusScript } from '../../utils/scriptExecution.js';
+/**
+ * Apply tags to a task while respecting mutually exclusive tag groups.
+ *
+ * When a tag belongs to a mutually exclusive group (its parent tag has
+ * childrenAreMutuallyExclusive === true), sibling tags from that group are
+ * removed before the new tag is added.
+ *
+ * @param taskId OmniFocus task primary key
+ * @param tagNames Tag names to apply
+ * @param mode 'add' preserves existing tags; 'replace' clears existing tags first
+ */
+export async function applyTagsExclusive(taskId, tagNames, mode = 'add') {
+    const result = await executeOmniFocusScript('@applyTagsExclusive.js', {
+        taskId,
+        tagNames,
+        mode,
+    });
+    if (typeof result === 'string') {
+        try {
+            return JSON.parse(result);
+        }
+        catch {
+            return { success: false, error: result };
+        }
+    }
+    return result;
+}
+/**
+ * Pure decision helper for tests: determine which sibling tags should be removed
+ * when applying a tag from a mutually exclusive group.
+ */
+export function siblingsToRemove(parentExclusive, siblingNames, currentTagNames, targetTagName) {
+    if (!parentExclusive)
+        return [];
+    return siblingNames.filter(name => name !== targetTagName && currentTagNames.includes(name));
+}

package/dist/tools/primitives/applyTagsExclusive.test.js

@@ -0,0 +1,19 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { siblingsToRemove } from './applyTagsExclusive.js';
+test('siblingsToRemove returns empty when group is not exclusive', () => {
+    const result = siblingsToRemove(false, ['High', 'Medium', 'Low'], ['High'], 'Medium');
+    assert.deepEqual(result, []);
+});
+test('siblingsToRemove returns empty when tag has no parent group', () => {
+    const result = siblingsToRemove(true, [], ['High'], 'Medium');
+    assert.deepEqual(result, []);
+});
+test('siblingsToRemove removes current siblings but not target', () => {
+    const result = siblingsToRemove(true, ['High', 'Medium', 'Low'], ['High', 'Low'], 'Medium');
+    assert.deepEqual(result, ['High', 'Low']);
+});
+test('siblingsToRemove ignores siblings not currently applied', () => {
+    const result = siblingsToRemove(true, ['High', 'Medium', 'Low'], ['Low'], 'Medium');
+    assert.deepEqual(result, ['Low']);
+});

package/dist/tools/primitives/editItem.js

@@ -2,6 +2,7 @@ import { executeAppleScript } from '../../utils/scriptExecution.js';
 import { buildAppleScriptJsonHelpers } from '../../utils/appleScriptJson.js';
 import { appleScriptDateCode } from '../../utils/dateFormatter.js';
 import { escapeAppleScriptString } from '../../utils/appleScriptString.js';
+import { applyTagsExclusive } from './applyTagsExclusive.js';
 function hasTaskMoveTarget(params) {
     return Boolean(params.newProjectId ||
         params.newProjectName ||
@@ -483,13 +484,44 @@ export async function editItem(params) {
         // Parse the result
         try {
             const result = JSON.parse(stdout);
-            // Return the result
+            if (!result.success) {
+                return {
+                    success: false,
+                    error: result.error
+                };
+            }
+            const itemId = result.id;
+            const exclusiveTags = params.exclusiveTags !== false;
+            // Enforce mutually exclusive tag groups when tags were added or replaced.
+            if (itemId && exclusiveTags && params.itemType === 'task') {
+                if (params.replaceTags && params.replaceTags.length > 0) {
+                    const exclusivityResult = await applyTagsExclusive(itemId, params.replaceTags, 'replace');
+                    return {
+                        success: true,
+                        id: result.id,
+                        name: result.name,
+                        changedProperties: result.changedProperties,
+                        removedSiblings: exclusivityResult.removedSiblings,
+                        missingTags: exclusivityResult.missing,
+                    };
+                }
+                if (params.addTags && params.addTags.length > 0) {
+                    const exclusivityResult = await applyTagsExclusive(itemId, params.addTags, 'add');
+                    return {
+                        success: true,
+                        id: result.id,
+                        name: result.name,
+                        changedProperties: result.changedProperties,
+                        removedSiblings: exclusivityResult.removedSiblings,
+                        missingTags: exclusivityResult.missing,
+                    };
+                }
+            }
             return {
-                success: result.success,
+                success: true,
                 id: result.id,
                 name: result.name,
                 changedProperties: result.changedProperties,
-                error: result.error
             };
         }
         catch (parseError) {

package/dist/tools/primitives/editItem.test.js

@@ -112,3 +112,25 @@ test('generateAppleScript escapes edit responses through AppleScript helper', ()
     assert.match(script, /my jsonEscape\(changedPropsText\)/);
     assert.match(script, /my jsonEscape\(errorMessage\)/);
 });
+test('generateAppleScript sets planned date from preamble variable', () => {
+    const script = generateAppleScript({
+        id: 'task-123',
+        itemType: 'task',
+        newPlannedDate: '2026-03-15'
+    });
+    const tellIndex = script.indexOf('tell application "OmniFocus"');
+    const preambleIndex = script.indexOf('set newPlannedDateValue to current date');
+    assert.ok(preambleIndex > -1 && preambleIndex < tellIndex);
+    assert.match(script, /set planned date of foundItem to newPlannedDateValue/);
+    assert.match(script, /set end of changedProperties to "planned date"/);
+});
+test('generateAppleScript clears planned date with missing value', () => {
+    const script = generateAppleScript({
+        id: 'task-123',
+        itemType: 'task',
+        newPlannedDate: ''
+    });
+    assert.match(script, /set planned date of foundItem to missing value/);
+    assert.match(script, /set end of changedProperties to "planned date"/);
+    assert.doesNotMatch(script, /set newPlannedDateValue to current date/);
+});

package/dist/tools/primitives/setRepetitionRule.js

@@ -0,0 +1,85 @@
+import { executeOmniFocusScript } from '../../utils/scriptExecution.js';
+/**
+ * Build the ICS rule string from components. Exposed for testing.
+ */
+export function buildRepetitionRuleString(params) {
+    let ruleString = params.ruleString || 'FREQ=WEEKLY';
+    ruleString = ruleString.trim().replace(/^RRULE:/i, '');
+    ruleString = ruleString.replace(/;?(COUNT|UNTIL)=[^;]*/gi, '');
+    if (params.count && params.count > 0) {
+        ruleString += `;COUNT=${params.count}`;
+    }
+    if (params.endDate) {
+        const until = toICSDateTime(params.endDate);
+        if (until) {
+            ruleString += `;UNTIL=${until}`;
+        }
+    }
+    return ruleString;
+}
+function toICSDateTime(isoDate) {
+    const date = new Date(isoDate);
+    if (Number.isNaN(date.getTime()))
+        return null;
+    const pad = (n) => String(n).padStart(2, '0');
+    return (date.getUTCFullYear() +
+        pad(date.getUTCMonth() + 1) +
+        pad(date.getUTCDate()) +
+        'T' +
+        pad(date.getUTCHours()) +
+        pad(date.getUTCMinutes()) +
+        pad(date.getUTCSeconds()) +
+        'Z');
+}
+export function validateSetRepetitionRuleParams(params) {
+    if (!params.taskId) {
+        return { valid: false, error: 'taskId is required' };
+    }
+    if (params.clear === true) {
+        return { valid: true };
+    }
+    if (params.scheduleType && !['Regularly', 'FromCompletion'].includes(params.scheduleType)) {
+        return { valid: false, error: 'scheduleType must be Regularly or FromCompletion' };
+    }
+    if (params.anchorDateKey && !['DueDate', 'DeferDate', 'PlannedDate'].includes(params.anchorDateKey)) {
+        return { valid: false, error: 'anchorDateKey must be DueDate, DeferDate, or PlannedDate' };
+    }
+    if (params.count !== undefined && (typeof params.count !== 'number' || params.count <= 0)) {
+        return { valid: false, error: 'count must be a positive number' };
+    }
+    if (params.endDate) {
+        const date = new Date(params.endDate);
+        if (Number.isNaN(date.getTime())) {
+            return { valid: false, error: 'endDate must be a valid ISO date string' };
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Set, update, or clear the repetition rule on an OmniFocus task.
+ */
+export async function setRepetitionRule(params) {
+    const validation = validateSetRepetitionRuleParams(params);
+    if (!validation.valid) {
+        return { success: false, error: validation.error };
+    }
+    const result = await executeOmniFocusScript('@setRepetitionRule.js', {
+        taskId: params.taskId,
+        ruleString: params.ruleString,
+        scheduleType: params.scheduleType,
+        anchorDateKey: params.anchorDateKey,
+        catchUpAutomatically: params.catchUpAutomatically,
+        endDate: params.endDate,
+        count: params.count,
+        clear: params.clear,
+    });
+    if (typeof result === 'string') {
+        try {
+            return JSON.parse(result);
+        }
+        catch {
+            return { success: false, error: result };
+        }
+    }
+    return result;
+}