@@ -0,0 +1 @@
+- Add Nous observation recovery tracking with a seven-day lifecycle, hub-relayed recovery comments, and issue closure.
@@ -20,6 +20,7 @@ import (
 	"github.com/hivecommons/hive/pkg/github"
 	"github.com/hivecommons/hive/pkg/hivestate"
 	"github.com/hivecommons/hive/pkg/hub/spoke"
+	"github.com/hivecommons/hive/pkg/nous"
 )
 
 // Self-report publisher (hivecommons/hive#11868). Each governor cycle it takes
@@ -28,7 +29,7 @@ import (
 //
 //   - dry-run → nothing (preview stays on the dashboard);
 //   - Nous observations → the hub relay only; the spoke GitHub client is never used;
-//   - the API budget is not normal → defer ordinary reports (the report re-emits next cycle);
+//   - the API budget is not normal → defer ordinary reports (observations still relay);
 //   - fingerprint already written by this hive → at most one "also seen"
 //     comment per 24h, otherwise skip;
 //   - fingerprint closed upstream inside the 7-day cooldown → record and skip
@@ -44,6 +45,7 @@ import (
 
 // selfReportHubRelayPath is the hub ingest the spoke falls back to.
 const selfReportHubRelayPath = "/api/selfreport/ingest"
+const selfReportObservationClass = "observation"
 
 // selfReportRelayTimeout bounds one relay POST.
 const selfReportRelayTimeout = 20 * time.Second
@@ -62,10 +64,11 @@ type selfReportRelay func(ctx context.Context, req selfReportRelayRequest) (self
 
 // selfReportRelayRequest is the wire shape shared with pkg/hub.
 type selfReportRelayRequest struct {
+	Action      string                          `json:"action,omitempty"`
 	HiveID      string                          `json:"hive_id"`
 	Fingerprint string                          `json:"fingerprint"`
 	Class       string                          `json:"class,omitempty"`
-	Title       string                          `json:"title"`
+	Title       string                          `json:"title,omitempty"`
 	Body        string                          `json:"body"`
 	Labels      []string                        `json:"labels,omitempty"`
 	Version     string                          `json:"version,omitempty"`
@@ -81,33 +84,36 @@ type selfReportRelayResponse struct {
 	Number int    `json:"number"`
 	URL    string `json:"url"`
 	Joined bool   `json:"joined"`
+	Reason string `json:"reason,omitempty"`
 }
 
 type selfReportPublishDeps struct {
-	dryRun    bool
-	gh        selfReportWriter
-	relay     selfReportRelay
-	repo      string
-	hiveSlug  string
-	version   string
-	cluster   string
-	limits    fleetreport.FilingLimits
-	now       func() time.Time
-	tracker   *fleetreport.RuntimeTracker
-	budgetOK  func() bool
-	hubLinked bool
+	dryRun       bool
+	gh           selfReportWriter
+	relay        selfReportRelay
+	repo         string
+	hiveSlug     string
+	version      string
+	cluster      string
+	limits       fleetreport.FilingLimits
+	now          func() time.Time
+	tracker      *fleetreport.RuntimeTracker
+	budgetOK     func() bool
+	hubLinked    bool
+	observations *nous.ObservationLedger
 }
 
 func newSelfReportPublishDeps(cfg *config.Config, ghClient *github.Client, dashSrv *dashboard.Server) selfReportPublishDeps {
 	version, _ := dashboardBuildInfo()
 	d := selfReportPublishDeps{
-		dryRun:  true,
-		repo:    config.DefaultFleetReportRepo,
-		limits:  fleetreport.DefaultFilingLimits,
-		now:     time.Now,
-		tracker: fleetreport.DefaultTracker(),
-		version: version,
-		cluster: os.Getenv("HIVE_CLUSTER_ID"),
+		dryRun:       true,
+		repo:         config.DefaultFleetReportRepo,
+		limits:       fleetreport.DefaultFilingLimits,
+		now:          time.Now,
+		tracker:      fleetreport.DefaultTracker(),
+		version:      version,
+		cluster:      os.Getenv("HIVE_CLUSTER_ID"),
+		observations: nous.NewObservationLedger(nous.DefaultObservationLedgerPath),
 	}
 	if ghClient != nil {
 		d.gh = ghClient
@@ -158,12 +164,44 @@ func publishFleetReportsWith(ctx context.Context, logger *slog.Logger, dashSrv *
 	}
 	now := deps.now()
 	state := dashSrv.FleetReportState()
+	var observationRecoveries []nous.RecoveryRequest
+	if deps.observations != nil {
+		active := make([]nous.ActiveObservation, 0)
+		for _, report := range res.Reports {
+			if !isObservationReport(report) {
+				continue
+			}
+			before, after := observationBeforeAfter(report)
+			open := state.Open[report.Fingerprint]
+			issueNumber, issueURL := open.Number, open.URL
+			if open.Recovered || !open.ClosedAt.IsZero() {
+				issueNumber, issueURL = 0, ""
+			}
+			active = append(active, nous.ActiveObservation{
+				Fingerprint: report.Fingerprint,
+				IssueNumber: issueNumber,
+				URL:         issueURL,
+				Before:      before,
+				After:       after,
+				Evidence:    report.Body,
+			})
+		}
+		var err error
+		observationRecoveries, err = deps.observations.Reconcile(active, now)
+		if err != nil {
+			logger.Warn("fleet report: observation lifecycle ledger failed", "error", err)
+		}
+	}
 	for _, report := range res.Reports {
-		if !isObservationReport(report) && !budgetNormal {
+		isObservation := isObservationReport(report)
+		if !isObservation && !budgetNormal {
 			logger.Info("fleet report: API budget not normal; deferring non-observation self-report", "fingerprint", report.Fingerprint)
 			continue
 		}
 		open := state.Open[report.Fingerprint]
+		if isObservation && open.Recovered {
+			open = fleetreport.OpenIssue{}
+		}
 		if fleetreport.ClosedRecently(open.ClosedAt, now, deps.limits) {
 			continue
 		}
@@ -174,7 +212,7 @@ func publishFleetReportsWith(ctx context.Context, logger *slog.Logger, dashSrv *
 
 		var write github.FleetReportResult
 		var err error
-		if isObservationReport(report) {
+		if isObservation {
 			// Observations are hub-owned reports. Never fall back to the
 			// spoke's GitHub client, even when it can write another repo.
 			if deps.relay == nil {
@@ -246,6 +284,9 @@ func publishFleetReportsWith(ctx context.Context, logger *slog.Logger, dashSrv *
 		created := write.Created
 		dashSrv.UpdateFleetReportState(func(st *fleetreport.State) {
 			o := st.Open[report.Fingerprint]
+			if isObservation && o.Recovered {
+				o = fleetreport.OpenIssue{}
+			}
 			o.Number, o.URL = write.Number, write.URL
 			o.OpenedByHive = o.OpenedByHive || created
 			o.Joined = o.Joined || write.Joined
@@ -260,11 +301,40 @@ func publishFleetReportsWith(ctx context.Context, logger *slog.Logger, dashSrv *
 				fleetreport.RecordFiling(st, now)
 			}
 		})
+		if isObservationReport(report) && deps.observations != nil && write.Number > 0 {
+			if err := deps.observations.RecordIssue(report.Fingerprint, write.Number, write.URL, now); err != nil {
+				logger.Warn("fleet report: observation issue ledger update failed", "fingerprint", report.Fingerprint, "error", err)
+			}
+		}
 		state = dashSrv.FleetReportState()
 		logger.Info("fleet report: upstream report recorded", "fingerprint", report.Fingerprint, "class", report.Class, "issue", write.Number, "created", created, "joined", write.Joined, "commented", write.Commented, "body_updated", write.BodyUpdated)
 	}
 
+	for _, recovery := range observationRecoveries {
+		report := fleetreport.Report{
+			Fingerprint: recovery.Fingerprint,
+			Trigger:     selfReportObservationClass,
+			Class:       selfReportObservationClass,
+			Body:        recovery.Comment,
+		}
+		if _, err := relayObservationRecovery(ctx, deps, report); err != nil {
+			logger.Warn("fleet report: observation recovery relay failed", "fingerprint", recovery.Fingerprint, "issue", recovery.IssueNumber, "error", err)
+			continue
+		}
+		if deps.observations != nil {
+			if err := deps.observations.MarkClosed(recovery.Fingerprint, now); err != nil {
+				logger.Warn("fleet report: observation close ledger update failed", "fingerprint", recovery.Fingerprint, "error", err)
+				continue
+			}
+		}
+		dashSrv.MarkFleetReportRecovered(recovery.Fingerprint)
+		logger.Info("fleet report: observation recovery recorded", "fingerprint", recovery.Fingerprint, "issue", recovery.IssueNumber)
+	}
 	for _, report := range res.Recoveries {
+		if isObservationReport(report) {
+			// Observation recovery is gated by the durable seven-day ledger above.
+			continue
+		}
 		open, ok := state.Open[report.Fingerprint]
 		if !ok {
 			continue
@@ -346,6 +416,38 @@ func firstEvidence(report fleetreport.Report) fleetreport.Evidence {
 	return fleetreport.Evidence{}
 }
 
+func observationBeforeAfter(report fleetreport.Report) (string, string) {
+	const seriesPrefix = "| series | `"
+	start := strings.Index(report.Body, seriesPrefix)
+	if start < 0 {
+		return "", ""
+	}
+	seriesStart := start + len(seriesPrefix)
+	seriesEnd := strings.IndexByte(report.Body[seriesStart:], '`')
+	if seriesEnd < 0 {
+		return "", ""
+	}
+	var series []float64
+	if err := json.Unmarshal([]byte(report.Body[seriesStart:seriesStart+seriesEnd]), &series); err != nil || len(series) < 2 {
+		return "", ""
+	}
+	return fmt.Sprintf("%g", series[0]), fmt.Sprintf("%g", series[len(series)-1])
+}
+
+func relayObservationRecovery(ctx context.Context, deps selfReportPublishDeps, report fleetreport.Report) (selfReportRelayResponse, error) {
+	if deps.relay == nil {
+		return selfReportRelayResponse{}, errSelfReportObservationNoRelay
+	}
+	return deps.relay(ctx, selfReportRelayRequest{
+		Action:      "recover",
+		HiveID:      deps.hiveSlug,
+		Fingerprint: report.Fingerprint,
+		Class:       selfReportObservationClass,
+		Body:        report.Body,
+		Repo:        config.DefaultFleetReportRepo,
+	})
+}
+
 // selfReportShouldRelay: a 403/404 from the report repo means this hive's
 // credential cannot write there (self-hosted PAT scoped to its own repos, or
 // the App not installed on the report org). Anything else is a real error.
@@ -394,7 +496,7 @@ func hubSelfReportRelay(hubURL string, bearer func() string) selfReportRelay {
 		if err := json.Unmarshal(raw, &out); err != nil {
 			return selfReportRelayResponse{}, err
 		}
-		if !out.OK {
+		if !out.OK && req.Action != "recover" {
 			return selfReportRelayResponse{}, errors.New("hub declined the self-report")
 		}
 		return out, nil
 
@@ -15,6 +15,7 @@ import (
 	"github.com/hivecommons/hive/pkg/dashboard"
 	"github.com/hivecommons/hive/pkg/fleetreport"
 	"github.com/hivecommons/hive/pkg/github"
+	"github.com/hivecommons/hive/pkg/nous"
 )
 
 // fakeSelfReportWriter scripts the GitHub seam the publisher drives.
@@ -273,3 +274,98 @@ func TestSelfReportShouldRelay(t *testing.T) {
 		}
 	}
 }
+
+func TestPublishObservationRecoveryUnknownHubIssueIsNoop(t *testing.T) {
+	srv := selfReportTestServer(t)
+	now := time.Date(2026, 9, 24, 12, 0, 0, 0, time.UTC)
+	fp := "observation-recovery"
+	ledger := nous.NewObservationLedger(filepath.Join(t.TempDir(), "observations.json"))
+	if _, err := ledger.Reconcile([]nous.ActiveObservation{{
+		Fingerprint: fp,
+		IssueNumber: 42,
+		URL:         "https://github.com/hivecommons/hive/issues/42",
+		Before:      "p90=900ms",
+		After:       "p90=100ms",
+		Evidence:    "last sample",
+	}}, now); err != nil {
+		t.Fatal(err)
+	}
+	if err := ledger.RecordIssue(fp, 42, "https://github.com/hivecommons/hive/issues/42", now); err != nil {
+		t.Fatal(err)
+	}
+	srv.UpdateFleetReportState(func(st *fleetreport.State) {
+		st.Open[fp] = fleetreport.OpenIssue{
+			Number: 42, URL: "https://github.com/hivecommons/hive/issues/42",
+			Trigger: selfReportObservationClass, Class: selfReportObservationClass, PostedAt: now,
+		}
+	})
+	w := &fakeSelfReportWriter{}
+	var relayed []selfReportRelayRequest
+	deps := selfReportDeps(w, &now)
+	deps.observations = ledger
+	deps.relay = func(_ context.Context, req selfReportRelayRequest) (selfReportRelayResponse, error) {
+		relayed = append(relayed, req)
+		return selfReportRelayResponse{Reason: "unknown_fingerprint"}, nil
+	}
+	// The first cycle without the finding starts the seven-day window; the
+	// recovery request is produced only by a later cycle past that window.
+	publishFleetReportsWith(context.Background(), slog.Default(), srv, &fleetreport.Result{}, deps)
+	if len(relayed) != 0 {
+		t.Fatalf("recovery relayed before the seven-day window: %#v", relayed)
+	}
+	now = now.Add(8 * 24 * time.Hour)
+	publishFleetReportsWith(context.Background(), slog.Default(), srv, &fleetreport.Result{}, deps)
+	if len(relayed) != 1 {
+		t.Fatalf("recovery relays = %d, want 1", len(relayed))
+	}
+	if relayed[0].Action != "recover" || relayed[0].Class != selfReportObservationClass || !strings.Contains(relayed[0].Body, "p90=900ms") || !strings.Contains(relayed[0].Body, "p90=100ms") {
+		t.Fatalf("recovery relay = %#v", relayed[0])
+	}
+	records, err := ledger.Records()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if records[fp].ClosedAt.IsZero() {
+		t.Fatalf("unknown hub fingerprint was not acknowledged locally: %#v", records[fp])
+	}
+	if !srv.FleetReportState().Open[fp].Recovered {
+		t.Fatal("dashboard state did not record observation recovery")
+	}
+}
+
+func TestPublishObservationReportsRelayThroughHubOnly(t *testing.T) {
+	srv := selfReportTestServer(t)
+	now := time.Date(2026, 9, 24, 12, 0, 0, 0, time.UTC)
+	fp := "h1:queue-growth"
+	ledger := nous.NewObservationLedger(filepath.Join(t.TempDir(), "observations.json"))
+	w := &fakeSelfReportWriter{ensure: func(fleetreport.Report, github.FleetReportOptions) (github.FleetReportResult, error) {
+		t.Fatal("observation used the spoke GitHub writer")
+		return github.FleetReportResult{}, nil
+	}}
+	var relayed []selfReportRelayRequest
+	deps := selfReportDeps(w, &now)
+	deps.observations = ledger
+	deps.budgetOK = func() bool { return false }
+	deps.relay = func(_ context.Context, req selfReportRelayRequest) (selfReportRelayResponse, error) {
+		relayed = append(relayed, req)
+		return selfReportRelayResponse{OK: true, Number: 7, URL: "https://github.com/hivecommons/hive/issues/7"}, nil
+	}
+	report := fleetreport.Report{
+		Fingerprint: fp,
+		Trigger:     selfReportObservationClass,
+		Class:       selfReportObservationClass,
+		Title:       "Queue depth is growing",
+		Body:        "<!-- hive-fleet-fingerprint:h1:queue-growth -->\n| series | `[10,20]` |",
+	}
+	publishFleetReportsWith(context.Background(), slog.Default(), srv, &fleetreport.Result{Reports: []fleetreport.Report{report}}, deps)
+	if len(relayed) != 1 || relayed[0].Repo != "hivecommons/hive" || relayed[0].Action != "" || relayed[0].Class != selfReportObservationClass {
+		t.Fatalf("observation relay = %#v", relayed)
+	}
+	records, err := ledger.Records()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if records[fp].IssueNumber != 7 || records[fp].Before != "10" || records[fp].After != "20" {
+		t.Fatalf("observation ledger = %#v", records[fp])
+	}
+}
@@ -40,6 +40,28 @@ Nous state lives in three places, none of which is `hive.yaml`:
 | Experiment campaigns | `/data/nous/campaigns.json` | `pkg/nous` campaign store (file version 2), written by `POST/PATCH /api/nous/campaigns` (including restarts) and by the legacy `PUT /api/nous/config/goals` / `POST /api/nous/campaign/start`; see [Campaigns and the per-campaign baseline](#campaigns-and-the-per-campaign-baseline) |
 | Mode, output mode, repo allow-list, fast-fail bounds, schedule | in-memory `NousState.Config`, set via `PUT /api/nous/config/*` | dashboard ⚙ *Experiment Lab Configuration* dialog (lab-wide guardrails only) or direct API calls |
 
+### Observation finding recovery
+
+Observation detectors keep their issue lifecycle in
+`/data/nous/observations.json`, keyed by finding fingerprint. Each record stores
+the issue number and URL, `opened_at`, `last_seen_at`, and (while the finding is
+absent) `recovered_since`, plus the before/after values and last evidence used
+in the recovery comment.
+
+Every evaluation reconciles the currently active findings with this ledger. An
+active finding clears `recovered_since`; an absent finding starts the recovery
+window. After **seven consecutive days** without the finding, the spoke sends
+the hub relay an `action: "recover"` request. The hub searches for the open
+issue marker, comments the before/after values and evidence, and closes the
+issue. A missing or already-closed fingerprint is an idempotent `ok: false`
+no-op, not an evaluation error.
+
+After a successful recovery, the ledger records `closed_at`. If the same
+fingerprint fires again, it starts a fresh lifecycle and the hub's open-only
+search creates a new issue rather than reopening the old one. The spoke never
+writes recovery comments or closes issues directly; the hub relay is the
+authoritative write path.
+
 The in-memory `Config` map (goals/repos/output/fast_fail/schedule/
 principles sections) is **not currently persisted back to disk
 across a process restart** — it is rebuilt from defaults each time the hive
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+- Add Nous observation recovery tracking with a seven-day lifecycle, hub-relayed recovery comments, and issue closure.`