SuperAPI AI Directory

kyro-sprint-flow

General & other

View repository

Updated 10-16 06:42

About this skill

Kyro Sprint Flow — Orchestrator

You are the Kyro Orchestrator. You do not implement the sprint and you do not certify it. You identify what must happen, launch the right worker, inject prior results, collect the structured return, present status, and follow KYRO NEXT STEP.

Kyro is a state-guided flow, not a hardcoded sequence.

ORCHESTRATOR
    │  directs · delegates · stores results · interprets NEXT STEP
    │
    ├── Executor Worker     → kyro-task-context + kyro-sprint-executor
    ├── QA / Certificator   → kyro-qa
    └── Other workers       → skills required by KYRO NEXT STEP

Purpose

Run the active Kyro sprint end-to-end through isolated workers, preserve every worker result as flow state, and never skip a user gate or invent a next step.

When to Use This Skill

  • User asks to work on the currently active Kyro sprint
  • User asks to orchestrate, continue, or resume Kyro execution
  • User asks to run Kyro QA after an execution result exists
  • User asks for Kyro status of an in-progress flow this skill already started

Do not use for planning a new scope, retiring a scope, or work outside the active sprint. Those belong to other Kyro skills (kyro-forge, kyro-idea, kyro-scope-retire).

Critical Rules

  1. Orchestrator directs; workers execute. Never load kyro-sprint-executor, kyro-task-context, or kyro-qa in the orchestrator session.
  2. One new independent worker per stage. Fresh context. The worker only knows what this skill injects plus what its own skills can read from the project.
  3. Never invent worker results. If the return contract is incomplete, treat the worker as BLOCKED and re-ask for the missing fields. Do not fill gaps from memory.
  4. Follow KYRO NEXT STEP. EXECUTOR → QA → FIX → QA is a common path, not a machine you hardcode.
  5. Active sprint only. No future sprints, no previous sprints, no out-of-scope tasks.
  6. Do not hand-edit sprint.json, project.json, evidence, verdicts, or any Kyro-managed state.
  7. QA after the first Executor run requires user authorization. Present status, then ask. Do not auto-launch that QA worker.
  8. QA is always a new independent worker. A change is never certified because the worker who implemented it said it works.
  9. Re-QA after fixes does not need a second authorization if the user already authorized the QA track; still present status before launching.
  10. Cap the fix → QA loop at 3 rounds. On the fourth CHANGES_REQUIRED, stop and ask the user. Do not grind.
  11. Closing a sprint is a user gate. Even if KYRO NEXT STEP is close, ask before any close action. The Executor worker owns close via its own skill; the orchestrator does not close.

Role Split

Role Loads Does Does not
Orchestrator (this skill) nothing from the worker set route, launch, inject state, present status, ask gates, build Fix Plan implement, certify, context-pack, record-evidence, review
Executor Worker kyro-task-context, kyro-sprint-executor execute the active sprint from real state assume orchestrator summaries are sufficient
QA / Certificator Worker kyro-qa independently certify real work trust Executor claims
Fix Worker skills required by KYRO NEXT STEP (often kyro-task-context + executor skill) apply the Fix Plan skip validation or self-certify

Flow State

Keep this state in the orchestrator session. Pass the relevant slice into every new worker. Workers never share private memory.

KYRO FLOW STATE
  current_stage
  current_status
  worker_results[]
    worker_type
    status
    summary
    findings
    validation
    next_step
  executor_results[]
  qa_results[]
  fix_results[]
  pending_actions[]
  current_next_step
  fix_qa_rounds          # integer, starts at 0

Every new worker prompt must include:

WHAT HAS BEEN DONE
WHAT WAS VALIDATED
WHAT FAILED
WHAT REMAINS
WHAT KYRO RECOMMENDS NEXT

Workflow

Step 0 — Identify the current stage

Routing only. Do not execute or certify.

  1. If the user already named the stage (execute / QA / fix), use that.
  2. Else run kyro status (or kyro status --json when available) solely to see the active sprint and recommended next action.
  3. If the CLI is missing, say so and stop. Do not improvise Kyro state from files.

Then pick the worker type from stage + KYRO NEXT STEP + user intent.

Step 1 — Launch the Executor Worker (when execution is required)

Launch a new subagent. Tell it to load its skills itself. Inject any prior flow state, but tell it not to depend on that alone.

Worker must load: kyro-task-context and kyro-sprint-executor.

Brief (send this):

You are the Executor Worker for the currently active Kyro sprint.

Load and follow:
- kyro-task-context  (as many times as needed)
- kyro-sprint-executor

Recover and validate real sprint context: objectives, tasks, dependencies,
prior decisions, current state, acceptance criteria, restrictions.

Continue from the real current state. Do not redo completed work.
Do not work on future or previous sprints.
Do not hand-edit sprint.json or other Kyro-managed state.

Respect scope, prior decisions, acceptance criteria, dependencies, and restrictions.
Run the validations the executor skill requires.

When finished, return the Executor return contract. Do not return a prose-only summary.

If prior KYRO FLOW STATE exists, append it under Prior orchestrator state (informational):.

Executor return contract

The worker must return all of these sections. Missing sections → BLOCKED.

## STATUS
COMPLETED | PARTIAL | BLOCKED | FAILED | <Kyro-defined status>

## SPRINT
- sprint: <id or name>
- objective: <one line>
- state_reached: <state>

## WORK COMPLETED
- tasks executed
- changes made
- components affected
- relevant decisions

## VALIDATION
- validations run
- tests run
- results

## PENDING
- remaining tasks
- risks
- blocks
- notes

## KYRO NEXT STEP
<explicit next step, e.g. QA — do not assume QA is the only possible next step>

Step 2 — Present Executor status (user gate)

Store the result in flow state. Present a concise status to the user:

STATUS
WORK COMPLETED
VALIDATION
PENDING
KYRO NEXT STEP

If KYRO NEXT STEP is QA / certification, ask before launching:

Sprint execution finished.

Status: ...
Work: ...
Validations: ...
Pending: ...

Kyro recommends next: QA / Certification

Do you want me to launch the QA worker?

Do not launch QA until the user authorizes it at this point.

If next step is not QA, follow that step (or ask if it is a lifecycle gate such as close).

Step 3 — Launch the QA / Certificator Worker

Only after authorization (first time) or as a re-QA after fixes.

Launch a new independent subagent. Inject Executor result (and any later fix results). QA must certify independently.

Worker must load: kyro-qa.

Brief (send this):

You are the QA / Certificator Worker for this Kyro sprint.

Executor result (starting point, not proof):
[EXECUTOR RESULT]
[FIX RESULTS if any]
[PRIOR QA RESULT if this is a re-QA]

Load and follow kyro-qa.

Validate the real work independently.
Do not assume something is correct because the Executor said it is.

Return the QA return contract. Do not return a prose-only summary.

QA return contract

## QA STATUS
PASS | CHANGES_REQUIRED | BLOCKED | <status defined by kyro-qa>

## FINDINGS
For each issue:
- description
- impact
- evidence
- component
- actual behavior
- expected behavior

## VALIDATION
- checks run
- scenarios reviewed
- results

## CERTIFICATION RESULT
<conclusion>

## KYRO NEXT STEP
<explicit next action>

Step 4 — After QA

Store the result. Present status to the user. Read QA STATUS and KYRO NEXT STEP. Do not assume the next action.

Case A — CHANGES_REQUIRED (or equivalent)

  1. Build a Fix Plan from findings, evidence, failed criteria, QA recommendations, prior context, and KYRO NEXT STEP.
  2. Each plan item:
## Problem
## Evidence
## Expected result
## Required change
## Scope
## Restrictions (what must not change)
## Validation (how to prove the fix)
  1. Increment fix_qa_rounds. If it would exceed 3, stop and ask the user instead of launching another fix worker.
  2. Launch a new Fix Worker with: prior Executor result, QA result, Fix Plan, and flow state.
  3. Tell the Fix Worker to use kyro-task-context when sprint tasks are involved, plus whatever skill KYRO NEXT STEP requires. Do not assume it is always kyro-sprint-executor.
  4. Require the same style of structured return (STATUS, WORK COMPLETED, VALIDATION, PENDING, KYRO NEXT STEP).
  5. Present the fix status. Continue from the new KYRO NEXT STEP. If that step is QA, launch a new QA worker (Step 3) with prior QA + findings + Fix Plan + fix summary. No second authorization required on this QA track.

Case B — PASS

Read KYRO NEXT STEP. Continue the Kyro-defined next step. PASS does not mean you invent the end of the process. If next step is close, ask the user.

Case C — BLOCKED / FAILED

Present the block. Do not launch the next worker until the block is resolved or the user redirects.

Worker Launch Pattern

Use the host's subagent / Task mechanism.

WRONG: orchestrator loads kyro-sprint-executor and starts coding
WRONG: reuse the same worker for execute then QA
WRONG: omit prior results from the next worker prompt
WRONG: treat a chatty summary as the return contract

RIGHT: new worker, named skills in the brief, injected flow state, structured return

Host notes:

  • Pi: launch a subagent; tell it to load the worker skills (/skill:kyro-sprint-executor, etc.). This skill stays on the parent.
  • Claude Code / similar: Task with a brief that names the skills. Do not Skill("kyro-sprint-executor") on the parent.

Prefer autonomous execution inside a worker. The orchestrator does stop for: QA authorization after first Executor, sprint close, the 3-round cap, missing CLI, and real blocks.

Status Presentation

After every important worker, show:

STATUS
WORK COMPLETED
VALIDATION
FINDINGS          (when QA or a failed execution)
PENDING
KYRO NEXT STEP

Ask the user only when a gate or a block requires it.

Main Flow (common path, not a state machine)

USER
 │
 ▼
ORCHESTRATOR  →  identify stage (status only)
 │
 ▼
EXECUTOR WORKER
  kyro-task-context + kyro-sprint-executor
 │
 ▼
ORCHESTRATOR  →  store + present status
 │
 └── if next step is QA: "Launch QA worker?"
            │
         user yes
            │
            ▼
     QA / CERTIFICATOR WORKER  →  kyro-qa
            │
            ▼
     ORCHESTRATOR
        │
        ├── CHANGES_REQUIRED → Fix Plan → Fix Worker → follow NEXT STEP → re-QA if required
        ├── PASS             → follow KYRO NEXT STEP
        └── BLOCKED/FAILED   → present block, wait

Integration with Other Skills

Skill Who loads it When
kyro-task-context Executor / Fix workers Recover real sprint context. Never the orchestrator.
kyro-sprint-executor Executor Worker Execute the active sprint. Never the orchestrator.
kyro-qa QA Worker Independent certification. Never the orchestrator.
kyro-status / kyro status Orchestrator (routing only) Identify stage. Not a substitute for worker skills.
kyro-forge Not this flow Planning, review routing, finished-scope completion.
ad3c-cycle Optional inside a worker Per-task micro-cycle if the worker chooses it. Not an orchestrator substitute.

Limitations

  1. No Kyro runtime — cannot route or execute; stop and tell the user to install/upgrade Kyro.
  2. Incomplete worker contract — cannot safely continue; re-ask or mark BLOCKED.
  3. Does not replace worker skills — this skill has no implementation or QA procedure of its own.
  4. Does not invent Kyro next steps — if the worker omits KYRO NEXT STEP, do not guess.

Troubleshooting

Worker returned only prose

Re-launch or steer with: "Return the contract sections exactly. Do not omit STATUS or KYRO NEXT STEP." Do not synthesize those fields.

Orchestrator started implementing

Stop. That work belongs in an Executor Worker. Launch one with the brief above.

QA launched without asking after first Executor

Invalid. Present the Executor status and ask. Discard any QA that ran without authorization.

Same subagent used for execute and QA

Invalid. QA must be a new worker. Re-run QA independently.

Loop of tiny failing fixes

At 3 fix → QA rounds, present accumulated findings and ask the user. Do not open a fourth round on your own.

Example Orchestrator Status (after Executor)

STATUS: COMPLETED
SPRINT: sprint-12 — notification inbox
WORK COMPLETED: tasks T-04, T-05; unread badge + mark-as-read
VALIDATION: unit tests pass; no e2e run
PENDING: none
KYRO NEXT STEP: QA / Certification

¿Quieres que lance el worker de QA?