2 files changed, 186 insertions, 0 deletions
diff --git a/internal/task/currentattempt.go b/internal/task/currentattempt.go
new file mode 100644
index 0000000..24eed10
--- /dev/null
+++ b/internal/task/currentattempt.go
@@ -0,0 +1,56 @@
+package task
+
+// TaskLookup is the minimal interface CurrentAttempt needs: resolving a
+// task by ID and finding tasks that depend on it. Both
+// internal/executor.Store and internal/scheduler.StoryStore already satisfy
+// this structurally, so CurrentAttempt lives here (in the lowest-level
+// package both already import) rather than being duplicated in each.
+type TaskLookup interface {
+	GetTask(id string) (*Task, error)
+	ListDependents(taskID string) ([]*Task, error)
+}
+
+// maxAttemptChainWalk bounds CurrentAttempt's forward walk as a defense
+// against a pathological/cyclic DependsOn chain (task creation doesn't
+// reject cycles) -- in practice, no caller creates chains anywhere near
+// this long; a much smaller, intentional policy limit (e.g.
+// internal/scheduler's own maxFixAttempts) is what actually bounds real
+// fix-attempt chains in normal operation.
+const maxAttemptChainWalk = 100
+
+// CurrentAttempt resolves the task that currently represents the logical
+// position anchored at anchorID: anchorID itself, or -- if it was rejected
+// and a fix attempt exists -- the fix attempt, walking forward through
+// however many rejections have occurred. A fix-attempt task is identified
+// structurally: a task with the same ParentTaskID as the task it supersedes,
+// whose sole DependsOn entry is that task's own ID -- the exact shape a
+// fix-attempt is spawned with, whether at a story's root (ParentTaskID ==
+// "") or at an arbitrary subtask position (ParentTaskID set). This is the
+// one place "which task is current" is ever decided; callers resolve
+// through this before checking a position's own completion/verdict state,
+// never operating on a raw anchor ID directly once a fix-attempt might
+// exist. See docs/superpowers/specs/2026-07-09-recursive-arbitrated-review-design.md.
+func CurrentAttempt(store TaskLookup, anchorID string) (*Task, error) {
+	current, err := store.GetTask(anchorID)
+	if err != nil {
+		return nil, err
+	}
+	for i := 0; i < maxAttemptChainWalk; i++ {
+		dependents, err := store.ListDependents(current.ID)
+		if err != nil {
+			return nil, err
+		}
+		var next *Task
+		for _, d := range dependents {
+			if d.ParentTaskID == current.ParentTaskID && len(d.DependsOn) == 1 && d.DependsOn[0] == current.ID {
+				next = d
+				break
+			}
+		}
+		if next == nil {
+			return current, nil
+		}
+		current = next
+	}
+	return current, nil
+}
diff --git a/internal/task/currentattempt_test.go b/internal/task/currentattempt_test.go
new file mode 100644
index 0000000..76661d8
--- /dev/null
+++ b/internal/task/currentattempt_test.go
@@ -0,0 +1,130 @@
+package task
+
+import (
+	"errors"
+	"testing"
+)
+
+type fakeLookup struct {
+	tasks map[string]*Task
+}
+
+func newFakeLookup() *fakeLookup {
+	return &fakeLookup{tasks: make(map[string]*Task)}
+}
+
+func (f *fakeLookup) GetTask(id string) (*Task, error) {
+	t, ok := f.tasks[id]
+	if !ok {
+		return nil, errors.New("not found")
+	}
+	return t, nil
+}
+
+func (f *fakeLookup) ListDependents(taskID string) ([]*Task, error) {
+	var out []*Task
+	for _, t := range f.tasks {
+		for _, d := range t.DependsOn {
+			if d == taskID {
+				out = append(out, t)
+				break
+			}
+		}
+	}
+	return out, nil
+}
+
+func TestCurrentAttempt_NoFixAttempt_ReturnsAnchorItself(t *testing.T) {
+	lookup := newFakeLookup()
+	lookup.tasks["a"] = &Task{ID: "a"}
+
+	got, err := CurrentAttempt(lookup, "a")
+	if err != nil {
+		t.Fatalf("CurrentAttempt: %v", err)
+	}
+	if got.ID != "a" {
+		t.Errorf("got %q, want a", got.ID)
+	}
+}
+
+func TestCurrentAttempt_OneFixAttempt_ResolvesToIt(t *testing.T) {
+	lookup := newFakeLookup()
+	lookup.tasks["a"] = &Task{ID: "a", ParentTaskID: "parent-1"}
+	lookup.tasks["a-fix1"] = &Task{ID: "a-fix1", ParentTaskID: "parent-1", DependsOn: []string{"a"}}
+
+	got, err := CurrentAttempt(lookup, "a")
+	if err != nil {
+		t.Fatalf("CurrentAttempt: %v", err)
+	}
+	if got.ID != "a-fix1" {
+		t.Errorf("got %q, want a-fix1", got.ID)
+	}
+}
+
+func TestCurrentAttempt_ChainOfFixAttempts_ResolvesToTip(t *testing.T) {
+	lookup := newFakeLookup()
+	lookup.tasks["a"] = &Task{ID: "a", ParentTaskID: "parent-1"}
+	lookup.tasks["a-fix1"] = &Task{ID: "a-fix1", ParentTaskID: "parent-1", DependsOn: []string{"a"}}
+	lookup.tasks["a-fix2"] = &Task{ID: "a-fix2", ParentTaskID: "parent-1", DependsOn: []string{"a-fix1"}}
+
+	got, err := CurrentAttempt(lookup, "a")
+	if err != nil {
+		t.Fatalf("CurrentAttempt: %v", err)
+	}
+	if got.ID != "a-fix2" {
+		t.Errorf("got %q, want a-fix2 (tip of the chain)", got.ID)
+	}
+
+	// Resolving from an intermediate link in the chain also lands on the tip.
+	got, err = CurrentAttempt(lookup, "a-fix1")
+	if err != nil {
+		t.Fatalf("CurrentAttempt: %v", err)
+	}
+	if got.ID != "a-fix2" {
+		t.Errorf("resolving from a-fix1: got %q, want a-fix2", got.ID)
+	}
+}
+
+// TestCurrentAttempt_DependentWithDifferentParent_NotTreatedAsFixAttempt
+// proves a task that depends on "a" but has a DIFFERENT ParentTaskID (e.g.
+// an unrelated Evaluator task depending on a Builder for scheduling reasons)
+// must not be mistaken for a's fix attempt.
+func TestCurrentAttempt_DependentWithDifferentParent_NotTreatedAsFixAttempt(t *testing.T) {
+	lookup := newFakeLookup()
+	lookup.tasks["a"] = &Task{ID: "a", ParentTaskID: "parent-1"}
+	lookup.tasks["unrelated"] = &Task{ID: "unrelated", ParentTaskID: "", DependsOn: []string{"a"}}
+
+	got, err := CurrentAttempt(lookup, "a")
+	if err != nil {
+		t.Fatalf("CurrentAttempt: %v", err)
+	}
+	if got.ID != "a" {
+		t.Errorf("got %q, want a (unrelated dependent must not be treated as a fix attempt)", got.ID)
+	}
+}
+
+// TestCurrentAttempt_DependentWithMultipleDependsOn_NotTreatedAsFixAttempt
+// proves a fix attempt has exactly one DependsOn entry (the task it
+// supersedes); a task depending on "a" among several dependencies (e.g. an
+// Arbitration task depending on all 4 Evaluators) must not be mistaken for
+// a's fix attempt.
+func TestCurrentAttempt_DependentWithMultipleDependsOn_NotTreatedAsFixAttempt(t *testing.T) {
+	lookup := newFakeLookup()
+	lookup.tasks["a"] = &Task{ID: "a", ParentTaskID: "parent-1"}
+	lookup.tasks["multi-dep"] = &Task{ID: "multi-dep", ParentTaskID: "parent-1", DependsOn: []string{"a", "b"}}
+
+	got, err := CurrentAttempt(lookup, "a")
+	if err != nil {
+		t.Fatalf("CurrentAttempt: %v", err)
+	}
+	if got.ID != "a" {
+		t.Errorf("got %q, want a", got.ID)
+	}
+}
+
+func TestCurrentAttempt_UnknownAnchor_ReturnsError(t *testing.T) {
+	lookup := newFakeLookup()
+	if _, err := CurrentAttempt(lookup, "does-not-exist"); err == nil {
+		t.Error("expected an error for an unknown anchor ID")
+	}
+}