b6817899b4
Remove Go code that makes workflow decisions. All health checking, staleness detection, nudging, and escalation belongs in the Deacon molecule where Claude executes it. Removed: - internal/daemon/backoff.go (190 lines) - exponential backoff decisions - internal/doctor/stale_check.go (284 lines) - staleness detection - IsFresh/IsStale/IsVeryStale from keepalive.go - pokeMayor, pokeWitnesses, pokeWitness from daemon.go - Heartbeat staleness classification from pokeDeacon Changed: - Lifecycle parsing now uses structured body (JSON or simple text) instead of keyword matching on subject line - Daemon now only ensures Deacon is running and sends simple heartbeats - No backoff, no staleness classification, no decision-making Total: ~800 lines removed from Go code The Deacon molecule will handle all health checking, nudging, and escalation. Go is now just a message router. See gt-gaxo epic for full rationale. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
93 lines
2.2 KiB
Go
93 lines
2.2 KiB
Go
// Package keepalive provides agent activity signaling via file touch.
|
|
package keepalive
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/steveyegge/gastown/internal/workspace"
|
|
)
|
|
|
|
// State represents the keepalive file contents.
|
|
type State struct {
|
|
LastCommand string `json:"last_command"`
|
|
Timestamp time.Time `json:"timestamp"`
|
|
}
|
|
|
|
// Touch updates the keepalive file in the workspace's .runtime directory.
|
|
// It silently ignores errors (best-effort signaling).
|
|
func Touch(command string) {
|
|
TouchWithArgs(command, nil)
|
|
}
|
|
|
|
// TouchWithArgs updates the keepalive file with the full command including args.
|
|
// It silently ignores errors (best-effort signaling).
|
|
func TouchWithArgs(command string, args []string) {
|
|
root, err := workspace.FindFromCwd()
|
|
if err != nil || root == "" {
|
|
return // Not in a workspace, nothing to do
|
|
}
|
|
|
|
// Build full command string
|
|
fullCmd := command
|
|
if len(args) > 0 {
|
|
fullCmd = command + " " + strings.Join(args, " ")
|
|
}
|
|
|
|
TouchInWorkspace(root, fullCmd)
|
|
}
|
|
|
|
// TouchInWorkspace updates the keepalive file in a specific workspace.
|
|
// It silently ignores errors (best-effort signaling).
|
|
func TouchInWorkspace(workspaceRoot, command string) {
|
|
runtimeDir := filepath.Join(workspaceRoot, ".runtime")
|
|
|
|
// Ensure .runtime directory exists
|
|
if err := os.MkdirAll(runtimeDir, 0755); err != nil {
|
|
return
|
|
}
|
|
|
|
state := State{
|
|
LastCommand: command,
|
|
Timestamp: time.Now().UTC(),
|
|
}
|
|
|
|
data, err := json.Marshal(state)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
keepalivePath := filepath.Join(runtimeDir, "keepalive.json")
|
|
_ = os.WriteFile(keepalivePath, data, 0644)
|
|
}
|
|
|
|
// Read returns the current keepalive state for the workspace.
|
|
// Returns nil if the file doesn't exist or can't be read.
|
|
func Read(workspaceRoot string) *State {
|
|
keepalivePath := filepath.Join(workspaceRoot, ".runtime", "keepalive.json")
|
|
|
|
data, err := os.ReadFile(keepalivePath)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
var state State
|
|
if err := json.Unmarshal(data, &state); err != nil {
|
|
return nil
|
|
}
|
|
|
|
return &state
|
|
}
|
|
|
|
// Age returns how old the keepalive signal is.
|
|
// Returns a very large duration if the state is nil.
|
|
func (s *State) Age() time.Duration {
|
|
if s == nil {
|
|
return 24 * time.Hour * 365 // No keepalive
|
|
}
|
|
return time.Since(s.Timestamp)
|
|
}
|