Doctrine-Aware Self-Improving AI Roadmap

# Doctrine-Aware Self-Improving AI Roadmap

Date: 2026-07-02
Product path: `unthinkable`
Topic: `doctrine-aware-ai`
Status: active architecture roadmap
Primary prototype target: `prototypes/unthinkable/tactical-battle/playable-battle/`

## Purpose

Omega War should build tactical AI as a doctrine-constrained commander system, not as a runtime neural network and not as a larger flat finite-state machine. The runtime AI must remain deterministic, serializable, explainable, and bounded by authored faction-era doctrine.

Neural-network or reinforcement-learning work is allowed only offline for now. Offline simulations may discover useful weights, plan timings, counter-rules, build orders, difficulty curves, and failure cases. Shipped browser runtime behavior should consume distilled data tables, utility weights, and authored rules.

## Current Gap

The current tactical AI direction is explainable, but too flat. A single commander FSM can capture scripted pressure and readable logs, yet it does not separate doctrine, general personality, difficulty, player adaptation, plan selection, tactical utility, and unit micro.

## Architecture Direction

Runtime AI should be layered: doctrine profile, general personality, difficulty profile, commander planner, tactical utility layer, and unit micro layer. Doctrine is the boundary, not flavor text. AI may improve within doctrine; it must not converge into generic optimal RTS cheese.

## Doctrine Baselines

Soviet 2nd Guards should prefer mass, echelon pressure, armor exploitation, artillery preparation, and shock commitment.

UK 11th Armoured should prefer combined arms, recon, deliberate armor commitment, artillery observation, and air support.

## Serializable Runtime Contracts

`AiCommanderProfile` stores side, force id, doctrine id, personality id, difficulty id, plan weights, risk knobs, adaptation settings, and seed.

`AiIntentState` stores current plan, plan reason, target objectives, build step, group assignments, known player habits, adaptation memory, last adaptation reason, cooldowns, and log.

`AiDoctrineProfile` stores allowed plans, preferred unit categories, phase priorities, historical bias weights, risk limits, forbidden behaviors, penalized behaviors, fallback behaviors, and adaptation boundaries.

## Learning Memory

Runtime learning memory stores only compact, explainable signals: player overuses center rush, player ignores flank, player delays anti-armor, player punishes unsupported armor, AI lost too many units during probes, artillery fired with poor effect, command-post defense arrived too late, or reserve budget was too low after Phase B.

Every adaptive change must emit a log entry.

## Self-Improvement Modes

Mode 1: doctrine-bounded tuning. Mode 2: player-specific adaptation. Mode 3: offline open-ended exploration distilled into data.

## Difficulty And Fun Rules

Difficulty tunes competence, not cheating. Easy slows reactions and weakens adaptation. Normal uses doctrine-faithful plan switching and fair scouting. Hard improves timing, grouping, target priority, recovery, and player-habit counters without hidden omniscience or impossible economy.

## Implementation Path

Phase 0 amends EXP-08 around the AI contracts. Phase 1 upgrades the Soviet opponent. Phase 2 reuses the framework for UK spectator AI. Phase 3 adds an offline tuning harness.

## Test Plan

Create AI-vs-script and AI-vs-AI scenario tests for near-point capture, center contest, honest escalation, damaged-unit retreats, command-surface defense, repeated center-rush adaptation, repeated flank-play adaptation, and doctrine constraint enforcement.

## Acceptance Criteria

AI feels less exploitable after repeated play. AI decisions remain explainable in logs. AI still looks like its faction and commander. AI can lose without collapsing into one-lane stupidity. Difficulty increases competence without hidden omniscience or impossible economy. No runtime neural model is required for the browser prototype. Save/reload preserves commander profile, intent state, adaptation memory, cooldowns, and log context.