Skip to content

rundesk-ai/rundesk-cli / src/skills/delegating-work

delegating-work

Verified

Use when named delegation is a genuine option for current work, when preparing or reviewing a handoff, or when continuing delegated work to a verified outcome. It supplies context recovery, deliberate skill selection, necessary-only delegation, evidence requirements, and continuation discipline. Do not use for ordinary Rundesk operations, domain-specific implementation guidance, or conversation with no genuine delegation option.

FileKindSize
SKILL.mdskill md11.5 KB
references/brief-examples.mdmarkdown5.0 KB
references/operations.mdmarkdown5.0 KB

references/operations.md

View on GitHub
# Delegation operations

Read this reference before starting a handoff or acting on one already in progress. It is the
command and state contract; the main skill owns the judgment about whether to delegate and how to
review the result.

## Start and inspect

Inside an agent turn, `ask` hands work to another agent and returns immediately:

```sh
"$RUNDESK_COMMAND" ask <agent> '<brief>'
```

The target is selected from the team offered to the current turn. Do not inspect gateways as an
extra preflight: `ask` enforces delegation scope and current route admission and returns a refusal
if either no longer permits the handoff. A turn already answering a delegation cannot delegate
again. Do not bypass either boundary with an attended `ask`.

An optional provider, account alias, or model applies only to this handoff and does not reconfigure
the target:

```sh
"$RUNDESK_COMMAND" ask <agent> '<brief>' --provider <provider> [--alias <alias>] [--model <model>]
```

Keep the returned delegation id. Use the management surface to inspect it:

| Need | Inside the delegating agent's turn | From an attended terminal |
|---|---|---|
| List delegated work | `"$RUNDESK_COMMAND" asked` | `"$RUNDESK_COMMAND" asked --agent <delegator>` |
| Show one in full | `"$RUNDESK_COMMAND" asked show <id>` | `"$RUNDESK_COMMAND" asked --agent <delegator> show <id>` |

`show` distinguishes what provider, alias, and model were requested; what was fixed at admission;
and what the target provider actually reported. Do not turn an unreported terminal model into the
requested or configured one.

## Steer, stop, or resume

Use a separate verb for each state transition:

| Operation | Command inside the delegating turn | Valid state and effect |
|---|---|---|
| Steer | `"$RUNDESK_COMMAND" asked say <id> '<words>'` | `working`; offers guidance to the live provider and keeps it for the next turn if missed |
| Stop | `"$RUNDESK_COMMAND" asked stop <id>` | `working`; records a stop request, then shows `stopping` until the target settles as `stopped` |
| Resume | `"$RUNDESK_COMMAND" asked resume <id> '<more>'` | `answered`; reopens the same delegation, conversation, provider selection, and provider session |

From a terminal, put `--agent <delegator>` immediately after `asked`. `say`, `stop`, and `resume`
cannot change the provider or model chosen when the handoff was admitted.

Do not infer success from the management command alone. `say` proves guidance was stored, not that
the active provider accepted it. `stop` proves a request was recorded, not that the process has
ended. `resume` proves answered work was reopened, not that the additional result is complete.

### Match steering to the provider

`say` has one Rundesk meaning, but providers deliver it differently:

- **Codex** uses native `turn/steer` against the active turn. Use it naturally for relevant course
  corrections or timely clarification while work is still `working`.
- **Claude** has no native turn-steer request. Its adapter interrupts the active provider request,
  waits for the interrupted result to drain, then sends the replacement in the same session.
- **Grok** has no native turn-steer request. Its adapter cancels the active prompt, waits for that
  cancellation to settle, then sends the replacement in the same session.

Claude and Grok therefore use stop-and-continue delivery. Consolidate guidance and steer them only
when their current work needs to change or letting it continue would waste or worsen the result. Do
not use steering for status checks, optional commentary, or a stream of small preferences. These
provider mechanics are not the delegation `stop` or `resume` operations and do not change the
delegation's provider or session.

A steered turn may answer the new guidance while omitting work required by the original brief.
Review the return against both. If the delegation is now `answered` and required evidence is still
missing, resume the same delegation with a bounded correction instead of accepting the partial
answer or opening a duplicate handoff.

## Follow the asynchronous return

The target works from its own home, instructions, memory, and skills. Its answer returns verbatim and
unchecked to the delegating agent. If the original provider turn is still active and steerable, the
answer may reach it there; otherwise Rundesk wakes a review turn.

Do not poll. While the target owns the next action, either continue independent in-scope work or end
with the delegated answer as the event that resumes the parent outcome. When the answer arrives,
review it before adopting any claim or artifact.

The states name the only valid next actions:

- `working`: inspect, steer, or request stop.
- `stopping`: wait for the terminal stop; do not claim it is already stopped.
- `stopped`: closed without an answer; start a new delegation if more work is needed.
- `answered`: review the result, or resume it with a bounded follow-up.

Two handoffs to the same target are separate delegations and conversations. Resume only when the
follow-up depends on the prior context; otherwise create a new bounded handoff.
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall