gastownhall/beads · warning

issue %s is not eligible for Tier 1 compaction: %s

Error message

issue %s is not eligible for Tier 1 compaction: %s

What it means

CheckEligibility returned eligible=false together with a non-empty reason string, so CompactTier1 refuses to compact and reports the store's reason. This is an expected policy rejection, not an internal failure — the issue fails one of the Tier 1 eligibility rules (e.g. already compacted, too small, closed).

Source

Thrown at internal/compact/compactor.go:100

		summarizer: haiClient,
		config:     config,
	}, nil
}

// CompactTier1 compacts a single issue at Tier 1 (basic summarization).
func (c *Compactor) CompactTier1(ctx context.Context, issueID string) error {
	if ctx.Err() != nil {
		return ctx.Err()
	}

	// Check eligibility before fetching issue (fail fast)
	eligible, reason, err := c.store.CheckEligibility(ctx, issueID, 1)
	if err != nil {
		return fmt.Errorf("failed to verify eligibility: %w", err)
	}
	if !eligible {
		if reason != "" {
			return fmt.Errorf("issue %s is not eligible for Tier 1 compaction: %s", issueID, reason)
		}
		return fmt.Errorf("issue %s is not eligible for Tier 1 compaction", issueID)
	}

	issue, err := c.store.GetIssue(ctx, issueID)
	if err != nil {
		return fmt.Errorf("failed to fetch issue: %w", err)
	}

	// Calculate original size
	originalSize := len(issue.Description) + len(issue.Design) + len(issue.Notes) + len(issue.AcceptanceCriteria)

	if c.config.DryRun {
		return fmt.Errorf("dry-run: would compact %s (original size: %d bytes)", issueID, originalSize)
	}

	// Get summary from AI
	summary, err := c.summarizer.SummarizeTier1(ctx, issue)

View on GitHub (pinned to 71377f2769)

Solutions

1. Read the appended reason in the message to see which eligibility rule failed
2. Filter candidate issues through CheckEligibility yourself before batch compaction
3. Reopen the issue or adjust its state if the reason is stale/incorrect
4. Skip the issue if ineligible — this is an expected outcome in batch runs

Example fix

// before
for _, id := range ids {
    if err := c.CompactTier1(ctx, id); err != nil { return err } // aborts on first ineligible
}
// after
for _, id := range ids {
    if err := c.CompactTier1(ctx, id); err != nil {
        if strings.Contains(err.Error(), "not eligible for Tier 1 compaction") { continue }
        return err
    }
}

eligible, reason, err := store.CheckEligibility(ctx, issueID, 1)
if err != nil { return err }
if !eligible {
    log.Printf("skipping %s: %s", issueID, reason)
    continue
}

if err := c.CompactTier1(ctx, id); err != nil {
    if strings.Contains(err.Error(), "not eligible for Tier 1 compaction") {
        return nil // expected policy skip
    }
    return err
}

When it happens

Trigger: Calling CompactTier1 on an issue the store deems ineligible, with a reason — e.g. the issue is closed, already has a compaction record, or its content is below the minimum size threshold.

Common situations: Re-running compaction on an already-compacted issue; targeting a closed issue; scripting over many issues where some are intentionally skipped; typos leading to the wrong issue ID being selected.

Related errors

• issue %s is not eligible for Tier 1 compaction
• no store is open for this workspace
• not found
• no absolute native user directory is available
• ExternalDoltConfig: set either Socket OR (Host, Port), not b

AI-assisted analysis of gastownhall/beads@71377f2769 (2026-08-30). Data as JSON: /api/errors/ed5d863aad03e451. Report an issue: GitHub.