# sprintx-openclaw-handoff

Adopt this skill: https://proskills.md/skills/other/terry3838-sprintx-skill

Page: https://proskills.md/skills/other/terry3838-sprintx-skill
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: SKILL.md
size: 5478
sha: 37635e5f50a5a733b689058b6bb452a1a95747e2
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/SKILL.md

````text
---
name: sprintx-openclaw-handoff
description: Guide an existing OpenClaw operator through the SprintX handoff proof packet with the minimum safe steps: verify prerequisites, connect with sx auth, select the project, send the first event and artifact, then confirm read-back with sx status and sx brief.
version: 0.1.3
metadata:
  openclaw:
    requires:
      bins:
        - sx
    install:
      - kind: node
        package: "@sprint-x/cli"
        bins:
          - sx
    homepage: https://www.sprintx.co.kr/docs/getting-started/openclaw-handoff-quickstart
    emoji: "🧭"
---

# SprintX OpenClaw Handoff

Use this skill when an OpenClaw user needs to connect an existing SprintX account and project with the smallest proof packet that SprintX can verify today.

Do not use this skill for broad SprintX task management, review workflows, project creation, or generic natural-language control. This skill is a thin handoff layer over the shipped SprintX CLI contract.

한국어 안내:
- 이 스킬은 OpenClaw와 SprintX를 최소 연결 확인 경로로 붙일 때만 사용합니다.
- 기본 경로는 browser-approved `sx auth`입니다.
- 한국어 상세 문서는 `references/source-of-truth.md`의 링크를 따르세요.

## Primary Workflow

### 1. Confirm prerequisites

Before giving commands, verify all three are true:

1. The user is signed into SprintX on the web.
2. The user already has a SprintX project.
3. The user can see a `projectId` from `/dashboard?handoff=1&projectId=<id>` or the handoff card.

If the project does not exist yet, stop and send the user to SprintX onboarding first. Do not invent a project-creation flow inside this skill.

### 2. Check whether `sx` already exists

Ask the operator to run:

```bash
sx --help
```

If `sx` is already installed, skip installation and go straight to `sx auth`.

If `sx` is missing, install it:

```bash
npm install -g @sprint-x/cli
sx --help
```

### 3. Choose the project context

Default path:
- If the handoff URL or handoff card already shows a `projectId`, use it directly.

Command:

```bash
sx project use <project-id>
```

Success signal:
- Output includes `project_id`
- Output includes `receipt_id`

Recovery path only:
- Only use `sx project list` when the user does not have the `projectId` yet or needs to recover it from shared projects.

```bash
sx project list
```

Do not make `sx project list` the default first-touch step.

### 4. Run the proof packet in order

Run these commands in this order:

```bash
sx auth
sx project use <project-id>
sx event --type runtime.started --summary "OpenClaw handoff started"
sx artifact add --title "first-log" --reference-uri "file:///tmp/openclaw.log" --content-type "text/plain" --summary "Initial OpenClaw evidence"
sx status
sx brief
```

Ordering matters:
- `sx event` must happen before the first artifact receipt.
- `sx artifact upload` is still an alias, but prefer `sx artifact add` in the primary path.

### 5. Confirm success at each step

Use these pass/fail signals:

- `sx auth`
  The CLI opens the SprintX approval URL or prints it in headless mode, then stores the local session.
- `sx project use`
  Returns `project_id` and `receipt_id`.
- `sx event`
  Returns `status: accepted`.
- `sx artifact add`
  Returns `status: accepted`.
- `sx status`
  Reads the expected project context.
- `sx brief`
  Returns a bounded next-step summary for the same project.

If the user reaches `sx status` and `sx brief` successfully, the handoff is complete.

## Troubleshooting And Advanced Operators

The default path is always browser-approved `sx auth`.

Only move to this section when the user is in CI, headless, or another browserless environment.

### Headless auth

Use:

```bash
sx --headless auth
```

In headless mode, the approval URL is printed to stdout. The user should open that URL in a browser session that is already signed into SprintX.

### Access-token override

If the environment already injects an access token, SprintX CLI can skip browser auth.

Treat this as advanced or break-glass behavior only.

Hard rule:
- Do not ask users to paste tokens into chat.
- Do not recommend token copy/paste as the default onboarding path.

If the user needs the exact token override procedure or API URL override steps, point them to the upstream SprintX CLI docs in `references/source-of-truth.md`.

## Rescue Map

Always name the failure class and give the explicit next command or next check. Do not end with vague copy like "something went wrong."

- `cli_missing`
  Install `@sprint-x/cli`, then rerun `sx --help`.
- `auth_required`
  Run `sx auth`.
- `project_context_missing`
  Run `sx project use <projectId>`.
- `project_membership_invalid`
  Re-check SprintX project access on the web, then rerun `sx auth`.
- `artifact_before_event`
  Run `sx event` first, then retry `sx artifact add`.
- `readback_failed`
  Reconfirm auth and project context, then retry `sx status` and `sx brief`.
- `api_unreachable`
  Verify the SprintX API base URL, connectivity, and retry window.

## Guardrails

- SprintX is not the executor. OpenClaw executes, SprintX reads and governs.
- Do not expose provider API key management as part of this flow.
- Do not introduce broader CLI commands into the hero path.
- Keep the interaction checklist-like and explicit.

## Source Of Truth

Read `references/source-of-truth.md` when you need:
- the public quickstart links
- the Korean docs links
- ClawHub publish guidance for this repo
````

## File: README.md
size: 5985
sha: 696281ec49eda28b96efc20f595b2cee0debbb8f
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/README.md

````text
# SprintX OpenClaw Handoff

Standalone public repo for SprintX's first ClawHub skill.

This skill helps an existing OpenClaw operator connect SprintX with the minimum proof packet that SprintX can verify today:

```text
sx auth
-> sx project use
-> sx event
-> sx artifact add
-> sx status
-> sx brief
```

It is intentionally narrow.

- No custom MCP server
- No hidden SprintX automation
- No generic natural-language control plane
- No project creation flow inside the skill

Links:
- ClawHub: https://clawhub.ai/terry3838/sprintx-openclaw-handoff
- GitHub: https://github.com/terry3838/SprintX-SKILL
- SprintX handoff quickstart: https://www.sprintx.co.kr/docs/getting-started/openclaw-handoff-quickstart
- SprintX CLI quickstart: https://www.sprintx.co.kr/docs/getting-started/cli-quickstart
- Korean README: [README.ko.md](./README.ko.md)
- Chinese README: [README.zh.md](./README.zh.md)

## Why This Exists

OpenClaw users can already connect to SprintX with the shipped CLI.

The problem is first-use friction. The first connection still asks people to remember too much:

- which command comes first
- where the `projectId` comes from
- what success looks like
- what to do when the packet fails halfway through

This skill compresses that into one operator-facing flow.

Not more magic. Less confusion.

## What The Skill Does

The skill guides the operator through:

1. Checking SprintX prerequisites
2. Verifying that `sx` already exists before recommending install
3. Using the handoff card or handoff URL as the primary `projectId` source
4. Falling back to `sx project list` only when recovery is needed
5. Running the proof packet in the correct order
6. Verifying success with `sx status` and `sx brief`
7. Handling common failures with explicit rescue guidance

## Who This Is For

Use this if:

- you already use OpenClaw
- you already have a SprintX account
- you already have a SprintX project or can create one on the web
- you want the safest current handoff path, not a broad integration surface

Do not use this skill if you want:

- SprintX project creation from chat
- task CRUD from the skill itself
- review or approval workflows
- a remote MCP server

## Quick Start

### 1. Install the skill

From ClawHub:

```bash
clawhub install sprintx-openclaw-handoff
```

If your environment requires non-interactive install and you have already reviewed the skill:

```bash
clawhub install sprintx-openclaw-handoff --force --no-input
```

### 2. Let the skill walk the operator

Typical prompt:

```text
Use $sprintx-openclaw-handoff to connect my existing OpenClaw runtime to SprintX.
```

### 3. Follow the proof packet

The skill will keep the operator on the narrow path:

```bash
sx auth
sx project use <project-id>
sx event --type runtime.started --summary "OpenClaw handoff started"
sx artifact add --title "first-log" --reference-uri "file:///tmp/openclaw.log" --content-type "text/plain" --summary "Initial OpenClaw evidence"
sx status
sx brief
```

## Prerequisites

Before the handoff starts, the operator should have:

- a SprintX web session
- a SprintX project
- access to `/dashboard?handoff=1&projectId=<id>` or the handoff card

If the `projectId` is already visible there, the skill uses it directly.

`sx project list` is not the default first step. It is recovery only.

## Trust Boundary

This is important.

- SprintX is not the executor. OpenClaw executes, SprintX reads and governs.
- The default auth path is browser-approved `sx auth`.
- Access-token override is treated as advanced or break-glass only.
- The skill explicitly warns against pasting tokens into chat.
- Provider API keys are outside this flow.

## Advanced Operators

Headless and CI-style users are supported, but not as the primary path.

Examples:

```bash
sx --headless auth
```

The skill also documents the advanced access-token override, but keeps it out of the main onboarding path on purpose.

## Repo Structure

```text
SprintX-SKILL/
├── SKILL.md
├── README.md
├── CHANGELOG.md
├── LICENSE
├── LICENSE.md
├── package.json
├── references/
│   └── source-of-truth.md
├── scripts/
│   ├── check-skill.mjs
│   └── check-contract.mjs
└── .github/workflows/ci.yml
```

Design choice:

- `SKILL.md` is the only operator-truth document
- `README.md` is for humans evaluating the repo
- `references/` holds upstream links and source-of-truth docs
- CI validates the repo, but publish stays manual

## Validation

Run:

```bash
npm run check
```

This verifies:

- frontmatter shape
- declared runtime requirements
- install metadata
- license presence
- command order
- recovery-only `sx project list`
- advanced-only token guidance

## Release Model

This repo uses validation CI plus manual ClawHub publish.

Publish:

```bash
clawhub publish . \
  --slug sprintx-openclaw-handoff \
  --name "SprintX OpenClaw Handoff" \
  --version 0.1.3 \
  --tags latest \
  --changelog "Add localized READMEs and tighten metadata to match real requirements"
```

We keep publish manual on purpose. The current ClawHub docs clearly support CLI-driven skill publish, while plugin/package auto-publish flows are more mature than skill auto-publish flows today.

Note:

- In the locally verified `clawhub` CLI, the working command is top-level `clawhub publish <path>`.
- Some upstream docs still describe `clawhub skill publish`.
- Re-check the installed CLI help before cutting a release.

## Korean Note

이 저장소는 SprintX의 첫 공개 OpenClaw skill 저장소입니다.

- 기본 경로는 `sx auth -> sx project use -> sx event -> sx artifact add -> sx status -> sx brief`
- `projectId`는 handoff URL/card가 우선
- `sx project list`는 복구 경로
- access-token override는 기본 경로가 아니라 advanced-only

한국어 상세 문서:

- https://www.sprintx.co.kr/docs/getting-started/openclaw-handoff-quickstart
- https://www.sprintx.co.kr/docs/getting-started/cli-quickstart.ko
````

## File: scripts/check-contract.mjs
size: 2383
sha: e325ff3d126b03058dd1d731ec046dfdf74fda0d
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/scripts/check-contract.mjs

```text
import fs from "node:fs";
import path from "node:path";

const root = path.resolve(path.dirname(new URL(import.meta.url).pathname), "..");
const skill = fs.readFileSync(path.join(root, "SKILL.md"), "utf8");
const readme = fs.readFileSync(path.join(root, "README.md"), "utf8");
const references = fs.readFileSync(path.join(root, "references", "source-of-truth.md"), "utf8");

function fail(message) {
  console.error(`ERROR: ${message}`);
  process.exit(1);
}

function assertIncludes(haystack, needle, message) {
  if (!haystack.includes(needle)) {
    fail(message);
  }
}

function assertOrdered(haystack, needles, message) {
  let cursor = -1;
  for (const needle of needles) {
    const next = haystack.indexOf(needle, cursor + 1);
    if (next === -1) {
      fail(message);
    }
    cursor = next;
  }
}

assertOrdered(
  skill,
  ["sx auth", "sx project use", "sx event", "sx artifact add", "sx status", "sx brief"],
  "primary command order must remain sx auth -> sx project use -> sx event -> sx artifact add -> sx status -> sx brief"
);

assertIncludes(
  skill,
  "Only use `sx project list` when the user does not have the `projectId` yet or needs to recover it from shared projects.",
  "skill must keep sx project list as recovery-only guidance"
);

assertIncludes(
  skill,
  "The default path is always browser-approved `sx auth`.",
  "skill must keep browser-approved sx auth as the default path"
);

assertIncludes(
  skill,
  "Do not ask users to paste tokens into chat.",
  "skill must explicitly warn against token paste into chat"
);

assertIncludes(
  skill,
  "Do not use this skill for broad SprintX task management, review workflows, project creation, or generic natural-language control.",
  "skill must preserve the thin handoff boundary"
);

assertIncludes(
  readme,
  "manual ClawHub publish",
  "README must document manual publish"
);

assertIncludes(
  readme,
  "clawhub publish .",
  "README must use the working top-level clawhub publish command"
);

assertIncludes(
  references,
  "https://www.sprintx.co.kr/docs/getting-started/openclaw-handoff-quickstart",
  "references must include the public handoff quickstart"
);

assertIncludes(
  references,
  "https://raw.githubusercontent.com/openclaw/clawhub/main/docs/skill-format.md",
  "references must include ClawHub skill format docs"
);

console.log("Instruction contract checks passed.");
```

## File: scripts/check-skill.mjs
size: 1898
sha: 05bf7533a9eec2aeb6fdf04d058d57739535729c
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/scripts/check-skill.mjs

```text
import fs from "node:fs";
import path from "node:path";

const root = path.resolve(path.dirname(new URL(import.meta.url).pathname), "..");
const skillPath = path.join(root, "SKILL.md");
const licensePath = path.join(root, "LICENSE");

function fail(message) {
  console.error(`ERROR: ${message}`);
  process.exit(1);
}

if (!fs.existsSync(skillPath)) {
  fail("SKILL.md not found");
}

const skill = fs.readFileSync(skillPath, "utf8");
const frontmatterMatch = skill.match(/^---\n([\s\S]*?)\n---\n/);

if (!frontmatterMatch) {
  fail("Missing YAML frontmatter");
}

const frontmatter = frontmatterMatch[1];

const requiredChecks = [
  [/^name:\s*sprintx-openclaw-handoff$/m, "name must be sprintx-openclaw-handoff"],
  [/^description:\s*.+$/m, "description is required"],
  [/^version:\s*\d+\.\d+\.\d+$/m, "version must be semver"],
  [/^metadata:\s*$/m, "metadata block is required"],
  [/^\s+openclaw:\s*$/m, "metadata.openclaw block is required"],
  [/^\s+requires:\s*$/m, "metadata.openclaw.requires block is required"],
  [/^\s+bins:\s*$/m, "requires.bins block is required"],
  [/^\s+-\s+sx$/m, "requires.bins must declare sx"],
  [/^\s+install:\s*$/m, "install block is required"],
  [/^\s+-\s+kind:\s+node$/m, "install must declare node kind"],
  [/^\s+package:\s+"@sprint-x\/cli"$/m, "install must declare @sprint-x/cli"],
  [/^\s+homepage:\s+https:\/\/www\.sprintx\.co\.kr\/docs\/getting-started\/openclaw-handoff-quickstart$/m, "homepage must point to the public handoff quickstart"]
];

for (const [pattern, message] of requiredChecks) {
  if (!pattern.test(frontmatter)) {
    fail(message);
  }
}

if (!fs.existsSync(licensePath)) {
  fail("LICENSE not found");
}

const license = fs.readFileSync(licensePath, "utf8");
if (!license.includes("MIT No Attribution")) {
  fail("LICENSE must be MIT-0 / MIT No Attribution");
}

console.log("SKILL frontmatter and license checks passed.");
```

## File: references/source-of-truth.md
size: 1398
sha: 8286c6f2a42735d5c80487f20ed68cd77a3be7e7
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/references/source-of-truth.md

```text
# Source Of Truth

Use these upstream references instead of re-explaining SprintX behavior inside multiple repo files.

## SprintX public docs

- OpenClaw handoff quickstart
  https://www.sprintx.co.kr/docs/getting-started/openclaw-handoff-quickstart
  Why: primary public handoff story and success signals.

- CLI quickstart (English)
  https://www.sprintx.co.kr/docs/getting-started/cli-quickstart
  Why: exact CLI examples, headless notes, and environment-variable details.

- CLI quickstart (Korean)
  https://www.sprintx.co.kr/docs/getting-started/cli-quickstart.ko
  Why: Korean operator-facing detail for the same CLI path.

## SprintX engineering truth

- CLI auth boundary and current truth
  https://github.com/terry3838/SprintX/blob/main/docs/engineering/SX_AUTH_V1.md
  Why: browser-approved auth is the primary path; device flow remains follow-up.

- Product boundary and runtime contract
  https://github.com/terry3838/SprintX/blob/main/docs/engineering/TECH_SPEC.md
  Why: confirms SprintX is the governed delivery control plane, not the executor.

## ClawHub references

- Skill format
  https://raw.githubusercontent.com/openclaw/clawhub/main/docs/skill-format.md
  Why: frontmatter, allowed files, semver, and MIT-0 publish rules.

- CLI docs
  https://raw.githubusercontent.com/openclaw/clawhub/main/docs/cli.md
  Why: manual `clawhub skill publish` flow and supported commands.
```

## File: .github/workflows/ci.yml
size: 397
sha: 7cbba860724aca1060c4ffd1314a4a016f84537b
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/.github/workflows/ci.yml

```text
name: Validate Skill Repo

on:
  push:
    branches:
      - main
  pull_request:

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v5

      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: "20"

      - name: Validate SKILL frontmatter and contract
        run: npm run check
```

## File: .gitignore
size: 14
sha: c2658d7d1b31848c3b71960543cb0368e56cd4c7
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/.gitignore

```text
node_modules/
```

## File: CHANGELOG.md
size: 1084
sha: 5170382c3c4bfe2d21c8ba38873f3b8cdba50771
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/CHANGELOG.md

```text
# Changelog

## 0.1.3 - 2026-04-13

- Add Korean and Chinese README variants
- Rewrite access-token guidance so the skill only declares the real required runtime dependency (`sx`)
- Republish the bundle with narrower metadata to reduce registry packaging ambiguity

## 0.1.2 - 2026-04-13

- Rewrite the README for humans instead of maintainers
- Add a clearer quick start, trust boundary, audience, and repo structure explanation
- Republish the registry bundle so ClawHub and GitHub show the same onboarding story

## 0.1.1 - 2026-04-13

- Declare `SX_API_URL` in frontmatter because the troubleshooting path references it
- Add `LICENSE.md` so the published file list carries a visible license artifact
- Keep the published release instructions aligned with the locally verified `clawhub publish` command

## 0.1.0 - 2026-04-13

- Scaffold standalone public repo for the first SprintX ClawHub skill
- Lock the v1 handoff flow to `sx auth -> sx project use -> sx event -> sx artifact add -> sx status -> sx brief`
- Add repo-local validation for frontmatter and instruction contract
```

## File: LICENSE
size: 915
sha: 7e0c82086ebcdfb9146855edbdb38205901fc446
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/LICENSE

```text
MIT No Attribution

Copyright 2026 SprintX contributors

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
Software, and to permit persons to whom the Software is furnished to do so.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
```

## File: LICENSE.md
size: 132
sha: 33739cf317981abd75101fc5d54716ee87af2258
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/LICENSE.md

```text
# MIT No Attribution

This repo is published to ClawHub under **MIT-0**.

See the root [LICENSE](./LICENSE) file for the full text.
```

## File: package.json
size: 303
sha: f329a7ab2641547dd112bdba7878f1dd083dd961
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/package.json

```text
{
  "name": "sprintx-skill-repo",
  "private": true,
  "version": "0.1.3",
  "type": "module",
  "scripts": {
    "check": "node scripts/check-skill.mjs && node scripts/check-contract.mjs",
    "check:skill": "node scripts/check-skill.mjs",
    "check:contract": "node scripts/check-contract.mjs"
  }
}
```

## File: README.ko.md
size: 4961
sha: c73cb0ef9eb0d52c2a8e57a8a3a40f29a0281a3e
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/README.ko.md

````text
# SprintX OpenClaw Handoff

SprintX의 첫 공개 ClawHub skill 저장소입니다.

이 스킬은 기존 OpenClaw 사용자가 SprintX와 연결할 때, 지금 기준으로 가장 안전하고 짧은 handoff proof packet만 안내합니다.

```text
sx auth
-> sx project use
-> sx event
-> sx artifact add
-> sx status
-> sx brief
```

의도적으로 범위를 좁게 유지합니다.

- custom MCP server 없음
- 숨겨진 SprintX 자동화 없음
- 범용 자연어 control plane 아님
- 프로젝트 생성 flow 내장 안 함

링크:
- ClawHub: https://clawhub.ai/terry3838/sprintx-openclaw-handoff
- GitHub: https://github.com/terry3838/SprintX-SKILL
- SprintX handoff quickstart: https://www.sprintx.co.kr/docs/getting-started/openclaw-handoff-quickstart
- SprintX CLI quickstart (ko): https://www.sprintx.co.kr/docs/getting-started/cli-quickstart.ko

## 왜 필요한가

OpenClaw 사용자는 이미 SprintX CLI로 연결할 수 있습니다.

문제는 첫 연결 마찰입니다.

- 어떤 명령부터 쳐야 하는지
- `projectId`를 어디서 가져와야 하는지
- 성공 신호가 뭔지
- 중간에 실패하면 무엇을 해야 하는지

이 스킬은 그걸 하나의 operator flow로 압축합니다.

마법을 늘리는 게 아니라, 혼란을 줄입니다.

## 이 스킬이 하는 일

1. SprintX 사전 조건 확인
2. `sx`가 이미 있는지 먼저 확인
3. handoff card / handoff URL을 기본 `projectId` source로 사용
4. 필요할 때만 `sx project list`로 복구
5. proof packet을 올바른 순서로 실행
6. `sx status`, `sx brief`로 성공 확인
7. 실패 시 명시적인 rescue guidance 제공

## 이런 사람에게 맞다

다음 조건이면 잘 맞습니다.

- 이미 OpenClaw를 쓴다
- 이미 SprintX 계정이 있다
- SprintX 프로젝트가 있다
- 넓은 통합 surface가 아니라 가장 안전한 현재 handoff 경로가 필요하다

다음 목적에는 맞지 않습니다.

- chat에서 SprintX 프로젝트 생성
- skill 자체에서 task CRUD
- review / approval workflow
- remote MCP server 기반 연동

## 빠른 시작

### 1. skill 설치

```bash
clawhub install sprintx-openclaw-handoff
```

비대화형 환경에서 이미 검토를 끝냈다면:

```bash
clawhub install sprintx-openclaw-handoff --force --no-input
```

### 2. skill 호출

예시 프롬프트:

```text
Use $sprintx-openclaw-handoff to connect my existing OpenClaw runtime to SprintX.
```

### 3. proof packet 실행

```bash
sx auth
sx project use <project-id>
sx event --type runtime.started --summary "OpenClaw handoff started"
sx artifact add --title "first-log" --reference-uri "file:///tmp/openclaw.log" --content-type "text/plain" --summary "Initial OpenClaw evidence"
sx status
sx brief
```

## 전제 조건

시작 전에 다음이 있어야 합니다.

- SprintX 웹 로그인 세션
- SprintX 프로젝트
- `/dashboard?handoff=1&projectId=<id>` 또는 handoff card 접근

`projectId`가 이미 보이면 그 값을 바로 씁니다.

`sx project list`는 기본 단계가 아니라 복구 경로입니다.

## 신뢰 경계

- SprintX는 executor가 아닙니다. OpenClaw가 실행하고, SprintX는 읽고 거버넌스를 제공합니다.
- 기본 auth 경로는 browser-approved `sx auth`입니다.
- access-token override는 advanced 또는 break-glass 용도입니다.
- 이 스킬은 토큰을 채팅에 붙여 넣지 말라고 명시합니다.
- provider API key는 이 flow 밖입니다.

## Advanced Operators

headless/CI 환경도 지원하지만 기본 경로는 아닙니다.

```bash
sx --headless auth
```

access-token override도 문서화하지만, 일부러 메인 onboarding path 밖에 둡니다.

## 저장소 구조

```text
SprintX-SKILL/
├── SKILL.md
├── README.md
├── README.ko.md
├── README.zh.md
├── CHANGELOG.md
├── LICENSE
├── LICENSE.md
├── package.json
├── references/
│   └── source-of-truth.md
├── scripts/
│   ├── check-skill.mjs
│   └── check-contract.mjs
└── .github/workflows/ci.yml
```

설계 원칙:

- `SKILL.md`만 operator truth
- `README*`는 사람이 읽는 문서
- `references/`는 upstream source-of-truth 링크
- CI는 검증만 하고 publish는 수동

## 검증

```bash
npm run check
```

이 검증은 다음을 확인합니다.

- frontmatter shape
- 실제 필요한 runtime requirement
- install metadata
- license 존재
- command order
- recovery-only `sx project list`
- advanced-only token guidance

## 배포

```bash
clawhub publish . \
  --slug sprintx-openclaw-handoff \
  --name "SprintX OpenClaw Handoff" \
  --version 0.1.3 \
  --tags latest \
  --changelog "Add localized READMEs and tighten metadata to match real requirements"
```

현재는 수동 publish를 유지합니다.

이유는 ClawHub에서 skill publish는 CLI 경로가 가장 분명하고, plugin/package auto-publish 쪽이 더 성숙했기 때문입니다.
````

## File: README.zh.md
size: 4678
sha: d2a485866c36fb50d5460a577459950a2006ce82
upstream: https://github.com/terry3838/sprintx-skill/blob/HEAD/README.zh.md

````text
# SprintX OpenClaw Handoff

这是 SprintX 的第一个公开 ClawHub skill 仓库。

这个 skill 只做一件事：帮助已有的 OpenClaw 用户，用当前最安全、最短的 proof packet 把 SprintX 接起来。

```text
sx auth
-> sx project use
-> sx event
-> sx artifact add
-> sx status
-> sx brief
```

它刻意保持很窄的边界。

- 没有自定义 MCP server
- 没有隐藏的 SprintX 自动化
- 不是通用自然语言 control plane
- 不在 skill 里创建项目

链接:
- ClawHub: https://clawhub.ai/terry3838/sprintx-openclaw-handoff
- GitHub: https://github.com/terry3838/SprintX-SKILL
- SprintX handoff quickstart: https://www.sprintx.co.kr/docs/getting-started/openclaw-handoff-quickstart
- SprintX CLI quickstart: https://www.sprintx.co.kr/docs/getting-started/cli-quickstart

## 为什么需要它

OpenClaw 用户本来就可以通过 SprintX CLI 完成连接。

真正的问题是第一次接入时的信息负担太高：

- 哪个命令先执行
- `projectId` 从哪里拿
- 什么算成功
- 半路失败后下一步该做什么

这个 skill 把这些内容压缩成一条面向 operator 的清晰流程。

不是增加魔法，而是减少混乱。

## 这个 skill 会做什么

1. 检查 SprintX 前置条件
2. 先确认本地是否已经有 `sx`
3. 优先使用 handoff card / handoff URL 里的 `projectId`
4. 只有在恢复场景里才使用 `sx project list`
5. 按正确顺序执行 proof packet
6. 用 `sx status` 和 `sx brief` 验证成功
7. 失败时给出明确的 rescue guidance

## 适合谁

适合：

- 已经在使用 OpenClaw
- 已经有 SprintX 账号
- 已经有 SprintX 项目，或者能在 Web 端创建
- 想走当前最安全的 handoff 路径，而不是追求大而全的集成

不适合：

- 想在聊天里创建 SprintX 项目
- 想直接通过 skill 做 task CRUD
- 想把 review / approval 流程也塞进来
- 想要 remote MCP server 方案

## 快速开始

### 1. 安装 skill

```bash
clawhub install sprintx-openclaw-handoff
```

如果你在非交互环境里，而且已经完成审核：

```bash
clawhub install sprintx-openclaw-handoff --force --no-input
```

### 2. 调用 skill

示例提示词：

```text
Use $sprintx-openclaw-handoff to connect my existing OpenClaw runtime to SprintX.
```

### 3. 执行 proof packet

```bash
sx auth
sx project use <project-id>
sx event --type runtime.started --summary "OpenClaw handoff started"
sx artifact add --title "first-log" --reference-uri "file:///tmp/openclaw.log" --content-type "text/plain" --summary "Initial OpenClaw evidence"
sx status
sx brief
```

## 前置条件

开始前你应该已经有：

- SprintX Web 登录会话
- 一个 SprintX 项目
- `/dashboard?handoff=1&projectId=<id>` 或 handoff card 的访问权限

如果 `projectId` 已经能看到，就直接使用它。

`sx project list` 不是默认第一步，只是恢复路径。

## 信任边界

- SprintX 不是 executor。OpenClaw 执行，SprintX 负责读取和治理。
- 默认认证路径是 browser-approved `sx auth`。
- access-token override 只作为 advanced / break-glass 用途。
- 这个 skill 明确禁止把 token 粘贴到聊天里。
- provider API key 不属于这个流程。

## Advanced Operators

支持 headless / CI 场景，但这不是主路径。

```bash
sx --headless auth
```

skill 也会提到 access-token override，但会刻意放在主 onboarding 路径之外。

## 仓库结构

```text
SprintX-SKILL/
├── SKILL.md
├── README.md
├── README.ko.md
├── README.zh.md
├── CHANGELOG.md
├── LICENSE
├── LICENSE.md
├── package.json
├── references/
│   └── source-of-truth.md
├── scripts/
│   ├── check-skill.mjs
│   └── check-contract.mjs
└── .github/workflows/ci.yml
```

设计原则：

- `SKILL.md` 是唯一的 operator truth
- `README*` 是给人看的
- `references/` 保存上游 source-of-truth 链接
- CI 只做验证，不做自动 publish

## 验证

```bash
npm run check
```

会检查：

- frontmatter 结构
- 真实需要的 runtime requirement
- install metadata
- license 是否存在
- command 顺序
- `sx project list` 是否仍然只是恢复路径
- token guidance 是否仍然是 advanced-only

## 发布

```bash
clawhub publish . \
  --slug sprintx-openclaw-handoff \
  --name "SprintX OpenClaw Handoff" \
  --version 0.1.3 \
  --tags latest \
  --changelog "Add localized READMEs and tighten metadata to match real requirements"
```

目前仍然保留手动 publish。

原因很简单：ClawHub 对 skill publish 的 CLI 路径最清晰，而 plugin/package 的 auto-publish 体系要更成熟一些。
````
