Create a new memory entry with context

Check if the index is empty

Check if the knowledge directory exists

Save a stage to disk Serializes the stage to YAML frontmatter + markdown body and writes to `.work/stages/`. Uses depth-prefixed filenames (e.g., `01

Load a stage from disk Finds and reads the stage file from `.work/stages/`, handling both prefixed (e.g., `01-stage-id.md`) and non-prefixed (`stage-

Transition a stage to a new status with validation Loads the stage from `.work/stages/{stage_id}.md`, validates and updates its status using validate

Append content to a knowledge file (knowledge files are append-only)

Trigger dependent stages when a stage is completed Finds all stages that depend on `completed_stage_id` and checks if all their dependencies are now

Branch naming conventions for loom stages Generate loom branch name from stage ID

Clear the current line (status line) before printing a message. This prevents output from being mangled when the status line is being updated.

Save stage state to .work/stages/

Public helpers for submodules

Validate the loom metadata

Build the SYSTEM + USER prompt for the supplied dispute. `plan_path` is the live plan markdown (used to surface acceptance criteria as the agent sees

Remove heartbeat for a stage (when session ends)

Resolve target branch from config value or repo default Uses the provided config branch if available, otherwise falls back to the repository's defaul

Install hook script and its dependencies to temp directory and return path

Atomically read-modify-write a stage file under a single exclusive lock. This is the lost-update-safe alternative to the load → mutate → `save_stage`

Set a stage to an arbitrary status without validation. Use this for simple status updates where no side effects (like updating dependent stages) are

Attempt to transition the stage to a new status with validation. This is the primary method for changing stage status. It validates that the transiti

Run a git command, check for success, and return stdout as a trimmed String. On failure, bails with the full command + directory + exit code + stdout

Execute the map command

Validate the integrity of the work directory

Apply a runtime amendment to a single stage. Steps (all under flock on `.work/plan_versions/.lock`): 1. Resolve `plan_path` (parameter is preferred;

Helper to create a minimal valid stage definition

Get the HEAD commit SHA of a branch Uses `git rev-parse` to resolve the branch name to its HEAD commit SHA. # Arguments `branch` - The branch name t

Resolve the base branch for a stage based on its dependencies. # Logic With progressive merge, stages are only scheduled when all dependencies are `

Write a length-prefixed JSON message to a stream. Format: 4-byte big-endian length prefix + JSON data # Arguments `stream` - The stream to write to

Find a stage file by stage ID, regardless of its depth prefix. Searches for files matching the pattern `*-{stage_id}.md` or `{stage_id}.md` in the st

Run a setup `git` command and assert it succeeded, surfacing stderr on failure. Without this, a failed setup step is swallowed and only manifests late

Write file contents crash-atomically with an exclusive (write) lock. Acquires an exclusive lock on the parent directory, then writes to a sibling `<f

Helper to create minimal valid metadata with given stages

Load and parse config.toml from a work directory # Arguments `work_dir` - Path to the .work directory (not the config file itself) # Returns `Ok(Som

Load a stage from .work/stages/

Test helper: Mark stage as completed in graph

Load stage definition from .work/stages/

Open `work_dir` as a dirfd suitable as a base for the rest of this module. The dirfd has `O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC`; if `work_dir` itself

Extract YAML frontmatter from markdown content and deserialize it. Delegates to [`extract_frontmatter_raw`] for the indentation-aware extraction, the

Generate Claude Code settings JSON from sandbox config

Run all acceptance criteria for a stage with default configuration This is a convenience wrapper around `run_acceptance_with_config` that uses the de

Apply verdict files that haven't been applied yet (no `applied.marker`). Idempotent under crash recovery: a `.applying` marker is written before mutat

Detect session status changes and context levels

Mark the stage as queued with validation. # Returns `Ok(())` if the transition succeeded, `Err` if invalid

Returns the list of valid statuses this status can transition to.

Append an entry to a stage's memory journal

Validates that an ID is safe for use in file paths. An ID is valid if: - It is not empty - It is no longer than MAX_ID_LENGTH characters - It contain

Compute levels for all stages in a collection. Returns a HashMap mapping stage IDs to their computed levels.

Expand all variables in a criterion string. Variables use the format `${VARIABLE_NAME}`. Unknown variables are left unchanged. # Example ```ignore

Test helper: Create a temporary git repository with initial commit

Mark a stage as executing. Validates that the stage is currently in `Queued` status.

Mark a stage as merged to the merge point. This is called after progressive merge verifies and merges a completed stage. After marking as merged, dep

Get the project root (parent of .work directory)

Mark the session as running with validation. # Returns `Ok(())` if the transition succeeded, `Err` if invalid

Validate a bash command for worktree isolation violations. # Arguments `command` - The bash command to validate `current_stage` - The current stage I

Initialize the knowledge directory with default files

List all stages from `.work/stages/` Reads all `.md` files in the stages directory and parses them into Stage structs. # Arguments `work_dir` - Path

Read file contents with a shared (read) lock. Acquires a shared lock on the parent directory before reading, allowing multiple concurrent readers but

Mark a stage as completed and update dependent stages. # Returns A vector of stage IDs that became ready (transitioned to `Queued`) as a result of t

Read a knowledge file

Safely resolves a zip entry path, protecting against zip slip attacks. Returns the safe output path if the entry is valid, or an error if: - The path

Mark the stage as blocked with validation. # Returns `Ok(())` if the transition succeeded, `Err` if invalid

Check if all dependencies of a stage are satisfied A dependency is satisfied if: - Its status is `Completed`, AND - `merged` is true, AND - (non-know

Test helper: Build execution graph from stage definitions

Scan `.work/disputes/<stage>/<n>/` for pending disputes and spawn workers for each. Skips disputes that: - already have a `verdict.md` (worker succee

Test helper: Create a branch with a commit adding a file