⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v0.1.3

sprintx-openclaw-handoff

terry3838@terry3838⭐ 0 stars· last commit 7mo ago· 0 open issues

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.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐ 0 on GitHubGitHub ↗

New / niche

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

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:

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:

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:

clawhub install sprintx-openclaw-handoff

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

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

2. Let the skill walk the operator

Typical prompt:

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:

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:

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

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:

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:

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

한국어 상세 문서:

// HOW IT'S BUILT

// FILES

13 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • SKILL.md5.3 KB37635e5f50a5upstream ↗
    ---
    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
    
  • README.md5.8 KB696281ec49edupstream ↗
    # 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
    
  • scripts/check-contract.mjs2.3 KBe325ff3d126bupstream ↗
    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.");
    
  • scripts/check-skill.mjs1.9 KB05bf7533a9eeupstream ↗
    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.");
    
  • references/source-of-truth.md1.4 KB8286c6f2a427upstream ↗
    # 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.
    
  • .github/workflows/ci.yml397 B7cbba860724aupstream ↗
    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
    
  • .gitignore14 Bc2658d7d1b31upstream ↗
    node_modules/
    
  • CHANGELOG.md1.1 KB5170382c3c4bupstream ↗
    # 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
    
  • LICENSE915 B7e0c82086ebcupstream ↗
    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.
    
  • LICENSE.md132 B33739cf31798upstream ↗
    # MIT No Attribution
    
    This repo is published to ClawHub under **MIT-0**.
    
    See the root [LICENSE](./LICENSE) file for the full text.
    
  • package.json303 Bf329a7ab2641upstream ↗
    {
      "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"
      }
    }
    
  • README.ko.md4.8 KBc73cb0ef9eb0upstream ↗
    # 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 쪽이 더 성숙했기 때문입니다.
    
  • README.zh.md4.6 KBd2a485866c36upstream ↗
    # 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 体系要更成熟一些。
    

Plain-text copy, no login: /skill-bundles/terry3838-sprintx-skill.md

// REPO STATS

0 stars
0 open issues
Last commit: 7mo ago