icaire-fanout-tasks
Fan out currently discussed ICAIRE task pages into separate Codex threads using handoff prompts built from the ICAIRE Cortex MCP task tools. Use when the user wants ICAIRE task threads, selected tasks
SKILL.mdskills/icaire-fanout-tasks/SKILL.md
GitHubICAIRE Fanout Tasks
Use this skill when the user wants currently discussed ICAIRE task pages fanned
out into handoff-ready Codex threads. ICAIRE tasks are page-backed records under
tasks/*.md; do not read or reconstruct local TODO files.
By default, create one new Codex thread per ready task in the current conversation scope when the Codex app thread tools are available. The current conversation scope is narrower than the whole task queue: it means tasks the user just named, task slugs or titles just created or discussed, task numbers from the immediately preceding ICAIRE what's-next snapshot, or a set explicitly filtered in the user's fanout request.
Only fan out the broad active queue when the skill is invoked as the accepted
follow-up to an ICAIRE what's-next snapshot, for example after the assistant
offers fanout and the user replies yes, or when the user explicitly asks for
all ready/open/in-progress ICAIRE tasks, daily kickoff threads, or another broad
queue scope.
Only return copyable prompts instead of creating threads when the user explicitly asks for prompts only, or when live thread creation is unavailable after targeted tool discovery.
Contract
- Use ICAIRE Cortex MCP, not local TODO files.
- Resolve the requested fanout scope before listing tasks. Do not default to the whole active ICAIRE queue merely because the user said "fan out".
- Start with
meonly when the request is for the authenticated member. If the authenticated user is not an active member, stop and explain that ICAIRE membership must be configured before member-scoped task fanout works. - Fetch tasks with
tasks/listonly for the resolved scope. - When task records include
readinessandexecution_mode, use them as handoff hints, then read the task body before generating prompts. - Prefer slash tool names; use underscore aliases only if needed.
- Discover and use
codex_app.create_threadfor live fanout when available. - Output launched thread IDs or links in chat. Do not write a file unless explicitly asked.
Workflow
- Resolve the fanout scope before listing tasks:
- If the user names task slugs, task titles, task numbers, or says "these", "this", "the ones we just made", or similar, restrict fanout to those currently discussed tasks.
- If the user is responding to an immediately preceding ICAIRE what's-next
snapshot with
yes, "fan these out", or selected numbers, preserve that snapshot's numbering and fan out only the accepted ready items. - If the user explicitly asks for "all", "daily kickoff", "all ready", "all open", "all in progress", or a broad assignee/status/priority filter, use that broad queue scope.
- If there is no recoverable current task scope and no explicit broad scope, ask the user which tasks to fan out instead of defaulting to the whole active queue.
- Call
meand confirmmember.person_slugexists only when the request is for "my" or assigned-to-me tasks. - Call
tasks/listonly for the resolved scope:- for broad queue scope, call
tasks/listtwice by default: first withstatus: "in_progress", then withstatus: "open" - for selected task numbers from an ICAIRE what's-next snapshot, reuse the
snapshot task records when available; otherwise call
tasks/listfor the necessary status/filter and match by slug/title - for slugs or titles from the current conversation, call the narrowest
available
tasks/listfilters, then match by slug/title from the MCP records; do not launch unrelated tasks merely because they share a status or priority
- for broad queue scope, call
- If
tasks/listis not visible, use targeted Codex tool discovery for the ICAIREtasks/listtool before falling back to runtime or code inspection. - Honor explicit scoping in the user's request:
- use
assignee: mefor "my tasks" or "assigned to me" - use a specific
people/<slug>when the user names an assignee - use a named priority such as
p0,p1,p2, orp3when requested - use a named status when requested; otherwise use the resolved scope rules above
- use
- Use the returned task title, body, priority, assignees, source slugs, readiness, execution mode, and slug to create one prompt per fanout-ready task. The prompt itself must contain the task context needed to begin; do not make the worker fetch or read the task page before starting.
- Read linked
source_slugsonly when the task body is too thin to produce a good handoff prompt. - Treat
readinessandexecution_modeas useful hints, then read the task body. If## Open Questionscontains substantive questions, keep the task out of worker prompt blocks and list it as needing input, unless the task is clearly an interactive guided session whose purpose is to answer those questions with the user. - Classify the remaining tasks with
readinessandexecution_mode:- Generate autonomous handoff prompts for tasks with
readiness: "ready"andexecution_mode: "agent". - Generate guided-session prompts for tasks with
readiness: "ready"andexecution_mode: "interactive", instructing Codex to walk through the task with the user step by step. - Keep
readiness: "underspecified"andexecution_mode: "user"tasks out of prompt blocks and list them separately as needing user action or input. - If
execution_modeis absent because the remote server has not yet been updated, infer conservatively: useagentfor autonomous implementation or research,interactivefor review/judgement/approval, anduseronly for actions Codex cannot physically help with. Ifreadinessis absent because the remote server has not yet been updated, infer readiness conservatively from the task body and open questions.
- Generate autonomous handoff prompts for tasks with
- Produce up to 10 prompts, ordered by status, priority, due date, and task order returned by the server.
- Discover the Codex thread tools before concluding live fanout is unavailable:
- Call
tool_searchforcreate_thread. - Use
codex_app.list_projectswhen available to choose an appropriate target for each worker thread. - Use
codex_app.create_threadfor each ready task, passing the generated handoff prompt as the new thread's initial prompt. - Use a repo project target with a local or worktree environment when the task clearly belongs to a known local project.
- Use
target: { "type": "projectless" }for general ICAIRE work or tasks that do not clearly belong to one code repository. - Preserve returned thread IDs or links so they can be reported.
Respond in chat with the launched thread list and any blocked/non-fanned-out tasks. Do not write the result to a file, do not return only a file link, and do not make the user open an artifact to see what was launched.
Output Requirements
Default output is capped at 10 ready items within the resolved scope. Keep each worker prompt short, self-contained, and suitable as the initial prompt for a fresh Codex thread:
- When live thread creation succeeds, start with
Launched ICAIRE task threads. - Show ready
in_progresstasks first, followed by readyopentasks. - Include only tasks whose MCP record has
readiness: "ready"andexecution_mode: "agent"orexecution_mode: "interactive"after the open-questions override above, or conservatively inferred equivalents only when fields are absent. - Each ready task must be one concise fenced text prompt block that leads with the actual task content, using plain language drawn from the task page rather than a slug-heavy reference style.
- Do not use task slugs as prompt headings or lead text.
- The first paragraph must be only the task-specific brief: what to do, what to focus on, and the concrete output expected for this task. Do not mix generic workflow instructions into this paragraph.
- Put the reusable worker instructions in a separate paragraph after the task-specific brief.
- For
execution_mode: interactivetasks, the prompt must ask Codex to work with the user step by step, pause at judgement or approval points, and avoid making the final decision for the user. Prepend this sentence before the task-specific brief:I need to get this done, and I want you to walk me through it step by step. - After that prepend, keep the same task-specific brief format as autonomous prompts: what to do, what to focus on, and the concrete output expected for this task.
- Each prompt should stand on its own by pulling in the key task details, so a reader can tell what they are doing without needing to parse internal file references first or find the task in the brain before beginning.
- The reusable-instructions paragraph should be concise and use this wording:
Show me the result for approval once you finish the task. Once approved, update the ICAIRE brain, marking the task as done or in_progress, enriching related pages and their timelines, and noting the successor task if needed. - Include the source task slug only as a compact completion/update reference,
for example
Source task: tasks/<slug>. Do not instruct the worker to read, open, find, or fetch the task from the brain before starting. - Do not format ready tasks as a numbered list.
- Do not add generic boilerplate about reading files, preserving local changes, verification, or commits beyond the required completion handoff.
- When live thread creation succeeds, do not print the full worker prompts by default. Instead, show a concise launched-thread list with each task title, execution mode, and returned thread ID or link.
- When the user explicitly asks for copyable prompts only, or live thread creation is unavailable, print the prompt blocks instead of thread IDs.
- Show a
Needs user action before fanoutsection after ready prompts for input-needed tasks andexecution_mode: "user"tasks. - Keep the input-needed list succinct; name each task by human-readable title
or action, not slug, and include the blocking question(s), preferring the task
page's
## Open Questionssection when present.
If no actionable ICAIRE task pages match the requested filters, say that directly and do not invent prompts.
If live thread creation is unavailable after targeted create_thread
discovery, output exactly:
Parallel execution unavailable here.
Then provide the shortest useful set of copyable worker prompts.
Guardrails
- Treat MCP task data as authoritative for task status and assignees.
- Do not use local TODO files for this skill.
- Do not mutate tasks while fanning them out.
- Do not fan out the whole active queue merely because the skill was invoked. Whole-queue fanout is allowed only after an ICAIRE what's-next snapshot fanout offer is accepted, or when the user explicitly requests a broad queue scope.
- When the user has just created or discussed one or more ICAIRE tasks, treat those tasks as the fanout scope unless they say otherwise.
- Creating Codex threads is allowed by this skill; mutating ICAIRE task pages is not.
- Do not create prompts for tasks with
status: doneorstatus: archivedunless the user explicitly asks for those statuses. - Do not create prompts for input-needed tasks or tasks with
readiness: underspecifiedwhen readiness is present. - Do not create prompts for tasks with
execution_mode: user. - Keep each prompt scoped to one task; split multi-task records into input-needed items rather than guessing hidden subtasks.
- Do not show other members' tasks when the user asked for their own next work.
- Do not silently fall back to all tasks when
mecannot resolve. - Do not treat external people as assignable members.
- Do not claim fanout ran unless
codex_app.create_threadsucceeded for the relevant workers.