@@ -191,10 +191,29 @@ Notes, rationale blocks, and appendices are **informative** and carry no conform
 **MUST** be rejected at compile time with a descriptive error.
 
 **R-SCHEMA-003**: Every key in the `experiments` map, except the reserved `storage` key
-(§7.1), **MUST** be an experiment name that matches the regular expression
+(§7.1) and `identity` key (§4.1.1), **MUST** be an experiment name that matches the regular expression
 `^[a-zA-Z_][a-zA-Z0-9_]*$`. Keys that do not match **MUST** be silently skipped with a
 compile-time warning emitted to stderr.
 
+#### 4.1.1 Experiment History Identity
+
+The reserved `identity` key **MUST** accept one of `full`, `frontmatter`, or
+`workflow`. If omitted or unrecognized, implementations **MUST** use
+`frontmatter`.
+
+| Value | Fingerprint |
+|---|---|
+| `full` | Compiler freshness hash and complete workflow body hash |
+| `frontmatter` | SHA-256 of normalized workflow frontmatter text, excluding the markdown body |
+| `workflow` | Workflow ID derived from the workflow filename |
+
+The default `frontmatter` mode **MUST** preserve history across body-only edits,
+including workflows that inline imports or use body template expressions.
+`full` **MUST** create a new identity when the workflow body changes.
+`workflow` **MUST** preserve identity across frontmatter and body edits to the
+same workflow ID. Identity selection **MUST NOT** change the immutable source
+revision used to route work to a worker.
+
 > **Note (informative)**: The identifier pattern ensures experiment names can be used as
 > GitHub Actions step output names and embedded in `${{ experiments.<name> }}` expressions
 > without bracket notation.
 
@@ -37,6 +37,7 @@ on:
 engine: copilot
 
 experiments:
+  identity: frontmatter # full, frontmatter (default), or workflow
   style: [concise, detailed]
 ---
 
@@ -101,6 +102,23 @@ by variant.
 > underscore, followed by letters, digits, or underscores. For example, use
 > `style` or `feature_1`. Names that do not match this pattern are ignored.
 
+### Choosing experiment history identity
+
+The reserved `identity` key controls when experiment history is considered to
+belong to a new workflow evaluation:
+
+| Value | Identity fingerprint |
+|---|---|
+| `full` | Compiler freshness hash plus the complete workflow body hash. Prompt or imported-body changes start a new history. |
+| `frontmatter` (default) | SHA-256 of the normalized workflow frontmatter text only. Body-only edits keep the same history. |
+| `workflow` | Workflow ID derived from the workflow filename. Frontmatter and body edits keep the same history. |
+
+For example, set `experiments.identity: full` when every prompt revision should
+be evaluated as a separate harness. Use `workflow` only when history should span
+all revisions of that workflow. This choice affects experiment-history grouping;
+it does not change the immutable source revision used to route a dispatched
+worker.
+
 ## Using variants in the prompt
 
 Reference a variant with `${{ experiments.<name> }}`. At runtime, gh-aw
 
@@ -1205,15 +1205,19 @@ bounded operation are specified in section 7.17.
 | Implementation conformance | Runtime/operator codecs, selector, publisher, binder, and recovery enforce the same contract on real APIs | Native implementations and source-hashed exact conformance results exist; compiler/effects integration and supported-host evidence remain incomplete as tracked in section 9.1 |
 | Operational evidence | Reproducible source/tool identities and explicit passed/violation/incomplete verdicts | Exhausted finite cases are documented separately from two unfinished searches; artifact collection is not a proof |
 
-For workflow evaluation identity, use the compiled frontmatter SHA alone.
-Prompt-body changes are routine minor revisions: a changed body hash does not
-create a new evaluation identity or require repeating the entire protocol
-verification suite. Retain the body hash as provenance when available. This
-does not replace the immutable Git revision required to dispatch and
-authenticate an approved worker route, nor does it waive focused validation
-of changed behavior or the protocol-safety acceptance cases below. The
+Workflow authors may choose the fingerprint scope used for experiment
+evaluation identity: `full` (compiler freshness and complete body hashes),
+`frontmatter` (the default, a pure frontmatter hash), or `workflow` (workflow
+ID). In the default mode, prompt-body changes are routine minor revisions: a
+changed body hash does not create a new evaluation identity or require
+repeating the entire protocol verification suite. Retain the body hash as
+provenance when available. This choice does not replace the immutable Git
+revision required to dispatch and authenticate an approved worker route, nor
+does it waive focused validation of changed behavior or the protocol-safety
+acceptance cases below. The
 [formal model](../../../../../specs/work-queue/README.md#evaluation-identity-and-worker-routing)
-checks this separation and the immutability of a dispatched worker's revision.
+checks all three identity scopes and the immutability of a dispatched worker's
+revision.
 
 The scheduler admits the largest **fair prefix** allowed by the request and
 capacity limits. It does not promise to fill every physically idle slot.
 
@@ -1,6 +1,8 @@
 package workflow
 
 import (
+	"crypto/sha256"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"math"
@@ -34,12 +36,26 @@ const (
 	ExperimentsStorageRepo ExperimentStorageMode = "repo"
 )
 
+// ExperimentIdentityMode controls which workflow fingerprint scopes experiment history.
+type ExperimentIdentityMode string
+
+const (
+	// ExperimentsIdentityFull includes compiler freshness and body hashes.
+	ExperimentsIdentityFull ExperimentIdentityMode = "full"
+	// ExperimentsIdentityFrontmatter hashes only the workflow's frontmatter text.
+	ExperimentsIdentityFrontmatter ExperimentIdentityMode = "frontmatter"
+	// ExperimentsIdentityWorkflow uses the workflow identifier without content hashes.
+	ExperimentsIdentityWorkflow ExperimentIdentityMode = "workflow"
+)
+
 // experimentsBranchPrefix is the git branch prefix used when storage: repo is selected.
 // Branches are named "experiments/{sanitizedWorkflowID}".
 const experimentsBranchPrefix = "experiments"
 
-// experimentsStorageReservedKey is the reserved key in the experiments map that controls storage mode.
-const experimentsStorageReservedKey = "storage"
+const (
+	experimentsStorageReservedKey  = "storage"
+	experimentsIdentityReservedKey = "identity"
+)
 
 // experimentNamePattern validates experiment names as identifier-style keys.
 // Experiment names must match [a-zA-Z_][a-zA-Z0-9_]* so they can be used
@@ -74,8 +90,8 @@ func extractExperimentConfigsFromFrontmatter(frontmatter map[string]any) map[str
 	}
 	result := make(map[string]*ExperimentConfig, len(rawMap))
 	for name, val := range rawMap {
-		// "storage" is a reserved key that controls persistence mode, not an experiment name.
-		if name == experimentsStorageReservedKey {
+		// These reserved keys configure experiment behavior, not experiment names.
+		if name == experimentsStorageReservedKey || name == experimentsIdentityReservedKey {
 			continue
 		}
 		if !experimentNamePattern.MatchString(name) {
@@ -119,6 +135,27 @@ func extractExperimentsStorageFromFrontmatter(frontmatter map[string]any) Experi
 	return ExperimentsStorageRepo
 }
 
+// extractExperimentsIdentityFromFrontmatter reads the identity mode from the experiments
+// map. Frontmatter identity is the default to keep routine prompt edits from resetting history.
+func extractExperimentsIdentityFromFrontmatter(frontmatter map[string]any) ExperimentIdentityMode {
+	raw, ok := frontmatter["experiments"].(map[string]any)
+	if !ok {
+		return ExperimentsIdentityFrontmatter
+	}
+	if identityRaw, ok := raw[experimentsIdentityReservedKey]; ok {
+		if identity, ok := identityRaw.(string); ok {
+			mode := ExperimentIdentityMode(identity)
+			switch mode {
+			case ExperimentsIdentityFull, ExperimentsIdentityFrontmatter, ExperimentsIdentityWorkflow:
+				return mode
+			default:
+				experimentsLog.Printf("Unknown experiments identity %q; falling back to %q", identity, ExperimentsIdentityFrontmatter)
+			}
+		}
+	}
+	return ExperimentsIdentityFrontmatter
+}
+
 // experimentsBranchName returns the git branch name used for repo-based experiment storage.
 // Format: "experiments/{sanitizedWorkflowID}"
 func experimentsBranchName(workflowID string) string {
@@ -685,10 +722,31 @@ func (c *Compiler) generatePickExperimentStep(data *WorkflowData, experimentName
 }
 
 func experimentHarnessVersion(data *WorkflowData) string {
-	if data.FrontmatterHash == "" {
+	if data == nil {
+		return "unknown"
+	}
+	switch data.ExperimentsIdentity {
+	case ExperimentsIdentityFull:
+		if data.FrontmatterHash == "" || data.BodyHash == "" {
+			return "unknown"
+		}
+		return data.FrontmatterHash + ":" + data.BodyHash
+	case ExperimentsIdentityWorkflow:
+		if data.WorkflowID == "" {
+			return "unknown"
+		}
+		return data.WorkflowID
+	default:
+		frontmatter := strings.TrimSpace(strings.ReplaceAll(data.FrontmatterYAML, "\r\n", "\n"))
+		if frontmatter != "" {
+			hash := sha256.Sum256([]byte(frontmatter))
+			return hex.EncodeToString(hash[:])
+		}
+		if data.FrontmatterHash != "" {
+			return data.FrontmatterHash
+		}
 		return "unknown"
 	}
-	return data.FrontmatterHash
 }
 
 // generateExperimentArtifactUploadStep generates the artifact upload step shared by both storage modes.
 
@@ -3,6 +3,7 @@
 package workflow
 
 import (
+	"bytes"
 	"encoding/json"
 	"os"
 	"path/filepath"
@@ -171,12 +172,75 @@ func TestGenerateExperimentSteps_SpecJSON(t *testing.T) {
 
 func TestExperimentHarnessVersionUsesOnlyFrontmatterHash(t *testing.T) {
 	assert.Equal(t, "frontmatter-hash", experimentHarnessVersion(&WorkflowData{FrontmatterHash: "frontmatter-hash", BodyHash: "body-hash"}))
-	assert.Equal(t, "frontmatter-hash", experimentHarnessVersion(&WorkflowData{FrontmatterHash: "frontmatter-hash", BodyHash: "different-body"}))
+	frontmatter := "experiments:\n  style: [short, long]"
+	assert.Equal(t,
+		experimentHarnessVersion(&WorkflowData{FrontmatterYAML: frontmatter, FrontmatterHash: "frontmatter-hash", BodyHash: "body-hash"}),
+		experimentHarnessVersion(&WorkflowData{FrontmatterYAML: frontmatter, FrontmatterHash: "changed-by-inline-body", BodyHash: "different-body"}),
+		"pure frontmatter identity must ignore compiler freshness and body hashes",
+	)
 	assert.Equal(t, "frontmatter-hash", experimentHarnessVersion(&WorkflowData{FrontmatterHash: "frontmatter-hash"}))
 	assert.Equal(t, "unknown", experimentHarnessVersion(&WorkflowData{BodyHash: "body-hash"}))
 	assert.Equal(t, "unknown", experimentHarnessVersion(&WorkflowData{}))
 }
 
+func TestExperimentHarnessVersionIdentityModes(t *testing.T) {
+	base := &WorkflowData{
+		WorkflowID:          "daily-fact",
+		FrontmatterYAML:     "experiments:\n  style: [short, long]",
+		FrontmatterHash:     "compiler-freshness-hash",
+		BodyHash:            "body-hash",
+		ExperimentsIdentity: ExperimentsIdentityFrontmatter,
+	}
+	frontmatterVersion := experimentHarnessVersion(base)
+	bodyEdit := *base
+	bodyEdit.FrontmatterHash = "freshness-hash-changed-by-body"
+	bodyEdit.BodyHash = "different-body-hash"
+	assert.Equal(t, frontmatterVersion, experimentHarnessVersion(&bodyEdit))
+
+	full := *base
+	full.ExperimentsIdentity = ExperimentsIdentityFull
+	fullVersion := experimentHarnessVersion(&full)
+	full.BodyHash = "different-body-hash"
+	assert.NotEqual(t, fullVersion, experimentHarnessVersion(&full))
+
+	workflow := *base
+	workflow.ExperimentsIdentity = ExperimentsIdentityWorkflow
+	assert.Equal(t, "daily-fact", experimentHarnessVersion(&workflow))
+	workflow.BodyHash = "different-body-hash"
+	workflow.FrontmatterHash = "different-frontmatter-hash"
+	assert.Equal(t, "daily-fact", experimentHarnessVersion(&workflow))
+}
+
+func TestCompileWorkflowFrontmatterIdentityIgnoresInlinedBodyEdits(t *testing.T) {
+	compile := func(body string) string {
+		t.Helper()
+		dir := t.TempDir()
+		workflowPath := filepath.Join(dir, "harness.md")
+		content := `---
+on: workflow_dispatch
+strict: false
+engine: copilot
+inlined-imports: true
+experiments:
+  style: [short, long]
+---
+
+` + body + "\n"
+		require.NoError(t, os.WriteFile(workflowPath, []byte(content), 0600))
+		require.NoError(t, NewCompiler().CompileWorkflow(workflowPath))
+		lock, err := os.ReadFile(filepath.Join(dir, "harness.lock.yml"))
+		require.NoError(t, err)
+		const marker = "GH_AW_HARNESS_VERSION: "
+		lineStart := bytes.Index(lock, []byte(marker))
+		require.NotEqual(t, -1, lineStart, "compiled workflow should expose the experiment identity")
+		lineEnd := bytes.IndexByte(lock[lineStart:], '\n')
+		require.NotEqual(t, -1, lineEnd, "compiled identity should end at a newline")
+		return strings.TrimSpace(string(lock[lineStart+len(marker) : lineStart+lineEnd]))
+	}
+
+	assert.Equal(t, compile("First prompt body."), compile("Revised prompt body."))
+}
+
 func TestGenerateExperimentSteps_SingleQuoteEscaping(t *testing.T) {
 	c := &Compiler{}
 	data := &WorkflowData{
@@ -691,17 +755,38 @@ func TestExperimentsBranchName(t *testing.T) {
 
 // ── storage key is excluded from experiment configs ───────────────────────
 
-func TestExtractExperimentConfigsFromFrontmatter_StorageKeyIsSkipped(t *testing.T) {
+func TestExtractExperimentConfigsFromFrontmatter_ReservedKeysAreSkipped(t *testing.T) {
 	frontmatter := map[string]any{
 		"experiments": map[string]any{
-			"storage": "repo",
-			"my_exp":  []any{"A", "B"},
+			"storage":  "repo",
+			"identity": "frontmatter",
+			"my_exp":   []any{"A", "B"},
 		},
 	}
 	got := extractExperimentConfigsFromFrontmatter(frontmatter)
 	require.NotNil(t, got, "experiment configs should not be nil")
 	assert.Contains(t, got, "my_exp", "my_exp should be present")
 	assert.NotContains(t, got, "storage", "storage key should be excluded from experiment configs")
+	assert.NotContains(t, got, "identity", "identity key should be excluded from experiment configs")
+}
+
+func TestExtractExperimentsIdentityFromFrontmatter(t *testing.T) {
+	tests := []struct {
+		name        string
+		frontmatter map[string]any
+		want        ExperimentIdentityMode
+	}{
+		{name: "defaults to frontmatter", frontmatter: map[string]any{}, want: ExperimentsIdentityFrontmatter},
+		{name: "full", frontmatter: map[string]any{"experiments": map[string]any{"identity": "full"}}, want: ExperimentsIdentityFull},
+		{name: "frontmatter", frontmatter: map[string]any{"experiments": map[string]any{"identity": "frontmatter"}}, want: ExperimentsIdentityFrontmatter},
+		{name: "workflow", frontmatter: map[string]any{"experiments": map[string]any{"identity": "workflow"}}, want: ExperimentsIdentityWorkflow},
+		{name: "unknown defaults to frontmatter", frontmatter: map[string]any{"experiments": map[string]any{"identity": "other"}}, want: ExperimentsIdentityFrontmatter},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, extractExperimentsIdentityFromFrontmatter(tt.frontmatter))
+		})
+	}
 }
 
 func TestParseExperimentMetricEvalReference(t *testing.T) {
 
@@ -647,6 +647,7 @@ func (c *Compiler) extractAdditionalConfigurations( //nolint:largefunc // Existi
 	workflowData.ExperimentConfigs = extractExperimentConfigsFromFrontmatter(frontmatter)
 	workflowData.Experiments = experimentVariantsFromConfigs(workflowData.ExperimentConfigs)
 	workflowData.ExperimentsStorage = extractExperimentsStorageFromFrontmatter(frontmatter)
+	workflowData.ExperimentsIdentity = extractExperimentsIdentityFromFrontmatter(frontmatter)
 
 	// Rewrite ${{ experiments.<name> }} references that ended up in engine.model (e.g.
 	// `engine: { model: ${{ experiments.model }} }`) so the compiled workflow reads the
 
@@ -210,6 +210,7 @@ type WorkflowData struct {
 	Experiments                    map[string][]string             // A/B testing experiments: maps experiment name to variant list (from frontmatter)
 	ExperimentConfigs              map[string]*ExperimentConfig    // Full A/B experiment metadata (populated alongside Experiments)
 	ExperimentsStorage             ExperimentStorageMode           // "cache" or "repo" (default "repo"); controls how experiment state is persisted across runs
+	ExperimentsIdentity            ExperimentIdentityMode          // "full", "frontmatter" (default), or "workflow"; controls experiment history identity across runs
 	CachedConcurrencyGroupExprSet  bool                            // true once CachedConcurrencyGroupExprErr has been populated; distinguishes "valid (nil)" from "not yet computed"
 	CachedParsedToolsets           []string                        // cached result of ParseGitHubToolsets for the GitHub tool (for performance optimization); populated by applyDefaults
 	CachedAllowedDomainsStr        string                          // cached allowed-domains string for sanitization (for performance optimization); computed once and reused across multiple compilation steps
 
@@ -2,13 +2,16 @@ SPECIFICATION Spec
 CONSTANTS
     FrontmatterHashes = {"fm-1", "fm-2"}
     BodyHashes = {"body-1", "body-2"}
+    FreshnessHashes = {"fresh-1", "fresh-2", "fresh-3"}
+    WorkflowIDs = {"workflow-a"}
+    IdentityModes = {"full", "frontmatter", "workflow"}
     Revisions = {"rev-1", "rev-2", "rev-3"}
     Workers = {"worker-1", "worker-2"}
     None = "none"
 INVARIANT TypeOK
-INVARIANT EvaluationIdentityIsFrontmatter
-PROPERTY BodyEditPreservesIdentity
-PROPERTY FrontmatterEditUpdatesIdentity
+INVARIANT EvaluationIdentityUsesConfiguredMode
+PROPERTY BodyEditIdentityBehavior
+PROPERTY FrontmatterEditIdentityBehavior
 PROPERTY DispatchCapturesCurrentRevision
 PROPERTY DispatchBindingsAreImmutable
 CHECK_DEADLOCK FALSE