🌾 Graft

"Put your tasks on the table, graft the shoot, and let the work take root."

Graft is an autonomous Software Development Life Cycle (SDLC) orchestrator. It implements the OpenAI Symphony specification, combining the graph-native task engine of Farm Table with the isolated container runtime and git worktree management of Scion.

💡 Why "Graft"?

Botanical: In horticulture, a scion (a young shoot) is grafted onto rootstock at the farm table / potting bench to cultivate fruit.
Hard Graft: British/Irish slang for roll-up-your-sleeves, day-to-night relentless hard work that gets the job done. Graft is the tireless worker clearing the chore list off the table while you sleep.
Symphonic Harmony: Graft translates declarative WORKFLOW.md contracts and directed task DAGs into synchronized agent executions.

🏗️ Architecture & Core Mechanics

                               ┌─────────────────────────────────────────────────────────────┐
                               │                        WORKFLOW.MD                          │
                               │   (Repository-owned prompt template + runtime settings)     │
                               └──────────────────────────────┬──────────────────────────────┘
                                                              │
                                                              ▼
┌──────────────────────────────────────┐          ┌──────────────────────────────────────────┐
│             FARM TABLE               │          │                   GRAFT                  │
│          (Task Substrate)            │          │             (Symphony Engine)            │
│                                      │  Ready   │                                          │
│ • Directed Task DAG (blocked_by)     ├─────────►│ 1. Evaluates DAG readiness               │
│ • Critical path & bottleneck queries │  Tasks   │ 2. Enforces global & per-state limits    │
│ • Atomic CAS claims (task_claim)     │◄─────────┤ 3. Renders Liquid prompt per task        │
│ • Live event stream (ft watch)       │  Claim   │ 4. Dispatches isolated agent run         │
└──────────────────────────────────────┘          └────────────────────┬─────────────────────┘
                                                                       │
                                                                       │ Dispatches Worker
                                                                       ▼
                                                  ┌──────────────────────────────────────────┐
                                                  │                 SCION                    │
                                                  │          (Execution Engine)              │
                                                  │                                          │
                                                  │ • Dedicated Git Worktree per task        │
                                                  │ • Multi-harness (Claude, Gemini, Codex)  │
                                                  │ • Farm Table MCP injected into container │
                                                  │ • Detached execution + scion attach      │
                                                  └──────────────────────────────────────────┘

✨ Key Superpowers

🕸️ Graph-Aware Autonomous Dispatching: Standard Symphony with Linear or GitHub can only poll flat lists of issues. Graft uses Farm Table's graph engine (GetReadyTasks). When Agent A closes Task 1, downstream Tasks 2 & 3 automatically unlock and dispatch in parallel.
🛡️ Total Workspace & Git Worktree Isolation: Workers don't clobber files or collide on HEAD. Scion provisions a clean, ephemeral Git worktree and container sandbox for every task attempt.
📜 In-Repo WORKFLOW.md Policy: Teams version their agent prompt, concurrency limits, retry backoffs, and lifecycle hooks alongside their code.
🔌 Agent Plugins Spec (v1.0.0) Ready: Ships as both a standalone CLI (graft) and a portable Agent Plugin with ready-to-use skills for coordinators and workers.
⚡ Dual Triggering: Supports both periodic polling ticks (cron / Scion scheduler) and reactive event streaming (ft watch gRPC stream).

📦 Agent Plugin & Skills Layout

Conforming to the Agent Plugins Specification v1.0.0:

graft/
├── plugin.json                 # Standard portable plugin manifest
├── mcp.json                    # Bundled Farm Table MCP server declaration
├── WORKFLOW.md                 # Default Symphony SDLC contract
├── bin/
│   └── graft                   # Standalone orchestrator CLI binary
└── skills/
    ├── graft-coordinator/      # Manager skill: audits DAGs, monitors runs, handles escalations
    │   └── SKILL.md
    └── graft-worker/           # Worker skill: in-container task claim, execution, and handoff
        └── SKILL.md

🚀 CLI Quick Start

1. Initialize Graft in your repository

graft init

Generates a starter WORKFLOW.md with Liquid prompt templates and runtime settings.

2. Run a One-Shot Dispatch

graft dispatch

Scans Farm Table for ready tasks, claims matching items, and spawns Scion workers.

3. Run the Continuous Loop (Daemon Mode)

# Polling loop with a 15-second cadence and dynamic file reloading
graft loop --workflow WORKFLOW.md --watch-reload

# Custom interval and concurrency
graft loop --verbose

4. Check Status & Active Worktrees

graft status

🧪 Testing & Validation Matrix

# Run unit and real-world E2E integration test suite
make test

# Run real-world dependency graph resolution E2E suite
make e2e

📄 License

Licensed under the Apache License, Version 2.0.