Using Moru
Running GitHub workflows
How workflows in .github/workflows run on Moru without changes, what the compatibility report says, which actions run and how to lock them, where Moru behaves differently from GitHub, and how to move to Moru's own format.
A repository imported from GitHub keeps its CI. Moru reads the workflows in .github/workflows/ and runs them as they are, on the runners of the person each run is
for, the same way it runs native workflows. You don’t have to
change the files. Each workflow gets a compatibility report that says what runs, what
runs a little differently, and what can’t run.
Moru translates each workflow into the same jobs a native file becomes. It doesn’t run GitHub’s runner. Most workflows that build and test code run unchanged. Workflows that talk to GitHub itself (its API, its tokens, its deployment environments) don’t.
Which folder runs#
A commit’s runs read .moru/workflows/ when it holds at least one .yml or .yaml file, and .github/workflows/ otherwise. Never both, so a repository halfway through
moving to the native format doesn’t run everything twice. The CI tab says which
folder is in use.
A file in .github/workflows/ whose only trigger is workflow_call is a reusable
workflow, not a workflow of its own: it runs only when another workflow calls it.
Triggers#
| GitHub | On Moru |
|---|---|
push | A push to a branch or tag, merges included. branches, branches-ignore, tags, tags-ignore, paths and paths-ignore work as on GitHub. |
pull_request | Every new revision of a change. branches and branches-ignore match the change’s target branch. types with opened, synchronize or reopened is ignored, with a note: Moru runs on every revision. A types list with none of them is refused. |
schedule | A schedule, with cron and the optional timezone. |
workflow_dispatch | A manual start from the CI tab or the API, with its inputs. Input types string, boolean, choice and number work; environment is refused. |
workflow_call | A reusable workflow. See Reusable workflows. |
pull_request_target, workflow_run, every other event | Refused. A workflow that also has a trigger Moru runs gets a note and runs on that one; a workflow with only refused triggers doesn’t run. |
In a job’s if, github.event_name is GitHub’s name for the trigger: pull_request for a change’s revision, push, schedule or workflow_dispatch. So if: github.event_name == 'push' works as it did.
runs-on#
GitHub’s hosted runner labels become Moru’s own labels, which every runner has from its OS and CPU:
runs-on | Runs on |
|---|---|
ubuntu-latest, ubuntu-24.04, … | linux |
ubuntu-24.04-arm, …-arm64 | linux and arm64 |
macos-latest, macos-15, … | macos (macos-…-arm64 adds arm64) |
self-hosted | Dropped: every Moru runner is self-hosted. |
Linux, macOS, X64, ARM64 | The same labels in lower case. |
windows-latest, any windows-… | Refused: Moru has no Windows runners. |
group: | Refused: Moru has no runner groups. Use labels. |
| any other label | Kept as it is. A runner matches it if a node admin gave it that label, or if it’s the runner’s name (see Named runners). |
ubuntu-latest doesn’t ask for a CPU, so it runs on any Linux runner, x64 or arm64.
When a matrix sends some combinations to Windows and others elsewhere, the Windows ones are dropped with a note and the rest run. They don’t count as jobs, so a required job doesn’t wait for them. A job that only runs on Windows is refused.
Expressions#
${{ }} works where GitHub allows it, with GitHub’s rules: its operators, loose
equality, case-insensitive string comparison, .* filters, and the functions contains, startsWith, endsWith, format, join, toJSON, fromJSON, hashFiles, case, success, failure, always and cancelled.
Every expression is checked when the workflow is read, so a typo or an unknown context
refuses the workflow with its line and column instead of failing halfway through a run.
The node works out what it can before a job is queued: a job’s if, name, runs-on, timeout-minutes, continue-on-error and strategy. The runner works out the rest as
the job runs.
The contexts are GitHub’s: github, env, vars, secrets, inputs, matrix, strategy, needs, steps, job and runner. Some of them hold less than on GitHub:
varsis always empty. Moru has no repository variables; put values inenv.github.tokenandsecrets.GITHUB_TOKENare empty. There’s no GitHub API to call.github.eventis a small payload Moru builds. For a change:action(openedfor the first revision, elsesynchronize),number, andpull_requestwithnumber,title,draft(alwaysfalse),head.sha,head.ref,base.shaandbase.ref.numberis the pull request’s number on GitHub when the change was delivered there, elsenull. For a push:ref,before,after,created,deleted,forcedandhead_commit.idand.message. For a manual start:inputs. For a schedule:schedule, the cron.github.actor,github.triggering_actor, the…_idfields and the API URLs are empty.github.server_urlis your node’s address.github.run_idis the Moru run’s ID.run_numbercounts the workflow’s runs, andrun_attemptcounts re-runs. The count is kept in the node’s index, not in git, so it starts again at 1 after the index is rebuilt and after the repository moves to another node; the first run after upgrading to a version that numbers runs is 1. Don’t userun_numberas a unique version number: add the commit to it.
A matrix can’t be computed from another job’s outputs yet
(fromJSON(needs.setup.outputs.matrix)), and a job’s name, runs-on, timeout-minutes and strategy can’t read needs. Both refuse the workflow with a
note that they come in a later version.
Environment and workflow commands#
Steps get the GITHUB_* and RUNNER_* variables GitHub sets, among them GITHUB_SHA, GITHUB_REF, GITHUB_WORKSPACE, GITHUB_EVENT_PATH, RUNNER_OS, RUNNER_ARCH and RUNNER_TEMP, plus CI=true and Moru’s own MORU_* variables. GITHUB_TOKEN is set,
and empty, so a token in the runner’s own environment never reaches a step.
The command files work as on GitHub: GITHUB_OUTPUT, GITHUB_ENV, GITHUB_PATH and GITHUB_STATE, with the name<<DELIMITER form for values over several lines. GITHUB_STEP_SUMMARY is accepted, but summaries aren’t shown yet. So are the commands a
step prints:
::add-mask::hides a value in everything logged after it.::group::,::endgroup::,::error,::warningand::noticestay in the log as they’re printed.::debug::shows only when the step’s env hasACTIONS_STEP_DEBUG=true.::stop-commands::works.::set-outputand::save-statework, with GitHub’s deprecation warning.::set-envand::add-pathfail the step unless its env hasACTIONS_ALLOW_UNSECURE_COMMANDS=true, as on GitHub.
Steps without shell run with bash -e, or sh -e where bash isn’t installed. In a job
with a container:, they run with sh -e, as on GitHub. bash, sh and python run
GitHub’s exact command lines, and a custom shell with {0} works. pwsh, powershell and cmd are refused.
A job without timeout-minutes gets 240 minutes, Moru’s most. GitHub’s default is 360,
and a larger value is cut to 240 with a note.
The compatibility report#
Each workflow on the CI tab has one of three verdicts:
- Runs as is: nothing to say.
- N notes: it runs, and the notes say what Moru does differently, such as ignoring
permissionsorconcurrency. A run keeps its notes, and its page lists them. - Refused: it doesn’t run. Each problem is listed with its line and column.
Under each workflow is the list of its uses:, each with its tier:
| Tier | Meaning |
|---|---|
| Built in | The runner does what the action does itself. Nothing is fetched. See Built-in replacements. |
| Fetched | A JavaScript, composite or Docker action, fetched from GitHub and run on the runner, or a docker:// image. |
| In the repo | A ./path action or reusable workflow, read from the job’s checkout. |
| Refused | It can’t run on Moru, with why. |
Fetched actions also say whether .moru/actions.lock locks them. See Locking actions.
A push or change that triggers a refused workflow still records a run, marked Refused. Its page lists the problems that refuse it, and the notes apart from them.
Actions#
Built-in replacements#
These actions aren’t fetched. The runner does their job with what’s already on the
machine. Every major version from v3 on is accepted, along with the inputs that version
has. An older major, such as actions/checkout@v2, is treated like v3: its inputs are
checked against v3’s. An input the replacement can’t honour refuses the workflow and names the input; one
that makes no difference on Moru (a token, a setup action’s cache) is a note.
| Action | On Moru |
|---|---|
actions/checkout | The job already has a checkout of the commit, with full history, branches and tags, so fetch-depth changes nothing. submodules and lfs run git submodule update and git lfs pull with the machine’s git. A repository, ref or path other than the job’s own is refused. |
actions/setup-node, -python, -go, -java, -dotnet | Nothing is installed. The step checks that the version asked for, or the one a version file names (.nvmrc, .python-version, go.mod, global.json, …), is on the runner’s PATH, and fails with what it found otherwise: “needs node 20 on PATH; this runner has 18.19.0”. The action’s outputs are set. |
jdx/mise-action | Runs the machine’s mise install and passes mise env on to later steps. Needs mise on PATH. |
dtolnay/rust-toolchain | Checks the toolchain is installed (rustup toolchain list), adds targets and components with rustup, and sets RUSTUP_TOOLCHAIN for later steps instead of changing the user’s default toolchain. |
actions/cache, actions/cache/restore, actions/cache/save | The runner’s own cache, with GitHub’s key and restore-keys rules. |
actions/upload-artifact, actions/download-artifact | The run’s artifacts on the node. Only the same run’s artifacts can be downloaded. archive: false is refused: artifacts are always zips. |
dorny/paths-filter | Matches its filters against the files the change or push changed, with the action’s own pattern rules, and sets every output the action sets. Every filter is true above 3,000 changed files, and when there’s no list of changed files: a new branch, a manual or scheduled run, a local run. |
Setup actions check the tools; they don’t install them. Put the versions your workflows need on the runner’s machine, with mise, asdf, Homebrew or your package manager.
JavaScript and composite actions#
Any other uses: owner/repo@ref is fetched from GitHub by the runner, at the commit the
run resolved, and run there:
- JavaScript actions run with
nodefrom the runner’sPATH.runs.using: node20needs Node 20 or later andnode24needs 24 or later; older values count asnode20. A missing or oldernodefails the step with the version it needs.preandpostscripts run as on GitHub, posts last first. - Composite actions run their steps inside the step that uses them, with their own
inputs. They can use other actions, up to 10 deep. - Local actions (
uses: ./path) are read from the job’s checkout.
A runner fetches an action once and keeps it in its cache directory. Use moru-runner run --actions-url to fetch from a mirror instead of https://github.com.
Services, job containers and Docker actions#
services:, container:, Docker actions (runs.using: docker) and uses: docker://… run on a runner with docker or podman, as described in Containers. GitHub’s keys and values work as they are: image, env, ports, volumes, options and credentials, and a service’s command and entrypoint. Expressions in them can read what GitHub allows, and secrets only in env and credentials. Steps can read job.services.<id>.ports['5432'], job.services.<id>.network, job.container.id and job.container.network, and they
get the MORU_SERVICE_<ID>_HOST and MORU_SERVICE_<ID>_PORT_<port> variables too.
A job with container: or services: goes to the runner of the person the run is for,
like any job: runs-on: ubuntu-latest still means a Linux runner, and a Mac runner with
Docker Desktop takes self-hosted container jobs. What runs differently from GitHub is
listed under Differences from GitHub.
Actions and secrets#
An action gets no secret unless the workflow passes it through with: or env:, as on
GitHub. Inside a composite action, secrets is empty. This holds in native workflows
too: a native job’s secrets reach its own run steps, never its uses: steps.
Locking actions#
A tag such as actions/setup-node@v4 can be moved to other code at any time. A lock
pins every action to a commit and checks its content. Run this in your checkout and
commit the file:
moru-runner ci lock It writes .moru/actions.lock, with the commit and the tree of every action your
workflows use, including the actions that composite actions use. Built-in replacements,
refused actions and ./path actions get no entry. The runner then fetches each action at
its locked commit and refuses it if the content doesn’t match. Run ci lock again after
you change a uses:, and ci lock --check in a hook or a CI step to catch a stale lock.
See ci lock.
Images are locked by digest. For each uses: docker://…, and each Docker action whose runs.image is docker://…, ci lock pulls the image with your docker or podman and
records its digest. Without an engine it writes the entry without a digest and says so.
After pulling, the runner checks the image against the lock and fails the step if the
digest changed since, naming both. An image pinned with @sha256:… counts as locked.
The image of a Docker action in the repository (uses: ./path) is never in the lock:
pin it with @sha256:….
Without a lock, a run still goes ahead. The node looks up each tag or branch on GitHub
when the run starts (at most 32 per run, and 64 for all the runs of one pushed ref,
revision, manual start or minute of a repository’s schedules), puts the commits
it found in the run, and marks the run Unlocked actions. A re-run uses the same
commits. Actions nested in an unlocked action are looked up by the runner and recorded
with the run. A uses: pinned to a full 40-character commit needs no lookup, but it’s
still listed as unlocked: without a lock entry there’s no tree to check.
A repository admin can turn on Require locked actions in the repository’s settings,
under Merging (or moru-node repo-policy --require-locked-actions true). Runs whose
workflow uses an action the lock doesn’t list, or a docker:// image without a digest
there, are then refused, with the list and the command to fix it. The runner refuses an
image without a digest that an action uses, too. The check covers the workflow’s own uses:. An action that a locked action uses is locked when ci lock wrote the entry;
otherwise the runner looks it up and the run’s record lists it as unlocked.
The lock covers uses: only. The images of container: and services: aren’t locked,
so pin those by digest (image: postgres:17@sha256:…) if you need them fixed. A Docker
action’s Dockerfile is locked with the action, but the FROM image it builds on isn’t.
A run whose only unlocked reference is a docker:// image is still marked unlocked.
A lock that doesn’t parse refuses every run whose workflow fetches actions or uses ./path actions, with the line and column of the problem. The CI tab shows it above the
workflows.
Reusable workflows#
A job can call a workflow from the same repository:
jobs:
ci:
uses: ./.github/workflows/build.yml
with: { target: release }
secrets: inherit The called workflow’s jobs are added to the run as <job>/<called job>, here ci/test and ci/lint, and its inputs and secrets are mapped as on GitHub. They can call
other workflows in turn, 10 levels deep in all. A required job inside one is named the
same way: checks/ci/test.
Reusable workflows from other repositories (uses: owner/repo/.github/workflows/x.yml@v1)
are refused. Copy the workflow into your repository. A called workflow’s outputs can’t
be read by the calling workflow yet.
ci import keeps these calls in the native files it writes.
Secrets#
A job is given the secrets its steps read as secrets.NAME, from the runner’s ci.toml, the same way a native job lists them
in secrets:. A runner that can’t give a job every secret it reads doesn’t take the job,
and the run page names the missing secret. secrets.GITHUB_TOKEN is never one of them:
it’s empty.
The secret’s name in ci.toml is the name the workflow uses. A reusable workflow called
with secrets: { token: ${{ secrets.NPM_TOKEN }} } reads NPM_TOKEN from the runner as
its token; with secrets: inherit, the names stay as they are.
A step reads a secret only through ${{ secrets.NAME }}, as on GitHub. Unlike a native
job, a GitHub job’s secrets aren’t put in the steps’ environment by name.
Caches, artifacts and required jobs#
actions/cache uses the runner’s cache store, which native cache: uses too. A
workflow’s or job’s cache-mode works: read restores and never saves, write-only saves and never restores, none does neither. Runs for changes default to read. See Caches.
Actions that talk to GitHub’s cache service themselves, such as Swatinem/rust-cache,
are fetched and run, but there’s no such service on Moru: they restore and save nothing,
and the job goes on without a cache. Use actions/cache, or a native cache:, with the
paths they would cache (for Rust, ~/.cargo/registry, ~/.cargo/git and target). ci import keeps a Swatinem/rust-cache step and adds a note saying so.
actions/upload-artifact and download-artifact use the run’s artifacts on the node.
See Artifacts.
Required jobs are named <workflow>/<job> as for native workflows: ci/test for the job test in .github/workflows/ci.yml. A job skipped by its own if counts as passed when
the jobs it needs succeeded. See Required jobs.
What’s refused, and what to do instead#
| Refused | Instead |
|---|---|
runs-on: windows-…, shell: pwsh, shell: cmd | Nothing on Moru. A matrix’s Windows combinations are dropped and the rest run. |
environment: | Give the job’s runner the secrets it needs, scoped in ci.toml, and gate the job with if. For deploys, use a deploy runner. |
pull_request_target, workflow_run and GitHub’s other events | pull_request for changes, needs between jobs of one workflow. |
actions/github-script, create-github-app-token, labeler, stale, dependency-review-action, github/codeql-action, softprops/action-gh-release, docker/setup-buildx-action and other actions that use GitHub’s API | A run step that does the work with a token from ci.toml. |
actions/attest*, deploy-pages, and sign-ins with GitHub’s OIDC token (aws-actions/configure-aws-credentials with only role-to-assume, google-github-actions/auth with workload_identity_provider, azure/login with client-id) | Keys from a secret: the same actions take them. |
| Reusable workflows from other repositories | Copy the workflow into .github/workflows/. |
runs-on: { group: … }, snapshot: | Labels. |
Concurrent steps (background, parallel, …), matrices computed from needs | These come in a later version. |
Writing GITHUB_ARTIFACTS or reading github.artifacts | actions/upload-artifact. |
Differences from GitHub#
Things that run, but not quite as they do on GitHub:
- Cancelling. Cancelling a run ends all its jobs at once, so jobs with
if: always()orif: cancelled()don’t run afterwards. When a job is cancelled or times out, its remaining steps don’t run,if: always()ones included, and neither do actions’poststeps.cancelled()is always false. - Superseding. A new revision or push cancels the unfinished jobs of the run it
replaces, whatever
concurrencysays. - Re-runs are new runs:
github.run_idchanges,run_attemptgoes up. Run numbers start again from 1 if the node’s index is ever rebuilt. pull_requesttypesare ignored when they includeopened,synchronizeorreopened: every revision runs. A list with none of them, such as[labeled], is refused.- No GitHub token.
GITHUB_TOKENandgithub.tokenare empty, andpermissionsis ignored. - Setup actions install nothing. They check what’s on the runner.
setup-javadoesn’t setJAVA_HOMEfor later steps, andrust-toolchainsetsRUSTUP_TOOLCHAINrather than the user’s default. - Caches are the runner’s own, not shared with other runners. A change’s runs restore
but don’t save unless
cache-modesayswrite. Withlookup-only,actions/cachenever saves. hashFileshashes files in name order, where GitHub follows the file system’s order. The same files can give a different hash than on GitHub; it matters only if you compare keys across the two.- Artifacts.
upload-artifact’sartifact-idoutput is the artifact’s name, andartifact-urlis the run’s page (in a local run, the zip’s path on your machine). A symbolic link in the checkout (or the job’s temporary folder) whose target is outside them is left out of the artifact, with a warning naming the link; GitHub follows it. This keeps a link committed to the repository from uploading files from the runner’s machine. Links that stay inside the checkout are followed, and a folder outside it that you name inpathis uploaded as on GitHub. - Timeouts. A job gets at most 240 minutes; that’s also the default.
- Matrix values. An unquoted
3.10is the number 3.1, as on GitHub. The report notes it: quote it to keep3.10. - Conditions with text around
${{ }}(if: ${{ a }} && b) are read as a string, true whenever it isn’t empty, as on GitHub. The report notes it. run-nameis ignored. Runs are named by their trigger.- Job summaries written to
GITHUB_STEP_SUMMARYaren’t shown yet.
In containers:
- Same paths, not
/__w. A job container sees the job’s folders at the same paths as the runner’s machine, soGITHUB_WORKSPACEandRUNNER_TEMPare the machine’s paths. GitHub mounts them under/__w. A workflow that hard-codes/__w/...needs changing. - One workspace per repository. As on GitHub, every job of a repository gets the same
GITHUB_WORKSPACE,<work-dir>/<owner>/<name>, so a build from one job (a nextest archive, say) runs in another. Across machines that holds when their runners share one--work-dir. A runner runs one job of a repository at a time; see Where a job runs. RUNNER_OSis the runner’s own OS, somacOSon a Mac, even in a Linux container. GitHub has no containers on macOS.HOMEin a job container is the image’s own. Docker actions get/github/home, as on GitHub.- Ports are published on
127.0.0.1only, never on every interface.-pand--publishinoptionsare refused; list ports inports:. - Pulls. If a pull fails and the image is already on the machine, that one is used, with a warning in the log.
- Timeouts. When a step in a job container times out, its process gets
SIGTERM, thenSIGKILLafter 10 seconds. A process the step started that moved to a group of its own can keep running until the job’s container is removed at the end of the job. with.argsandwith.entrypointare used for a Docker action only when itsaction.ymlhas noargsorentrypoint, as GitHub’s runner does. For auses: docker://…step they’re always used.with.argsthat doesn’t split like a shell command line is split at spaces, with a note.- No Docker socket. Docker actions don’t get
/var/run/docker.sockmounted. Mount it inoptionsyourself if a job needs it. - Read-only actions. A job container sees the runner’s copies of fetched actions read-only.
- Variables that point at the machine. Docker actions don’t get
RUNNER_TEMP,RUNNER_TOOL_CACHE,GITHUB_ACTION_PATHorMORU_OUTPUT, which name folders the action’s container doesn’t see. - Logins.
credentialswith only one ofusernameandpasswordis skipped with a note, and the image is pulled without a login, as on GitHub. - Non-root images. Files a container wrote as root are given back to the runner’s user
when the job ends. An image whose
USERisn’t root gets the job’s temporary folder and command files opened to it, but on rootful Docker on Linux it can’t write to the checkout (or a Docker action to/github/workspace), as on GitHub.
Run a workflow on your machine#
moru-runner ci run reads .github/workflows/ too, with the same expressions, actions,
caches and artifacts. Jobs’ if, continue-on-error and strategy.fail-fast work as
they do on a node, and --input name=value gives a manual run its workflow_dispatch inputs. Actions in .moru/actions.lock run at their locked
commits, and --offline runs only those, from the cache. A local run’s caches are kept
apart from a runner’s. Services, job containers and Docker actions use your docker or podman. See ci run.
Moving to Moru’s format#
Workflows in .github/workflows/ keep running as they are. To switch to native
workflows, run moru-runner ci import in your checkout:
moru-runner ci import # every workflow in .github/workflows/
moru-runner ci import ci # just ci.yml It writes .moru/workflows/<name>.yml for each workflow, with the same file name and
job IDs, so required jobs (ci/test) keep their names. Each file starts with how many
TODOs it has, and # Note: lines for what changed without losing anything, such as concurrency being dropped.
What maps: push, pull_request (as change), schedule and workflow_dispatch (as manual, with its inputs) and their branch and path filters; env, runs-on, needs, timeout-minutes, plain matrices, container and services, the secrets a job reads,
and uses: steps with plain with: values. A job without timeout-minutes gets timeout: 4h (GitHub’s default is 6 hours; Moru’s limit is 4), and run: steps without
a shell now run with pipefail, so a pipeline fails when any command in it does; each
file’s # Note: lines say so. In run: scripts, ${{ matrix.k }}, ${{ env.X }}, ${{ secrets.X }}, ${{ inputs.x }}, ${{ needs.j.outputs.k }} and github.sha, ref, ref_name, repository and run_id become the variables a
native step gets. A job if that checks the event, the ref or the base branch becomes when:.
Everything else gets a # TODO: comment with the reason:
- A step that can’t be mapped stays in the file as a comment, and in its place is a step
that fails:
echo "moru: this step needs porting (see the TODO above)"; exit 1. Fixing the TODO means writing the replacement and deleting that failing step. - A job whose
ifcan’t be written aswhen:, or that has anenvironment:, gets that failing step first, a guard: dropping a deploy job’s condition would otherwise run it on every push.
An imported workflow fails rather than silently skip what it couldn’t carry over. The
import checks each file with the native reader on its own before writing it: a file that
wouldn’t read is skipped and reported, and the others are still written. It refuses to
overwrite a file in .moru/workflows/ without --force.
A job that calls a reusable workflow of the repository stays a call: uses: ./.github/workflows/build.yml becomes uses: ./.moru/workflows/build.yml, and build.yml is imported too, with workflow_call as a call trigger and its inputs.
The called jobs keep their required-job names (ci/build/compile). In with:, ${{ inputs.x }} becomes {input.x} and ${{ matrix.k }} becomes {matrix.k}; any
other expression gets a TODO and a placeholder value. secrets: inherit is dropped,
since a called job gets its secrets from the runner by name, and a secret passed under
another name gets a TODO. A calling job can’t hold the failing guard step, so one whose if can’t be written as when:, or whose matrix has an exclude, becomes a job to
port, and so does a call to a workflow in another repository. See Calling a workflow.
A few things differ from GitHub, and the import notes each one in the file it writes:
- Empty inputs. On GitHub,
${{ inputs.x }}is empty in a push run. Natively,{input.x}gets the input’s default there. - One type per input. A native file gives each input one type. An input that
workflow_dispatchdeclares as achoiceandworkflow_callas astringbecomes thechoice. One declared with other clashing types is left out ofcall, with a TODO. - Matrix keys. A calling job’s matrix key that the called jobs’ matrix also has is
renamed
<job>-<key>, since a called job has one value per key.
If you import only the calling file, the import warns that the file it calls isn’t in .moru/workflows/ and names the command that imports it. After writing, the import
also expands each call the way Moru will, and prints anything that would refuse the run
as a warning with its file, line and column.
With --flatten, the jobs of a reusable workflow become jobs of the file that calls it
instead, and a file that is only a reusable workflow isn’t written. That changes their
required-job names (ci/build/compile becomes ci/compile), and the import prints
each name that changes: update Required CI jobs, under Merging in the
repository’s settings, to match.
Once .moru/workflows/ has a file, .github/workflows/ stops running on Moru. If you
import only some workflows, the import lists the ones that stop. Commit the new files in
one change, run each job with moru-runner ci run, and keep .github/workflows/ if
GitHub still runs them.
On the CI tab of a repository that runs GitHub workflows, people with write access see Move CI to Moru’s format. It opens a new request with the steps above and their acceptance criteria filled in, ready to hand to an agent or a person.
See ci import for its flags and exit codes.