session-memory's extracted actions never set Action.At, so the wire
carried time.Time's zero value ("0001-01-01") and the Curators
dashboard rendered it as "105694 wks ago". Stamp the action with the
curator's clock at the producer, and backfill any zero Action.At in
activityTracker.record from the pass's own timestamp so an engine
with no clock (skillcurator) can't hit the same bug.
Closes archie-core-z6wy
86 lines
2.6 KiB
Go
86 lines
2.6 KiB
Go
package curator
|
|
|
|
import (
|
|
"slices"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// maxRecentActions bounds how much per-curator history activityTracker
|
|
// keeps in memory. Curator activity is inspectable, not archival -- there is
|
|
// deliberately no persistence layer here (archie-core-1786637489932-6),
|
|
// so this is a ring buffer, not a log.
|
|
const maxRecentActions = 20
|
|
|
|
// Activity is a curator's inspectable recent history: when it last ran, how
|
|
// many actions that run made, and the most recent actions across all runs.
|
|
// Recent is ordered newest first and capped at maxRecentActions.
|
|
type Activity struct {
|
|
LastRunAt time.Time
|
|
LastRunActions int
|
|
Recent []Action
|
|
}
|
|
|
|
// activityTracker records recent curator activity in memory, fed directly
|
|
// from the runtime's own emit point (Runtime.emitRun) rather than by
|
|
// re-subscribing to the event bus -- the runtime already has the pass
|
|
// result in hand, and EventSink is fire-and-forget with no replay. Activity
|
|
// resets on daemon restart, same as every other piece of runtime state the
|
|
// curator family holds only in memory.
|
|
type activityTracker struct {
|
|
mu sync.Mutex
|
|
data map[string]*Activity
|
|
}
|
|
|
|
func newActivityTracker() *activityTracker {
|
|
return &activityTracker{data: make(map[string]*Activity)}
|
|
}
|
|
|
|
// record appends one pass's actions to the curator's history, newest first,
|
|
// and updates the last-run summary. actions may be empty (an idle pass still
|
|
// updates LastRunAt).
|
|
func (t *activityTracker) record(name string, at time.Time, actions []Action) {
|
|
t.mu.Lock()
|
|
defer t.mu.Unlock()
|
|
|
|
a := t.data[name]
|
|
if a == nil {
|
|
a = &Activity{}
|
|
t.data[name] = a
|
|
}
|
|
a.LastRunAt = at
|
|
a.LastRunActions = len(actions)
|
|
|
|
merged := make([]Action, 0, len(actions)+len(a.Recent))
|
|
for _, action := range slices.Backward(actions) {
|
|
// A curator engine may not stamp its own actions (no clock
|
|
// dependency wired in); the pass's own "at" is the authoritative
|
|
// time for every action it produced, so backfill rather than let
|
|
// a zero time.Time reach the wire as "105694 wks ago".
|
|
if action.At.IsZero() {
|
|
action.At = at
|
|
}
|
|
merged = append(merged, action)
|
|
}
|
|
merged = append(merged, a.Recent...)
|
|
if len(merged) > maxRecentActions {
|
|
merged = merged[:maxRecentActions]
|
|
}
|
|
a.Recent = merged
|
|
}
|
|
|
|
// snapshot returns a copy of the named curator's activity, safe for the
|
|
// caller to read and mutate without racing the tracker's own writes.
|
|
func (t *activityTracker) snapshot(name string) (Activity, bool) {
|
|
t.mu.Lock()
|
|
defer t.mu.Unlock()
|
|
|
|
a, ok := t.data[name]
|
|
if !ok {
|
|
return Activity{}, false
|
|
}
|
|
cp := *a
|
|
cp.Recent = append([]Action(nil), a.Recent...)
|
|
return cp, true
|
|
}
|