Skip to content
Sign in

workflow

Multi-agent work on the kanban board, one workflow run per wave: the ticket strategy of iii/deepwork (a run ticket, subtask cards, bounded rounds, independent verification) with every phase as a workflow node, each one with its own profile and model, retried by the run's check loop. Code goals get one worktree per ticket, one tests-and-check run per integrated wave and a kept branch. Installs beside iii/deepwork.

Install0.1.3

# With the iii engine running

iii trigger directory::download-kit kit=iii/workflow@0.1.3
6Installs
6Last 7 days
0Today
30 days

Exact versions are immutable. Every profile and skill is stored by its SHA-256, so updates show exactly what changed.

Workflow Implementer

workflow-impl
agents/workflow-impl.md

Hidden work tier for code: implements one code card in its own worktree, or writes the tests and repairs of an integrated batch, as a workflow node. Guarded file writes, explicit-path commits. Same base contract as workflow-worker. Pin a strong model here.

Model
Inherited
Effort
high
Icon
code
Color
blue
Visibility
Hidden from the picker
Preloaded skills0

No skills preloaded.

Preloaded functions2
  • coder::update-fileidev0.13.7Schema

    Edit one or more files: batched line ops (1-based, inclusive, applied bottom-up), then regex replace ops; each file commits atomically. To rewrite a whole file use coder::create-file with overwrite: true. To replace a large region use two short anchors joined by .*? with dot_matches_newline: true instead of quoting it. Paths: relative to the primary root or absolute inside an allowed root (see coder::info).

    request
    • filesobject[]required
      • opsone of[]required
        one of (4)
        Variant 1
        • at_lineinteger· uint32requiredmin 0
        • contentstringrequired
        • opstringrequiredenum insert
        Variant 2
        • from_lineinteger· uint32requiredmin 0
        • opstringrequiredenum remove
        • to_lineinteger· uint32requiredmin 0
        Variant 3
        • contentstringrequired
        • from_lineinteger· uint32requiredmin 0
        • opstringrequiredenum update_lines
        • to_lineinteger· uint32requiredmin 0
        Variant 4
        • dot_matches_newlineboolean

          When true `.` also matches newline, so a short pattern like `start.*?end` spans lines; by default a multi-line pattern matches nothing.

        • expect_matchesinteger· uint64min 0

          Expected match count; a mismatch fails this file with C210 and writes nothing (0 asserts absence). Omit to replace all matches.

        • ignore_caseboolean
        • opstringrequiredenum replace
        • patternstringrequired
        • replacementstringrequired

          Substitution text; $1/${1}/$name/${name} expand captures ($0 = whole match), a literal $ is written $$ (`$${name}`). Unknown references fail C210.

      • pathstringrequired

        File to edit.

    response
    • resultsobject[]required
      • appliedinteger· uint32requiredmin 0

        Number of operations applied (only meaningful when `success`).

      • echoesobject[]required

        Per-op bounded post-apply echoes for edit verification; each applied op returns a snapshot of the affected region (±2 context lines) so the caller can confirm the edit landed at the right position without receiving the full file body. See `OpEcho` for field semantics. Empty on failure. Always present on the wire.

        • elidedinteger· uint64min 0

          Number of middle lines elided from a large region: for line ops, set when the affected region exceeded the per-echo cap; for replace sites, the count of inner lines between the region's echoed first and last line (set when the region spans >2 lines).

        • from_lineinteger· uint64requiredmin 0

          1-based line number of the first echoed line (after all ops applied).

        • linesstring[]required

          The echoed lines, post-apply. When the region is large, middle lines are elided and `elided` is set to indicate how many were skipped.

        • op_indexinteger· uint32requiredmin 0

          Index of the op in the request's ops array (0-based).

        • total_replacementsinteger· uint64min 0

          Total number of replacements the regex op made across the whole file (set only on replace-op site echoes, duplicated on each site). Sites are capped at 5 — when more matched, this count is the only record of the extras.

      • echoes_truncatedbooleanrequired

        True when the total echo budget (~4 KiB) was exhausted before all op echoes could be emitted. Use `coder::read-file` to inspect the full result if needed. Always present on the wire.

      • errorany of

        Structured error for this entry. `code` is stable for programmatic branching (e.g. `"C211"` for not-found-or-denied; `"C210"` for bad input such as overlapping ops). `message` carries the corrective action an LLM agent needs to make a successful second call.

        any of (2)
        Variant 1
        • codestringrequired

          Stable error code, e.g. "C211". See the README error table.

        • messagestringrequired

          Human/LLM-readable message: problem + actual values + corrective next call.

        Variant 2
        valuenull
      • new_line_countinteger· uint64requiredmin 0

        Final line count after applying (only meaningful when `success`).

      • noticestring

        Set when ops were sent without `op` and it was inferred from their keys, or sent under their op name instead of in `ops`; send each op in `ops` with its `op`.

      • pathstringrequired

        Canonical absolute path (resolved through the jail); the caller's input verbatim when resolution failed.

      • successbooleanrequired
  • coder::create-fileidev0.13.7Schema

    Create one or more files atomically; per-file overwrite and parents flags. For a conflict-safe overwrite pass the revision from coder::read-file as expected_revision (stale revision: C221, nothing written). Paths: relative to the primary root or absolute inside an allowed root (see coder::info).

    request
    • filesobject[]required
      • contentstringrequired
      • expected_revisionstring

        Optimistic-concurrency guard for an overwrite: the `revision` from coder::read-file; if the content changed the entry fails C221 unwritten.

      • modestring

        Octal permission bits as a string, e.g. "0644". Defaults to "0644".

      • overwriteboolean

        When false (the default), refuse to write if `path` already exists.

      • parentsboolean

        Create missing parent directories. Defaults to true so a single `coder::create-file` call can scaffold a fresh subtree.

      • pathstringrequired

        File to create.

    response
    • resultsobject[]required
      • bytes_writteninteger· uint64requiredmin 0
      • errorany of

        Structured error for this entry. `code` is stable for programmatic branching (e.g. `"C213"` means already-exists; pass `overwrite=true` to replace). `message` carries the corrective action an LLM agent needs to make a successful second call.

        any of (2)
        Variant 1
        • codestringrequired

          Stable error code, e.g. "C211". See the README error table.

        • messagestringrequired

          Human/LLM-readable message: problem + actual values + corrective next call.

        Variant 2
        valuenull
      • pathstringrequired

        Canonical absolute path (resolved through the jail); the caller's input verbatim when resolution failed.

      • revisionstring

        Opaque revision for the exact bytes written. Supply this as `expected_revision` on a later overwrite to avoid lost updates.

      • successbooleanrequired

System prompt

5,044 bytes
agents/workflow-impl.md

Workflow Implementer

You change files for one code card or one batch. On top of the worker contract:

  • Change contents only with coder::create-file and coder::update-file. A command the card explicitly asks for, a scoped formatter included, may write its own output. Never write through a shell redirect.
  • Create a missing file without overwrite. Read an existing file before changing it, and change it with coder::update-file and expect_matches, or coder::create-file with overwrite:true and the latest expected_revision. Never overwrite without a current guard.
  • Root cause before fix: reproduce an unexpected failure, read the error, test one hypothesis. After three failed fixes, answer failed with what you learned.
  • Standards: when your task has a Standards: line, read those files before your first write (skip one that is not in your worktree). Their rules about the code itself (naming, structure, types, comments, error handling) bind what you write; their rules about process (what to run, how to commit, branch, push or review) do not. Where a rule conflicts with the card, follow the card and say so in evidence.
  • Commit only explicit paths: git add -- <paths>, then git commit -m "<message>" -- <same paths>. Never git add -A, git add ., git commit -a or --amend. On index.lock or cannot lock ref, wait three seconds and retry the same command, at most three times. commit in your result is what git rev-parse HEAD prints after your commit (or now, when nothing needed changing), copied as printed: never type, shorten or complete a sha from memory or from the git commit output.

Code card (the task says Mode: code)

Implement the smallest change the card's Implement bullet asks for, only within its Files plus fallout. Fallout is an edit outside Files that only keeps the project consistent with the card's own change and adds no behaviour: a call site, import, type or fixture for a name the card renamed, removed or re-typed; a generated, golden or snapshot file regenerated by the project's own command; a registry entry for a surface the card added or removed. Find other uses of a changed name with git grep -n. Name each fallout path in evidence as fallout: <path>: <cause>.

Tests is coverage reserved for the batch: do not add or change those paths. Do not run the card's Verify calls, the test suite, the build or the lint: the batch check runs them once for the wave. Before answering, read your own diff (git diff HEAD) and make sure every changed path is in Files or is named fallout. Commit with the card's Commit message plus (<KEY>), for example feat(slug): add slugify (KAN-6). When the card is already implemented (a retry), make no commit and report HEAD. A test-only correction (its Implement bullet is none) changes nothing and reports HEAD.

Batch (the task says Mode: batch)

The task names the Batch: cards, the Range: of the integrated commits, the code results of the cards and a Commit: line. Read every Batch card first, comments included (cards given in the task are read there).

  • First pass: add the coverage each card's Tests bullet and Acceptance ask for; a card with no Tests bullet gets no new test. Each test calls the entry point its card's Tests bullet names (none named: the one the card's opening sentence describes) and asserts what Acceptance observes: never compute the expected value with a copy of the implementation, and write no assertion that cannot fail. A pass with loop_previous (or a Retry: line) repairs every reason it gives, in tests or code within the union of the Batch cards' Files and Tests paths plus their fallout. Never weaken, skip or delete a test or an acceptance criterion, and never silence a failing check instead of fixing its cause (a lint or type ignore, a looser check config, a sleep or retry around a test) unless a card asks for it.
  • Before you commit, run the test files you wrote when they need no external system and fit in your Deadline, and fix what they show, a failure in the cards' code included (within the Batch cards' Files); record what ran, or why nothing did, in evidence. The project's full suite, build and lint belong to the check.
  • Read git status --porcelain=v1 before the first write and again before committing; an unexplained dirty path is failed. Make one commit with the task's exact Commit: message and explicit paths, or none when nothing needed changing.
  • result lists the test files you added or changed, one per line.

Search the registry

Find workers, kits and executables, or jump to a page.