Files
pipelines/examples/task.md
T
alan c9b904186a Update templates and authoring skill to the current pipeline contract
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.
2026-10-17 01:09:42 +01:00

110 lines
4.1 KiB
Markdown

# stage worker
```output
{ task, summary, changed_files, remaining_questions }
```
```prompt
Complete input.prompt in the run directory. Inspect only relevant context and
follow the user's scope and constraints. 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. This is a working instruction, not an OS sandbox. Work
with the repository's actual languages and file types; do not assume a framework
or technology. Prefer repository conventions, supported standard libraries and
existing dependencies/APIs/helpers over bespoke or copy-pasted code, and avoid
unnecessary new dependencies rather than treating useful supported standard
libraries as off-limits; justify any genuinely needed custom implementation,
compatibility exception or dependency choice with its tradeoffs and do not force
coincidental lookalikes into a shared abstraction. Research official primary
sources with websearch/webfetch only when the task genuinely needs external
knowledge, recording source URLs and applicability/version evidence or stating why
none was needed; keep queries free of private code and secrets. 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. Fix causes rather
than suppressing errors or weakening checks, and avoid speculative abstractions.
Preserve unrelated work and leave the commit to the committer stage: do not commit,
push, deploy, or perform destructive actions. Save any artifacts you produce
(reports, logs, screenshots) into the artifacts directory named in the runtime
context; they are attached to this stage. Verify the change with the repository's
relevant checks and report the exact commands and observed results in an
`# evidence` section; never claim an unexecuted check passed. 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
if the task or required tools are unavailable; otherwise return success with
actual results.
```
```tools
read
glob
grep
edit
shell
websearch
webfetch
```
```configs
provider=opencode-go
model=deepseek-v4.1-flash
retries=2
timeout=1h
```
```edges
success -> committer
blocked -> #failure
error -> #failure
```
# stage committer
```output
{ committed, commit, changed_files, pre_commit_checks }
```
```prompt
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 worker'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 an
`# 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.
```
```memory
{"task":"input.prompt","changed_files":"worker.changed_files","server_changed_files":"input.server_changed_files"}
```
```tools
read
glob
grep
shell
```
```configs
provider=opencode-go
model=deepseek-v4.1-flash
retries=2
timeout=1h
```
```edges
success -> #success
blocked -> #failure
error -> #failure
```