Foreman · Pack · Integrates with Salesforce

Foreman

Hand it the Salesforce backlog. It builds, tests and releases.

The Salesforce pack turns Foreman loose on Salesforce DX projects. It builds several stories at once, each in its own sandbox, tests every change in the org, has it checked by a separate tester and three reviewers, then releases it through sf, your own CI or Gearset.

Preview · free to useForeman pack · Salesforce DX projects on GitHubRead the pack docs →

Install Foreman

Needs Claude Code on a paid plan or the API · Version 0.11.0 · Source on GitHub

Foreman sends stories to two sandboxes, where they are built, tested and validated, then released to QA and UAT. Production is released manually.
  1. 01StoryFrom your backlog
  2. 02SandboxBuilt and tested in its own org
  3. 03ValidateDry-run deploy of the change
  4. 04QADeployed, checked, rolled back on failure
  5. 05UATOptional, halts on failure
  6. ManualProductionYou release it yourself
One example path. You choose the stages; one sandbox and one branch are enough.

How it works

  1. 01

    Connect your orgs

    Sign in to the orgs Foreman may use on the Set up page. Each one is listed by its org ID, and Foreman checks with the org itself that it is a sandbox.

  2. 02

    Say where each step runs

    Pick where stories are built, where the tester runs its checks, and the release stages in order, up to four. One sandbox and one branch are enough.

  3. 03

    Salesforce agents build each story

    An architect picks an admin, developer, OmniStudio or Agentforce builder. It deploys to its own sandbox and writes the tests first.

  4. 04

    It ships down your path

    Validation, pull request, CI and merge, then each stage up to the one where you want stories to stop.

What it does

  • Several stories at once

    Give Foreman a pool of sandboxes and it builds one story in each, side by side. With scratch orgs, every story gets a fresh org of its own. Finished stories release one at a time, so they never trip over each other.

  • Fast by design

    Each release deploys only what the story changed, not the whole project, and the dry run runs the story's tests and the ones its change touches, not every test in the org. Every sf call has a time limit, so a stuck command never holds up the line.

  • Quality checked at every step

    Builders write the tests first: positive, negative, bulk and null cases. A separate tester that never edits re-runs them in the org, checks coverage per class (75% floor, 90% target by default), and runs LWC Jest and Code Analyzer. Then a Salesforce code reviewer, a compliance reviewer and a security reviewer check the change, and anything they find goes back to the builder.

  • Agents that know Salesforce

    Admin work goes to a builder that writes Flows as metadata and puts field access in permission sets. Apex and LWC go to a developer, and OmniStudio and Agentforce to builders of their own. The security reviewer checks Salesforce's own risks: object and field access, sharing and SOQL injection.

  • Three ways to release

    Foreman deploys with sf itself. Or your own GitHub Actions job deploys and Foreman confirms it in the org. Or Gearset promotes: Foreman merges the promotion pull request once Gearset passes it, or waits for your Promote click.

  • OmniStudio

    Foreman tells the standard runtime from the managed package. It deploys Data Mappers, then Integration Procedures, then OmniScripts and FlexCards, checks the right versions are active, and calls each changed Integration Procedure with a test input. On the managed package it parks the story with the activation steps for you.

  • Agentforce

    An Agentforce builder writes the agent, its actions and their Apex or Flows, plus a test spec. Foreman previews the agent with simulated actions, publishes and activates it, then runs the tests. Wrong routing blocks the story, and rolling back reactivates the previous version.

  • Rollback where it is safe

    On the first stage a failed check rolls back by itself: Foreman reverts the merge and deploys the reverse delta, metadata only, never data. A failure on a later stage like UAT, which people share, halts and alerts you instead.

  • Production stays yours

    Foreman deploys only to orgs on your allow-list, and checks each one is a sandbox before every step. Production can be connected as your Dev Hub or for reading, and releasing to it stays with you.

How it works

  • Sandboxes

    One sandbox for everything is enough to start; add more to build more stories at once. After a story that did not ship, Foreman cleans up what it left in that sandbox.

  • Scratch orgs

    Or build each story in its own scratch org, made from your definition through your Dev Hub and deleted when the story closes. Foreman keeps within the Dev Hub's daily limit.

  • Branches

    Keep qa, uat and main, or just main. Pull requests never go into your production branch.

  • Deletions wait for you

    Anything a story would delete waits for your yes. Flows and Record Types are never deleted: they go on the story's manual steps.

  • Old failures stay old

    Doctor records each org's existing test results first, so a failure that was already there isn't blamed on the story.

  • Official skills

    The agents use Salesforce's own skills, pinned to a release, with a lock file that doctor checks.

  • A careful command line

    Every sf call has a time limit. A login-rate error stops the call at once, and Foreman leaves that org alone for a while, an hour by default, so your user is not locked out.

  • Doctor checks the org side

    foreman doctor checks the Salesforce tools, that each org is signed in and is a sandbox, source tracking, that your workflows deploy only to allowed orgs, and the Agentforce and OmniStudio licences when you use them.

Where it runs

  • Your machine

    Story sessions get their own Salesforce sign-in folder holding only the orgs you allowed, so your other logins stay out of reach.

  • A container

    The runner image comes with the Salesforce CLI and the tools the pack needs already in it.

  • What you need

    A Salesforce DX project in a GitHub repository, at least one sandbox, and what Foreman itself needs. A Dev Hub for scratch orgs, and Gearset, only if you use them.

Install

Needs Claude Code on a paid plan or the API. Free to use.

  1. Add the plugin

    In Claude Code, run these two commands.

    /plugin marketplace add finefactory-ai/foreman#v0.11.0
    /plugin install foreman@foreman
  2. Set up your project

    In your project, run /foreman:init. It looks at your stack and opens the Set up page, which walks each step and takes each key on its own card.

  3. Check it, then give it a story

    Run foreman doctor. It finds and explains most set-up problems and says what to do. Then start the run with foreman run.

The install guide has what the machine and the project need, and how to move to a later release. The source and every release are on GitHub.

Foreman is free to use, change and share, at work included, under the Functional Source License (FSL-1.1-ALv2). You may not offer it, or something built from it, to others as a commercial product or service that replaces Foreman or does much the same job. The LICENSE file that comes with Foreman governs.

Foreman runs AI agents unattended, with your keys. It can change, merge and deploy code. Start with least-privilege tokens, branch protection and a target that is not production, and review what it ships. It is provided as is, without warranty.

Salesforce, Agentforce, OmniStudio and Salesforce DX are trademarks of Salesforce, Inc. Gearset is a trademark of its owner. FineFactory is not affiliated with or endorsed by Salesforce or Gearset.

Questions about Foreman?

Found a bug, or want to suggest something? Open an issue on GitHub and we'll answer there. For anything you'd rather not post in public, email us.