work-implement-queue

Drain the repo's queue of implementable issues — every ready issue plus every changes-requested issue (re-work after review) — and carry each to a pushed, reviewable state by delegating to work-implement. The loop implements nothing itself: the tracker is the queue, each issue is worked in a fresh worker, and the output is an issue in reviewRequested, handed to the work-review-queue. Run it through a repeating driver for continuous operation.

Opted out? If the repo config sets work to false, all work-* skills are disabled for the repo — stop immediately and tell the user they are turned off in .tituskirch-skills.json. An absent work block is not disabled. Check .work == false on the resolved config before acquiring the lock or building the queue (step 1, right after the required-worker check). A missing jq or config exits non-zero too, so a pass is not evidence the config was read.

OpenCode unattended run. OpenCode ignores this skill's Claude Code-only disallowed-tools field, so do not run it unattended unless the effective OpenCode agent permission is question: deny. Copy this skill's templates/opencode-agent.md to .opencode/agents/work-implement-queue.md in the consuming repo, restart OpenCode, then use opencode run --auto --agent work-implement-queue "Run the implementation queue once.". The template denies questions and permits only the general subagent through OpenCode's task tool, so each issue still reaches a fresh worker. OpenCode has no native /loop; a scheduler or a human starts each later drain.

Workflow

1. Load config & lock

• work-implement is required, and checked first — before resolving anything, before taking the lock. Absent: stop, name it, and report that no issue was touched, having leased nothing and held nothing.
• Resolve the config with this skill's own templates/resolve-config.sh and read it by the rules work-implement's REFERENCE states under Reading the config; the tracker is work.tracker, falling back to issue.tracker. Where that tracker is a forge (github, gitlab), the host it talks to is resolved per repo rather than assumed — The forge and its host there.
• Acquire the implement single-flight lock by mkdir at $(git rev-parse --git-common-dir)/tituskirch-skills/work/implement.lock, retiring the old loose implement.lock first; held → a second implement-drain in this checkout exits. The review loop takes a separate lock, so implement and review drains run concurrently. The primitive, the heartbeat-timestamp stale rule, that migration and the single-checkout boundary: The single-flight lock in work-implement's REFERENCE.

2. Reconcile — reclaim crashed implementations

Before building the queue, reclaim issues an earlier implement-run crashed on: an issue in working with no pushed artifact (no PR, no pushed commit) was leased but abandoned before its push. The lock proves no live worker in this checkout only, never in another clone, so gate the reclaim on the assignee the claim set — an issue assigned to a different runner, or under one shared bot identity to this one, is presumed live and left alone unless a weaker age fallback clears it. Only an unassigned issue, or this runner's own crashed lease where identities are per-runner, is flipped back to ready (dropping the assignee), or blocked where it left an unrecoverable state. Full rules, incl. the same-bot caveat: Reconcile in work-implement's REFERENCE. Idempotent — nothing to reclaim is the normal outcome.