@agimon-ai/doompi-task 0.0.1-alpha.29 → 0.0.1-alpha.30

package/dist/commands/task/promptGuidelines.cjs

@@ -1,2 +1,2 @@
-const e=["Use `task` only for complex jobs where persistent coordination materially improves execution, such as work with dependencies, multiple parallel workstreams, substantial delegated work, or a long-running plan that must survive context compaction. Do not use it for simple requests, routine edits, straightforward command sequences, or merely because a request contains several steps. Never create a task list only to restate new instructions.",`Capture a whole plan in one call: {"action":"upsert","tasks":[{"subject":"Research existing tool"},{"subject":"Write the reducer"},{"subject":"Add tests"}]}. Batch whenever you are writing the plan down — the initial list, a revised plan, or wiring dependencies across several tasks — because one call keeps ids and blockers consistent and shows the user the whole plan at once.`,`Do not batch parent progress. Mark a task in_progress with its own call BEFORE beginning work, and completed with its own call IMMEDIATELY when it is done. upsert accepts many tasks, but a batch of completions sent at the end of a turn is still wrong: upsert batching is for writing a plan down, single calls are for reporting progress, and the user watches the task list to see where you are. Native assignments[] fan-out is separate from progress reporting. Exactly one task should be in_progress for your own work; delegated tasks run in parallel and do not count against that.`,`Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors, use status "failed" or keep it in_progress and add a new task for the blocker in the same upsert.`,`When every non-deleted task is completed, review the full task list once more and call task {"action":"clear"} to close it. Do not leave an all-completed list open.`,`Status is a state machine: pending → in_progress → completed, plus failed (recoverable, can go back to pending or in_progress) and deleted as a tombstone. Pass activeForm (present-continuous, e.g. 'writing tests') when marking in_progress.`,`One call does both: an entry with an id changes that task, an entry without an id creates one. To change status, upsert the task by id, e.g. {"action":"upsert","tasks":[{"id":3,"status":"completed"}]}. Never omit the id when you meant to change an existing task — an entry with no id creates a new one instead. An entry that carries an id and no other field is rejected.`,`Use blockedBy for dependencies (A is blocked by B). On an entry with no id pass blockedBy as the initial set; on an entry with an id use addBlockedBy / removeBlockedBy (additive merge, do not resend the full array). To depend on a task created earlier in the SAME call, give that earlier entry a "ref" and list the ref string in place of an id: [{"ref":"api","subject":"Design the API"},{"subject":"Implement the API","blockedBy":["api"]}]. A ref must be declared before it is used. Cycles are rejected.`,`upsert applies each entry independently: the entries that pass are committed and the failures are reported with their array index. A failed entry changed nothing, so resend only the corrected failures — never resend the whole call, because an already-applied entry with no id would create a duplicate task.`,`Before assigning work, call subagent with {"action":"agents"} and match each task to an exact discovered agent name. Prefer a discovered general-purpose write-capable agent such as delegate or worker when no specialist fits. Use a focused inlineAgent only for read-only work.`,`Assign every unblocked pending task, including implementation tasks. Use assignments[] for every assign call, including one task: {"action":"assign","assignments":[{"id":1,"agent":"researcher"}]}. Put all assign-time fields — including model, inlineAgent, instructions, relevantFiles, priorFindings, and context — inside each assignments[] entry; assign has no top-level single-task form. For two or more independent ready tasks, use one native batch instead of repeated calls. Do not wrap repeated task assign calls in multi_tool; assignments[] reduces tool overhead and returns one indexed result. Do not use a direct subagent run for work already represented in the shared task list, so ownership and terminal results stay visible.`,`A batched assign applies each entry independently. Successful entries are already running if another entry fails; retry only failed entries after correcting them, and never resend successful entries.`,`Hand over what you already know when you assign. Pass relevantFiles with the paths you have actually read or located for that task, and priorFindings with the facts you established: symbol names, call sites, the approach you picked, what you ruled out. A fresh-context child starts with none of your context and will otherwise spend most of its run re-reading the repo. It treats this verified pack as satisfying initial context exploration, reads known paths directly, and widens discovery only for a concrete missing dependency. Send at most a dozen files and only ones you really opened — a guessed path costs the child more than an omitted one — and keep priorFindings to a few lines of facts, not directives.`,`After assigning work, continue non-overlapping parent work or end your turn. Do not poll or duplicate delegated scope.`,`When a delegated task completes and unblocks another task, repeat agent discovery if needed and assign that newly eligible task promptly. Do not poll in a loop. Completion notifications wake the parent session.`,`If a child asks for a decision through intercom, or an assignment fails to start for another concrete issue, respond, rescope, or retry explicitly. Do not silently leave the task pending.`,`assign refuses tasks that are blocked, already delegated, or completed. Resolve blockers first. Use {"action":"cancel","id":3} to stop a running delegation; the task returns to pending.`,`Doom Task records delegated lifecycle and results on the shared task. The child does not update task status directly. Read the completion or failure result before deciding what to do next.`,`The task list is scoped to this session tree: delegated subagents share it, while unrelated sessions start empty. It persists for later inspection until retention cleanup.`,`Subject must be short and imperative (e.g. 'Research existing tool'); description is long-form detail written when you plan the task, and the delegated brief is that description plus the assign-time instructions, relevantFiles and priorFindings. Put durable scope in description and what you learned while exploring in the assign-time pack — do not repeat one in the other.`];exports.DEFAULT_PROMPT_GUIDELINES=e;
+const e=[`Capture a whole plan in one call: {"action":"upsert","tasks":[{"subject":"Research existing tool"},{"subject":"Write the reducer"},{"subject":"Add tests"}]}. Batch whenever you are writing the plan down — the initial list, a revised plan, or wiring dependencies across several tasks — because one call keeps ids and blockers consistent and shows the user the whole plan at once.`,`Do not batch parent progress. Mark a task in_progress with its own call BEFORE beginning work, and completed with its own call IMMEDIATELY when it is done. upsert accepts many tasks, but a batch of completions sent at the end of a turn is still wrong: upsert batching is for writing a plan down, single calls are for reporting progress, and the user watches the task list to see where you are. Native assignments[] fan-out is separate from progress reporting. Exactly one task should be in_progress for your own work; delegated tasks run in parallel and do not count against that.`,`Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors, use status "failed" or keep it in_progress and add a new task for the blocker in the same upsert.`,`When every non-deleted task is completed, review the full task list once more and call task {"action":"clear"} to close it. Do not leave an all-completed list open.`,`Status is a state machine: pending → in_progress → completed, plus failed (recoverable, can go back to pending or in_progress) and deleted as a tombstone. Pass activeForm (present-continuous, e.g. 'writing tests') when marking in_progress.`,`One call does both: an entry with an id changes that task, an entry without an id creates one. To change status, upsert the task by id, e.g. {"action":"upsert","tasks":[{"id":3,"status":"completed"}]}. Never omit the id when you meant to change an existing task — an entry with no id creates a new one instead. An entry that carries an id and no other field is rejected.`,`Use blockedBy for dependencies (A is blocked by B). On an entry with no id pass blockedBy as the initial set; on an entry with an id use addBlockedBy / removeBlockedBy (additive merge, do not resend the full array). To depend on a task created earlier in the SAME call, give that earlier entry a "ref" and list the ref string in place of an id: [{"ref":"api","subject":"Design the API"},{"subject":"Implement the API","blockedBy":["api"]}]. A ref must be declared before it is used. Cycles are rejected.`,`upsert applies each entry independently: the entries that pass are committed and the failures are reported with their array index. A failed entry changed nothing, so resend only the corrected failures — never resend the whole call, because an already-applied entry with no id would create a duplicate task.`,`Before assigning work, call subagent with {"action":"agents"} and match each task to an exact discovered agent name. Prefer a discovered general-purpose write-capable agent such as delegate or worker when no specialist fits. Use a focused inlineAgent only for read-only work.`,`Apply the session's general delegation criteria before selecting tracked work. Use assignments[] for every assign call, including one task: {"action":"assign","assignments":[{"id":1,"agent":"researcher"}]}. Put every assign-time field, including model, inlineAgent, instructions, relevantFiles, priorFindings, and context, inside its assignments[] entry; assign has no top-level single-task form. For two or more independent ready tasks selected for delegation, use one native batch instead of repeated calls. Do not wrap repeated task assign calls in multi_tool; assignments[] reduces tool overhead and returns one indexed result. Do not use a direct subagent run for work already represented in the shared task list, so ownership and terminal results stay visible.`,`A batched assign applies each entry independently. Successful entries are already running if another entry fails; retry only failed entries after correcting them, and never resend successful entries.`,`Populate relevantFiles only with files you actually read or located, and priorFindings only with verified facts such as symbol names, call sites, the selected approach, and ruled-out alternatives. Send at most a dozen files; a guessed path costs more than an omitted one. Keep priorFindings to a few lines of facts, not directives.`,`When delegated task completion unblocks another tracked task, reconsider that newly eligible task promptly and repeat agent discovery before assigning it if needed.`,`If a child asks for a decision through intercom, or an assignment fails to start for another concrete issue, respond, rescope, or retry explicitly. Do not silently leave the task pending.`,`assign refuses tasks that are blocked, already delegated, or completed. Resolve blockers first. Use {"action":"cancel","id":3} to stop a running delegation; the task returns to pending.`,`Doom Task records delegated lifecycle and results on the shared task. The child does not update task status directly.`,`The task list is scoped to this session tree: delegated subagents share it, while unrelated sessions start empty. It persists for later inspection until retention cleanup.`,`Subject must be short and imperative (e.g. 'Research existing tool'); description is long-form detail written when you plan the task, and the delegated brief is that description plus the assign-time instructions, relevantFiles and priorFindings. Put durable scope in description and what you learned while exploring in the assign-time pack — do not repeat one in the other.`];exports.DEFAULT_PROMPT_GUIDELINES=e;
 //# sourceMappingURL=promptGuidelines.cjs.map

package/dist/commands/task/promptGuidelines.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"promptGuidelines.cjs","names":[],"sources":["../../../src/commands/task/promptGuidelines.ts"],"sourcesContent":["export const DEFAULT_PROMPT_GUIDELINES: string[] = [\n  'Use `task` only for complex jobs where persistent coordination materially improves execution, such as work with dependencies, multiple parallel workstreams, substantial delegated work, or a long-running plan that must survive context compaction. Do not use it for simple requests, routine edits, straightforward command sequences, or merely because a request contains several steps. Never create a task list only to restate new instructions.',\n  'Capture a whole plan in one call: {\"action\":\"upsert\",\"tasks\":[{\"subject\":\"Research existing tool\"},{\"subject\":\"Write the reducer\"},{\"subject\":\"Add tests\"}]}. Batch whenever you are writing the plan down — the initial list, a revised plan, or wiring dependencies across several tasks — because one call keeps ids and blockers consistent and shows the user the whole plan at once.',\n  'Do not batch parent progress. Mark a task in_progress with its own call BEFORE beginning work, and completed with its own call IMMEDIATELY when it is done. upsert accepts many tasks, but a batch of completions sent at the end of a turn is still wrong: upsert batching is for writing a plan down, single calls are for reporting progress, and the user watches the task list to see where you are. Native assignments[] fan-out is separate from progress reporting. Exactly one task should be in_progress for your own work; delegated tasks run in parallel and do not count against that.',\n  'Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors, use status \"failed\" or keep it in_progress and add a new task for the blocker in the same upsert.',\n  'When every non-deleted task is completed, review the full task list once more and call task {\"action\":\"clear\"} to close it. Do not leave an all-completed list open.',\n  \"Status is a state machine: pending → in_progress → completed, plus failed (recoverable, can go back to pending or in_progress) and deleted as a tombstone. Pass activeForm (present-continuous, e.g. 'writing tests') when marking in_progress.\",\n  'One call does both: an entry with an id changes that task, an entry without an id creates one. To change status, upsert the task by id, e.g. {\"action\":\"upsert\",\"tasks\":[{\"id\":3,\"status\":\"completed\"}]}. Never omit the id when you meant to change an existing task — an entry with no id creates a new one instead. An entry that carries an id and no other field is rejected.',\n  'Use blockedBy for dependencies (A is blocked by B). On an entry with no id pass blockedBy as the initial set; on an entry with an id use addBlockedBy / removeBlockedBy (additive merge, do not resend the full array). To depend on a task created earlier in the SAME call, give that earlier entry a \"ref\" and list the ref string in place of an id: [{\"ref\":\"api\",\"subject\":\"Design the API\"},{\"subject\":\"Implement the API\",\"blockedBy\":[\"api\"]}]. A ref must be declared before it is used. Cycles are rejected.',\n  'upsert applies each entry independently: the entries that pass are committed and the failures are reported with their array index. A failed entry changed nothing, so resend only the corrected failures — never resend the whole call, because an already-applied entry with no id would create a duplicate task.',\n  'Before assigning work, call subagent with {\"action\":\"agents\"} and match each task to an exact discovered agent name. Prefer a discovered general-purpose write-capable agent such as delegate or worker when no specialist fits. Use a focused inlineAgent only for read-only work.',\n  'Assign every unblocked pending task, including implementation tasks. Use assignments[] for every assign call, including one task: {\"action\":\"assign\",\"assignments\":[{\"id\":1,\"agent\":\"researcher\"}]}. Put all assign-time fields — including model, inlineAgent, instructions, relevantFiles, priorFindings, and context — inside each assignments[] entry; assign has no top-level single-task form. For two or more independent ready tasks, use one native batch instead of repeated calls. Do not wrap repeated task assign calls in multi_tool; assignments[] reduces tool overhead and returns one indexed result. Do not use a direct subagent run for work already represented in the shared task list, so ownership and terminal results stay visible.',\n  'A batched assign applies each entry independently. Successful entries are already running if another entry fails; retry only failed entries after correcting them, and never resend successful entries.',\n  'Hand over what you already know when you assign. Pass relevantFiles with the paths you have actually read or located for that task, and priorFindings with the facts you established: symbol names, call sites, the approach you picked, what you ruled out. A fresh-context child starts with none of your context and will otherwise spend most of its run re-reading the repo. It treats this verified pack as satisfying initial context exploration, reads known paths directly, and widens discovery only for a concrete missing dependency. Send at most a dozen files and only ones you really opened — a guessed path costs the child more than an omitted one — and keep priorFindings to a few lines of facts, not directives.',\n  'After assigning work, continue non-overlapping parent work or end your turn. Do not poll or duplicate delegated scope.',\n  'When a delegated task completes and unblocks another task, repeat agent discovery if needed and assign that newly eligible task promptly. Do not poll in a loop. Completion notifications wake the parent session.',\n  'If a child asks for a decision through intercom, or an assignment fails to start for another concrete issue, respond, rescope, or retry explicitly. Do not silently leave the task pending.',\n  'assign refuses tasks that are blocked, already delegated, or completed. Resolve blockers first. Use {\"action\":\"cancel\",\"id\":3} to stop a running delegation; the task returns to pending.',\n  'Doom Task records delegated lifecycle and results on the shared task. The child does not update task status directly. Read the completion or failure result before deciding what to do next.',\n  'The task list is scoped to this session tree: delegated subagents share it, while unrelated sessions start empty. It persists for later inspection until retention cleanup.',\n  \"Subject must be short and imperative (e.g. 'Research existing tool'); description is long-form detail written when you plan the task, and the delegated brief is that description plus the assign-time instructions, relevantFiles and priorFindings. Put durable scope in description and what you learned while exploring in the assign-time pack — do not repeat one in the other.\",\n];\n"],"mappings":"AAAA,MAAa,EAAsC,CACjD,4bACA,6XACA,ukBACA,mNACA,uKACA,kPACA,qXACA,0fACA,qTACA,sRACA,iuBACA,0MACA,4sBACA,yHACA,qNACA,8LACA,4LACA,+LACA,8KACA,uXACF"}
+{"version":3,"file":"promptGuidelines.cjs","names":[],"sources":["../../../src/commands/task/promptGuidelines.ts"],"sourcesContent":["export const DEFAULT_PROMPT_GUIDELINES: string[] = [\n  'Capture a whole plan in one call: {\"action\":\"upsert\",\"tasks\":[{\"subject\":\"Research existing tool\"},{\"subject\":\"Write the reducer\"},{\"subject\":\"Add tests\"}]}. Batch whenever you are writing the plan down — the initial list, a revised plan, or wiring dependencies across several tasks — because one call keeps ids and blockers consistent and shows the user the whole plan at once.',\n  'Do not batch parent progress. Mark a task in_progress with its own call BEFORE beginning work, and completed with its own call IMMEDIATELY when it is done. upsert accepts many tasks, but a batch of completions sent at the end of a turn is still wrong: upsert batching is for writing a plan down, single calls are for reporting progress, and the user watches the task list to see where you are. Native assignments[] fan-out is separate from progress reporting. Exactly one task should be in_progress for your own work; delegated tasks run in parallel and do not count against that.',\n  'Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors, use status \"failed\" or keep it in_progress and add a new task for the blocker in the same upsert.',\n  'When every non-deleted task is completed, review the full task list once more and call task {\"action\":\"clear\"} to close it. Do not leave an all-completed list open.',\n  \"Status is a state machine: pending → in_progress → completed, plus failed (recoverable, can go back to pending or in_progress) and deleted as a tombstone. Pass activeForm (present-continuous, e.g. 'writing tests') when marking in_progress.\",\n  'One call does both: an entry with an id changes that task, an entry without an id creates one. To change status, upsert the task by id, e.g. {\"action\":\"upsert\",\"tasks\":[{\"id\":3,\"status\":\"completed\"}]}. Never omit the id when you meant to change an existing task — an entry with no id creates a new one instead. An entry that carries an id and no other field is rejected.',\n  'Use blockedBy for dependencies (A is blocked by B). On an entry with no id pass blockedBy as the initial set; on an entry with an id use addBlockedBy / removeBlockedBy (additive merge, do not resend the full array). To depend on a task created earlier in the SAME call, give that earlier entry a \"ref\" and list the ref string in place of an id: [{\"ref\":\"api\",\"subject\":\"Design the API\"},{\"subject\":\"Implement the API\",\"blockedBy\":[\"api\"]}]. A ref must be declared before it is used. Cycles are rejected.',\n  'upsert applies each entry independently: the entries that pass are committed and the failures are reported with their array index. A failed entry changed nothing, so resend only the corrected failures — never resend the whole call, because an already-applied entry with no id would create a duplicate task.',\n  'Before assigning work, call subagent with {\"action\":\"agents\"} and match each task to an exact discovered agent name. Prefer a discovered general-purpose write-capable agent such as delegate or worker when no specialist fits. Use a focused inlineAgent only for read-only work.',\n  'Apply the session\\'s general delegation criteria before selecting tracked work. Use assignments[] for every assign call, including one task: {\"action\":\"assign\",\"assignments\":[{\"id\":1,\"agent\":\"researcher\"}]}. Put every assign-time field, including model, inlineAgent, instructions, relevantFiles, priorFindings, and context, inside its assignments[] entry; assign has no top-level single-task form. For two or more independent ready tasks selected for delegation, use one native batch instead of repeated calls. Do not wrap repeated task assign calls in multi_tool; assignments[] reduces tool overhead and returns one indexed result. Do not use a direct subagent run for work already represented in the shared task list, so ownership and terminal results stay visible.',\n  'A batched assign applies each entry independently. Successful entries are already running if another entry fails; retry only failed entries after correcting them, and never resend successful entries.',\n  'Populate relevantFiles only with files you actually read or located, and priorFindings only with verified facts such as symbol names, call sites, the selected approach, and ruled-out alternatives. Send at most a dozen files; a guessed path costs more than an omitted one. Keep priorFindings to a few lines of facts, not directives.',\n  'When delegated task completion unblocks another tracked task, reconsider that newly eligible task promptly and repeat agent discovery before assigning it if needed.',\n  'If a child asks for a decision through intercom, or an assignment fails to start for another concrete issue, respond, rescope, or retry explicitly. Do not silently leave the task pending.',\n  'assign refuses tasks that are blocked, already delegated, or completed. Resolve blockers first. Use {\"action\":\"cancel\",\"id\":3} to stop a running delegation; the task returns to pending.',\n  'Doom Task records delegated lifecycle and results on the shared task. The child does not update task status directly.',\n  'The task list is scoped to this session tree: delegated subagents share it, while unrelated sessions start empty. It persists for later inspection until retention cleanup.',\n  \"Subject must be short and imperative (e.g. 'Research existing tool'); description is long-form detail written when you plan the task, and the delegated brief is that description plus the assign-time instructions, relevantFiles and priorFindings. Put durable scope in description and what you learned while exploring in the assign-time pack — do not repeat one in the other.\",\n];\n"],"mappings":"AAAA,MAAa,EAAsC,CACjD,6XACA,ukBACA,mNACA,uKACA,kPACA,qXACA,0fACA,qTACA,sRACA,iwBACA,0MACA,8UACA,uKACA,8LACA,4LACA,wHACA,8KACA,uXACF"}

package/dist/commands/task/promptGuidelines.mjs

@@ -1,2 +1,2 @@
-const e=["Use `task` only for complex jobs where persistent coordination materially improves execution, such as work with dependencies, multiple parallel workstreams, substantial delegated work, or a long-running plan that must survive context compaction. Do not use it for simple requests, routine edits, straightforward command sequences, or merely because a request contains several steps. Never create a task list only to restate new instructions.",`Capture a whole plan in one call: {"action":"upsert","tasks":[{"subject":"Research existing tool"},{"subject":"Write the reducer"},{"subject":"Add tests"}]}. Batch whenever you are writing the plan down — the initial list, a revised plan, or wiring dependencies across several tasks — because one call keeps ids and blockers consistent and shows the user the whole plan at once.`,`Do not batch parent progress. Mark a task in_progress with its own call BEFORE beginning work, and completed with its own call IMMEDIATELY when it is done. upsert accepts many tasks, but a batch of completions sent at the end of a turn is still wrong: upsert batching is for writing a plan down, single calls are for reporting progress, and the user watches the task list to see where you are. Native assignments[] fan-out is separate from progress reporting. Exactly one task should be in_progress for your own work; delegated tasks run in parallel and do not count against that.`,`Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors, use status "failed" or keep it in_progress and add a new task for the blocker in the same upsert.`,`When every non-deleted task is completed, review the full task list once more and call task {"action":"clear"} to close it. Do not leave an all-completed list open.`,`Status is a state machine: pending → in_progress → completed, plus failed (recoverable, can go back to pending or in_progress) and deleted as a tombstone. Pass activeForm (present-continuous, e.g. 'writing tests') when marking in_progress.`,`One call does both: an entry with an id changes that task, an entry without an id creates one. To change status, upsert the task by id, e.g. {"action":"upsert","tasks":[{"id":3,"status":"completed"}]}. Never omit the id when you meant to change an existing task — an entry with no id creates a new one instead. An entry that carries an id and no other field is rejected.`,`Use blockedBy for dependencies (A is blocked by B). On an entry with no id pass blockedBy as the initial set; on an entry with an id use addBlockedBy / removeBlockedBy (additive merge, do not resend the full array). To depend on a task created earlier in the SAME call, give that earlier entry a "ref" and list the ref string in place of an id: [{"ref":"api","subject":"Design the API"},{"subject":"Implement the API","blockedBy":["api"]}]. A ref must be declared before it is used. Cycles are rejected.`,`upsert applies each entry independently: the entries that pass are committed and the failures are reported with their array index. A failed entry changed nothing, so resend only the corrected failures — never resend the whole call, because an already-applied entry with no id would create a duplicate task.`,`Before assigning work, call subagent with {"action":"agents"} and match each task to an exact discovered agent name. Prefer a discovered general-purpose write-capable agent such as delegate or worker when no specialist fits. Use a focused inlineAgent only for read-only work.`,`Assign every unblocked pending task, including implementation tasks. Use assignments[] for every assign call, including one task: {"action":"assign","assignments":[{"id":1,"agent":"researcher"}]}. Put all assign-time fields — including model, inlineAgent, instructions, relevantFiles, priorFindings, and context — inside each assignments[] entry; assign has no top-level single-task form. For two or more independent ready tasks, use one native batch instead of repeated calls. Do not wrap repeated task assign calls in multi_tool; assignments[] reduces tool overhead and returns one indexed result. Do not use a direct subagent run for work already represented in the shared task list, so ownership and terminal results stay visible.`,`A batched assign applies each entry independently. Successful entries are already running if another entry fails; retry only failed entries after correcting them, and never resend successful entries.`,`Hand over what you already know when you assign. Pass relevantFiles with the paths you have actually read or located for that task, and priorFindings with the facts you established: symbol names, call sites, the approach you picked, what you ruled out. A fresh-context child starts with none of your context and will otherwise spend most of its run re-reading the repo. It treats this verified pack as satisfying initial context exploration, reads known paths directly, and widens discovery only for a concrete missing dependency. Send at most a dozen files and only ones you really opened — a guessed path costs the child more than an omitted one — and keep priorFindings to a few lines of facts, not directives.`,`After assigning work, continue non-overlapping parent work or end your turn. Do not poll or duplicate delegated scope.`,`When a delegated task completes and unblocks another task, repeat agent discovery if needed and assign that newly eligible task promptly. Do not poll in a loop. Completion notifications wake the parent session.`,`If a child asks for a decision through intercom, or an assignment fails to start for another concrete issue, respond, rescope, or retry explicitly. Do not silently leave the task pending.`,`assign refuses tasks that are blocked, already delegated, or completed. Resolve blockers first. Use {"action":"cancel","id":3} to stop a running delegation; the task returns to pending.`,`Doom Task records delegated lifecycle and results on the shared task. The child does not update task status directly. Read the completion or failure result before deciding what to do next.`,`The task list is scoped to this session tree: delegated subagents share it, while unrelated sessions start empty. It persists for later inspection until retention cleanup.`,`Subject must be short and imperative (e.g. 'Research existing tool'); description is long-form detail written when you plan the task, and the delegated brief is that description plus the assign-time instructions, relevantFiles and priorFindings. Put durable scope in description and what you learned while exploring in the assign-time pack — do not repeat one in the other.`];export{e as DEFAULT_PROMPT_GUIDELINES};
+const e=[`Capture a whole plan in one call: {"action":"upsert","tasks":[{"subject":"Research existing tool"},{"subject":"Write the reducer"},{"subject":"Add tests"}]}. Batch whenever you are writing the plan down — the initial list, a revised plan, or wiring dependencies across several tasks — because one call keeps ids and blockers consistent and shows the user the whole plan at once.`,`Do not batch parent progress. Mark a task in_progress with its own call BEFORE beginning work, and completed with its own call IMMEDIATELY when it is done. upsert accepts many tasks, but a batch of completions sent at the end of a turn is still wrong: upsert batching is for writing a plan down, single calls are for reporting progress, and the user watches the task list to see where you are. Native assignments[] fan-out is separate from progress reporting. Exactly one task should be in_progress for your own work; delegated tasks run in parallel and do not count against that.`,`Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors, use status "failed" or keep it in_progress and add a new task for the blocker in the same upsert.`,`When every non-deleted task is completed, review the full task list once more and call task {"action":"clear"} to close it. Do not leave an all-completed list open.`,`Status is a state machine: pending → in_progress → completed, plus failed (recoverable, can go back to pending or in_progress) and deleted as a tombstone. Pass activeForm (present-continuous, e.g. 'writing tests') when marking in_progress.`,`One call does both: an entry with an id changes that task, an entry without an id creates one. To change status, upsert the task by id, e.g. {"action":"upsert","tasks":[{"id":3,"status":"completed"}]}. Never omit the id when you meant to change an existing task — an entry with no id creates a new one instead. An entry that carries an id and no other field is rejected.`,`Use blockedBy for dependencies (A is blocked by B). On an entry with no id pass blockedBy as the initial set; on an entry with an id use addBlockedBy / removeBlockedBy (additive merge, do not resend the full array). To depend on a task created earlier in the SAME call, give that earlier entry a "ref" and list the ref string in place of an id: [{"ref":"api","subject":"Design the API"},{"subject":"Implement the API","blockedBy":["api"]}]. A ref must be declared before it is used. Cycles are rejected.`,`upsert applies each entry independently: the entries that pass are committed and the failures are reported with their array index. A failed entry changed nothing, so resend only the corrected failures — never resend the whole call, because an already-applied entry with no id would create a duplicate task.`,`Before assigning work, call subagent with {"action":"agents"} and match each task to an exact discovered agent name. Prefer a discovered general-purpose write-capable agent such as delegate or worker when no specialist fits. Use a focused inlineAgent only for read-only work.`,`Apply the session's general delegation criteria before selecting tracked work. Use assignments[] for every assign call, including one task: {"action":"assign","assignments":[{"id":1,"agent":"researcher"}]}. Put every assign-time field, including model, inlineAgent, instructions, relevantFiles, priorFindings, and context, inside its assignments[] entry; assign has no top-level single-task form. For two or more independent ready tasks selected for delegation, use one native batch instead of repeated calls. Do not wrap repeated task assign calls in multi_tool; assignments[] reduces tool overhead and returns one indexed result. Do not use a direct subagent run for work already represented in the shared task list, so ownership and terminal results stay visible.`,`A batched assign applies each entry independently. Successful entries are already running if another entry fails; retry only failed entries after correcting them, and never resend successful entries.`,`Populate relevantFiles only with files you actually read or located, and priorFindings only with verified facts such as symbol names, call sites, the selected approach, and ruled-out alternatives. Send at most a dozen files; a guessed path costs more than an omitted one. Keep priorFindings to a few lines of facts, not directives.`,`When delegated task completion unblocks another tracked task, reconsider that newly eligible task promptly and repeat agent discovery before assigning it if needed.`,`If a child asks for a decision through intercom, or an assignment fails to start for another concrete issue, respond, rescope, or retry explicitly. Do not silently leave the task pending.`,`assign refuses tasks that are blocked, already delegated, or completed. Resolve blockers first. Use {"action":"cancel","id":3} to stop a running delegation; the task returns to pending.`,`Doom Task records delegated lifecycle and results on the shared task. The child does not update task status directly.`,`The task list is scoped to this session tree: delegated subagents share it, while unrelated sessions start empty. It persists for later inspection until retention cleanup.`,`Subject must be short and imperative (e.g. 'Research existing tool'); description is long-form detail written when you plan the task, and the delegated brief is that description plus the assign-time instructions, relevantFiles and priorFindings. Put durable scope in description and what you learned while exploring in the assign-time pack — do not repeat one in the other.`];export{e as DEFAULT_PROMPT_GUIDELINES};
 //# sourceMappingURL=promptGuidelines.mjs.map

package/dist/commands/task/promptGuidelines.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"promptGuidelines.mjs","names":[],"sources":["../../../src/commands/task/promptGuidelines.ts"],"sourcesContent":["export const DEFAULT_PROMPT_GUIDELINES: string[] = [\n  'Use `task` only for complex jobs where persistent coordination materially improves execution, such as work with dependencies, multiple parallel workstreams, substantial delegated work, or a long-running plan that must survive context compaction. Do not use it for simple requests, routine edits, straightforward command sequences, or merely because a request contains several steps. Never create a task list only to restate new instructions.',\n  'Capture a whole plan in one call: {\"action\":\"upsert\",\"tasks\":[{\"subject\":\"Research existing tool\"},{\"subject\":\"Write the reducer\"},{\"subject\":\"Add tests\"}]}. Batch whenever you are writing the plan down — the initial list, a revised plan, or wiring dependencies across several tasks — because one call keeps ids and blockers consistent and shows the user the whole plan at once.',\n  'Do not batch parent progress. Mark a task in_progress with its own call BEFORE beginning work, and completed with its own call IMMEDIATELY when it is done. upsert accepts many tasks, but a batch of completions sent at the end of a turn is still wrong: upsert batching is for writing a plan down, single calls are for reporting progress, and the user watches the task list to see where you are. Native assignments[] fan-out is separate from progress reporting. Exactly one task should be in_progress for your own work; delegated tasks run in parallel and do not count against that.',\n  'Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors, use status \"failed\" or keep it in_progress and add a new task for the blocker in the same upsert.',\n  'When every non-deleted task is completed, review the full task list once more and call task {\"action\":\"clear\"} to close it. Do not leave an all-completed list open.',\n  \"Status is a state machine: pending → in_progress → completed, plus failed (recoverable, can go back to pending or in_progress) and deleted as a tombstone. Pass activeForm (present-continuous, e.g. 'writing tests') when marking in_progress.\",\n  'One call does both: an entry with an id changes that task, an entry without an id creates one. To change status, upsert the task by id, e.g. {\"action\":\"upsert\",\"tasks\":[{\"id\":3,\"status\":\"completed\"}]}. Never omit the id when you meant to change an existing task — an entry with no id creates a new one instead. An entry that carries an id and no other field is rejected.',\n  'Use blockedBy for dependencies (A is blocked by B). On an entry with no id pass blockedBy as the initial set; on an entry with an id use addBlockedBy / removeBlockedBy (additive merge, do not resend the full array). To depend on a task created earlier in the SAME call, give that earlier entry a \"ref\" and list the ref string in place of an id: [{\"ref\":\"api\",\"subject\":\"Design the API\"},{\"subject\":\"Implement the API\",\"blockedBy\":[\"api\"]}]. A ref must be declared before it is used. Cycles are rejected.',\n  'upsert applies each entry independently: the entries that pass are committed and the failures are reported with their array index. A failed entry changed nothing, so resend only the corrected failures — never resend the whole call, because an already-applied entry with no id would create a duplicate task.',\n  'Before assigning work, call subagent with {\"action\":\"agents\"} and match each task to an exact discovered agent name. Prefer a discovered general-purpose write-capable agent such as delegate or worker when no specialist fits. Use a focused inlineAgent only for read-only work.',\n  'Assign every unblocked pending task, including implementation tasks. Use assignments[] for every assign call, including one task: {\"action\":\"assign\",\"assignments\":[{\"id\":1,\"agent\":\"researcher\"}]}. Put all assign-time fields — including model, inlineAgent, instructions, relevantFiles, priorFindings, and context — inside each assignments[] entry; assign has no top-level single-task form. For two or more independent ready tasks, use one native batch instead of repeated calls. Do not wrap repeated task assign calls in multi_tool; assignments[] reduces tool overhead and returns one indexed result. Do not use a direct subagent run for work already represented in the shared task list, so ownership and terminal results stay visible.',\n  'A batched assign applies each entry independently. Successful entries are already running if another entry fails; retry only failed entries after correcting them, and never resend successful entries.',\n  'Hand over what you already know when you assign. Pass relevantFiles with the paths you have actually read or located for that task, and priorFindings with the facts you established: symbol names, call sites, the approach you picked, what you ruled out. A fresh-context child starts with none of your context and will otherwise spend most of its run re-reading the repo. It treats this verified pack as satisfying initial context exploration, reads known paths directly, and widens discovery only for a concrete missing dependency. Send at most a dozen files and only ones you really opened — a guessed path costs the child more than an omitted one — and keep priorFindings to a few lines of facts, not directives.',\n  'After assigning work, continue non-overlapping parent work or end your turn. Do not poll or duplicate delegated scope.',\n  'When a delegated task completes and unblocks another task, repeat agent discovery if needed and assign that newly eligible task promptly. Do not poll in a loop. Completion notifications wake the parent session.',\n  'If a child asks for a decision through intercom, or an assignment fails to start for another concrete issue, respond, rescope, or retry explicitly. Do not silently leave the task pending.',\n  'assign refuses tasks that are blocked, already delegated, or completed. Resolve blockers first. Use {\"action\":\"cancel\",\"id\":3} to stop a running delegation; the task returns to pending.',\n  'Doom Task records delegated lifecycle and results on the shared task. The child does not update task status directly. Read the completion or failure result before deciding what to do next.',\n  'The task list is scoped to this session tree: delegated subagents share it, while unrelated sessions start empty. It persists for later inspection until retention cleanup.',\n  \"Subject must be short and imperative (e.g. 'Research existing tool'); description is long-form detail written when you plan the task, and the delegated brief is that description plus the assign-time instructions, relevantFiles and priorFindings. Put durable scope in description and what you learned while exploring in the assign-time pack — do not repeat one in the other.\",\n];\n"],"mappings":"AAAA,MAAa,EAAsC,CACjD,4bACA,6XACA,ukBACA,mNACA,uKACA,kPACA,qXACA,0fACA,qTACA,sRACA,iuBACA,0MACA,4sBACA,yHACA,qNACA,8LACA,4LACA,+LACA,8KACA,uXACF"}
+{"version":3,"file":"promptGuidelines.mjs","names":[],"sources":["../../../src/commands/task/promptGuidelines.ts"],"sourcesContent":["export const DEFAULT_PROMPT_GUIDELINES: string[] = [\n  'Capture a whole plan in one call: {\"action\":\"upsert\",\"tasks\":[{\"subject\":\"Research existing tool\"},{\"subject\":\"Write the reducer\"},{\"subject\":\"Add tests\"}]}. Batch whenever you are writing the plan down — the initial list, a revised plan, or wiring dependencies across several tasks — because one call keeps ids and blockers consistent and shows the user the whole plan at once.',\n  'Do not batch parent progress. Mark a task in_progress with its own call BEFORE beginning work, and completed with its own call IMMEDIATELY when it is done. upsert accepts many tasks, but a batch of completions sent at the end of a turn is still wrong: upsert batching is for writing a plan down, single calls are for reporting progress, and the user watches the task list to see where you are. Native assignments[] fan-out is separate from progress reporting. Exactly one task should be in_progress for your own work; delegated tasks run in parallel and do not count against that.',\n  'Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors, use status \"failed\" or keep it in_progress and add a new task for the blocker in the same upsert.',\n  'When every non-deleted task is completed, review the full task list once more and call task {\"action\":\"clear\"} to close it. Do not leave an all-completed list open.',\n  \"Status is a state machine: pending → in_progress → completed, plus failed (recoverable, can go back to pending or in_progress) and deleted as a tombstone. Pass activeForm (present-continuous, e.g. 'writing tests') when marking in_progress.\",\n  'One call does both: an entry with an id changes that task, an entry without an id creates one. To change status, upsert the task by id, e.g. {\"action\":\"upsert\",\"tasks\":[{\"id\":3,\"status\":\"completed\"}]}. Never omit the id when you meant to change an existing task — an entry with no id creates a new one instead. An entry that carries an id and no other field is rejected.',\n  'Use blockedBy for dependencies (A is blocked by B). On an entry with no id pass blockedBy as the initial set; on an entry with an id use addBlockedBy / removeBlockedBy (additive merge, do not resend the full array). To depend on a task created earlier in the SAME call, give that earlier entry a \"ref\" and list the ref string in place of an id: [{\"ref\":\"api\",\"subject\":\"Design the API\"},{\"subject\":\"Implement the API\",\"blockedBy\":[\"api\"]}]. A ref must be declared before it is used. Cycles are rejected.',\n  'upsert applies each entry independently: the entries that pass are committed and the failures are reported with their array index. A failed entry changed nothing, so resend only the corrected failures — never resend the whole call, because an already-applied entry with no id would create a duplicate task.',\n  'Before assigning work, call subagent with {\"action\":\"agents\"} and match each task to an exact discovered agent name. Prefer a discovered general-purpose write-capable agent such as delegate or worker when no specialist fits. Use a focused inlineAgent only for read-only work.',\n  'Apply the session\\'s general delegation criteria before selecting tracked work. Use assignments[] for every assign call, including one task: {\"action\":\"assign\",\"assignments\":[{\"id\":1,\"agent\":\"researcher\"}]}. Put every assign-time field, including model, inlineAgent, instructions, relevantFiles, priorFindings, and context, inside its assignments[] entry; assign has no top-level single-task form. For two or more independent ready tasks selected for delegation, use one native batch instead of repeated calls. Do not wrap repeated task assign calls in multi_tool; assignments[] reduces tool overhead and returns one indexed result. Do not use a direct subagent run for work already represented in the shared task list, so ownership and terminal results stay visible.',\n  'A batched assign applies each entry independently. Successful entries are already running if another entry fails; retry only failed entries after correcting them, and never resend successful entries.',\n  'Populate relevantFiles only with files you actually read or located, and priorFindings only with verified facts such as symbol names, call sites, the selected approach, and ruled-out alternatives. Send at most a dozen files; a guessed path costs more than an omitted one. Keep priorFindings to a few lines of facts, not directives.',\n  'When delegated task completion unblocks another tracked task, reconsider that newly eligible task promptly and repeat agent discovery before assigning it if needed.',\n  'If a child asks for a decision through intercom, or an assignment fails to start for another concrete issue, respond, rescope, or retry explicitly. Do not silently leave the task pending.',\n  'assign refuses tasks that are blocked, already delegated, or completed. Resolve blockers first. Use {\"action\":\"cancel\",\"id\":3} to stop a running delegation; the task returns to pending.',\n  'Doom Task records delegated lifecycle and results on the shared task. The child does not update task status directly.',\n  'The task list is scoped to this session tree: delegated subagents share it, while unrelated sessions start empty. It persists for later inspection until retention cleanup.',\n  \"Subject must be short and imperative (e.g. 'Research existing tool'); description is long-form detail written when you plan the task, and the delegated brief is that description plus the assign-time instructions, relevantFiles and priorFindings. Put durable scope in description and what you learned while exploring in the assign-time pack — do not repeat one in the other.\",\n];\n"],"mappings":"AAAA,MAAa,EAAsC,CACjD,6XACA,ukBACA,mNACA,uKACA,kPACA,qXACA,0fACA,qTACA,sRACA,iwBACA,0MACA,8UACA,uKACA,8LACA,4LACA,wHACA,8KACA,uXACF"}

package/dist/commands/task/taskTool.cjs

@@ -1,3 +1,3 @@
-const e=require("../../schemas/task.cjs"),t=require("../../services/store/reducer.cjs"),n=require("../../types/telemetry.cjs"),r=require("../../tui/format2.cjs");require("../../types/config.cjs");const i=require("./promptGuidelines.cjs"),a=require("./responseEnvelope.cjs"),o=`Track only complex, multi-step jobs that benefit from persistent progress or delegation; skip simple work`,s=`tool.action`,c=`task.id`,l=new Set([`upsert`,`list`,`get`,`delete`,`clear`]);var u=class extends Error{};function d(e,t){return new u([`Task ${e} failed: ${t}`,``,`Options:`,`- List the task board and inspect the current ids, states, and blockers.`,`- Correct the arguments or state conflict, then retry once.`,`- Ask the user before cancelling work or changing dependencies to recover.`].join(`
-`))}function f(t,n){let r=Object.keys(n).filter(r=>n[r]!==void 0&&!e.taskActionAcceptsField(t,r));if(r.length===0)return;let i=t===`upsert`?` ${e.MSG_UPSERT_FIELD_MISPLACED}`:``;throw d(t,`${t} does not accept ${r.join(`, `)}.${i}`)}function p(e){let t=e.assignments;if(!t||t.length===0)throw d(`assign`,`assign requires a non-empty assignments[] array`);return t}function m(e,t){return{agent:e.agent,inlineAgent:e.inlineAgent,instructions:e.instructions,relevantFiles:e.relevantFiles,priorFindings:e.priorFindings,model:e.model,context:e.context,signal:t}}async function h(e,t,r,i){let a=[];for(let[o,l]of t.entries()){let t;try{t=await e.assign(l.id,m(l,r))}catch(e){i?.error(n.TASK_EVENT.toolFailed,e,{[s]:`assign`,[c]:l.id}),t={ok:!1,message:e instanceof Error?e.message:String(e)}}a.push({index:o,id:l.id,agent:l.agent,...t})}return a}async function g(e,n,r,i){let{document:o,value:s}=await e.mutate(e=>{let a=t.applyTaskMutation(e,n,r,void 0,i);return{...t.isCommittingOp(a.op)?{document:a.document}:{},value:a}});if(s.op.kind===`error`)throw d(n,s.op.message);if(s.op.kind===`upsert`&&s.op.applied===0)throw d(n,a.formatUpsertFailureText(s.op));return a.buildToolResult(n,r,o,s.op)}function _(t,m){let{store:_,delegation:v,maxTasks:y=15}=m;t.registerTool({name:e.TOOL_NAME,label:e.TOOL_LABEL,description:`Track complex jobs with a shared task list and delegate tracked work to subagents. Use this only when persistent coordination is useful, such as work with dependencies, parallel workstreams, or a long-running plan. Do not use it for simple requests, routine edits, straightforward command sequences, or merely because the user listed multiple steps. Actions: upsert (write tasks: an entry with an id changes that task and one without an id creates one), list, get, delete (tombstone), clear (close/reset the list), assign (hand tasks through assignments[] to named background subagents), cancel (stop a delegated run). upsert and assign apply entries independently: successes remain committed or delegated and failures are reported by array index. Batch a plan and independent assignments, but report progress one task at a time. Status: pending → in_progress → completed, plus failed and a deleted tombstone. The list is shared within the current session tree, including delegated subagents, while unrelated sessions start empty. Session stores persist until retention cleanup.`,promptSnippet:o,promptGuidelines:i.DEFAULT_PROMPT_GUIDELINES,parameters:e.TaskParamsSchema,renderShell:`self`,async execute(e,t,r,i,o){let b=t.action,x=t;try{if(await m.waitUntilReady?.(o,r),f(b,x),l.has(b)){let e=await g(_,b,x,y);return m.onChange?.(),e}if(b===`assign`){let e=p(x),t=e[0],n=e.length===1&&t?`Delegating task #${t.id}...`:`Delegating ${e.length} tasks...`;i?.(a.buildTextResult(b,x,_.snapshot,n));let o=await h(v,e,r,m.report);m.onChange?.();let s=a.formatAssignmentResults(o),c=o.flatMap(e=>e.ok?[e.id]:[]);if(c.length===0)throw d(b,s);return a.buildAssignmentResult(x,_.snapshot,s,{assigned:c,failed:o.length-c.length})}i?.(a.buildTextResult(b,x,_.snapshot,`Requesting cancellation for task #${x.id??`unknown`}...`));let e=await v.cancel(x.id??NaN);if(m.onChange?.(),!e.ok)throw d(b,e.message);return a.buildTextResult(b,x,_.snapshot,e.message,void 0)}catch(e){throw m.report?.error(n.TASK_EVENT.toolFailed,e,{[s]:b,...x.id===void 0?{}:{[c]:x.id}}),e instanceof u?e:d(b,e instanceof Error?e.message:String(e))}},renderCall(e,t,n){return r.renderTaskCall(e,t,_.snapshot.tasks)},renderResult(e,t,n,i){return r.renderTaskResult(e,t,n)}})}exports.DEFAULT_PROMPT_GUIDELINES=i.DEFAULT_PROMPT_GUIDELINES,exports.DEFAULT_PROMPT_SNIPPET=o,exports.registerTaskTool=_;
+const e=require("../../schemas/task.cjs"),t=require("../../services/store/reducer.cjs"),n=require("../../types/telemetry.cjs"),r=require("../../tui/format2.cjs");require("../../types/config.cjs");const i=require("./promptGuidelines.cjs"),a=require("./responseEnvelope.cjs"),o=`tool.action`,s=`task.id`,c=new Set([`upsert`,`list`,`get`,`delete`,`clear`]);var l=class extends Error{};function u(e,t){return new l([`Task ${e} failed: ${t}`,``,`Options:`,`- List the task board and inspect the current ids, states, and blockers.`,`- Correct the arguments or state conflict, then retry once.`,`- Ask the user before cancelling work or changing dependencies to recover.`].join(`
+`))}function d(t,n){let r=Object.keys(n).filter(r=>n[r]!==void 0&&!e.taskActionAcceptsField(t,r));if(r.length===0)return;let i=t===`upsert`?` ${e.MSG_UPSERT_FIELD_MISPLACED}`:``;throw u(t,`${t} does not accept ${r.join(`, `)}.${i}`)}function f(e){let t=e.assignments;if(!t||t.length===0)throw u(`assign`,`assign requires a non-empty assignments[] array`);return t}function p(e,t){return{agent:e.agent,inlineAgent:e.inlineAgent,instructions:e.instructions,relevantFiles:e.relevantFiles,priorFindings:e.priorFindings,model:e.model,context:e.context,signal:t}}async function m(e,t,r,i){let a=[];for(let[c,l]of t.entries()){let t;try{t=await e.assign(l.id,p(l,r))}catch(e){i?.error(n.TASK_EVENT.toolFailed,e,{[o]:`assign`,[s]:l.id}),t={ok:!1,message:e instanceof Error?e.message:String(e)}}a.push({index:c,id:l.id,agent:l.agent,...t})}return a}async function h(e,n,r,i){let{document:o,value:s}=await e.mutate(e=>{let a=t.applyTaskMutation(e,n,r,void 0,i);return{...t.isCommittingOp(a.op)?{document:a.document}:{},value:a}});if(s.op.kind===`error`)throw u(n,s.op.message);if(s.op.kind===`upsert`&&s.op.applied===0)throw u(n,a.formatUpsertFailureText(s.op));return a.buildToolResult(n,r,o,s.op)}function g(t,p){let{store:g,delegation:_,maxTasks:v=15}=p;t.registerTool({name:e.TOOL_NAME,label:e.TOOL_LABEL,description:`Track complex jobs with a shared task list and delegate tracked work to subagents. Use this only when persistent coordination is useful, such as work with dependencies, parallel workstreams, or a long-running plan. Do not use it for simple requests, routine edits, straightforward command sequences, or merely because the user listed multiple steps. Actions: upsert (write tasks: an entry with an id changes that task and one without an id creates one), list, get, delete (tombstone), clear (close/reset the list), assign (hand tasks through assignments[] to named background subagents), cancel (stop a delegated run). upsert and assign apply entries independently: successes remain committed or delegated and failures are reported by array index. Batch a plan and independent assignments, but report progress one task at a time. Status: pending → in_progress → completed, plus failed and a deleted tombstone. The list is shared within the current session tree, including delegated subagents, while unrelated sessions start empty. Session stores persist until retention cleanup.`,promptGuidelines:i.DEFAULT_PROMPT_GUIDELINES,parameters:e.TaskParamsSchema,renderShell:`self`,async execute(e,t,r,i,y){let b=t.action,x=t;try{if(await p.waitUntilReady?.(y,r),d(b,x),c.has(b)){let e=await h(g,b,x,v);return p.onChange?.(),e}if(b===`assign`){let e=f(x),t=e[0],n=e.length===1&&t?`Delegating task #${t.id}...`:`Delegating ${e.length} tasks...`;i?.(a.buildTextResult(b,x,g.snapshot,n));let o=await m(_,e,r,p.report);p.onChange?.();let s=a.formatAssignmentResults(o),c=o.flatMap(e=>e.ok?[e.id]:[]);if(c.length===0)throw u(b,s);return a.buildAssignmentResult(x,g.snapshot,s,{assigned:c,failed:o.length-c.length})}i?.(a.buildTextResult(b,x,g.snapshot,`Requesting cancellation for task #${x.id??`unknown`}...`));let e=await _.cancel(x.id??NaN);if(p.onChange?.(),!e.ok)throw u(b,e.message);return a.buildTextResult(b,x,g.snapshot,e.message,void 0)}catch(e){throw p.report?.error(n.TASK_EVENT.toolFailed,e,{[o]:b,...x.id===void 0?{}:{[s]:x.id}}),e instanceof l?e:u(b,e instanceof Error?e.message:String(e))}},renderCall(e,t,n){return r.renderTaskCall(e,t,g.snapshot.tasks)},renderResult(e,t,n,i){return r.renderTaskResult(e,t,n)}})}exports.DEFAULT_PROMPT_GUIDELINES=i.DEFAULT_PROMPT_GUIDELINES,exports.DEFAULT_PROMPT_SNIPPET=`Track only complex, multi-step jobs that benefit from persistent progress or delegation; skip simple work`,exports.registerTaskTool=g;
 //# sourceMappingURL=taskTool.cjs.map

package/dist/commands/task/taskTool.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"taskTool.cjs","names":["taskActionAcceptsField","MSG_UPSERT_FIELD_MISPLACED","TASK_EVENT","applyTaskMutation","isCommittingOp","formatUpsertFailureText","buildToolResult","TOOL_NAME","TOOL_LABEL","DEFAULT_PROMPT_GUIDELINES","TaskParamsSchema","buildTextResult","formatAssignmentResults","buildAssignmentResult","renderTaskCall","renderTaskResult"],"sources":["../../../src/commands/task/taskTool.ts"],"sourcesContent":["import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';\nimport {\n  MSG_UPSERT_FIELD_MISPLACED,\n  TaskParamsSchema,\n  TOOL_LABEL,\n  TOOL_NAME,\n  taskActionAcceptsField,\n} from '../../schemas/task.ts';\nimport type { AssignOptions, DelegationManager, DelegationOutcome } from '../../services/delegation/manager.ts';\nimport { applyTaskMutation, isCommittingOp, type ReducerAction } from '../../services/store/reducer.ts';\nimport type { TaskStore } from '../../adapters/store/taskStore';\nimport type { TaskAction, TaskAssignment, TaskMutationParams } from '../../services/store/types.ts';\nimport { renderTaskCall, renderTaskResult } from '../../tui/format.ts';\nimport { DEFAULT_MAX_TASKS } from '../../types/config.ts';\nimport { TASK_EVENT, type TaskFailureReporter } from '../../types/telemetry.ts';\nimport { DEFAULT_PROMPT_GUIDELINES } from './promptGuidelines.ts';\nimport {\n  type AssignmentItemResult,\n  buildAssignmentResult,\n  buildTextResult,\n  buildToolResult,\n  formatAssignmentResults,\n  formatUpsertFailureText,\n  type ToolResult,\n} from './responseEnvelope.ts';\n\nexport { DEFAULT_PROMPT_GUIDELINES } from './promptGuidelines.ts';\n\nexport const DEFAULT_PROMPT_SNIPPET =\n  'Track only complex, multi-step jobs that benefit from persistent progress or delegation; skip simple work';\n\nexport interface TaskToolDependencies {\n  store: TaskStore;\n  delegation: DelegationManager;\n  maxTasks?: number;\n  onChange?: () => void;\n  report?: TaskFailureReporter;\n  waitUntilReady?: (context: ExtensionContext, signal?: AbortSignal) => Promise<void>;\n}\n\nconst ACTION_ATTRIBUTE = 'tool.action';\nconst TASK_ID_ATTRIBUTE = 'task.id';\nconst REDUCER_ACTIONS = new Set<TaskAction>(['upsert', 'list', 'get', 'delete', 'clear']);\n\nclass TaskToolExecutionError extends Error {}\n\nfunction actionableTaskError(action: TaskAction, message: string): TaskToolExecutionError {\n  return new TaskToolExecutionError(\n    [\n      `Task ${action} failed: ${message}`,\n      '',\n      'Options:',\n      '- List the task board and inspect the current ids, states, and blockers.',\n      '- Correct the arguments or state conflict, then retry once.',\n      '- Ask the user before cancelling work or changing dependencies to recover.',\n    ].join('\\n'),\n  );\n}\n\n/**\n * Reject a field that belongs to a different action.\n *\n * The params schema is flat and shared across every action, so this is the only\n * place `{\"action\":\"upsert\",\"id\":3}` can be caught — and it must be, because\n * the entry it carries has no id and would silently create a duplicate task.\n */\nfunction rejectStrayFields(action: TaskAction, params: TaskMutationParams): void {\n  const stray = Object.keys(params).filter((key) => params[key] !== undefined && !taskActionAcceptsField(action, key));\n  if (stray.length === 0) return;\n  const hint = action === 'upsert' ? ` ${MSG_UPSERT_FIELD_MISPLACED}` : '';\n  throw actionableTaskError(action, `${action} does not accept ${stray.join(', ')}.${hint}`);\n}\n\n/** assignments[] is the only assign contract, even when it contains one task. */\nfunction resolveAssignments(params: TaskMutationParams): TaskAssignment[] {\n  const assignments = params.assignments;\n  if (!assignments || assignments.length === 0) {\n    throw actionableTaskError('assign', 'assign requires a non-empty assignments[] array');\n  }\n  return assignments;\n}\n\nfunction assignOptions(request: TaskAssignment, signal: AbortSignal | undefined): AssignOptions {\n  return {\n    agent: request.agent,\n    inlineAgent: request.inlineAgent,\n    instructions: request.instructions,\n    relevantFiles: request.relevantFiles,\n    priorFindings: request.priorFindings,\n    model: request.model,\n    context: request.context,\n    signal,\n  };\n}\n\nasync function executeAssignmentBatch(\n  delegation: DelegationManager,\n  assignments: readonly TaskAssignment[],\n  signal: AbortSignal | undefined,\n  report: TaskFailureReporter | undefined,\n): Promise<AssignmentItemResult[]> {\n  const results: AssignmentItemResult[] = [];\n  for (const [index, assignment] of assignments.entries()) {\n    let outcome: DelegationOutcome;\n    try {\n      outcome = await delegation.assign(assignment.id, assignOptions(assignment, signal));\n    } catch (error) {\n      report?.error(TASK_EVENT.toolFailed, error, {\n        [ACTION_ATTRIBUTE]: 'assign',\n        [TASK_ID_ATTRIBUTE]: assignment.id,\n      });\n      outcome = { ok: false, message: error instanceof Error ? error.message : String(error) };\n    }\n    results.push({ index, id: assignment.id, agent: assignment.agent, ...outcome });\n  }\n  return results;\n}\n\n/** Run an action through the reducer, persisting only when it produced a change. */\nasync function executeReducerAction(\n  store: TaskStore,\n  action: ReducerAction,\n  params: TaskMutationParams,\n  maxTasks: number,\n): Promise<ToolResult> {\n  const { document, value } = await store.mutate((current) => {\n    const result = applyTaskMutation(current, action, params, undefined, maxTasks);\n    return {\n      ...(isCommittingOp(result.op) ? { document: result.document } : {}),\n      value: result,\n    };\n  });\n  if (value.op.kind === 'error') throw actionableTaskError(action, value.op.message);\n  // An upsert that applied nothing is a failed call: it wrote nothing and left\n  // `rev` alone, so it must not read to the model as a success. A batch where\n  // some entries landed returns normally — that is what partial apply means.\n  if (value.op.kind === 'upsert' && value.op.applied === 0) {\n    throw actionableTaskError(action, formatUpsertFailureText(value.op));\n  }\n  // `document` is the committed document, so `details.rev` matches what landed\n  // on disk; `value.document` is the pre-write copy and lags by one.\n  return buildToolResult(action, params, document, value.op);\n}\n\nexport function registerTaskTool(pi: ExtensionAPI, dependencies: TaskToolDependencies): void {\n  const { store, delegation, maxTasks = DEFAULT_MAX_TASKS } = dependencies;\n\n  pi.registerTool({\n    name: TOOL_NAME,\n    label: TOOL_LABEL,\n    description:\n      'Track complex jobs with a shared task list and delegate tracked work to subagents. Use this only when persistent coordination is useful, such as work with dependencies, parallel workstreams, or a long-running plan. Do not use it for simple requests, routine edits, straightforward command sequences, or merely because the user listed multiple steps. Actions: upsert (write tasks: an entry with an id changes that task and one without an id creates one), list, get, delete (tombstone), clear (close/reset the list), assign (hand tasks through assignments[] to named background subagents), cancel (stop a delegated run). upsert and assign apply entries independently: successes remain committed or delegated and failures are reported by array index. Batch a plan and independent assignments, but report progress one task at a time. Status: pending → in_progress → completed, plus failed and a deleted tombstone. The list is shared within the current session tree, including delegated subagents, while unrelated sessions start empty. Session stores persist until retention cleanup.',\n    promptSnippet: DEFAULT_PROMPT_SNIPPET,\n    promptGuidelines: DEFAULT_PROMPT_GUIDELINES,\n    parameters: TaskParamsSchema,\n    // Task rows carry their own status colors. Owning the shell prevents Pi's\n    // pending/success/error background fill from obscuring those row states.\n    renderShell: 'self',\n\n    async execute(_toolCallId, params, signal, onUpdate, ctx) {\n      const action = params.action as TaskAction;\n      const mutationParams = params as TaskMutationParams;\n\n      try {\n        await dependencies.waitUntilReady?.(ctx, signal);\n        rejectStrayFields(action, mutationParams);\n        if (REDUCER_ACTIONS.has(action)) {\n          const result = await executeReducerAction(store, action as ReducerAction, mutationParams, maxTasks);\n          dependencies.onChange?.();\n          return result;\n        }\n\n        if (action === 'assign') {\n          const assignments = resolveAssignments(mutationParams);\n          const first = assignments[0];\n          const progress =\n            assignments.length === 1 && first\n              ? `Delegating task #${first.id}...`\n              : `Delegating ${assignments.length} tasks...`;\n          onUpdate?.(buildTextResult(action, mutationParams, store.snapshot, progress));\n          const results = await executeAssignmentBatch(delegation, assignments, signal, dependencies.report);\n          dependencies.onChange?.();\n          const text = formatAssignmentResults(results);\n          const assigned = results.flatMap((item) => (item.ok ? [item.id] : []));\n          if (assigned.length === 0) throw actionableTaskError(action, text);\n          return buildAssignmentResult(mutationParams, store.snapshot, text, {\n            assigned,\n            failed: results.length - assigned.length,\n          });\n        }\n\n        onUpdate?.(\n          buildTextResult(\n            action,\n            mutationParams,\n            store.snapshot,\n            `Requesting cancellation for task #${mutationParams.id ?? 'unknown'}...`,\n          ),\n        );\n        const outcome = await delegation.cancel(mutationParams.id ?? Number.NaN);\n        dependencies.onChange?.();\n        if (!outcome.ok) throw actionableTaskError(action, outcome.message);\n        return buildTextResult(action, mutationParams, store.snapshot, outcome.message, undefined);\n      } catch (error) {\n        // Rethrown so pi still renders the failure to the model; recorded\n        // because this is where a store fault becomes visible to the user.\n        dependencies.report?.error(TASK_EVENT.toolFailed, error, {\n          [ACTION_ATTRIBUTE]: action,\n          ...(mutationParams.id === undefined ? {} : { [TASK_ID_ATTRIBUTE]: mutationParams.id }),\n        });\n        if (error instanceof TaskToolExecutionError) throw error;\n        throw actionableTaskError(action, error instanceof Error ? error.message : String(error));\n      }\n    },\n\n    // Render hooks receive no session identity, so they read the store snapshot\n    // that the executing session last loaded. That is the foreground session's\n    // own view, which is exactly what its transcript should show.\n    renderCall(args, theme, _context) {\n      return renderTaskCall(args as never, theme, store.snapshot.tasks);\n    },\n\n    renderResult(result, options, theme, _context) {\n      return renderTaskResult(result, options, theme);\n    },\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"taskTool.cjs","names":["taskActionAcceptsField","MSG_UPSERT_FIELD_MISPLACED","TASK_EVENT","applyTaskMutation","isCommittingOp","formatUpsertFailureText","buildToolResult","TOOL_NAME","TOOL_LABEL","DEFAULT_PROMPT_GUIDELINES","TaskParamsSchema","buildTextResult","formatAssignmentResults","buildAssignmentResult","renderTaskCall","renderTaskResult"],"sources":["../../../src/commands/task/taskTool.ts"],"sourcesContent":["import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';\nimport {\n  MSG_UPSERT_FIELD_MISPLACED,\n  TaskParamsSchema,\n  TOOL_LABEL,\n  TOOL_NAME,\n  taskActionAcceptsField,\n} from '../../schemas/task.ts';\nimport type { AssignOptions, DelegationManager, DelegationOutcome } from '../../services/delegation/manager.ts';\nimport { applyTaskMutation, isCommittingOp, type ReducerAction } from '../../services/store/reducer.ts';\nimport type { TaskStore } from '../../adapters/store/taskStore';\nimport type { TaskAction, TaskAssignment, TaskMutationParams } from '../../services/store/types.ts';\nimport { renderTaskCall, renderTaskResult } from '../../tui/format.ts';\nimport { DEFAULT_MAX_TASKS } from '../../types/config.ts';\nimport { TASK_EVENT, type TaskFailureReporter } from '../../types/telemetry.ts';\nimport { DEFAULT_PROMPT_GUIDELINES } from './promptGuidelines.ts';\nimport {\n  type AssignmentItemResult,\n  buildAssignmentResult,\n  buildTextResult,\n  buildToolResult,\n  formatAssignmentResults,\n  formatUpsertFailureText,\n  type ToolResult,\n} from './responseEnvelope.ts';\n\nexport { DEFAULT_PROMPT_GUIDELINES } from './promptGuidelines.ts';\n\n/** @deprecated Task usage policy now lives only in the tool description. */\nexport const DEFAULT_PROMPT_SNIPPET =\n  'Track only complex, multi-step jobs that benefit from persistent progress or delegation; skip simple work';\n\nexport interface TaskToolDependencies {\n  store: TaskStore;\n  delegation: DelegationManager;\n  maxTasks?: number;\n  onChange?: () => void;\n  report?: TaskFailureReporter;\n  waitUntilReady?: (context: ExtensionContext, signal?: AbortSignal) => Promise<void>;\n}\n\nconst ACTION_ATTRIBUTE = 'tool.action';\nconst TASK_ID_ATTRIBUTE = 'task.id';\nconst REDUCER_ACTIONS = new Set<TaskAction>(['upsert', 'list', 'get', 'delete', 'clear']);\n\nclass TaskToolExecutionError extends Error {}\n\nfunction actionableTaskError(action: TaskAction, message: string): TaskToolExecutionError {\n  return new TaskToolExecutionError(\n    [\n      `Task ${action} failed: ${message}`,\n      '',\n      'Options:',\n      '- List the task board and inspect the current ids, states, and blockers.',\n      '- Correct the arguments or state conflict, then retry once.',\n      '- Ask the user before cancelling work or changing dependencies to recover.',\n    ].join('\\n'),\n  );\n}\n\n/**\n * Reject a field that belongs to a different action.\n *\n * The params schema is flat and shared across every action, so this is the only\n * place `{\"action\":\"upsert\",\"id\":3}` can be caught — and it must be, because\n * the entry it carries has no id and would silently create a duplicate task.\n */\nfunction rejectStrayFields(action: TaskAction, params: TaskMutationParams): void {\n  const stray = Object.keys(params).filter((key) => params[key] !== undefined && !taskActionAcceptsField(action, key));\n  if (stray.length === 0) return;\n  const hint = action === 'upsert' ? ` ${MSG_UPSERT_FIELD_MISPLACED}` : '';\n  throw actionableTaskError(action, `${action} does not accept ${stray.join(', ')}.${hint}`);\n}\n\n/** assignments[] is the only assign contract, even when it contains one task. */\nfunction resolveAssignments(params: TaskMutationParams): TaskAssignment[] {\n  const assignments = params.assignments;\n  if (!assignments || assignments.length === 0) {\n    throw actionableTaskError('assign', 'assign requires a non-empty assignments[] array');\n  }\n  return assignments;\n}\n\nfunction assignOptions(request: TaskAssignment, signal: AbortSignal | undefined): AssignOptions {\n  return {\n    agent: request.agent,\n    inlineAgent: request.inlineAgent,\n    instructions: request.instructions,\n    relevantFiles: request.relevantFiles,\n    priorFindings: request.priorFindings,\n    model: request.model,\n    context: request.context,\n    signal,\n  };\n}\n\nasync function executeAssignmentBatch(\n  delegation: DelegationManager,\n  assignments: readonly TaskAssignment[],\n  signal: AbortSignal | undefined,\n  report: TaskFailureReporter | undefined,\n): Promise<AssignmentItemResult[]> {\n  const results: AssignmentItemResult[] = [];\n  for (const [index, assignment] of assignments.entries()) {\n    let outcome: DelegationOutcome;\n    try {\n      outcome = await delegation.assign(assignment.id, assignOptions(assignment, signal));\n    } catch (error) {\n      report?.error(TASK_EVENT.toolFailed, error, {\n        [ACTION_ATTRIBUTE]: 'assign',\n        [TASK_ID_ATTRIBUTE]: assignment.id,\n      });\n      outcome = { ok: false, message: error instanceof Error ? error.message : String(error) };\n    }\n    results.push({ index, id: assignment.id, agent: assignment.agent, ...outcome });\n  }\n  return results;\n}\n\n/** Run an action through the reducer, persisting only when it produced a change. */\nasync function executeReducerAction(\n  store: TaskStore,\n  action: ReducerAction,\n  params: TaskMutationParams,\n  maxTasks: number,\n): Promise<ToolResult> {\n  const { document, value } = await store.mutate((current) => {\n    const result = applyTaskMutation(current, action, params, undefined, maxTasks);\n    return {\n      ...(isCommittingOp(result.op) ? { document: result.document } : {}),\n      value: result,\n    };\n  });\n  if (value.op.kind === 'error') throw actionableTaskError(action, value.op.message);\n  // An upsert that applied nothing is a failed call: it wrote nothing and left\n  // `rev` alone, so it must not read to the model as a success. A batch where\n  // some entries landed returns normally — that is what partial apply means.\n  if (value.op.kind === 'upsert' && value.op.applied === 0) {\n    throw actionableTaskError(action, formatUpsertFailureText(value.op));\n  }\n  // `document` is the committed document, so `details.rev` matches what landed\n  // on disk; `value.document` is the pre-write copy and lags by one.\n  return buildToolResult(action, params, document, value.op);\n}\n\nexport function registerTaskTool(pi: ExtensionAPI, dependencies: TaskToolDependencies): void {\n  const { store, delegation, maxTasks = DEFAULT_MAX_TASKS } = dependencies;\n\n  pi.registerTool({\n    name: TOOL_NAME,\n    label: TOOL_LABEL,\n    description:\n      'Track complex jobs with a shared task list and delegate tracked work to subagents. Use this only when persistent coordination is useful, such as work with dependencies, parallel workstreams, or a long-running plan. Do not use it for simple requests, routine edits, straightforward command sequences, or merely because the user listed multiple steps. Actions: upsert (write tasks: an entry with an id changes that task and one without an id creates one), list, get, delete (tombstone), clear (close/reset the list), assign (hand tasks through assignments[] to named background subagents), cancel (stop a delegated run). upsert and assign apply entries independently: successes remain committed or delegated and failures are reported by array index. Batch a plan and independent assignments, but report progress one task at a time. Status: pending → in_progress → completed, plus failed and a deleted tombstone. The list is shared within the current session tree, including delegated subagents, while unrelated sessions start empty. Session stores persist until retention cleanup.',\n    promptGuidelines: DEFAULT_PROMPT_GUIDELINES,\n    parameters: TaskParamsSchema,\n    // Task rows carry their own status colors. Owning the shell prevents Pi's\n    // pending/success/error background fill from obscuring those row states.\n    renderShell: 'self',\n\n    async execute(_toolCallId, params, signal, onUpdate, ctx) {\n      const action = params.action as TaskAction;\n      const mutationParams = params as TaskMutationParams;\n\n      try {\n        await dependencies.waitUntilReady?.(ctx, signal);\n        rejectStrayFields(action, mutationParams);\n        if (REDUCER_ACTIONS.has(action)) {\n          const result = await executeReducerAction(store, action as ReducerAction, mutationParams, maxTasks);\n          dependencies.onChange?.();\n          return result;\n        }\n\n        if (action === 'assign') {\n          const assignments = resolveAssignments(mutationParams);\n          const first = assignments[0];\n          const progress =\n            assignments.length === 1 && first\n              ? `Delegating task #${first.id}...`\n              : `Delegating ${assignments.length} tasks...`;\n          onUpdate?.(buildTextResult(action, mutationParams, store.snapshot, progress));\n          const results = await executeAssignmentBatch(delegation, assignments, signal, dependencies.report);\n          dependencies.onChange?.();\n          const text = formatAssignmentResults(results);\n          const assigned = results.flatMap((item) => (item.ok ? [item.id] : []));\n          if (assigned.length === 0) throw actionableTaskError(action, text);\n          return buildAssignmentResult(mutationParams, store.snapshot, text, {\n            assigned,\n            failed: results.length - assigned.length,\n          });\n        }\n\n        onUpdate?.(\n          buildTextResult(\n            action,\n            mutationParams,\n            store.snapshot,\n            `Requesting cancellation for task #${mutationParams.id ?? 'unknown'}...`,\n          ),\n        );\n        const outcome = await delegation.cancel(mutationParams.id ?? Number.NaN);\n        dependencies.onChange?.();\n        if (!outcome.ok) throw actionableTaskError(action, outcome.message);\n        return buildTextResult(action, mutationParams, store.snapshot, outcome.message, undefined);\n      } catch (error) {\n        // Rethrown so pi still renders the failure to the model; recorded\n        // because this is where a store fault becomes visible to the user.\n        dependencies.report?.error(TASK_EVENT.toolFailed, error, {\n          [ACTION_ATTRIBUTE]: action,\n          ...(mutationParams.id === undefined ? {} : { [TASK_ID_ATTRIBUTE]: mutationParams.id }),\n        });\n        if (error instanceof TaskToolExecutionError) throw error;\n        throw actionableTaskError(action, error instanceof Error ? error.message : String(error));\n      }\n    },\n\n    // Render hooks receive no session identity, so they read the store snapshot\n    // that the executing session last loaded. That is the foreground session's\n    // own view, which is exactly what its transcript should show.\n    renderCall(args, theme, _context) {\n      return renderTaskCall(args as never, theme, store.snapshot.tasks);\n    },\n\n    renderResult(result, options, theme, _context) {\n      return renderTaskResult(result, options, theme);\n    },\n  });\n}\n"],"mappings":"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"}

package/dist/commands/task/taskTool.d.cts

@@ -4,6 +4,7 @@ import { DelegationManager } from "../../services/delegation/manager.cjs";
 import { DEFAULT_PROMPT_GUIDELINES } from "./promptGuidelines.cjs";
 import { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 //#region src/commands/task/taskTool.d.ts
+/** @deprecated Task usage policy now lives only in the tool description. */
 declare const DEFAULT_PROMPT_SNIPPET = "Track only complex, multi-step jobs that benefit from persistent progress or delegation; skip simple work";
 interface TaskToolDependencies {
   store: TaskStore;

package/dist/commands/task/taskTool.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"taskTool.d.cts","names":[],"sources":["../../../src/commands/task/taskTool.ts"],"mappings":";;;;;;cA4Ba;UAGI;EACf,OAAO;EACP,YAAY;EACZ;EACA;EACA,SAAS;EACT,kBAAkB,SAAS,kBAAkB,SAAS,gBAAgB;;iBA2GxD,iBAAiB,IAAI,cAAc,cAAc"}
+{"version":3,"file":"taskTool.d.cts","names":[],"sources":["../../../src/commands/task/taskTool.ts"],"mappings":";;;;;;;cA6Ba;UAGI;EACf,OAAO;EACP,YAAY;EACZ;EACA;EACA,SAAS;EACT,kBAAkB,SAAS,kBAAkB,SAAS,gBAAgB;;iBA2GxD,iBAAiB,IAAI,cAAc,cAAc"}

package/dist/commands/task/taskTool.d.mts

@@ -4,6 +4,7 @@ import { DelegationManager } from "../../services/delegation/manager.mjs";
 import { DEFAULT_PROMPT_GUIDELINES } from "./promptGuidelines.mjs";
 import { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 //#region src/commands/task/taskTool.d.ts
+/** @deprecated Task usage policy now lives only in the tool description. */
 declare const DEFAULT_PROMPT_SNIPPET = "Track only complex, multi-step jobs that benefit from persistent progress or delegation; skip simple work";
 interface TaskToolDependencies {
   store: TaskStore;

package/dist/commands/task/taskTool.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"taskTool.d.mts","names":[],"sources":["../../../src/commands/task/taskTool.ts"],"mappings":";;;;;;cA4Ba;UAGI;EACf,OAAO;EACP,YAAY;EACZ;EACA;EACA,SAAS;EACT,kBAAkB,SAAS,kBAAkB,SAAS,gBAAgB;;iBA2GxD,iBAAiB,IAAI,cAAc,cAAc"}
+{"version":3,"file":"taskTool.d.mts","names":[],"sources":["../../../src/commands/task/taskTool.ts"],"mappings":";;;;;;;cA6Ba;UAGI;EACf,OAAO;EACP,YAAY;EACZ;EACA;EACA,SAAS;EACT,kBAAkB,SAAS,kBAAkB,SAAS,gBAAgB;;iBA2GxD,iBAAiB,IAAI,cAAc,cAAc"}

package/dist/commands/task/taskTool.mjs

@@ -1,3 +1,3 @@
 import{MSG_UPSERT_FIELD_MISPLACED as e,TOOL_LABEL as t,TOOL_NAME as n,TaskParamsSchema as r,taskActionAcceptsField as i}from"../../schemas/task.mjs";import{applyTaskMutation as a,isCommittingOp as o}from"../../services/store/reducer.mjs";import{TASK_EVENT as s}from"../../types/telemetry.mjs";import{renderTaskCall as c,renderTaskResult as l}from"../../tui/format2.mjs";import"../../types/config.mjs";import{DEFAULT_PROMPT_GUIDELINES as u}from"./promptGuidelines.mjs";import{buildAssignmentResult as d,buildTextResult as f,buildToolResult as p,formatAssignmentResults as m,formatUpsertFailureText as h}from"./responseEnvelope.mjs";const g=`Track only complex, multi-step jobs that benefit from persistent progress or delegation; skip simple work`,_=`tool.action`,v=`task.id`,y=new Set([`upsert`,`list`,`get`,`delete`,`clear`]);var b=class extends Error{};function x(e,t){return new b([`Task ${e} failed: ${t}`,``,`Options:`,`- List the task board and inspect the current ids, states, and blockers.`,`- Correct the arguments or state conflict, then retry once.`,`- Ask the user before cancelling work or changing dependencies to recover.`].join(`
-`))}function S(t,n){let r=Object.keys(n).filter(e=>n[e]!==void 0&&!i(t,e));if(r.length===0)return;let a=t===`upsert`?` ${e}`:``;throw x(t,`${t} does not accept ${r.join(`, `)}.${a}`)}function C(e){let t=e.assignments;if(!t||t.length===0)throw x(`assign`,`assign requires a non-empty assignments[] array`);return t}function w(e,t){return{agent:e.agent,inlineAgent:e.inlineAgent,instructions:e.instructions,relevantFiles:e.relevantFiles,priorFindings:e.priorFindings,model:e.model,context:e.context,signal:t}}async function T(e,t,n,r){let i=[];for(let[a,o]of t.entries()){let t;try{t=await e.assign(o.id,w(o,n))}catch(e){r?.error(s.toolFailed,e,{[_]:`assign`,[v]:o.id}),t={ok:!1,message:e instanceof Error?e.message:String(e)}}i.push({index:a,id:o.id,agent:o.agent,...t})}return i}async function E(e,t,n,r){let{document:i,value:s}=await e.mutate(e=>{let i=a(e,t,n,void 0,r);return{...o(i.op)?{document:i.document}:{},value:i}});if(s.op.kind===`error`)throw x(t,s.op.message);if(s.op.kind===`upsert`&&s.op.applied===0)throw x(t,h(s.op));return p(t,n,i,s.op)}function D(e,i){let{store:a,delegation:o,maxTasks:p=15}=i;e.registerTool({name:n,label:t,description:`Track complex jobs with a shared task list and delegate tracked work to subagents. Use this only when persistent coordination is useful, such as work with dependencies, parallel workstreams, or a long-running plan. Do not use it for simple requests, routine edits, straightforward command sequences, or merely because the user listed multiple steps. Actions: upsert (write tasks: an entry with an id changes that task and one without an id creates one), list, get, delete (tombstone), clear (close/reset the list), assign (hand tasks through assignments[] to named background subagents), cancel (stop a delegated run). upsert and assign apply entries independently: successes remain committed or delegated and failures are reported by array index. Batch a plan and independent assignments, but report progress one task at a time. Status: pending → in_progress → completed, plus failed and a deleted tombstone. The list is shared within the current session tree, including delegated subagents, while unrelated sessions start empty. Session stores persist until retention cleanup.`,promptSnippet:g,promptGuidelines:u,parameters:r,renderShell:`self`,async execute(e,t,n,r,c){let l=t.action,u=t;try{if(await i.waitUntilReady?.(c,n),S(l,u),y.has(l)){let e=await E(a,l,u,p);return i.onChange?.(),e}if(l===`assign`){let e=C(u),t=e[0],s=e.length===1&&t?`Delegating task #${t.id}...`:`Delegating ${e.length} tasks...`;r?.(f(l,u,a.snapshot,s));let c=await T(o,e,n,i.report);i.onChange?.();let p=m(c),h=c.flatMap(e=>e.ok?[e.id]:[]);if(h.length===0)throw x(l,p);return d(u,a.snapshot,p,{assigned:h,failed:c.length-h.length})}r?.(f(l,u,a.snapshot,`Requesting cancellation for task #${u.id??`unknown`}...`));let e=await o.cancel(u.id??NaN);if(i.onChange?.(),!e.ok)throw x(l,e.message);return f(l,u,a.snapshot,e.message,void 0)}catch(e){throw i.report?.error(s.toolFailed,e,{[_]:l,...u.id===void 0?{}:{[v]:u.id}}),e instanceof b?e:x(l,e instanceof Error?e.message:String(e))}},renderCall(e,t,n){return c(e,t,a.snapshot.tasks)},renderResult(e,t,n,r){return l(e,t,n)}})}export{u as DEFAULT_PROMPT_GUIDELINES,g as DEFAULT_PROMPT_SNIPPET,D as registerTaskTool};
+`))}function S(t,n){let r=Object.keys(n).filter(e=>n[e]!==void 0&&!i(t,e));if(r.length===0)return;let a=t===`upsert`?` ${e}`:``;throw x(t,`${t} does not accept ${r.join(`, `)}.${a}`)}function C(e){let t=e.assignments;if(!t||t.length===0)throw x(`assign`,`assign requires a non-empty assignments[] array`);return t}function w(e,t){return{agent:e.agent,inlineAgent:e.inlineAgent,instructions:e.instructions,relevantFiles:e.relevantFiles,priorFindings:e.priorFindings,model:e.model,context:e.context,signal:t}}async function T(e,t,n,r){let i=[];for(let[a,o]of t.entries()){let t;try{t=await e.assign(o.id,w(o,n))}catch(e){r?.error(s.toolFailed,e,{[_]:`assign`,[v]:o.id}),t={ok:!1,message:e instanceof Error?e.message:String(e)}}i.push({index:a,id:o.id,agent:o.agent,...t})}return i}async function E(e,t,n,r){let{document:i,value:s}=await e.mutate(e=>{let i=a(e,t,n,void 0,r);return{...o(i.op)?{document:i.document}:{},value:i}});if(s.op.kind===`error`)throw x(t,s.op.message);if(s.op.kind===`upsert`&&s.op.applied===0)throw x(t,h(s.op));return p(t,n,i,s.op)}function D(e,i){let{store:a,delegation:o,maxTasks:p=15}=i;e.registerTool({name:n,label:t,description:`Track complex jobs with a shared task list and delegate tracked work to subagents. Use this only when persistent coordination is useful, such as work with dependencies, parallel workstreams, or a long-running plan. Do not use it for simple requests, routine edits, straightforward command sequences, or merely because the user listed multiple steps. Actions: upsert (write tasks: an entry with an id changes that task and one without an id creates one), list, get, delete (tombstone), clear (close/reset the list), assign (hand tasks through assignments[] to named background subagents), cancel (stop a delegated run). upsert and assign apply entries independently: successes remain committed or delegated and failures are reported by array index. Batch a plan and independent assignments, but report progress one task at a time. Status: pending → in_progress → completed, plus failed and a deleted tombstone. The list is shared within the current session tree, including delegated subagents, while unrelated sessions start empty. Session stores persist until retention cleanup.`,promptGuidelines:u,parameters:r,renderShell:`self`,async execute(e,t,n,r,c){let l=t.action,u=t;try{if(await i.waitUntilReady?.(c,n),S(l,u),y.has(l)){let e=await E(a,l,u,p);return i.onChange?.(),e}if(l===`assign`){let e=C(u),t=e[0],s=e.length===1&&t?`Delegating task #${t.id}...`:`Delegating ${e.length} tasks...`;r?.(f(l,u,a.snapshot,s));let c=await T(o,e,n,i.report);i.onChange?.();let p=m(c),h=c.flatMap(e=>e.ok?[e.id]:[]);if(h.length===0)throw x(l,p);return d(u,a.snapshot,p,{assigned:h,failed:c.length-h.length})}r?.(f(l,u,a.snapshot,`Requesting cancellation for task #${u.id??`unknown`}...`));let e=await o.cancel(u.id??NaN);if(i.onChange?.(),!e.ok)throw x(l,e.message);return f(l,u,a.snapshot,e.message,void 0)}catch(e){throw i.report?.error(s.toolFailed,e,{[_]:l,...u.id===void 0?{}:{[v]:u.id}}),e instanceof b?e:x(l,e instanceof Error?e.message:String(e))}},renderCall(e,t,n){return c(e,t,a.snapshot.tasks)},renderResult(e,t,n,r){return l(e,t,n)}})}export{u as DEFAULT_PROMPT_GUIDELINES,g as DEFAULT_PROMPT_SNIPPET,D as registerTaskTool};
 //# sourceMappingURL=taskTool.mjs.map

package/dist/commands/task/taskTool.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"taskTool.mjs","names":[],"sources":["../../../src/commands/task/taskTool.ts"],"sourcesContent":["import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';\nimport {\n  MSG_UPSERT_FIELD_MISPLACED,\n  TaskParamsSchema,\n  TOOL_LABEL,\n  TOOL_NAME,\n  taskActionAcceptsField,\n} from '../../schemas/task.ts';\nimport type { AssignOptions, DelegationManager, DelegationOutcome } from '../../services/delegation/manager.ts';\nimport { applyTaskMutation, isCommittingOp, type ReducerAction } from '../../services/store/reducer.ts';\nimport type { TaskStore } from '../../adapters/store/taskStore';\nimport type { TaskAction, TaskAssignment, TaskMutationParams } from '../../services/store/types.ts';\nimport { renderTaskCall, renderTaskResult } from '../../tui/format.ts';\nimport { DEFAULT_MAX_TASKS } from '../../types/config.ts';\nimport { TASK_EVENT, type TaskFailureReporter } from '../../types/telemetry.ts';\nimport { DEFAULT_PROMPT_GUIDELINES } from './promptGuidelines.ts';\nimport {\n  type AssignmentItemResult,\n  buildAssignmentResult,\n  buildTextResult,\n  buildToolResult,\n  formatAssignmentResults,\n  formatUpsertFailureText,\n  type ToolResult,\n} from './responseEnvelope.ts';\n\nexport { DEFAULT_PROMPT_GUIDELINES } from './promptGuidelines.ts';\n\nexport const DEFAULT_PROMPT_SNIPPET =\n  'Track only complex, multi-step jobs that benefit from persistent progress or delegation; skip simple work';\n\nexport interface TaskToolDependencies {\n  store: TaskStore;\n  delegation: DelegationManager;\n  maxTasks?: number;\n  onChange?: () => void;\n  report?: TaskFailureReporter;\n  waitUntilReady?: (context: ExtensionContext, signal?: AbortSignal) => Promise<void>;\n}\n\nconst ACTION_ATTRIBUTE = 'tool.action';\nconst TASK_ID_ATTRIBUTE = 'task.id';\nconst REDUCER_ACTIONS = new Set<TaskAction>(['upsert', 'list', 'get', 'delete', 'clear']);\n\nclass TaskToolExecutionError extends Error {}\n\nfunction actionableTaskError(action: TaskAction, message: string): TaskToolExecutionError {\n  return new TaskToolExecutionError(\n    [\n      `Task ${action} failed: ${message}`,\n      '',\n      'Options:',\n      '- List the task board and inspect the current ids, states, and blockers.',\n      '- Correct the arguments or state conflict, then retry once.',\n      '- Ask the user before cancelling work or changing dependencies to recover.',\n    ].join('\\n'),\n  );\n}\n\n/**\n * Reject a field that belongs to a different action.\n *\n * The params schema is flat and shared across every action, so this is the only\n * place `{\"action\":\"upsert\",\"id\":3}` can be caught — and it must be, because\n * the entry it carries has no id and would silently create a duplicate task.\n */\nfunction rejectStrayFields(action: TaskAction, params: TaskMutationParams): void {\n  const stray = Object.keys(params).filter((key) => params[key] !== undefined && !taskActionAcceptsField(action, key));\n  if (stray.length === 0) return;\n  const hint = action === 'upsert' ? ` ${MSG_UPSERT_FIELD_MISPLACED}` : '';\n  throw actionableTaskError(action, `${action} does not accept ${stray.join(', ')}.${hint}`);\n}\n\n/** assignments[] is the only assign contract, even when it contains one task. */\nfunction resolveAssignments(params: TaskMutationParams): TaskAssignment[] {\n  const assignments = params.assignments;\n  if (!assignments || assignments.length === 0) {\n    throw actionableTaskError('assign', 'assign requires a non-empty assignments[] array');\n  }\n  return assignments;\n}\n\nfunction assignOptions(request: TaskAssignment, signal: AbortSignal | undefined): AssignOptions {\n  return {\n    agent: request.agent,\n    inlineAgent: request.inlineAgent,\n    instructions: request.instructions,\n    relevantFiles: request.relevantFiles,\n    priorFindings: request.priorFindings,\n    model: request.model,\n    context: request.context,\n    signal,\n  };\n}\n\nasync function executeAssignmentBatch(\n  delegation: DelegationManager,\n  assignments: readonly TaskAssignment[],\n  signal: AbortSignal | undefined,\n  report: TaskFailureReporter | undefined,\n): Promise<AssignmentItemResult[]> {\n  const results: AssignmentItemResult[] = [];\n  for (const [index, assignment] of assignments.entries()) {\n    let outcome: DelegationOutcome;\n    try {\n      outcome = await delegation.assign(assignment.id, assignOptions(assignment, signal));\n    } catch (error) {\n      report?.error(TASK_EVENT.toolFailed, error, {\n        [ACTION_ATTRIBUTE]: 'assign',\n        [TASK_ID_ATTRIBUTE]: assignment.id,\n      });\n      outcome = { ok: false, message: error instanceof Error ? error.message : String(error) };\n    }\n    results.push({ index, id: assignment.id, agent: assignment.agent, ...outcome });\n  }\n  return results;\n}\n\n/** Run an action through the reducer, persisting only when it produced a change. */\nasync function executeReducerAction(\n  store: TaskStore,\n  action: ReducerAction,\n  params: TaskMutationParams,\n  maxTasks: number,\n): Promise<ToolResult> {\n  const { document, value } = await store.mutate((current) => {\n    const result = applyTaskMutation(current, action, params, undefined, maxTasks);\n    return {\n      ...(isCommittingOp(result.op) ? { document: result.document } : {}),\n      value: result,\n    };\n  });\n  if (value.op.kind === 'error') throw actionableTaskError(action, value.op.message);\n  // An upsert that applied nothing is a failed call: it wrote nothing and left\n  // `rev` alone, so it must not read to the model as a success. A batch where\n  // some entries landed returns normally — that is what partial apply means.\n  if (value.op.kind === 'upsert' && value.op.applied === 0) {\n    throw actionableTaskError(action, formatUpsertFailureText(value.op));\n  }\n  // `document` is the committed document, so `details.rev` matches what landed\n  // on disk; `value.document` is the pre-write copy and lags by one.\n  return buildToolResult(action, params, document, value.op);\n}\n\nexport function registerTaskTool(pi: ExtensionAPI, dependencies: TaskToolDependencies): void {\n  const { store, delegation, maxTasks = DEFAULT_MAX_TASKS } = dependencies;\n\n  pi.registerTool({\n    name: TOOL_NAME,\n    label: TOOL_LABEL,\n    description:\n      'Track complex jobs with a shared task list and delegate tracked work to subagents. Use this only when persistent coordination is useful, such as work with dependencies, parallel workstreams, or a long-running plan. Do not use it for simple requests, routine edits, straightforward command sequences, or merely because the user listed multiple steps. Actions: upsert (write tasks: an entry with an id changes that task and one without an id creates one), list, get, delete (tombstone), clear (close/reset the list), assign (hand tasks through assignments[] to named background subagents), cancel (stop a delegated run). upsert and assign apply entries independently: successes remain committed or delegated and failures are reported by array index. Batch a plan and independent assignments, but report progress one task at a time. Status: pending → in_progress → completed, plus failed and a deleted tombstone. The list is shared within the current session tree, including delegated subagents, while unrelated sessions start empty. Session stores persist until retention cleanup.',\n    promptSnippet: DEFAULT_PROMPT_SNIPPET,\n    promptGuidelines: DEFAULT_PROMPT_GUIDELINES,\n    parameters: TaskParamsSchema,\n    // Task rows carry their own status colors. Owning the shell prevents Pi's\n    // pending/success/error background fill from obscuring those row states.\n    renderShell: 'self',\n\n    async execute(_toolCallId, params, signal, onUpdate, ctx) {\n      const action = params.action as TaskAction;\n      const mutationParams = params as TaskMutationParams;\n\n      try {\n        await dependencies.waitUntilReady?.(ctx, signal);\n        rejectStrayFields(action, mutationParams);\n        if (REDUCER_ACTIONS.has(action)) {\n          const result = await executeReducerAction(store, action as ReducerAction, mutationParams, maxTasks);\n          dependencies.onChange?.();\n          return result;\n        }\n\n        if (action === 'assign') {\n          const assignments = resolveAssignments(mutationParams);\n          const first = assignments[0];\n          const progress =\n            assignments.length === 1 && first\n              ? `Delegating task #${first.id}...`\n              : `Delegating ${assignments.length} tasks...`;\n          onUpdate?.(buildTextResult(action, mutationParams, store.snapshot, progress));\n          const results = await executeAssignmentBatch(delegation, assignments, signal, dependencies.report);\n          dependencies.onChange?.();\n          const text = formatAssignmentResults(results);\n          const assigned = results.flatMap((item) => (item.ok ? [item.id] : []));\n          if (assigned.length === 0) throw actionableTaskError(action, text);\n          return buildAssignmentResult(mutationParams, store.snapshot, text, {\n            assigned,\n            failed: results.length - assigned.length,\n          });\n        }\n\n        onUpdate?.(\n          buildTextResult(\n            action,\n            mutationParams,\n            store.snapshot,\n            `Requesting cancellation for task #${mutationParams.id ?? 'unknown'}...`,\n          ),\n        );\n        const outcome = await delegation.cancel(mutationParams.id ?? Number.NaN);\n        dependencies.onChange?.();\n        if (!outcome.ok) throw actionableTaskError(action, outcome.message);\n        return buildTextResult(action, mutationParams, store.snapshot, outcome.message, undefined);\n      } catch (error) {\n        // Rethrown so pi still renders the failure to the model; recorded\n        // because this is where a store fault becomes visible to the user.\n        dependencies.report?.error(TASK_EVENT.toolFailed, error, {\n          [ACTION_ATTRIBUTE]: action,\n          ...(mutationParams.id === undefined ? {} : { [TASK_ID_ATTRIBUTE]: mutationParams.id }),\n        });\n        if (error instanceof TaskToolExecutionError) throw error;\n        throw actionableTaskError(action, error instanceof Error ? error.message : String(error));\n      }\n    },\n\n    // Render hooks receive no session identity, so they read the store snapshot\n    // that the executing session last loaded. That is the foreground session's\n    // own view, which is exactly what its transcript should show.\n    renderCall(args, theme, _context) {\n      return renderTaskCall(args as never, theme, store.snapshot.tasks);\n    },\n\n    renderResult(result, options, theme, _context) {\n      return renderTaskResult(result, options, theme);\n    },\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"taskTool.mjs","names":[],"sources":["../../../src/commands/task/taskTool.ts"],"sourcesContent":["import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';\nimport {\n  MSG_UPSERT_FIELD_MISPLACED,\n  TaskParamsSchema,\n  TOOL_LABEL,\n  TOOL_NAME,\n  taskActionAcceptsField,\n} from '../../schemas/task.ts';\nimport type { AssignOptions, DelegationManager, DelegationOutcome } from '../../services/delegation/manager.ts';\nimport { applyTaskMutation, isCommittingOp, type ReducerAction } from '../../services/store/reducer.ts';\nimport type { TaskStore } from '../../adapters/store/taskStore';\nimport type { TaskAction, TaskAssignment, TaskMutationParams } from '../../services/store/types.ts';\nimport { renderTaskCall, renderTaskResult } from '../../tui/format.ts';\nimport { DEFAULT_MAX_TASKS } from '../../types/config.ts';\nimport { TASK_EVENT, type TaskFailureReporter } from '../../types/telemetry.ts';\nimport { DEFAULT_PROMPT_GUIDELINES } from './promptGuidelines.ts';\nimport {\n  type AssignmentItemResult,\n  buildAssignmentResult,\n  buildTextResult,\n  buildToolResult,\n  formatAssignmentResults,\n  formatUpsertFailureText,\n  type ToolResult,\n} from './responseEnvelope.ts';\n\nexport { DEFAULT_PROMPT_GUIDELINES } from './promptGuidelines.ts';\n\n/** @deprecated Task usage policy now lives only in the tool description. */\nexport const DEFAULT_PROMPT_SNIPPET =\n  'Track only complex, multi-step jobs that benefit from persistent progress or delegation; skip simple work';\n\nexport interface TaskToolDependencies {\n  store: TaskStore;\n  delegation: DelegationManager;\n  maxTasks?: number;\n  onChange?: () => void;\n  report?: TaskFailureReporter;\n  waitUntilReady?: (context: ExtensionContext, signal?: AbortSignal) => Promise<void>;\n}\n\nconst ACTION_ATTRIBUTE = 'tool.action';\nconst TASK_ID_ATTRIBUTE = 'task.id';\nconst REDUCER_ACTIONS = new Set<TaskAction>(['upsert', 'list', 'get', 'delete', 'clear']);\n\nclass TaskToolExecutionError extends Error {}\n\nfunction actionableTaskError(action: TaskAction, message: string): TaskToolExecutionError {\n  return new TaskToolExecutionError(\n    [\n      `Task ${action} failed: ${message}`,\n      '',\n      'Options:',\n      '- List the task board and inspect the current ids, states, and blockers.',\n      '- Correct the arguments or state conflict, then retry once.',\n      '- Ask the user before cancelling work or changing dependencies to recover.',\n    ].join('\\n'),\n  );\n}\n\n/**\n * Reject a field that belongs to a different action.\n *\n * The params schema is flat and shared across every action, so this is the only\n * place `{\"action\":\"upsert\",\"id\":3}` can be caught — and it must be, because\n * the entry it carries has no id and would silently create a duplicate task.\n */\nfunction rejectStrayFields(action: TaskAction, params: TaskMutationParams): void {\n  const stray = Object.keys(params).filter((key) => params[key] !== undefined && !taskActionAcceptsField(action, key));\n  if (stray.length === 0) return;\n  const hint = action === 'upsert' ? ` ${MSG_UPSERT_FIELD_MISPLACED}` : '';\n  throw actionableTaskError(action, `${action} does not accept ${stray.join(', ')}.${hint}`);\n}\n\n/** assignments[] is the only assign contract, even when it contains one task. */\nfunction resolveAssignments(params: TaskMutationParams): TaskAssignment[] {\n  const assignments = params.assignments;\n  if (!assignments || assignments.length === 0) {\n    throw actionableTaskError('assign', 'assign requires a non-empty assignments[] array');\n  }\n  return assignments;\n}\n\nfunction assignOptions(request: TaskAssignment, signal: AbortSignal | undefined): AssignOptions {\n  return {\n    agent: request.agent,\n    inlineAgent: request.inlineAgent,\n    instructions: request.instructions,\n    relevantFiles: request.relevantFiles,\n    priorFindings: request.priorFindings,\n    model: request.model,\n    context: request.context,\n    signal,\n  };\n}\n\nasync function executeAssignmentBatch(\n  delegation: DelegationManager,\n  assignments: readonly TaskAssignment[],\n  signal: AbortSignal | undefined,\n  report: TaskFailureReporter | undefined,\n): Promise<AssignmentItemResult[]> {\n  const results: AssignmentItemResult[] = [];\n  for (const [index, assignment] of assignments.entries()) {\n    let outcome: DelegationOutcome;\n    try {\n      outcome = await delegation.assign(assignment.id, assignOptions(assignment, signal));\n    } catch (error) {\n      report?.error(TASK_EVENT.toolFailed, error, {\n        [ACTION_ATTRIBUTE]: 'assign',\n        [TASK_ID_ATTRIBUTE]: assignment.id,\n      });\n      outcome = { ok: false, message: error instanceof Error ? error.message : String(error) };\n    }\n    results.push({ index, id: assignment.id, agent: assignment.agent, ...outcome });\n  }\n  return results;\n}\n\n/** Run an action through the reducer, persisting only when it produced a change. */\nasync function executeReducerAction(\n  store: TaskStore,\n  action: ReducerAction,\n  params: TaskMutationParams,\n  maxTasks: number,\n): Promise<ToolResult> {\n  const { document, value } = await store.mutate((current) => {\n    const result = applyTaskMutation(current, action, params, undefined, maxTasks);\n    return {\n      ...(isCommittingOp(result.op) ? { document: result.document } : {}),\n      value: result,\n    };\n  });\n  if (value.op.kind === 'error') throw actionableTaskError(action, value.op.message);\n  // An upsert that applied nothing is a failed call: it wrote nothing and left\n  // `rev` alone, so it must not read to the model as a success. A batch where\n  // some entries landed returns normally — that is what partial apply means.\n  if (value.op.kind === 'upsert' && value.op.applied === 0) {\n    throw actionableTaskError(action, formatUpsertFailureText(value.op));\n  }\n  // `document` is the committed document, so `details.rev` matches what landed\n  // on disk; `value.document` is the pre-write copy and lags by one.\n  return buildToolResult(action, params, document, value.op);\n}\n\nexport function registerTaskTool(pi: ExtensionAPI, dependencies: TaskToolDependencies): void {\n  const { store, delegation, maxTasks = DEFAULT_MAX_TASKS } = dependencies;\n\n  pi.registerTool({\n    name: TOOL_NAME,\n    label: TOOL_LABEL,\n    description:\n      'Track complex jobs with a shared task list and delegate tracked work to subagents. Use this only when persistent coordination is useful, such as work with dependencies, parallel workstreams, or a long-running plan. Do not use it for simple requests, routine edits, straightforward command sequences, or merely because the user listed multiple steps. Actions: upsert (write tasks: an entry with an id changes that task and one without an id creates one), list, get, delete (tombstone), clear (close/reset the list), assign (hand tasks through assignments[] to named background subagents), cancel (stop a delegated run). upsert and assign apply entries independently: successes remain committed or delegated and failures are reported by array index. Batch a plan and independent assignments, but report progress one task at a time. Status: pending → in_progress → completed, plus failed and a deleted tombstone. The list is shared within the current session tree, including delegated subagents, while unrelated sessions start empty. Session stores persist until retention cleanup.',\n    promptGuidelines: DEFAULT_PROMPT_GUIDELINES,\n    parameters: TaskParamsSchema,\n    // Task rows carry their own status colors. Owning the shell prevents Pi's\n    // pending/success/error background fill from obscuring those row states.\n    renderShell: 'self',\n\n    async execute(_toolCallId, params, signal, onUpdate, ctx) {\n      const action = params.action as TaskAction;\n      const mutationParams = params as TaskMutationParams;\n\n      try {\n        await dependencies.waitUntilReady?.(ctx, signal);\n        rejectStrayFields(action, mutationParams);\n        if (REDUCER_ACTIONS.has(action)) {\n          const result = await executeReducerAction(store, action as ReducerAction, mutationParams, maxTasks);\n          dependencies.onChange?.();\n          return result;\n        }\n\n        if (action === 'assign') {\n          const assignments = resolveAssignments(mutationParams);\n          const first = assignments[0];\n          const progress =\n            assignments.length === 1 && first\n              ? `Delegating task #${first.id}...`\n              : `Delegating ${assignments.length} tasks...`;\n          onUpdate?.(buildTextResult(action, mutationParams, store.snapshot, progress));\n          const results = await executeAssignmentBatch(delegation, assignments, signal, dependencies.report);\n          dependencies.onChange?.();\n          const text = formatAssignmentResults(results);\n          const assigned = results.flatMap((item) => (item.ok ? [item.id] : []));\n          if (assigned.length === 0) throw actionableTaskError(action, text);\n          return buildAssignmentResult(mutationParams, store.snapshot, text, {\n            assigned,\n            failed: results.length - assigned.length,\n          });\n        }\n\n        onUpdate?.(\n          buildTextResult(\n            action,\n            mutationParams,\n            store.snapshot,\n            `Requesting cancellation for task #${mutationParams.id ?? 'unknown'}...`,\n          ),\n        );\n        const outcome = await delegation.cancel(mutationParams.id ?? Number.NaN);\n        dependencies.onChange?.();\n        if (!outcome.ok) throw actionableTaskError(action, outcome.message);\n        return buildTextResult(action, mutationParams, store.snapshot, outcome.message, undefined);\n      } catch (error) {\n        // Rethrown so pi still renders the failure to the model; recorded\n        // because this is where a store fault becomes visible to the user.\n        dependencies.report?.error(TASK_EVENT.toolFailed, error, {\n          [ACTION_ATTRIBUTE]: action,\n          ...(mutationParams.id === undefined ? {} : { [TASK_ID_ATTRIBUTE]: mutationParams.id }),\n        });\n        if (error instanceof TaskToolExecutionError) throw error;\n        throw actionableTaskError(action, error instanceof Error ? error.message : String(error));\n      }\n    },\n\n    // Render hooks receive no session identity, so they read the store snapshot\n    // that the executing session last loaded. That is the foreground session's\n    // own view, which is exactly what its transcript should show.\n    renderCall(args, theme, _context) {\n      return renderTaskCall(args as never, theme, store.snapshot.tasks);\n    },\n\n    renderResult(result, options, theme, _context) {\n      return renderTaskResult(result, options, theme);\n    },\n  });\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agimon-ai/doompi-task",
-  "version": "0.0.1-alpha.29",
+  "version": "0.0.1-alpha.30",
   "description": "Persistent, dependency-aware task graphs and subagent delegation for Pi coding sessions.",
   "keywords": [
     "ai",
@@ -150,9 +150,9 @@
   "dependencies": {
     "@deepseek-ai/cordis": "4.0.1",
     "typebox": "1.3.16",
-    "@agimon-ai/doompi-extension-contracts": "0.0.1-alpha.29",
-    "@agimon-ai/doompi-ui": "0.0.1-alpha.29",
-    "@agimon-ai/doompi-telemetry": "0.0.1-alpha.29"
+    "@agimon-ai/doompi-extension-contracts": "0.0.1-alpha.30",
+    "@agimon-ai/doompi-telemetry": "0.0.1-alpha.30",
+    "@agimon-ai/doompi-ui": "0.0.1-alpha.30"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "0.84.2",