SkillTape

Beta — Turn a real local workflow into a reviewable Agent Skill you can replay and verify before you share it.

SkillTape captures a command you already run, turns it into a reviewable Skill, and produces a Receipt that tells you whether the isolated replay succeeded. It runs locally; the first result needs no account, API key, model provider, or configuration file.

Watch the 30-second terminal demo · Download v0.2.3

Verified public release

SkillTape v0.2.3 is publicly available as native CLI, Console API and Console UI packages. Release run 38862770537 passed Linux, Intel Mac, Apple Silicon Mac and Windows builds, required provenance/SBOM/checksums and the published Windows installer smoke check. All eight downloaded archive/SBOM checksums matched. An isolated native Mac installation passed required-output success/failure and packaged Console checks.

Windows Replay/Verify still fail closed. The terminal demo records the historical v0.1.0 journey; the commands below install v0.2.3. Earlier releases remain available.

New in v0.2.3

• Require output files with repeatable verify --expect-file PATH; missing files fail verification and leave the delivery unpublished. See the example below.
• Inspect and compare real saved bundles in the Console's Delivery workbench, including actual file hashes and changes. Native physical inspection currently requires POSIX.
• Pass literal Capture arguments with --arg and cancel Unix Replay/Verify with orderly cleanup and exit 5. See arguments and cancellation.
• Use bounded stable exports, optional export --receipt association and complete no-overwrite delivery publication. The multi-organization example pairs actual local output with independent composite-key checks.

Get a verified Skill in five minutes

Install the fixed public v0.2.3 release without piping a download into a shell. The installer below is fetched from commit 9f6bec579258baa63234139af0fae650d9efdbd2, and the release base URL stays explicit.

SKILLTAPE_VERSION="0.2.3"
SKILLTAPE_RELEASE_BASE_URL="https://github.com/Chumaniac/skilltape/releases/download"
installer_path="$(mktemp)"
curl --fail --location --silent --show-error --output "$installer_path" \
  "https://raw.githubusercontent.com/Chumaniac/skilltape/9f6bec579258baa63234139af0fae650d9efdbd2/scripts/install.sh"
chmod +x "$installer_path"
export SKILLTAPE_VERSION SKILLTAPE_RELEASE_BASE_URL
bash "$installer_path"
export PATH="$HOME/.local/bin:$PATH"
skilltape --help

Then capture a harmless local command and get a verified result:

workspace="$(mktemp -d)"

skilltape capture demo --workspace "$workspace" --command /bin/echo --output "$workspace/tape" --yes --json
skilltape compile "$workspace/tape" --output "$workspace/skill"
skilltape lint "$workspace/skill" --strict --json
skilltape verify "$workspace/skill" --receipt "$workspace/receipt.json" --json

The final Receipt reports "status":"succeeded" when the isolated replay completed successfully.

What works today

On Linux, Replay and Verify require bwrap/Bubblewrap and an available user namespace. On macOS, Replay and Verify use the system /usr/bin/sandbox-exec. If that restricted executor is unavailable, Capture, Compile, Lint, and Export remain usable while Replay and Verify fail closed. Windows supports Capture, Compile, Lint, and Export; Replay and Verify intentionally fail closed until an equivalent restricted executor is integrated.

The packaged Console supports previous/next navigation through Tapes and events, keeping only the current page in memory. See the Console guide for startup details. This improvement is included in v0.2.3.

v0.2.3 also bounds server-side Tape event reads to 16 MiB and 100,000 events while validating the complete stream. Capture merges at most 10,000 events, charges allocated filesystem metadata against a 16 MiB budget, and rejects oversized terminal event streams before merging. These are retained-data budgets, not a process RSS guarantee. Complete Tapes are published without replacing an existing destination; budget or finalization failures do not publish a partial Tape. See the resource limits.

For retained deliveries, run skilltape console --workspace /path/to/saved-parent and choose Delivery workbench. This interface discovers actual bundles directly and provides bounded file checks and review actions. It never executes a workflow, edits files or declares business requirements accepted. These features are included in the public v0.2.3 packages.

v0.2.3 also bounds Replay/Verify inputs to 10,000 entries, depth 64, 16 MiB per file, and 64 MiB in total. Hashing and staging reject detected changes instead of reading a growing file without a limit. See the input integrity boundaries for platform and concurrent-change limits. These checks are included in v0.2.3.

Use SkillTape when

• You have a local command or workflow worth making repeatable and reviewable.
• You want to inspect the generated Skill before someone else runs it.
• You need a bounded Receipt from an isolated replay before sharing the result.

It is not yet for

• Replacing a general-purpose agent runtime or model provider.
• Claiming isolated replay on Windows before its restricted executor exists.
• Treating unreviewed Tapes, workflows, or permissions as safe to run.

Learn more

• Expansion and deep optimization roadmap — concrete priorities, domain workflows, limits and release gates.
• Stable export and Receipt association — consistent bytes and explicitly unauthenticated evidence.
• Verified local delivery — persistent artifacts, Receipt/file hashes, and an independently checked order-summary example.
• Project overview — Chinese introduction and current platform boundaries.
• Domain workflow examples — source examples for code-review evidence, knowledge references, data-export integrity, and incident-review materials; no external execution or platform connection.
• Quickstart — the same first verified result with troubleshooting.
• Installation — platform, update, source-build, and release details.
• Configuration — optional release, installation, and Console settings.
• Minimal Skill example — a small valid package to inspect.
• Security — sandbox boundaries, redaction, and responsible disclosure.
• Contributing — development and contribution guidance.

Require output files during Verify

With v0.2.3, use skilltape verify ./skill --expect-file result.csv --expect-file summary.txt --json. Each path is relative to the output root. Verify records each requirement in the Receipt and fails with exit code 3 if a required regular file is missing. A failed Verify does not publish a delivery directory. Unsafe paths fail before Replay; at most 64 paths of 1024 bytes each are accepted. This checks file existence, not business correctness or authenticated provenance. These requirements are available in the v0.2.3 CLI.

Require exact output bytes in current source

Build the current source to use verify --expect-sha256 PATH=SHA256. This option checks the actual output against an independently supplied 64-digit SHA-256, records a file_hash assertion in the Receipt, and leaves failed deliveries unpublished. It shares the 64-requirement budget with --expect-file and retains the existing sandbox. See the output digest guide for an example, limits and failure cases. This feature is not in the published v0.2.3 archives.