core choice logging and self-improvement readiness

Current state

AGInt (agents/core/agint.py): Logs perception, rule-based decision, orient (LLM) response, and BDI delegation via memory_agent.log_process() to per-agent process_trace.jsonl under data/memory/.../agent_workspaces/<agent_id>/process_trace.jsonl. No single stream of “choices” for auditing.
BDI in backend (mindx_backend_service/main_service.py): Sets chosen_agent from keyword rules, updates bdi_state and in-memory activity_log, and appends text lines to data/logs/agint/agint_cognitive_cycles.log. No structured choice record.
mindXagent (agents/core/mindXagent.py): _log_action_choices() only appends to in-memory self.action_choices (for UI). No persistent log. Improvement loop uses rule-based _identify_improvement_opportunities and _prioritize_improvements (no LLM); Ollama is used for chat/inject_user_prompt and is notified at startup.
StartupAgent (agents/orchestration/startup_agent.py): After Ollama connect, calls _notify_mindxagent_startup(ollama_result). autonomous_startup_improvement() uses Ollama (ollama_api.generate_text) to analyze startup and suggest improvements; results are logged via log_process but not as a normalized “core choice” with rationale/outcome.

To show that mindX is or is not a Gödel machine, we need a single, accurate log of core choices: what was perceived, what options were considered, what was chosen, why, and (when available) outcome.

1. Gödel choice schema and global log

Schema (one JSON object per line in a single file):
- source_agent, cycle_id (or request_id), timestamp_utc
- choice_type: e.g. agint_decision | bdi_agent_selection | mindx_improvement_selection | startup_ollama_improvement | mindx_action_choice
- perception_summary: short description of input/context
- options_considered: list of options (e.g. agent names, improvement goals)
- chosen_option: the selected option
- rationale: why this was chosen (rule name, LLM excerpt, or fixed string)
- outcome: optional, filled when known (e.g. success/failure, or deferred)
- Optional: llm_model when the choice involves Ollama/LLM output
Location: data/logs/godel_choices.jsonl (single global file, append-only).
Implementation: Add log_godel_choice(self, choice_record: Dict[str, Any]) -> Optional[Path] on MemoryAgent that:
- Ensures data/logs (and optionally data/logs/agint) exists.
- Appends one JSON line to data/logs/godel_choices.jsonl.
- Optionally also calls existing log_process("godel_core_choice", choice_record, {"agent_id": choice_record.get("source_agent", "system")}) so choices remain queryable via existing process_trace/timestamped memory.

2. Instrument core decision points

AGInt (agents/core/agint.py): After the rule-based decision in _orient_and_decide (and after LLM orient if used), build a Gödel choice record from:
- source_agent = self.agent_id
- choice_type = agint_decision
- perception_summary = truncated perception or directive
- options_considered = list of decision types (e.g. BDI_DELEGATION, RESEARCH, etc.) relevant to the rule
- chosen_option = the actual decision_type (and target if any)
- rationale = rule reason or orient response summary Call memory_agent.log_godel_choice(record) (if memory_agent exists).
Backend BDI (mindx_backend_service/main_service.py): Immediately after chosen_agent is set and before update_bdi_state, build a Gödel choice record:
- source_agent = e.g. bdi_directive_handler
- choice_type = bdi_agent_selection
- perception_summary = directive (truncated)
- options_considered = list(available_agents.keys())
- chosen_option = chosen_agent
- rationale = bdi_reasoning string Obtain memory_agent from the same place as other backend logging (e.g. command_handler.mastermind.memory_agent) and call await memory_agent.log_godel_choice(record).
mindXagent (agents/core/mindXagent.py): In _log_action_choices(), after appending to self.action_choices, build a Gödel choice record from the same context and choices (options_considered = goals/reasons, chosen_option = first item), and call await self.memory_agent.log_godel_choice(record) so every improvement selection is persisted.
mindXagent autonomous improvement loop: When an improvement is executed (success or failure), append a second record (or extend outcome) so the log has “selected” and “executed” with outcome (e.g. success/failure or error message).
StartupAgent (agents/orchestration/startup_agent.py): In autonomous_startup_improvement(), when Ollama returns analysis and suggestions and the agent applies or rejects them, log a Gödel choice:
- choice_type = startup_ollama_improvement
- perception_summary = e.g. “startup log analysis”
- options_considered = list of suggested improvements (from Ollama response)
- chosen_option = the one applied (or “none” if none applied)
- rationale = excerpt from Ollama analysis
- llm_model = model used Use await self.memory_agent.log_godel_choice(record).

3. Ollama-driven self-improvement readiness

Already in place: StartupAgent connects to Ollama on startup, notifies mindXagent via _notify_mindxagent_startup(ollama_result); mindXagent uses Ollama for chat and inject_user_prompt. StartupAgent’s autonomous_startup_improvement() uses Ollama to analyze startup and suggest improvements.
No code change required to “start” self-improvement from Ollama beyond ensuring the above logging is in place so that when you run autonomous startup improvement (or mindXagent improvement loop), every core choice is recorded.
Optional: If you want the mindXagent improvement loop to use Ollama for prioritization (instead of only rule-based priority), that would be a separate enhancement: call Ollama in _prioritize_improvements or after _identify_improvement_opportunities and log that as a Gödel choice (choice_type e.g. mindx_ollama_prioritization).

4. API and UI (optional)

API: Add a read-only endpoint, e.g. GET /godel/choices?limit=50&source_agent=..., that reads the last N lines from data/logs/godel_choices.jsonl, parses JSON lines, and returns them (newest first). This allows external auditing and dashboards.
UI: Small widget on Platform or Admin tab: “Last N core choices” table (source, type, chosen option, rationale, time). Fetches from the new API.

5. File and dependency summary

Area	File(s)	Change
Core directive	docs/survive.md	New file: inference-first mandate, mindX.sh commands, API/rate limits, find inference, free to paid, THOT/DAIO
Schema + global log	agents/memory_agent.py	Add `log_godel_choice()`, ensure `data/logs` and `godel_choices.jsonl`
StartupAgent	agents/orchestration/startup_agent.py	When `_auto_connect_ollama` fails, call `ensure_ollama_available()` then retry; log `startup_ollama_bootstrap`; in `autonomous_startup_improvement` log Gödel choice
AGInt	agents/core/agint.py	After decide, build and log Gödel choice
BDI backend	mindx_backend_service/main_service.py	After choosing agent, get memory_agent and log Gödel choice
mindXagent	agents/core/mindXagent.py	In `_log_action_choices`, persist via `log_godel_choice`; in improvement loop log execution outcome
API	mindx_backend_service/main_service.py	Add `GET /godel/choices` (optional)
UI	mindx_frontend_ui/components/platform-tab.js or admin tab	“Last core choices” widget (optional)

6. Order of implementation

Core directive: Create docs/survive.md with the inference-first mandate and mindX.sh commands (see section 0).
StartupAgent as inference controller: Add bootstrap-on-failure in StartupAgent: when _auto_connect_ollama() returns connected: False, call ensure_ollama_available() then retry; log Gödel choice startup_ollama_bootstrap / inference_acquired. (Requires log_godel_choice() to exist — so step 3 may be done first or in parallel.)
Add log_godel_choice() on MemoryAgent and create data/logs/godel_choices.jsonl on first write.
Instrument StartupAgent _auto_connect_ollama (success and bootstrap), then autonomous_startup_improvement; then AGInt, BDI in main_service, mindXagent _log_action_choices and improvement execution.
Add GET /godel/choices and UI widget if desired.

After this, all core choices (including inference acquisition and Ollama-driven startup/improvement) are logged in one place, so you can audit whether mindX behaves like a Gödel machine (inference as lifeblood; self-improvement decisions and rationale visible and traceable).