lark-task

task (v2)

CRITICAL — Before starting, you MUST first use the Read tool to read ../lark-shared/SKILL.md, which contains authentication and permission handling

Command selection and progressive discovery (required reading)

Before executing any Task command, you must first confirm that the capability actually exists; it is forbidden to assemble or guess +<verb>：

First precisely match the user's intent against the Shortcut table below. Only shortcuts explicitly listed in the table may be selected directly; when parameters are uncertain, read the corresponding reference or run the shortcut's --help。
When there is no exact match, or when it cannot be confirmed whether the current version supports it, first run lark-cli task --help, and take the command list output by the current CLI as authoritative.
When a matching shortcut exists in help, use the complete shortcut token listed in help (for example +create) to run lark-cli task <shortcut> --help, and then execute according to the actual flags.
When there is no matching shortcut in help, do not try a similar +<verb>; select a native resource from help, run lark-cli task <resource> --help to confirm the method, then run lark-cli schema task.<resource>.<method> to obtain the parameter structure, and finally call lark-cli task <resource> <method> ...。
When encountering unknown_subcommand , you must stop guessing or trying variants, and return to step 2 to rediscover the capability.

Shortcut names can only come from this Skill's Shortcut table or lark-cli task --help; native resource/method is based on level-by-level help, and parameter names, types, and nested structures are based on the method schema.

Task search tips: first distinguish whether the userspecifically specifies using the search skill, and whether they actually providequery keywords(such as task name, keyword, or fragment description). If the user specifically specifies using the search skill, or clearly provides task query keywords, then when the target istask, prioritize using +search. If the user does not specifically specify using the search skill, and the intent contains no query keywords, only scope conditions (such as "since the beginning of this year", "completed", "created by me", or "followed by me"), and using +search and +get-related-tasks / +get-my-tasks can both achieve the goal, you should prioritize using list-type capabilities rather than search-type capabilities. Among these, for "related to me / followed by me / created by me", prioritize considering +get-related-tasks; for lists of "assigned to me / my responsibility", prioritize considering +get-my-tasks. Do not mistake time-range terms themselves (such as "since the beginning of this year") for query and use search. Task search relevance tips：+search Currently does not automatically determine the relevance of search results to the search initiator. If the user explicitly requests searching for tasks "related to me", you must first identify the specific relationship, obtain the current user's open_id, and explicitly pass the corresponding --assignee(assignee),--creator(creator), or --follower(follower) filter condition; you cannot rely only on query and expect it to automatically return tasks related to the current user. Task list search tips: Task lists follow the same judgment logic. First, distinguish whether the user hasspecifically specified to use the search skill, and whether they have actually providedlist query keywords(e.g., list name, keyword, fragment description). If the user specifically specifies to use the search skill, or explicitly provides list query keywords, prioritize using +tasklist-search. If the user does not specifically specify to use the search skill, and there are no query keywords in the intent, only scope conditions (e.g., "task lists created by me", "lists created since the beginning of this year"), and using search or native list retrieval can both achieve the goal, prioritize using the native tasklists.list interface to retrieve lists (first schema task.tasklists.list, then lark-cli task tasklists list --as user ...), then perform local filtering and pagination control based on fields such as creator、created_at . Intent distinction supplement: For expressions like "search for tasks I follow in Feishu since the beginning of this year", although they literally contain "search", if there are no actual query keywords and the essence is to limit "related to me + time range", prioritize +get-related-tasks; for expressions like "search for task lists created by me in Feishu", if there are no list keywords and the essence is to limit "list scope + creator", prioritize native tasklists.list followed by filtering, rather than directly using a search-type shortcut. User identity recognition: In user identity scenarios, if the user mentions "me" (e.g., "assigned to me", "created by me"), by default obtain the current logged-in user's open_id as the corresponding parameter value. Terminology understanding — todo disambiguation (required reading)：

When the user mentions "todo / task",first determine the attribution, do not default to this skill.

Go to lark-meeting for minutes +todo(this skill is prohibited): the context contains Minutes / meeting minutes / minute_token / Minutes URL（/minutes/); or "create/modify a todo in a certain Minutes", "Minutes AI todo", "todo in meeting recording".

Go to this skill (lark-task): task lists, assigned to me, project todos, due date/reminder, subtasks, task list members; or the applink contains client/todo/task?guid=; or explicitly says "Feishu Tasks", "Task Center", "my task list".

Prohibited: when the user wants to add a todo in Minutes,do notcall task tasklists list、task +create or any task command to "find a list and then put the task". Friendly output: When outputting the execution result of a task (or list) to the user, it is recommended to also extract and output the url field (task link) from the command return result, so that the user can directly click to jump and view details.

Creation/update notes：

Only when due(due time) is set can repeat_rule(recurrence rule) and reminder(reminder time) be set.

If both start(start time) and due(due time) are set, the start time must be less than or equal to the due time.

When using tenant_access_token (app identity), you cannot add task members across tenants.

Query notes：

When outputting task details, if you need to render personnel fields such as assignee and creator, in addition to displaying id (for example, open_id), you must also try to obtain and display the person's real name through other means (for example, calling the contacts skill), so that users can identify them more easily.

When outputting checklist details, if you need to render personnel fields such as owner, member, and role members, you must also, like when displaying task members, in addition to displaying id , try to parse and display the corresponding person's real name.

When outputting task or checklist details, if you need to render fields such as creation time and due time, you need to use the local time zone to render them (format: 2006-01-02 15:04:05).

Task GUID definition: In the Task OpenAPI, the guid used to update/operate on tasks is the task's globally unique identifier (GUID), not the client-displayed task number (for example, t104121 / suite_entity_num). For a Feishu task applink (for example, .../client/todo/task?guid=...), you must use the guid parameter in the URL query as the task guid.

Shortest path to locate and modify a task from a task checklist：

When the task checklist GUID is known, use it directly; do not search first. When the task checklist applink is known, take the guid from the URL query as the tasklist_guid。

Only when there is only a checklist name or keyword and no GUID/applink, call +tasklist-search once to resolve the target checklist.

Follow the native API rules: first execute lark-cli schema task.tasklists.tasks, then execute lark-cli task tasklists tasks --params '{"tasklist_guid":"<tasklist_guid>"}' --as user。

From the checklist task results, take the task's guidand pass it directly to +update or +complete; passing the client-displayed number (for example, t104121) is prohibited. These two shortcuts can also directly accept a task applink containing guid= .

+update returns updated_fields and each task's server-side confirmed field;+complete returns status、completed_at、already_completed. When these fields have already confirmed the target state, do not routinely append tasks get; query details again only when the server does not return the required fields or the user explicitly requests a complete review.

Shortcut	Description
`+create`	create a task
`+update`	update task attributes
`+set-ancestor`	set or clear a task ancestor
`+comment`	add a comment to a task
`+complete`	mark a task as complete
`+reopen`	reopen a completed task
`+assign`	assign or remove task members
`+followers`	manage task followers
`+reminder`	manage task reminders
`+get-my-tasks`	List tasks assigned to me
`+get-related-tasks`	list tasks related to me
`+search`	search tasks
`+upload-attachment`	upload a local file as an attachment to a task
`+tasklist-create`	create a tasklist and optionally add tasks
`+tasklist-search`	search tasklists
`+tasklist-task-add`	add tasks to a tasklist
`+tasklist-members`	manage tasklist members

API Resources

lark-cli schema task.<resource>.<method>   # 调用 API 前必须先查看参数结构
lark-cli task <resource> <method> [flags] # 调用 API

Important: When using the native API, you must first run schema to view the --data / --params parameter structure; do not guess the field format.

tasks

create — Create task
delete — Delete task
get — Get task details
list — List tasks
patch — Update task

tasklists

add_members — Add checklist member
create — Create checklist
delete — Delete checklist
get — Get checklist details
list — Get checklist list
patch — Update checklist
remove_members — Remove checklist member
tasks — Get checklist task list

subtasks

create — Create subtask
list — Get a task's subtask list

members

add — Add task member
remove — Remove task member

sections

create — Create custom section
delete — Delete custom section
get — Get custom section details
list — Get custom section list
patch — Update custom group
tasks — Get custom group task list

custom_fields

create — Create custom field
get — Get custom field details
patch — Update custom field
list — Get custom field list
add — Add custom field to resource
remove — Remove custom field from resource

custom_field_options

create — Create custom field option
patch — Update custom field option

agent

update_agent_profile — Update the homepage content data of the task agent.
register_agent — Register AI agent

agent_task_step_info

append_task_steps — Write task record.

Permission table

Method	Required scope
`tasks.create`	`task:task:write`
`tasks.delete`	`task:task:write`
`tasks.get`	`task:task:read`
`tasks.list`	`task:task:read`
`tasks.patch`	`task:task:write`
`tasklists.add_members`	`task:tasklist:write`
`tasklists.create`	`task:tasklist:write`
`tasklists.delete`	`task:tasklist:write`
`tasklists.get`	`task:tasklist:read`
`tasklists.list`	`task:tasklist:read`
`tasklists.patch`	`task:tasklist:write`
`tasklists.remove_members`	`task:tasklist:write`
`tasklists.tasks`	`task:tasklist:read`
`subtasks.create`	`task:task:write`
`subtasks.list`	`task:task:read`
`members.add`	`task:task:write`
`members.remove`	`task:task:write`
`sections.create`	`task:section:write`
`sections.delete`	`task:section:write`
`sections.get`	`task:section:read`
`sections.list`	`task:section:read`
`sections.patch`	`task:section:write`
`sections.tasks`	`task:section:read`
`custom_fields.create`	`task:custom_field:write`
`custom_fields.get`	`task:custom_field:read`
`custom_fields.patch`	`task:custom_field:write`
`custom_fields.list`	`task:custom_field:read`
`custom_fields.add`	`task:custom_field:write`
`custom_fields.remove`	`task:custom_field:write`
`custom_field_options.create`	`task:custom_field:write`
`custom_field_options.patch`	`task:custom_field:write`
`agent.update_agent_profile`	`task:task:write`
`agent.register_agent`	`task:task:write`
`agent_task_step_info.append_task_steps`	`task:task:write`