ask-agent

Files (11)

• SKILL.md
• consumer-owned-workspace.md · references/
• current-workspace.md · references/
• git-integration.md · references/
• host-capabilities.md · references/
• native-lifecycle.md · references/
• result-handoff.md · references/
• task-interface.md · references/
• workspace-operations.md · references/
• ask_agent_task.py · scripts/
• ask_agent_workspace.py · scripts/

SKILL.md (first lines)

# Ask agent

Delegate through this session's native agents. The bundled helper owns Git
workspace preparation and eligible cleanup; the native host owns execution and
return; the parent owns acceptance and integration. `ask-agent` selects this
skill, not an agent type. Do not implement another model launcher, SDK client,
subprocess harness, scheduler, or file watcher to simulate native delegation.

The current workspace is the default for delegation: a fresh worker runs in
the caller's own checkout and branch, with no second worktree or repository.
A helper-managed worktree and a consumer-owned workspace are explicit
selections, never an automatic interpretation of an existing worktree, a speed
request, a request for fresh context, or a request to change code.

Default to a fresh background worker while the parent continues useful work.
An explicit request to wait takes precedence. Each invocation adds to the
initiating conversation's pending work; it does not replace earlier jobs.

On the default standalone current-workspace route, `mode: edit` changes only
the write set the parent declares from the request; the parent verifies the
edits, and the worker does not commit. Questions, digests and reviews use
`mode: report-only` and make no filesystem edits. A standalone isolated
worktree is an explicit choice: `mode: edit` defaults to commit delivery,
`delivery_mode: patch` selects a patch handoff, and `mode: ephemeral` permits
only scoped scratch writes whose findings return without code integration.

A standalone worktree `mode: edit` includes bringing the verified contribution
back into the designated caller or integration checkout by default. The parent
performs that integration and validates the combined result before reporting
the request SUCCEEDED. Current-workspace edits are accepted in place, while
`report-only` and `ephemeral` results have no code integration. A consumer-owned
route instead has in-place parent acceptance followed by its consumer's
separately owned final caller delivery. A successful worker return alone is not
completion. If integration or final delivery is blocked, report the blocker,
worker outcome and retained locations. An explicit review-only or
return-without-integration request overrides the integration default. Follow
the selected compact or legacy delivery contract and preserve caller dirty state.

## Select the route before preparing

This card declares `ask-agent/consumer-owned-workspace/v1` and
`ask-agent/current-workspace/v1`. Select exactly one route before any helper
preparation or native dispatch:

- **Current workspace** is the standalone default. A fresh worker runs in the
  caller's own checkout and branch, with no helper worktree, receipt or close.
  Use compact `mode: edit` with a write set for changes; edits are not committed
  automatically. Use `mode: report-only` for a question, digest or review. For
  standalone work, the task interface below performs the checks described in
  [Current workspace](references/current-workspace.md).
- **Standalone worktree** requires explicit selection with `workspace:
  worktree`. The compact task interface prepares the snapshot and supports
  `edit`, `report-only`, and findings-only `ephemeral` modes. Worktree edits
  default to commit delivery; select `delivery_mode: patch` only when patch
  delivery is intended. See [Task interface](references/task-interface.md).
- **Legacy/orchestrated helper-managed** requires `workspace_route:
  helper-managed` or an invoking consumer's explicit contract. It retains its
  direct helper workflow and `patch`, `commits`, or `report-only` delivery
  rules below. Plan Dispatcher, ShipLoop's parallel chain and a standalone
  improve-agent request select this existing contract; do not silently route
  them through the compact standalone interface.
- **Consumer-owned** requires an invoking consumer to explicitly set
  `workspace_route: consumer-owned` and `delivery_mode: in-place`, and to supply
  the complete workspace/ownership contract in
  [Consumer-owned workspace](references/consumer-owned-workspace.md). Its worker
  writes in the consumer's already-bound candidate; helper delivery modes do not
  apply.
An ordinary invocation that selects neither consumer-owned nor helper-managed
uses the current-workspace default. Plan Dispatcher, ShipLoop and improve-agent
never use it. A consumer that explicitly requests consumer-owned but
lacks this card capability or any required contract field stays pending with its
available locators. Do not silently switch that incomplete consumer request to
the helper-managed route, shared writes, an inherited context, or a second
worktree.

The currently declared consumer is the `improve-agent` skill, composing a
ShipLoop whole-skill Improve child. It supplies one fresh executor for the
complete bound Improve invocation. A standalone `improve-agent` request selects the
helper-managed route instead, and inline `improve` starts no agent. This is a
Codex native pilot with evidence from bounded native fixtures. Earlier helper-managed host
evidence does not qualify this composition on Codex, Claude, Grok, or another
host.

## Standalone task interface

For standalone current-workspace and isolated worktree tasks, use
[Task interface](references/task-interface.md). Bind
`scripts/ask_agent_task.py` from this selected skill package. Supply the task,
expected result, source, exact write set, `workspace`, and `mode` to `prepare`.
Only a worktree `edit` accepts `delivery_mode`; omitted means `commits`, and
explicit `patch` is supported. Current `edit` and `report-only` have no
delivery mode. `ephemeral` requires a worktree and a nonempty write set; it
returns findings only and has no commit, patch, or integration. Current editing
requires `exclusive_writer: true`; worktree preparation requires
`writers_quiescent: true`. These are parent attestations, not locks.

When parent and worker share access to local files, select `prepare --packet`
with a new absolute path outside the repositories, Git metadata and selected
package. The script retains the binding and emits a short native assignment;
`worker-start` validates its pinned digest and returns the complete actionable
task. Use the emitted command arguments, including the expected digest, without
reconstructing them. The parent retains the packet locator and hashes. This
transport satisfies the standalone task's context and authority requirements
below through the validated `action_packet.task.current_learnings` and
`action_packet.task.authorization`; the worker reads them before task work.
For hosts without shared file access, omit `--packet` and carry the existing
complete inline binding. Do not silently switch transport after a failure.

Retain the emitted binding or packet metadata and launch the native worker
with its emitted assignment.
The worker runs `worker-start` and `worker-finish`; after collecting the actual
native result, the parent runs `verify-return`. These scripts do not launch
agents, integrate contributions, or clean up worktrees. The parent owns
semantic acceptance, any commit/patch integration, combined checks, and later
cleanup. The compact route does not replace the legacy orchestrated or
consumer-owned contracts below. Its source implementation and local evidence
do not establish release or universal host support. Successful checks replace
the corresponding compact-route manual steps; do not repeat preparation or
assemble a second worker brief. Resolve failed checks before dispatch and never

From whichguy/skill-craft, MIT.

More from whichguy/skill-craft