improve

Files (15)

• LICENSE
• README.md
• SKILL.md
• openai.yaml · agents/
• callback-evidence.md · references/
• review-policy.md · references/
• shiploop-route.md · references/
• standalone-route.md · references/
• ADAPTER.md · runtime/until-loop/
• LICENSE · runtime/until-loop/
• PROVENANCE.json · runtime/until-loop/
• runtime-ephemeral.md · runtime/until-loop/references/
• until_loop_ephemeral.py · runtime/until-loop/scripts/
• until_loop_recover.py · runtime/until-loop/scripts/
• until_loop_session.py · runtime/until-loop/scripts/

SKILL.md (first lines)

# improve

Use the shared [Improve review policy](references/review-policy.md) to turn
“improve these changes” into a bounded review-and-improvement contract. This
standalone card binds that reusable policy to Until Loop's single-file callback
runtime. It does not create a second state machine or invoke `/goal`.

Pick the route first. A ShipLoop review (the argument `ShipLoop Improve: <handoff path>`)
follows "ShipLoop whole-skill subcall" below and reads [the ShipLoop route](references/shiploop-route.md)
once per context: a short core that opens its case files only when their case arises. Any other
invocation (`/improve`, an `improve-agent` worker) reads [the standalone route](references/standalone-route.md)
in full before interpreting or executing; it holds the standalone binding, context-loss continuation, completion summary, preview and execution
handoff, and has you read the shared policy in full.

Improve is an execution-capable coding agent, not an audit-only role. Within the
selected entrypoint's task and authority, use the available tools, MCP
interactions and skills to investigate, produce or revise code, tests, documents
and configuration, and perform authorized deployments or other operations.
Running inside an agent started by the [`improve-agent`](#agent-run-invocation)
skill adds no capability restriction. Carry existing authorization forward and
disclose actual host capability gaps. Parent-only control callbacks remain with
their owner.

This card runs inline: the conversation that invokes it executes every review
cycle, check and callback itself. It never hands the invocation, a review or a
check run to another agent unless an independent review is explicitly requested
(see [Agents and independent review](references/standalone-route.md#standalone-owner-binding)). To run the
whole invocation in a fresh native agent instead, use the `improve-agent` skill.

Use your judgment to find worthwhile improvements, including consequential
issues the initiating context did not anticipate. Suggested fixes are starting
points, not an exhaustive checklist or a ceiling on review depth or change size.
Choose the investigation and implementation needed for the candidate; preserve
the actual scope and accepted requirements. Complete meaningful checks, commit
authorized changed files according to the binding, and continue after material
changes until the selected loop's completion condition is met.

For the standalone entrypoint, this package bundles its Until Loop runtime at
[runtime/until-loop/ADAPTER.md](runtime/until-loop/ADAPTER.md). Resolve symlinks
to this card's physical directory before resolving relative links. Read that
bound card in full and follow its current adapter. The package-relative binding
is authoritative: do not substitute a separately installed runtime, an older
card, or an ambient same-named skill.

## Installed package binding

Start with the absolute path of the **selected, loaded** `SKILL.md` supplied by
the host. If the host exposes a selected skill-root alias, expand that alias
first. Keep that logical `SKILL_ROOT` as the host's selected identity; it is not
the target repository cwd, an author checkout, `PATH`, a same-named skill, or a
guessed cache. Claude Code may render `${CLAUDE_SKILL_DIR}` in card text where
supported, but it is not a portable shell environment variable.

```sh
# Replace this illustrative path with the selected absolute location before running.
SKILL_ROOT="/absolute/directory-containing-the-loaded-SKILL.md"
RUNTIME_SCRIPT="$SKILL_ROOT/runtime/until-loop/scripts/until_loop_ephemeral.py"
```

The exact package-relative script locator for a standalone run is
`runtime/until-loop/scripts/until_loop_ephemeral.py`. Its ordinary start must
use `start --isolated`: upstream 0.9.0 also provides host-session mode and
session/recovery helpers, but Improve keeps its own per-run temporary callback
state. Contract/Receipt parent calls continue to use the adapter's receipt-backed
isolated route. The bound adapter is the only CLI caller: it translates
natural-language intent into its internal contract, starts or resumes the
selected run, and consumes the exact callback it returns. Do not make the user
supply JSON or fixed runtime arguments. A skill-directory or marketplace
installation must keep this entire package tree together; the nested runtime is
an internal dependency, not a second standalone parent.

Standalone runs use that per-run temporary callback state. Do not replace
`RUNTIME_SCRIPT` with an ambient Until Loop installation. If Python, the
bundled file, or a repository prerequisite is missing, report that condition
rather than silently changing runtimes.

## ShipLoop whole-skill subcall

When this skill is invoked with the argument `ShipLoop Improve: <handoff path>`,
read that handoff file with a file-reading tool, not cat (the shell cuts it):
ShipLoop wrote it for one child, and it plays the role of
"the ShipLoop packet" in this section. When it (or a ShipLoop packet) names a
selected actual Improve card and prints a
`ShipLoop standalone Improve binding: <binding-id>` marker, this is a
**standalone whole-skill subcall**. Read [the ShipLoop route](references/shiploop-route.md)
once per context: its short core applies this card's standalone owner binding and the
Until Loop runtime's loop rules to a ShipLoop child, holds every rule a normal pass needs beyond
the handoff, and names the case file to open only when its case arises. Preserve the
exact binding marker in the child `context.request`. The ShipLoop packet supplies the bounded
candidate scope, permitted paths, current producer result, relevant work-item
`context`, evidence/reference locators, return route, and authority constraints;
retain those as frozen child-contract constraints rather than inventing an
alternate ShipLoop review protocol.

Treat a parent-provided candidate inventory as scope separately from Git
history. Retain every named included path, including relevant untracked product
or requirements artifacts, when the initial commit is empty or `HEAD` does not
move. Keep explicitly excluded scratch or pre-existing user paths outside that
candidate. When the inventory is large, retain one exact inventory locator
rather than recopying every path into each review record.

ShipLoop starts the child itself when its Improve stage begins: it writes the
opening from the run's state, freezes the child contract (binding line,
workspace, conditions, commit policy and return locators) and starts the bound
runtime with the receipt. Read the printed host receipt and continue the child
from it: for `active` status run its `next_argv` once, then follow the returned
instruction. Do not write the opening or start the runtime yourself. The runtime
rewrites the receipt itself at every step, the last time before it deletes its
state, and ShipLoop imports only a receipt written that way. Never write or edit
that receipt by hand.

The child `context.resources` must retain the child receipt location, the
exact parent return instruction or callback locator, and the printed host
receipt path for the child response. These locators make a final child receipt
sufficient for a fresh host to save its exact response at the required receipt
path and then return through the parent route. Do not infer a
different route from a remembered parent state.

The ShipLoop child follows the standalone binding's ordinary commit policy: after

From whichguy/skill-craft, MIT.

More from whichguy/skill-craft