Artifacts Reference

Crewplane writes project-local state under .crewplane/.

For human inspection, start with Inspecting Run Records. Use this reference when you need exact paths, stable workflow template keys, or skip/resume metadata.

Need	Start with
Human run overview	execution-stages/<run-key>/logs/summary.md
Event timeline	execution-stages/<run-key>/logs/events.ndjson
Skip/resume evidence	execution-stages/<run-key>/manifests/run.json
Final node outputs	execution-results/<run-key>/

Stage directories contain run-local logs, preflight bundles, manifests, and node artifacts. Result directories contain consolidated outputs, findings, and generated files intended for inspection or downstream handoff.

Root Layout

.crewplane/
  config.yml
  workflows/
  preflight/
    fingerprint.key
  locks/
  execution-stages/
  execution-results/

The output directories are hyphenated:

• .crewplane/execution-stages/
• .crewplane/execution-results/

Stage Runs

Each non-dry crewplane run allocates:

.crewplane/execution-stages/<run-key>/
.crewplane/execution-results/<run-key>/

<run-key> is the filesystem directory name for one run. It has the shape <workflow-id>-<run-id>, for example single-agent-review--5e34bc54c79a-20260629-202539.

Stage run contents can include:

logs/events.ndjson
logs/summary.md
preflight/execution-plan.json
preflight/dependency-graph.json
preflight/manifest.json
preflight/metadata.json
preflight/render-plans.json
preflight/execution-bundle.json
preflight/runtime-config-snapshot.json
preflight/static-resources.json
preflight/static-files/*
preflight/summary.md
preflight/token-catalog.json
manifests/run.json
manifests/nodes/*.json
<node-id>/logs/<provider>/*.log
<node-id>/review-state/review-loop-status.json
<node-id>/workspace-state*.json
<node-id>/workspace-setup/*.log
<node-id>/workspace-setup/*.json
<node-id>/workspace-bundles/*.bundle
<node-id>/resume-source.json
workspace-exports/*.json

Exact files depend on node mode and enabled features. Workspace files are present only for Experimental workspace isolation runs.

For review-loop nodes, review-loop-status.json records the executor and reviewer outputs selected when the loop ends. Each entry identifies the provider, task, role, audit round, local round, relative path, file size, and SHA-256 digest. Crewplane verifies both the status details and the referenced files before building the final node artifacts. If verification fails, the node fails.

Results

Consolidated node artifacts are written under the matching result directory:

.crewplane/execution-results/<run-key>/<node-id>-result.md
.crewplane/execution-results/<run-key>/<node-id>-findings.md
.crewplane/execution-results/<run-key>/generated-files/<stage>/<task>/...

Node result filenames use safe, bounded names derived from node IDs. Findings files are present for nodes that declare findings: true. Generated-file artifacts are present when Crewplane detects provider-created files that should be copied into the result tree.

Generated-file ownership depends on the workspace boundary:

• In an isolated managed workspace, Crewplane owns the workspace for the invocation and may capture filesystem changes.
• In the shared project root, Crewplane captures only files explicitly listed by the provider under a ## Generated Files section and verified by Git as changed since the invocation began. Without a usable Git baseline, generated-file capture fails closed.

Snapshot capture limits and snapshot copy failures do not invalidate an otherwise successful provider result. Crewplane preserves the result, captures accepted files, emits an artifact_capture_partial or artifact_capture_failed runtime-log event, and records rejected-file metadata in the generated-file snapshot metadata. Rejection metadata keeps the exact rejected_file_count while bounding detailed rejected_files records to 100; rejected_files_truncated reports whether details were omitted. If later publication into the consolidated result tree fails, Crewplane omits the failed generated-file link, preserves the consolidated result, and emits a stage_finalize_warning event.

Consolidated result and findings Markdown uses human-readable section headings. Stable provider task IDs remain in stage artifact filenames, logs, manifests, and review-loop state.

Stable Keys And Filenames

Workflow template keys are the stable interface for downstream nodes. Human-readable result filenames are stable enough to inspect, but code should prefer workflow template keys or manifest descriptors.

Provider log filenames, task IDs, and review-loop state files are implementation details for debugging and support.

Preflight Files

The root .crewplane/preflight/fingerprint.key stores the fingerprint key used for stable secret fingerprints when it can be persisted. Each executed run also writes a run-local preflight/ directory. Preflight compiles static resources, render plans, dependency edges, token catalog entries, provider records, runtime config snapshots, and the workflow_signature.

Runtime execution consumes compiled preflight artifacts and same-process secret handles. It does not re-read original {{file:...}} source paths.

Manifests

Run and node manifests record status, artifact descriptors, workflow identity, workflow_signature, resumed nodes, and Experimental workspace descriptors when applicable.

Terminal fields in manifests/run.json depend on the run status. Failed and cancelled runs include a nonblank reason, while successful runs include neither a failure nor cancellation reason. For resumed runs, the manifest records the source run together with the nodes restored from it. A node is added to this list only after Crewplane restores its artifacts.

At the end of a run, Crewplane finishes required post-run work and updates the event log and summary before recording the terminal status in manifests/run.json. It releases the run lock only after writing the manifest. A terminal manifest therefore indicates that normal finalization completed.

If Crewplane stops before finalization completes, a later run with the same workflow identity and signature can recover the stale lock. Recovery preserves a recorded terminal outcome when it can verify that outcome. Otherwise, it marks the interrupted run as cancelled with stale_lock_recovered. The event log and summary may be incomplete or show the last state written before the interruption.

Corrupt or untrusted manifests are treated as unusable history for skip/resume decisions.

Duplicate skip decisions reuse a previous successful run only when the recorded workflow_signature, node states, results, findings, retained generated files, sizes, digests, containment, and dependency closure are usable. Crewplane searches older matching successes if the newest success is incomplete or corrupt. Resume decisions use the same artifact validation before hydrating completed node boundaries from a failed or cancelled run into a new run. crewplane run --force bypasses both behaviors and records a new run.

Atomic artifact publication propagates file-data, replacement, and supported directory-sync failures. Crewplane suppresses only platform errors that explicitly mean directory synchronization is unsupported, so an integrity failure is not reported as a successful publication.

Logs

Provider logs are captured when settings.integrations.artifacts.options.log_cli_output is true. Run-level events and summaries are written under the run logs/ directory.

Downstream Artifact Keys

Workflow prompts can reference upstream artifacts with:

• {{node.output}}
• {{node.findings}}
• {{node.output_path}}
• {{node.findings_path}}
• {{node.output_size}}
• {{node.findings_size}}
• {{node.output_sha256}}
• {{node.findings_sha256}}