Skip to main content

Gitmoot v0.8.8

Pipeline stages can now be agents, not just shell commands — a stage can reason (ask/review), write code and open a PR (implement), wait for that PR to merge (a gate), or fan out a bounded sub-tree of agents (orchestrate). The persistent-memory system grows a curation loop alongside it: markdown ingest with a human confirm gate, deterministic distill-at-terminal, grooming proposals, and emergent knowledge clusters. Everything additive and off by default — existing pipelines, agents, and memory behave identically unless you opt in.

What's new since v0.8.7​

Pipeline agent stages — put a model inside the assembly line (#757, #770, #768, #758)

A pipeline stage can now run a named managed agent in place of a shell cmd. Four kinds share the same mechanics (own-runtime dispatch, upstream needs-context injection, fold-by-decision); all are leaves except orchestrate:

  • Read-only ask/review (#757). A stage runs an agent on its own runtime and folds by its gitmoot_result decision — model judgement inline in an otherwise-deterministic flow (e.g. an extract shell stage feeding a triage agent stage). Upstream stage results are fenced and injected into the prompt; a repo-bound stage runs in its own detached read-only worktree so same-repo stages parallelize without touching the live checkout.
  • Mutating implement (#768). action: implement + write: true makes a stage mutate the repo and open a pull request, folding on PR-opened, on a deterministic gitmoot/pipe-<run>-<stage> branch (a retry reuses the same branch/PR — never a duplicate). Guarded by a write: true double-key, and — on a scheduled pipeline — a pipeline-level allow_scheduled_writes, so an unattended nightly can never write code by accident. It never merges its own PR.
  • Composable gate (#768). A jobless gate: pr_merged stage waits — non-blocking, fail-open, bounded by the stage timeout — until the PR opened by its source implement stage merges, then lets the line continue. The clean way to express [implement] → [gate: pr_merged] → [deploy].
  • Orchestrate sub-tree (#758). orchestrate: true makes a stage a bounded coordinator: its delegations[] fan out as owned children (inheriting the full depth / job-budget / wall-clock / loop bounds), the stage waits for the whole sub-tree via the deterministic continuation chain, then folds the synthesis. A daemon restart re-derives the wait from rows — it never restarts the tree.

All four are built on a shared stage-kind foundation (#770) that keeps existing shell and read-only stages byte-identical. See the Pipelines Workflow doc and the CLI reference. Off by default — pipelines are opt-in and mutating stages are double-gated.

Persistent memory: a curation loop (#737 P3/P4, #763)

  • Markdown ingest + human-gated confirm (#753). gitmoot memory ingest stages markdown notes into the brain as pending observations behind the pre-filter (trust_mark=low); nothing reaches confirmed memory without an explicit gitmoot memory confirm. A minimal human-gated promotion slice lands with it.
  • Deterministic distill-at-terminal (#760). An optional, config-gated hook distills durable facts at a job's terminal — deterministic and fail-safe, off by default.
  • Grooming proposals (#759). gitmoot memory groom --propose emits a plan of retirement/rewrite suggestions and never applies anything; applying is always the owner's explicit --yes command, and a nightly proposal pipeline can stage the plan for review.
  • Emergent clusters + repo-tier knowledge bridge (#763 Track A, #764, #766). Confirmed memories surface as emergent clusters with a repo-tier knowledge bridge, wired into the dashboard's Knowledge view (cluster hubs + fact-detail fields).

Docs (#774)

  • The pipeline docs now cover the implement / gate / orchestrate stage kinds, their fields, and the mutating-stage safety model, across the site, the skill references, and llms-full.txt.

Everything above is additive and defaults-off; upgrade is a drop-in binary replacement.