aether-colony 3.1.17 → 5.1.0

package/.claude/commands/ant/init.md

@@ -1,6 +1,7 @@
+<!-- Generated from .aether/commands/init.yaml - DO NOT EDIT DIRECTLY -->
 ---
 name: ant:init
-description: "🌱🐜🆕🐜🌱 Initialize Aether colony - Queen sets intention, colony mobilizes"
+description: "Initialize Aether colony - scan repo, approve charter, create colony"
 ---
 
 You are the **Queen Ant Colony**. Initialize the colony with the Queen's intention.
@@ -13,23 +14,36 @@ Parse `$ARGUMENTS`:
 - If contains `--no-visual`: set `visual_mode = false` (visual is ON by default)
 - Otherwise: set `visual_mode = true`
 
-### Step 0: Initialize Visual Mode (if enabled)
 
-If `visual_mode` is true:
-```bash
-# Generate session ID
-init_id="init-$(date +%s)"
-
-# Initialize swarm display
-bash .aether/aether-utils.sh swarm-display-init "$init_id"
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "excavating" "Colony initialization" "Colony" '{"read":0,"grep":0,"edit":0,"bash":0}' 0 "fungus_garden" 0
-```
-
-### Step 0.5: Version Check (Non-blocking)
-
-Run using the Bash tool: `bash .aether/aether-utils.sh version-check 2>/dev/null || true`
 
-If the command succeeds and the JSON result contains a non-empty string, display it as a one-line notice. Proceed regardless of outcome.
+<failure_modes>
+### Colony State Overwrite
+Re-init mode detects existing COLONY_STATE.json and preserves all state. Charter content is updated in-place via charter-write. Colony state, wisdom, instincts, learnings, pheromones, and phase progress are never reset.
+
+### Write Failure Mid-Init
+If writing COLONY_STATE.json fails partway:
+- Remove the incomplete file (partial state is worse than no state)
+- Report the error
+- Recovery: user can run /ant:init again safely
+</failure_modes>
+
+<success_criteria>
+Command is complete when:
+- User has approved the charter prompt (Charter, Context, Pheromones sections)
+- Charter content is written to QUEEN.md via charter-write
+- COLONY_STATE.json exists and is valid JSON (fresh init only)
+- Session file is written
+- User sees confirmation of colony creation or re-init
+</success_criteria>
+
+<read_only>
+Do not touch during init:
+- .aether/dreams/ (user notes)
+- .aether/chambers/ (archived colonies)
+- .env* files
+- .claude/settings.json
+- .github/workflows/
+</read_only>
 
 ### Step 1: Validate Input
 
@@ -38,8 +52,8 @@ If `$ARGUMENTS` is empty or blank, output:
 ```
 Aether Colony
 
-  Initialize the colony with a goal. This creates the colony state,
-  initializes constraints, and logs the init event.
+  Initialize the colony with a goal. This scans the repo, generates
+  a charter for your approval, then creates colony files.
 
   Usage: /ant:init "<your goal here>"
 
@@ -51,32 +65,30 @@ Aether Colony
 
 Stop here. Do not proceed.
 
-### Step 1.5: Bootstrap System Files (Conditional)
+### Step 1.5: Verify Aether Setup
 
 Check if `.aether/aether-utils.sh` exists using the Read tool.
 
-**If the file already exists** — skip this step entirely. System files are present.
+**If the file already exists** -- skip this step entirely. Aether is set up.
 
 **If the file does NOT exist:**
-- Check if `~/.aether/system/` exists (expand `~` to the user's home directory)
-- **If the hub exists:** Run using the Bash tool:
-  ```
-  bash ~/.aether/system/aether-utils.sh bootstrap-system
-  ```
-  This copies system files from the global hub into `.aether/`. Display:
-  ```
-  Bootstrapped system files from global hub.
-  ```
-- **If the hub does NOT exist:** Output:
-  ```
-  No Aether system files found locally or in ~/.aether/.
-  Run `aether install` or `npx aether-colony install` to set up the global hub first.
-  ```
-  Stop here. Do not proceed.
-
-### Step 1.6: Initialize QUEEN.md Wisdom Document
-
-After bootstrap completes (or if system files already existed), run using the Bash tool:
+```
+Aether is not set up in this repo yet.
+
+Run /ant:lay-eggs first to create the .aether/ directory
+with all system files, then run /ant:init "your goal" to
+start a colony.
+
+If the global hub isn't installed either:
+  npm install -g aether-colony   (installs the hub)
+  /ant:lay-eggs                  (sets up this repo)
+  /ant:init "your goal"          (starts the colony)
+```
+Stop here. Do not proceed.
+
+### Step 2: Initialize QUEEN.md
+
+Run using the Bash tool with description "Initializing QUEEN.md...":
 ```
 bash .aether/aether-utils.sh queen-init
 ```
@@ -85,231 +97,370 @@ Parse the JSON result:
 - If `created` is true: Display `QUEEN.md initialized`
 - If `created` is false and `reason` is "already_exists": Display `QUEEN.md already exists`
 
-This step is non-blocking — proceed regardless of outcome.
+This step is non-blocking -- proceed regardless of outcome.
 
-### Step 2: Read Current State with Freshness Check
+### Step 3: Scan Repository
 
-Capture session start time:
+Run the scan via Bash tool:
 ```bash
-INIT_START=$(date +%s)
+scan_result=$(bash .aether/aether-utils.sh init-research 2>/dev/null)
+scan_data=$(echo "$scan_result" | jq '.result')
 ```
 
-Use the Read tool to read `.aether/data/COLONY_STATE.json`.
+Extract fields with jq defaults for missing data:
+- `tech_langs`: `.tech_stack.languages | if length > 0 then join(", ") else "not detected" end`
+- `tech_fwks`: `.tech_stack.frameworks | if length > 0 then join(", ") else "none" end`
+- `tech_pkg`: `.tech_stack.package_managers | join(", ")`
+- `complexity`: `.complexity.size`
+- `file_count`: `.complexity.metrics.file_count`
+- `top_dirs`: `.directory_structure.top_level_dirs | if . and length > 0 then join(", ") else "flat" end`
+- `commit_count`: `.git_history.commit_count // "unknown"`
+- `is_git`: `.git_history.is_git_repo // false`
+- `survey_suggestion`: `.survey_status.suggestion.reason // empty`
+- `has_active`: `.prior_colonies.has_active_colony // false`
+- `active_goal`: `.prior_colonies.active_goal // empty`
+
+**Intelligence fields (new):**
+- `colony_context_colonies`: `.colony_context.prior_colonies // []` -- array of prior colony summaries (each has goal, phases, outcome, summary)
+- `colony_context_charter`: `.colony_context.existing_charter // {}` -- existing charter content from QUEEN.md
+- `governance_rules`: `.governance.rules // []` -- array of governance rule objects (each has rule, source, strength)
+- `pheromone_suggestions`: `.pheromone_suggestions // []` -- array of suggestion objects (each has type, content, reason, priority)
+
+If `scan_result` is empty or `jq` fails, set all fields to fallback values (empty arrays/objects for intelligence fields) and proceed (graceful degradation -- never stop init because scan fails).
+
+### Step 4: Detect Re-Init Mode
+
+Use Read tool to check `.aether/data/COLONY_STATE.json`.
+
+- If file exists AND has a non-null `goal` field: set `reinit_mode = true`, store `existing_goal`
+- Otherwise: set `reinit_mode = false`
 
-Check freshness of existing state:
+If re-init mode, read existing charter entries from `.aether/QUEEN.md`:
 ```bash
-fresh_check=$(bash .aether/aether-utils.sh session-verify-fresh --command init "" "$INIT_START")
-is_stale=$(echo "$fresh_check" | jq -r '.stale | length')
-freshness_status=$([[ "$is_stale" -gt 0 ]] && echo "stale" || echo "fresh")
+existing_intent=$(grep '\[charter\] \*\*Intent\*\*:' .aether/QUEEN.md 2>/dev/null | sed 's/.*\*\*Intent\*\*: //' | sed 's/ (Colony:.*//' || true)
+existing_vision=$(grep '\[charter\] \*\*Vision\*\*:' .aether/QUEEN.md 2>/dev/null | sed 's/.*\*\*Vision\*\*: //' | sed 's/ (Colony:.*//' || true)
+existing_governance=$(grep '\[charter\] \*\*Governance\*\*:' .aether/QUEEN.md 2>/dev/null | sed 's/.*\*\*Governance\*\*: //' | sed 's/ (Colony:.*//' || true)
+existing_goals=$(grep '\[charter\] \*\*Goal\*\*:' .aether/QUEEN.md 2>/dev/null | sed 's/.*\*\*Goal\*\*: //' | sed 's/ (Colony:.*//' || true)
 ```
 
-If the `goal` field is not null:
-- If state is stale (old session): Warn user but proceed
-- If state is fresh (active session): Strongly recommend continuation
+Strip `(Colony: ...)` suffixes using sed. If grep finds nothing, variables remain empty.
 
-```
-Colony already initialized with goal: "{existing_goal}"
+### Step 5: Assemble and Display Approval Prompt
 
-State freshness: {freshness_status}
-Session: {session_id}
-Initialized: {initialized_at}
+Display a brief header:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   A E T H E R   C O L O N Y   I N I T
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
 
-To reinitialize with a new goal, the current state will be reset.
-Proceeding with new goal: "{new_goal}"
+If re-init mode, display:
+```
+Re-init mode detected (existing goal: "{existing_goal}")
+Charter will be updated. All colony state, wisdom, instincts, and progress will be preserved.
 ```
 
-**Note:** Init never auto-clears COLONY_STATE.json. Reinitialization is an explicit user choice.
+Then display the approval prompt as formatted Markdown. Section ordering: Prior Context (if any) -> Charter -> Context -> Pheromones.
 
-### Step 2.6: Load Prior Colony Knowledge (Optional)
+**Section 1: Prior Context (conditional -- only when prior colonies exist)**
 
-Check if `.aether/data/completion-report.md` exists using the Read tool.
+If `colony_context_colonies` has entries (length > 0), display:
+```markdown
+## Prior Context
 
-**If the file does NOT exist**, skip to Step 3 — this is a fresh colony with no prior history.
+Previous colonies in this repo:
 
-**If the file exists**, read it and extract:
-1. **Instincts** — look for the `## Colony Instincts` section. Each line has format: `N. [confidence] domain: description`. Keep only instincts with confidence >= 0.5.
-2. **Learnings** — look for the `## Colony Learnings (Validated)` section. Keep all numbered items.
+{For each colony (max 3, most recent first):}
+- **{goal}** -- {outcome} ({phases} phases){if summary is non-empty: ". {summary}"}
+```
 
-Store the extracted instincts and learnings for use in Step 3 (Write Colony State). Display a brief note:
+Per locked decision: when no prior colonies exist, omit this section entirely. No placeholder, no header.
 
-```
-🧠 Prior colony knowledge found:
-   {N} instinct(s) inherited (confidence >= 0.5)
-   {N} validated learning(s) carried forward
-```
+Keep each colony to 1-2 lines. Show goal, outcome (milestone), phase count, and summary from CROWNED-ANTHILL.md if available.
 
-If no instincts meet the threshold, display:
-```
-🧠 Prior colony knowledge found but no high-confidence instincts to inherit.
-```
+**Section 2: Charter**
+```markdown
+## Charter
 
-**Important:** This step is read-only and non-blocking. If the file is malformed or unreadable, skip silently and proceed to Step 3 with empty memory.
-
-### Step 3: Write Colony State
-
-Generate a session ID in the format `session_{unix_timestamp}_{random}` and an ISO-8601 UTC timestamp.
-
-Use the Write tool to write `.aether/data/COLONY_STATE.json` with the v3.0 structure.
-
-**If Step 2.6 found instincts to inherit**, convert each into the instinct format and seed the `memory.instincts` array. Each inherited instinct should have:
-- `id`: `instinct_inherited_{index}`
-- `trigger`: inferred from the instinct description
-- `action`: the instinct description
-- `confidence`: the original confidence value (from the completion report)
-- `domain`: the original domain (from the completion report)
-- `source`: `"inherited:completion-report"`
-- `evidence`: `["Validated in prior colony session"]`
-- `created_at`: current ISO-8601 timestamp
-- `last_applied`: null
-- `applications`: 0
-- `successes`: 0
-
-**If Step 2.6 found validated learnings**, seed `memory.phase_learnings` with each as:
-- `phase`: `"inherited"`
-- `learning`: the learning text
-- `status`: `"validated"`
-- `source`: `"inherited:completion-report"`
-
-**If Step 2.6 was skipped or found nothing**, use empty arrays as before.
-
-```json
-{
-  "version": "3.0",
-  "goal": "<the user's goal>",
-  "state": "READY",
-  "current_phase": 0,
-  "session_id": "<generated session_id>",
-  "initialized_at": "<ISO-8601 timestamp>",
-  "build_started_at": null,
-  "plan": {
-    "generated_at": null,
-    "confidence": null,
-    "phases": []
-  },
-  "memory": {
-    "phase_learnings": "<inherited learnings or []>",
-    "decisions": [],
-    "instincts": "<inherited instincts or []>"
-  },
-  "errors": {
-    "records": [],
-    "flagged_patterns": []
-  },
-  "signals": [],
-  "graveyards": [],
-  "events": [
-    "<ISO-8601 timestamp>|colony_initialized|init|Colony initialized with goal: <the user's goal>"
-  ]
-}
+**Intent:** {user's goal from $ARGUMENTS, or existing_intent if re-init}
+**Vision:** {derived from user's goal by Claude, or existing_vision if re-init}
+**Governance:** {see governance logic below}
+**Goals:** {blank for fresh init, or existing_goals if re-init}
 ```
 
-### Step 4: Initialize Constraints
+For fresh init, Claude should derive a brief Vision from the user's goal (1-2 sentences). Goals start blank. The user fills them in if desired.
 
-Write `.aether/data/constraints.json`:
+**Governance field logic:**
+- For fresh init with `governance_rules` available (length > 0): pre-populate with semicolon-separated rule text from the detected rules. Format: `"TDD required; ESLint enforced; Follow CONTRIBUTING.md"`. These are editable by the user.
+- For fresh init with no governance_rules: leave blank.
+- For re-init with existing_governance non-empty: pre-populate from existing QUEEN.md charter entries.
+- For re-init with existing_governance empty but governance_rules available: pre-populate from governance_rules.
 
-```json
-{
-  "version": "1.0",
-  "focus": [],
-  "constraints": []
-}
-```
+For re-init, pre-populate Intent, Vision, and Goals from existing QUEEN.md charter entries.
 
-### Step 5: Initialize Context Document
+**Section 3: Context**
+```markdown
+## Context
 
-Run using Bash tool:
+**Tech Stack:** {tech_langs} | {tech_fwks} | {tech_pkg}
+**Project Size:** {complexity} ({file_count} files)
+**Structure:** {top_dirs}
+**Git:** {commit_count} commits
+{if survey_suggestion: **Note:** {survey_suggestion}}
 ```
-bash .aether/aether-utils.sh context-update init "$ARGUMENTS"
+
+**Section 4: Pheromones**
+
+If `pheromone_suggestions` has entries (length > 0), display:
+```markdown
+## Pheromones
+
+Suggested signals based on repo analysis:
+
+1. [FOCUS] Testing infrastructure present (47 test files) -- maintain TDD discipline
+2. [REDIRECT] Environment files detected -- never commit secrets or .env files
+3. [FOCUS] Code quality tools configured -- follow existing lint/format rules
+
+Edit, remove, or add signals as needed. Approved signals will be auto-applied.
 ```
 
-This creates `.aether/CONTEXT.md` — the colony's persistent memory. If context collapses, this file tells the next session what we were doing.
+The numbered list uses the actual type and content from `pheromone_suggestions`. Each line format: `{N}. [{type}] {content}`.
 
-### Step 6: Validate State File
+Per locked decision: suggestions are fully editable. User can reword, remove, or add their own.
+Per locked decision: all sections look the same -- no visual distinction between auto-generated and user-written content.
 
-Use the Bash tool to run:
+If no pheromone suggestions available (empty array), display the existing default:
+```markdown
+## Pheromones
+
+No pheromone suggestions yet -- use /ant:focus and /ant:redirect to guide the colony.
 ```
-bash .aether/aether-utils.sh validate-state colony
+
+End with clear instructions:
 ```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Review the prompt above. You can:
+  - Edit any section (just describe your changes)
+  - Say "approve" or "looks good" to proceed
+  - Say "cancel" to abort
+
+If you don't respond, the colony will not be initialized.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**STOP HERE.** Wait for the user's response. Do NOT proceed to Step 6 until the user responds.
 
-This validates COLONY_STATE.json structure. If validation fails, output a warning.
+### Step 6: Handle User Response
 
-### Step 6.5: Detect Nestmates
+Parse the user's response:
+- If the user approves (says "approve", "looks good", "yes", "ok", or similar): proceed to Step 7
+- If the user provides edits: apply the edits to the relevant section(s), re-display the full prompt, increment a revision counter, and wait again
+- If the user cancels: display "Colony initialization cancelled." and stop
+- Max 2 revision rounds. After 2 rejections/edits, display: "Maximum revisions reached. Approve current version, or cancel init?" and wait for final decision
 
-Run using Bash tool: `node -e "const nl = require('./bin/lib/nestmate-loader'); console.log(JSON.stringify(nl.findNestmates(process.cwd())))"`
+When applying edits, Claude updates the section content in memory (not files) and re-displays the full prompt. Each re-display includes a revision counter: "(Revision {N}/2)"
 
-If nestmates are found:
-1. Display: `Nestmates found: N related colonies`
-2. List each nestmate with name and truncated goal
-3. Check for shared TO-DOs or cross-project dependencies
+### Step 7: Create Colony (Post-Approval)
 
-### Step 6.6: Register Repo (Silent)
+Only reached after user approval. ALL file writes happen here.
 
-Attempt to register this repo in the global hub. Both steps are silent on failure — registry is not required for the colony to work.
+**If re-init mode:**
 
-Run using the Bash tool (ignore errors):
+1. Write charter content via:
+```bash
+bash .aether/aether-utils.sh charter-write --intent "{approved_intent}" --vision "{approved_vision}" --governance "{approved_governance}" --goals "{approved_goals}"
 ```
-bash .aether/aether-utils.sh registry-add "$(pwd)" "$(jq -r '.version // "unknown"' ~/.aether/version.json 2>/dev/null || echo 'unknown')" 2>/dev/null || true
+
+2. Auto-apply approved pheromone suggestions (see pheromone auto-apply below).
+
+3. Optionally update the goal field in COLONY_STATE.json in-place:
+```bash
+jq --arg new_goal "{approved_intent}" '.goal = $new_goal' .aether/data/COLONY_STATE.json > .aether/data/COLONY_STATE.json.tmp && mv .aether/data/COLONY_STATE.json.tmp .aether/data/COLONY_STATE.json
 ```
 
-Then attempt to write `.aether/version.json` with the hub version:
+4. Run `bash .aether/aether-utils.sh session-init "$(jq -r '.session_id' .aether/data/COLONY_STATE.json)" "{approved_intent}"`
+
+5. Skip to Step 8 (display result). Do NOT write COLONY_STATE.json from template, do NOT write constraints.json, do NOT write pheromones.json.
+
+**If fresh init:**
+
+1. Initialize QUEEN.md (already done in Step 2)
+2. Write charter content via charter-write (same command as above)
+3. Auto-apply approved pheromone suggestions (see pheromone auto-apply below).
+4. Write COLONY_STATE.json from template:
+   - Generate a session ID in the format `session_{unix_timestamp}_{random}` and an ISO-8601 UTC timestamp
+   - Resolve template: check `~/.aether/system/templates/colony-state.template.json` first, then `.aether/templates/colony-state.template.json`
+   - If no template found: output "Template missing: colony-state.template.json. Run aether update to fix." and stop
+   - Read the template file. Follow its `_instructions` field
+   - Replace placeholders: `__GOAL__` with approved intent, `__SESSION_ID__` with generated session ID, `__ISO8601_TIMESTAMP__` with current timestamp, `__PHASE_LEARNINGS__` with `[]`, `__INSTINCTS__` with `[]`
+   - Remove ALL keys starting with underscore
+   - Write the resulting JSON to `.aether/data/COLONY_STATE.json` using the Write tool
+
+5. Write constraints.json from template:
+   - Resolve template: check `~/.aether/system/templates/constraints.template.json` first, then `.aether/templates/constraints.template.json`
+   - If no template found: output "Template missing: constraints.template.json. Run aether update to fix." and stop
+   - Read template, follow `_instructions`, remove `_` prefixed keys, write to `.aether/data/constraints.json`
+
+6. Initialize runtime files from templates (non-blocking):
+```bash
+for template in pheromones midden learning-observations; do
+  if [[ "$template" == "midden" ]]; then
+    target=".aether/data/midden/midden.json"
+  else
+    target=".aether/data/${template}.json"
+  fi
+  if [[ ! -f "$target" ]]; then
+    template_file=""
+    for path in ~/.aether/system/templates/${template}.template.json .aether/templates/${template}.template.json; do
+      if [[ -f "$path" ]]; then
+        template_file="$path"
+        break
+      fi
+    done
+    if [[ -n "$template_file" ]]; then
+      jq 'with_entries(select(.key | startswith("_") | not))' "$template_file" > "$target" 2>/dev/null || true
+    fi
+  fi
+done
 ```
+
+7. Run `bash .aether/aether-utils.sh context-update init "{approved_intent}"`
+8. Run `bash .aether/aether-utils.sh validate-state colony`
+9. Register repo (silent on failure):
+```bash
+domain_tags=$(bash .aether/aether-utils.sh domain-detect 2>/dev/null | jq -r '.result.tags // ""' || echo "")
+bash .aether/aether-utils.sh registry-add "$(pwd)" "$(jq -r '.version // "unknown"' ~/.aether/version.json 2>/dev/null || echo 'unknown')" --goal "{approved_intent}" --active true --tags "$domain_tags" 2>/dev/null || true
 cp ~/.aether/version.json .aether/version.json 2>/dev/null || true
 ```
+10. Seed QUEEN.md from hive (non-blocking):
+```bash
+domain_tags=$(jq -r --arg repo "$(pwd)" \
+  '[.repos[] | select(.path == $repo) | .domain_tags // []] | .[0] // [] | join(",")' \
+  "$HOME/.aether/registry.json" 2>/dev/null || echo "")
+seed_args="queen-seed-from-hive --limit 5"
+[[ -n "$domain_tags" ]] && seed_args="$seed_args --domain $domain_tags"
+seed_result=$(bash .aether/aether-utils.sh $seed_args 2>/dev/null || echo '{}')
+seeded_count=$(echo "$seed_result" | jq -r '.result.seeded // 0' 2>/dev/null || echo "0")
+```
+11. Run `bash .aether/aether-utils.sh session-init "{session_id}" "{approved_intent}"`
 
-If either command fails, proceed silently. These are optional bookkeeping.
+**Pheromone auto-apply (referenced by both re-init and fresh init paths above):**
 
-### Step 7: Display Result
+If approved pheromone suggestions exist (the user kept them in the prompt and didn't remove them during the approval loop):
 
-**If visual_mode is true, render final swarm display:**
+For each approved pheromone suggestion, call:
 ```bash
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "completed" "Colony initialized" "Colony" '{"read":5,"grep":2,"edit":3,"bash":2}' 100 "fungus_garden" 100
-bash .aether/aether-utils.sh swarm-display-inline "$init_id"
+bash .aether/aether-utils.sh pheromone-write "{type}" '{content}' --source "system:init" --reason '{reason}' --ttl "30d" 2>/dev/null || true
 ```
 
-Output this header:
+Implementation notes:
+- Claude (the LLM executing init.md) tracks which pheromones the user kept, edited, or removed during the approval loop (Step 6). Only emit pheromones that survived approval.
+- Use single quotes around pheromone content and reason to avoid shell metacharacter issues (per pitfall 4).
+- Each `pheromone-write` call uses `2>/dev/null || true` to make it non-blocking -- a failed write should never stop colony creation.
+- The `--source "system:init"` tag identifies these as init-derived pheromones.
+- The `--ttl "30d"` gives suggestions a 30-day lifespan (project-level conventions, not phase-specific).
+- `pheromone-write` handles deduplication via content hashing -- if a signal with the same content already exists, it will reinforce rather than duplicate.
+
+### Step 7.5: Import Previous Colony Data (optional)
 
+Check if previous colony chambers contain importable XML data:
+
+```bash
+# Find most recent chamber with XML files (per D-07)
+latest_chamber=$(ls -d .aether/chambers/20* 2>/dev/null | sort -r | head -1)
+xml_import_available=false
+import_summary=""
+
+if [[ -n "$latest_chamber" ]]; then
+  xml_count=$(find "$latest_chamber" -maxdepth 1 -name "*.xml" ! -name "colony-archive.xml" 2>/dev/null | wc -l | tr -d ' ')
+  if [[ "$xml_count" -gt 0 ]] && command -v xmllint >/dev/null 2>&1; then
+    xml_import_available=true
+    chamber_name=$(basename "$latest_chamber")
+    # Count importable items for display
+    signal_count=$(jq '.signals | length' "$latest_chamber/pheromones.json" 2>/dev/null || echo "0")
+    import_summary="Found ${signal_count} signal(s) and ${xml_count} XML file(s) from colony '${chamber_name}'"
+  fi
+fi
 ```
-🌱🐜🆕🐜🌱 ═══════════════════════════════════════════════════
-   A E T H E R   C O L O N Y
-═══════════════════════════════════════════════════ 🌱🐜🆕🐜🌱
+
+**If xml_import_available is true:**
+
+Display the import offer (per D-08):
 ```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   PREVIOUS COLONY DATA FOUND
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+{import_summary}
 
-Then output the result:
+Import signals and wisdom from this colony?
+This will add to (not replace) your current colony data.
 
+Import? (yes/no)
 ```
-👑 Queen has set the colony's intention
 
-   "{goal}"
+Use `AskUserQuestion` with yes/no options.
+
+**If user selects "yes":**
+
+Import ALL available data types (per D-09 -- no cherry-picking):
 
-🏠 Colony Status: READY
-📋 Session: <session_id>
+```bash
+# Import pheromones (per D-09)
+if [[ -f "$latest_chamber/pheromones.xml" ]]; then
+  pher_import=$(bash .aether/aether-utils.sh pheromone-import-xml "$latest_chamber/pheromones.xml" "imported" 2>/dev/null || echo '{"ok":false}')
+  pher_imported=$(echo "$pher_import" | jq -r '.result.imported // 0' 2>/dev/null || echo "0")
+  echo "Pheromones: ${pher_imported} signal(s) imported"
+fi
+
+# Import wisdom to queen-wisdom.json (per D-09)
+if [[ -f "$latest_chamber/queen-wisdom.xml" ]]; then
+  wis_import=$(bash .aether/aether-utils.sh wisdom-import-xml "$latest_chamber/queen-wisdom.xml" ".aether/data/queen-wisdom.json" 2>/dev/null || echo '{"ok":false}')
+  wis_imported=$(echo "$wis_import" | jq -r '.result.imported // 0' 2>/dev/null || echo "0")
+  echo "Wisdom: ${wis_imported} entries(s) imported to queen-wisdom.json"
+fi
+
+# Import registry lineage (per D-09)
+if [[ -f "$latest_chamber/colony-registry.xml" ]]; then
+  reg_import=$(bash .aether/aether-utils.sh registry-import-xml "$latest_chamber/colony-registry.xml" 2>/dev/null || echo '{"ok":false}')
+  reg_imported=$(echo "$reg_import" | jq -r '.result.imported // 0' 2>/dev/null || echo "0")
+  echo "Registry: ${reg_imported} colon(ies) lineage imported"
+fi
+```
 
-{If instincts or learnings were inherited from Step 2.6:}
-🧠 Inherited from prior colony:
-   {N} instinct(s) | {N} learning(s)
-{End if}
+All imports are non-blocking -- log warning and continue if any fails.
 
-{If nestmates found in Step 5.5:}
-🏘️ Nest Context: {N} sibling colonies detected
-   Context from related projects will be automatically considered
-   during planning and execution.
-{End if}
+**If user selects "no":**
 
-🐜 The colony awaits your command:
+Display "Import skipped. Starting fresh colony." and proceed to Step 8.
 
-   /ant:plan      📋 Generate project plan
-   /ant:colonize  🗺️  Analyze existing codebase first
-   /ant:watch     👁️  Set up live visibility
+**If xml_import_available is false (no chambers, no XML, or no xmllint):**
 
-💾 State persisted — safe to /clear, then run /ant:plan
+Skip silently -- proceed directly to Step 8 without any mention of import (per D-11).
+### Step 8: Display Result
+
+Display the success header and result block:
 
-📋 Context document created at `.aether/CONTEXT.md` — read this if session resets
 ```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   A E T H E R   C O L O N Y
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-### Step 8: Initialize Session
+Queen has set the colony's intention
 
-Initialize session tracking to enable `/ant:resume` after context clear:
+   "{approved_intent}"
 
-```bash
-bash .aether/aether-utils.sh session-init "$(jq -r '.session_id' .aether/data/COLONY_STATE.json)" "$ARGUMENTS"
+   Colony Status: READY
+
+{If re-init: "   Mode: Re-init (charter updated, state preserved)"}
+{If fresh and seeded_count > 0: "   Hive wisdom: {seeded_count} cross-colony pattern(s) seeded into QUEEN.md"}
+
+State persisted -- safe to /clear, then run /ant:plan
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   Next Up
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   /ant:plan                 Generate execution plan
+   /ant:status               Check colony state
+   /ant:focus                Set initial focus
 ```