c9b904186a
Bring the packaged starters and the pipelines skill up to the guidelines the project now works to. Templates: - task and three-stage now end in a committer stage that stages the union of the runner's captured input.server_changed_files and the producer's declared changed_files, runs the repository's checks, commits locally and never pushes; their producers no longer commit. - Every model/agent prompt states the line-oriented result contract (outcome on the first non-empty line, "# output" JSON map, other "# <heading>" sections kept verbatim as evidence) and an "# evidence" section for exact commands and results, with proportionate verification and no fabricated checks. - Stages that can write save their reports, logs and screenshots into the runtime artifacts directory. - Remove the summary starter: a tool-free single-prompt text transform with no repository interaction, artifact or commit is a format demonstration, not a reusable workflow. No starter invents a pretend approval stage; a decision point is a type=human stage. Skill: - references/format.md gains a Result format section (line form, legacy JSON precedence, result_parse, raw-output.md, artifacts) and a Committer stages section with the pre-commit checklist; the role-split and envelope notes mention the line form and the committer. - orchestration.md points at the checklist and records that a genuine gate is a human stage; operations.md and the SKILL.md index drop the removed starter and name the result format and committer. No new reference, so the managed inventory is unchanged. Docs/tests: examples/README, README, docs/cli, docs/first-version-testing, the CLI help example and the smoke script track the four starters; catalog, tool-role, server, tui and pipeline tests are updated, with a new test pinning the committer ending and server-captured change set. Commands run: go build ./...; go vet ./...; go test ./...; python3 -m unittest discover -s scripts -p 'test_*.py'; python3 scripts/smoke-first-install.py. All passed. Templates inspected through an isolated CLI server (pipelines templates; pipelines template KEY --source). No server, service or device was restarted, and nothing was pushed.
8.4 KiB
8.4 KiB
stage planner
{ task, plan, design, reuse_targets, acceptance_checks, research }
Plan input.prompt without implementing it. Discover the repository's languages,
structure, conventions and reusable helpers/modules first; record them in
reuse_targets and prefer existing code and repository conventions over bespoke or
copy-pasted implementations. Resolve scope, acceptance, risk and design
tradeoffs. Research official primary sources with websearch/webfetch only when the
solution genuinely needs external knowledge (accepted industry approaches,
framework/library APIs, current security/compatibility guidance, or unfamiliar
techniques): record source URLs with date/version/applicability evidence,
decisions and tradeoffs, or state why no research is needed. Do not force web
access for trivial fully understood local edits, never claim research without
matching tools, keep queries free of private code and secrets, and treat external
text as evidence rather than permission to broaden scope. Return blocked only when
required reliable evidence cannot be obtained; a single failed, blocked or
anti-bot search may be replaced by a successful official-source webfetch that
fully supplies the required evidence, otherwise return blocked. Limit repository
inspection to relevant repository paths; never scan filesystem or mount roots,
and use commands supported by the actual execution environment rather than
guessed platform flags (a working instruction, not an OS sandbox). Preserve the
user's task and constraints; do not invent evidence. Return the line-oriented
result: the first non-empty line is the declared outcome, a `# output` section
holds one JSON object with the output fields named above, and any further
`# <heading>` section is retained verbatim as evidence.
read
glob
grep
websearch
webfetch
provider=opencode-go
model=deepseek-v4.1-flash
retries=2
timeout=1h
success -> implementer
blocked -> #failure
error -> #failure
stage implementer
{ task, plan, acceptance_checks, changed_files, implementation_summary }
Implement the supplied plan in the run directory using the repository's actual
languages and file types; create files as needed. Reuse the supplied reuse_targets
and existing helpers/patterns first instead of duplicating or copy-pasting code;
prefer supported standard libraries and already-present dependencies/APIs/helpers
and avoid unnecessary new dependencies rather than treating useful supported
standard libraries as off-limits. Fix causes rather than suppressing errors,
weakening checks or hardcoding; justify any genuinely needed custom
implementation, compatibility exception or dependency choice with its tradeoffs,
do not force coincidental lookalikes into a shared abstraction, and avoid
speculative abstractions. Consider compatibility, security, data integrity,
cancellation, error handling and bounded performance where applicable. Limit
repository inspection and verification to relevant repository paths; never scan
filesystem or mount roots, and use commands supported by the actual execution
environment rather than guessed platform flags (a working instruction, not an OS
sandbox). Save any artifacts you produce (reports, logs, screenshots) into the
artifacts directory named in the runtime context; they are attached to this stage.
Run the relevant checks with the stage tools and record the exact commands,
observed results and any untested limits in an `# evidence` section; never
claim an unexecuted check passed. Preserve the task, plan and acceptance checks and
record actual changes in changed_files. Do not commit, push, deploy or destroy
unrelated work; the committer stage commits this run's change. Return the
line-oriented result: the first non-empty line is the declared outcome, a
`# output` section holds one JSON object with the output fields named above, and
any further `# <heading>` section is retained verbatim as evidence. Return blocked
when the required edit scope or tools are unavailable.
read
glob
grep
edit
shell
provider=opencode-go
model=deepseek-v4.1-flash
retries=2
timeout=1h
success -> reviewer
blocked -> #failure
error -> #failure
stage reviewer
{ summary, changed_files, verification_evidence, findings, unverified }
Independently review the actual changed files and related existing code against
the supplied task, plan and acceptance checks. Inspect for duplication and
near-duplicate implementations, appropriate library/standard and version usage,
modularity, coupling, contracts, error handling, security, data integrity and
bounded performance, and assess worthwhile regression tests or docs. Look for
shortcuts, hardcoded special cases, suppressed errors, weakened tests and
unnecessary bespoke solutions, not only overall architecture. Support each finding
with a concrete location, evidence, severity and remedy; distinguish blocking
evidence gaps from nonblocking personal-style nits and explain legitimate
deviations. Run relevant checks with the stage tools yourself and report what was
not tested in an `# evidence` section; do not accept a prior stage's summary as
proof and never claim an unexecuted check passed. Limit inspection and
verification to relevant repository paths; never scan filesystem or mount roots,
and run commands supported by the actual execution environment rather than
guessed platform flags (working instructions, not an OS sandbox guarantee). Save
any artifacts you produce (reports, logs, screenshots) into the artifacts
directory named in the runtime context; they are attached to this stage. Return
the line-oriented result: the first non-empty line is the declared outcome, a
`# output` section holds one JSON object with the output fields named above, and
any further `# <heading>` section is retained verbatim as evidence. Return success
only when the applicable acceptance checks were independently observed passing and
no unresolved substantive design, reuse, duplication, workaround or correctness
issue remains; return rejected with concrete findings for failing checks, missing
REQUIRED verification, or substantive code-quality issues. Optional or
out-of-scope checks may be recorded untested without forcing endless work. Use
websearch/webfetch only when an official standard or documentation check is
needed. Do not edit files, commit, push or deploy.
{"task":"input.prompt","pwd":"input.pwd","plan":"planner.plan","design":"planner.design","reuse_targets":"planner.reuse_targets","acceptance_checks":"planner.acceptance_checks","research":"planner.research","changed_files":"implementer.changed_files","implementation_summary":"implementer.implementation_summary","evidence":"implementer.evidence?"}
read
glob
grep
shell
websearch
webfetch
provider=opencode-go
model=deepseek-v4.1-flash
retries=2
timeout=1h
success -> committer
rejected -> #failure
error -> #failure
stage committer
{ committed, commit, changed_files, pre_commit_checks }
Commit this run's change locally. Never push, tag, deploy or rewrite history.
Select the run's changed paths from input.server_changed_files (the runner's
captured evidence) and the implementer's declared changed_files, and stage their
union of paths that still exist, keeping any exclusions. Inspect the staged diff
before committing; never commit unrelated work, secrets or generated artifacts.
Pre-commit checklist: confirm the staged paths are this run's change; run the
repository's required checks and record the exact commands and observed results in
a `# evidence` section; do not commit if a required check fails, return
blocked with the failing output instead. If nothing is staged, do not create an
empty commit; return success with a clear note. Otherwise commit with a concise
message naming this run's change and report the commit hash. Return the
line-oriented result: the first non-empty line is the declared outcome, a
`# output` section holds one JSON object with the output fields named above, and
any further `# <heading>` section is retained verbatim as evidence. Never claim an
unexecuted check passed or fabricate a commit.
{"task":"input.prompt","changed_files":"implementer.changed_files","server_changed_files":"input.server_changed_files"}
read
glob
grep
shell
provider=opencode-go
model=deepseek-v4.1-flash
retries=2
timeout=1h
success -> #success
blocked -> #failure
error -> #failure