feat: persistent memory system and ClawSchedule heartbeats

- Add ClawSchedule CRD for cron-based recurring tasks (heartbeat, scheduled, sweep)
  with concurrency policies (Forbid/Allow/Replace) and suspend support
- Add MemorySpec to ClawInstance (enabled, maxSizeKB, systemPrompt)
- ClawInstance controller creates/cleans up <instance>-memory ConfigMap
- AgentRun controller mounts memory ConfigMap at /memory, extracts memory
  updates from pod logs via __K8SCLAW_MEMORY__ markers, patches ConfigMap
- Agent-runner reads /memory/MEMORY.md at startup, prepends context to task,
  instructs LLM to emit memory updates, parses and emits markers
- ClawSchedule controller with robfig/cron/v3 creates AgentRuns on schedule,
  injects memory context when includeMemory=true
- TUI: schedules view (key 7), /schedule /schedules /memory commands,
  schedule row actions (describe, delete, logs)
- RBAC: clawschedules permissions, configmap create/update/patch/delete
- Fix .gitignore binary patterns to be root-relative (avoid ignoring internal/controller/)
- Add 3 new memory tests (volumes, mount, env), all 42 tests pass

Author: AlexsJones

.gitignore

@@ -1,11 +1,11 @@
 # Binaries
 bin/
-agent-runner
-apiserver
-controller
-ipc-bridge
-webhook
-k8sclaw
+/agent-runner
+/apiserver
+/controller
+/ipc-bridge
+/webhook
+/k8sclaw
 *.exe
 *.dll
 *.so

api/v1alpha1/clawinstance_types.go

@@ -27,6 +27,28 @@ type ClawInstanceSpec struct {
 	// AuthRefs references secrets containing AI provider credentials.
 	// +optional
 	AuthRefs []SecretRef `json:"authRefs,omitempty"`
+
+	// Memory configures persistent memory for this instance.
+	// When enabled, a MEMORY.md ConfigMap is managed and mounted into agent pods.
+	// +optional
+	Memory *MemorySpec `json:"memory,omitempty"`
+}
+
+// MemorySpec configures persistent memory for a ClawInstance.
+type MemorySpec struct {
+	// Enabled indicates whether persistent memory is active.
+	// +kubebuilder:default=true
+	Enabled bool `json:"enabled"`
+
+	// MaxSizeKB caps the memory ConfigMap size in kilobytes.
+	// +kubebuilder:default=256
+	// +optional
+	MaxSizeKB int `json:"maxSizeKB,omitempty"`
+
+	// SystemPrompt is injected into every agent run for this instance
+	// to instruct the agent on how to use memory.
+	// +optional
+	SystemPrompt string `json:"systemPrompt,omitempty"`
 }
 
 // ChannelSpec defines a channel connection.

api/v1alpha1/clawschedule_types.go

@@ -0,0 +1,95 @@
+package v1alpha1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// ClawScheduleSpec defines a recurring task for a ClawInstance.
+type ClawScheduleSpec struct {
+	// InstanceRef is the name of the ClawInstance this schedule belongs to.
+	InstanceRef string `json:"instanceRef"`
+
+	// Schedule is a cron expression (e.g. "*/5 * * * *").
+	Schedule string `json:"schedule"`
+
+	// Task is the task description sent to the agent on each trigger.
+	Task string `json:"task"`
+
+	// Type categorises the schedule: heartbeat, scheduled, or sweep.
+	// +kubebuilder:validation:Enum=heartbeat;scheduled;sweep
+	// +kubebuilder:default="scheduled"
+	Type string `json:"type,omitempty"`
+
+	// Suspend pauses scheduling when true.
+	// +optional
+	Suspend bool `json:"suspend,omitempty"`
+
+	// ConcurrencyPolicy controls what happens when a trigger fires while
+	// the previous run is still active.
+	// +kubebuilder:validation:Enum=Forbid;Allow;Replace
+	// +kubebuilder:default="Forbid"
+	ConcurrencyPolicy string `json:"concurrencyPolicy,omitempty"`
+
+	// IncludeMemory injects the instance's MEMORY.md as context for each run.
+	// +kubebuilder:default=true
+	IncludeMemory bool `json:"includeMemory,omitempty"`
+}
+
+// ClawScheduleStatus defines the observed state of a ClawSchedule.
+type ClawScheduleStatus struct {
+	// Phase is the current phase (Active, Suspended, Error).
+	// +optional
+	Phase string `json:"phase,omitempty"`
+
+	// LastRunTime is when the last AgentRun was triggered.
+	// +optional
+	LastRunTime *metav1.Time `json:"lastRunTime,omitempty"`
+
+	// NextRunTime is the computed next trigger time.
+	// +optional
+	NextRunTime *metav1.Time `json:"nextRunTime,omitempty"`
+
+	// LastRunName is the name of the most recently created AgentRun.
+	// +optional
+	LastRunName string `json:"lastRunName,omitempty"`
+
+	// TotalRuns is the total number of runs triggered by this schedule.
+	// +optional
+	TotalRuns int64 `json:"totalRuns,omitempty"`
+
+	// Conditions represent the latest available observations.
+	// +optional
+	Conditions []metav1.Condition `json:"conditions,omitempty"`
+}
+
+// +kubebuilder:object:root=true
+// +kubebuilder:subresource:status
+// +kubebuilder:printcolumn:name="Instance",type="string",JSONPath=".spec.instanceRef"
+// +kubebuilder:printcolumn:name="Schedule",type="string",JSONPath=".spec.schedule"
+// +kubebuilder:printcolumn:name="Type",type="string",JSONPath=".spec.type"
+// +kubebuilder:printcolumn:name="Phase",type="string",JSONPath=".status.phase"
+// +kubebuilder:printcolumn:name="Last Run",type="date",JSONPath=".status.lastRunTime"
+// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp"
+
+// ClawSchedule is the Schema for the clawschedules API.
+// It defines recurring tasks (heartbeats, scheduled jobs, sweeps) for a ClawInstance.
+type ClawSchedule struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Spec   ClawScheduleSpec   `json:"spec,omitempty"`
+	Status ClawScheduleStatus `json:"status,omitempty"`
+}
+
+// +kubebuilder:object:root=true
+
+// ClawScheduleList contains a list of ClawSchedule.
+type ClawScheduleList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []ClawSchedule `json:"items"`
+}
+
+func init() {
+	SchemeBuilder.Register(&ClawSchedule{}, &ClawScheduleList{})
+}

api/v1alpha1/zz_generated.deepcopy.go

@@ -58,6 +58,31 @@ func main() {
 	provider := strings.ToLower(getEnv("MODEL_PROVIDER", "openai"))
 	modelName := getEnv("MODEL_NAME", "gpt-4o-mini")
 	baseURL := strings.TrimRight(getEnv("MODEL_BASE_URL", ""), "/")
+	memoryEnabled := getEnv("MEMORY_ENABLED", "") == "true"
+
+	// Read existing memory if available.
+	var memoryContent string
+	if memoryEnabled {
+		if b, err := os.ReadFile("/memory/MEMORY.md"); err == nil {
+			memoryContent = strings.TrimSpace(string(b))
+			log.Printf("loaded memory (%d bytes)", len(memoryContent))
+		}
+	}
+
+	// Prepend memory context to the task if present.
+	if memoryContent != "" && memoryContent != "# Agent Memory\n\nNo memories recorded yet." {
+		task = fmt.Sprintf("## Your Memory\nThe following is your persistent memory from prior interactions:\n\n%s\n\n## Current Task\n%s", memoryContent, task)
+	}
+
+	// If memory is enabled, add memory instructions to system prompt.
+	if memoryEnabled {
+		memoryInstruction := "\n\nYou have persistent memory. After completing your task, " +
+			"output a memory update block wrapped in markers like this:\n" +
+			"__K8SCLAW_MEMORY__\n<your updated MEMORY.md content>\n__K8SCLAW_MEMORY_END__\n" +
+			"Include key facts, preferences, and context from this and past interactions. " +
+			"Keep it concise (under 256KB). Use markdown format."
+		systemPrompt += memoryInstruction
+	}
 
 	apiKey := firstNonEmpty(
 		os.Getenv("API_KEY"),
@@ -123,6 +148,14 @@ func main() {
 		fmt.Fprintf(os.Stdout, "\n__K8SCLAW_RESULT__%s__K8SCLAW_END__\n", string(markerBytes))
 	}
 
+	// Extract and emit memory update if the LLM produced one.
+	if memoryEnabled && res.Response != "" {
+		if memUpdate := extractMemoryUpdate(res.Response); memUpdate != "" {
+			fmt.Fprintf(os.Stdout, "\n__K8SCLAW_MEMORY__%s__K8SCLAW_MEMORY_END__\n", memUpdate)
+			log.Printf("emitted memory update (%d bytes)", len(memUpdate))
+		}
+	}
+
 	if res.Status == "error" {
 		log.Printf("agent-runner finished with error: %s", res.Error)
 		os.Exit(1)
@@ -269,3 +302,25 @@ func fatal(msg string) {
 	})
 	os.Exit(1)
 }
+
+// extractMemoryUpdate looks for a memory update block in the LLM response.
+// The agent is instructed to wrap its memory updates in:
+//
+//	__K8SCLAW_MEMORY__
+//	<content>
+//	__K8SCLAW_MEMORY_END__
+func extractMemoryUpdate(response string) string {
+	const startMarker = "__K8SCLAW_MEMORY__"
+	const endMarker = "__K8SCLAW_MEMORY_END__"
+
+	startIdx := strings.LastIndex(response, startMarker)
+	if startIdx < 0 {
+		return ""
+	}
+	payload := response[startIdx+len(startMarker):]
+	endIdx := strings.Index(payload, endMarker)
+	if endIdx < 0 {
+		return ""
+	}
+	return strings.TrimSpace(payload[:endIdx])
+}