aether-colony 3.1.17 → 5.1.0

package/.opencode/commands/ant/run.md

@@ -0,0 +1,201 @@
+<!-- Generated from .aether/commands/run.yaml - DO NOT EDIT DIRECTLY -->
+---
+name: ant:run
+description: "🤖🐜🔄🐜🤖 Autopilot — builds, verifies, learns, and advances through phases automatically with smart pausing"
+---
+
+### Step -1: Normalize Arguments
+
+Run: `normalized_args=$(bash .aether/aether-utils.sh normalize-args "$@")`
+
+This ensures arguments work correctly in both Claude Code and OpenCode. Use `$normalized_args` throughout this command.
+
+You are the **Queen**. Execute `/ant:run` — the adaptive autopilot loop.
+
+The arguments are: `$normalized_args`
+
+## Purpose
+
+This command automates the build-continue-advance cycle across multiple phases.
+It reads and executes the same playbooks used by `/ant:build` and `/ant:continue`,
+chaining them in a loop with intelligent pause conditions.
+
+## Rules
+
+1. Do **not** invoke nested slash commands (`/ant:build`, `/ant:continue`, etc.).
+2. Use the Read tool to load each playbook file, then execute it inline.
+3. Preserve variables/results from prior stages and pass them forward.
+4. Stop immediately on any pause condition (defined below).
+5. Keep existing behavior and output format from the playbooks.
+6. Log `autopilot_advance` events after each successful phase transition.
+
+## Arguments
+
+Parse `$normalized_args` for:
+- `--max-phases N` — Max phases to process (default: all remaining)
+- `--replan-interval N` — Pause for replan suggestion every N phases (default: 2)
+- `--continue` — Resume after a replan pause without replanning
+- `--dry-run` — Preview plan without executing
+- `--verbose` / `-v`, `--no-visual`, `--no-suggest` — Pass through to playbooks
+
+```
+/ant:run                       Run all remaining phases
+/ant:run --max-phases 2        Run at most 2 phases then stop
+/ant:run --replan-interval 3   Suggest replan every 3 phases instead of 2
+/ant:run --continue            Resume after replan pause without replanning
+/ant:run --dry-run             Preview the autopilot plan
+/ant:run --max-phases 3 -v     Run 3 phases with verbose output
+```
+
+## Dry Run Mode
+
+If `--dry-run`: read COLONY_STATE.json, list remaining incomplete phases
+(applying `--max-phases` cap), display the plan, then stop without executing.
+
+```
+━━━ A U T O P I L O T   P R E V I E W ━━━
+Goal: {goal} | Current: Phase {N} | Remaining: {count} | Max: {max or "all"}
+
+  Phase {id}: {name} ({task_count} tasks) -> build -> continue -> advance
+  ...
+
+Pause triggers: test failures, critical Chaos findings, new blockers,
+security gate failures, quality gate failures, runtime verification needed,
+replan suggestion (every {replan_interval} phases)
+```
+
+## Autopilot Loop
+
+### Step 0: Initialize
+
+1. Read `.aether/data/COLONY_STATE.json`; validate goal + plan.phases exist
+2. Determine remaining incomplete phases; apply `--max-phases` cap
+3. Set `phases_completed = 0`, `autopilot_start = $(date +%s)`
+4. Record pre-build blocker count: `bash .aether/aether-utils.sh flag-check-blockers {phase}`
+5. Display: `AUTOPILOT ENGAGED | Goal: {goal} | Phase {N} | Max: {max or "all"}`
+
+### Step 1: Build Phase
+
+Execute build playbooks in order, carrying cross-stage state
+(`phase_id`, `visual_mode`, `verbose_mode`, `suggest_enabled`,
+`prompt_section`, `wave_results`,
+`verification_status`, `synthesis_status`, `next_action`):
+
+1. `.aether/docs/command-playbooks/build-prep.md`
+2. `.aether/docs/command-playbooks/build-context.md`
+3. `.aether/docs/command-playbooks/build-wave.md`
+4. `.aether/docs/command-playbooks/build-verify.md`
+5. `.aether/docs/command-playbooks/build-complete.md`
+
+Capture the synthesis result for pause evaluation.
+
+### Step 2: Build Pause Check
+
+**PAUSE if ANY of these are true** (display reason, log event, STOP):
+
+| # | Condition | Source |
+|---|-----------|--------|
+| 1 | Watcher `verification_passed == false` | build-verify synthesis |
+| 2 | Any Chaos finding severity `critical` or `high` | build-verify synthesis |
+| 3 | New blocker flags created (count increased since Step 0.4) | flag-check-blockers |
+
+On pause, display the AUTOPILOT PAUSED banner with reason, affected phase,
+specific issues, and instruction: "Fix issues, then run /ant:run to resume."
+Log: `"<timestamp>|autopilot_paused|run|Paused at Phase {id}: {reason}"`
+
+**If no pause:** proceed to Step 3.
+
+### Step 3: Continue (Verify + Advance)
+
+Execute continue playbooks in order, carrying cross-stage state
+(`visual_mode`, `state`, `current_phase`, `verification_results`,
+`gate_results`, `advancement_result`, `next_phase_id`, `completion_state`):
+
+1. `.aether/docs/command-playbooks/continue-verify.md`
+2. `.aether/docs/command-playbooks/continue-gates.md`
+3. `.aether/docs/command-playbooks/continue-advance.md`
+4. `.aether/docs/command-playbooks/continue-finalize.md`
+
+**Autopilot override for runtime verification (Step 1.11 in continue-gates):**
+Skip the AskUserQuestion prompt. Instead, auto-PAUSE with reason
+"Runtime verification required" so the user can test manually before resuming.
+
+### Step 4: Continue Pause Check
+
+**PAUSE if ANY of these are true:**
+
+| # | Condition | Source |
+|---|-----------|--------|
+| 4 | Verification loop reported NOT READY | continue-verify |
+| 5 | Gatekeeper found critical CVEs | continue-gates |
+| 6 | Auditor critical findings or score < 60 | continue-gates |
+| 7 | Unresolved blocker flags remain | continue-gates |
+| 8 | Runtime verification needed | continue-gates Step 1.11 |
+| 9 | All phases complete (no next phase) | continue-advance |
+| 10 | Replan trigger fires (unless `--continue`) | autopilot-check-replan (Step 5.5) |
+
+For condition 9: jump to Step 6 (celebration). For condition 10: PAUSE with
+replan suggestion (see Step 5.5). For all others: PAUSE with reason, log event, STOP.
+
+**If no pause:** proceed to Step 5.
+
+### Step 5: Auto-Advance and Loop
+
+1. Increment `phases_completed`
+2. Update autopilot state: `bash .aether/aether-utils.sh autopilot-update --action advance --phase {next} --result success`
+3. Log: `"<timestamp>|autopilot_advance|run|Phase {prev} -> {next} ({phases_completed}/{max})"`
+4. Display: `--- Autopilot: Phase {prev} done -> Phase {next} ({N}/{max}) ---`
+5. **Replan check** (see Step 5.5)
+6. If `phases_completed >= max_phases` or no incomplete phases: go to Step 6
+7. Otherwise: update `current_phase`, return to Step 1
+
+### Step 5.5: Replan Trigger Check
+
+After each successful phase advance, check if a replan pause should fire:
+
+```bash
+bash .aether/aether-utils.sh autopilot-check-replan --interval {replan_interval}
+```
+
+If `--continue` flag was passed: skip this check entirely (user dismissed replan).
+
+If `result.should_replan == true`: **PAUSE** with replan suggestion banner:
+
+```
+━━━ R E P L A N   S U G G E S T E D ━━━
+Phases auto-completed: {N} | Learnings accumulated: {learnings_since_last}
+
+The colony has completed {N} phases since the last plan review.
+New learnings may have changed the optimal path forward.
+
+Options:
+  /ant:plan              Regenerate phases with current learnings
+  /ant:run --continue    Dismiss and continue without replanning
+```
+
+Log: `"<timestamp>|autopilot_replan_pause|run|Replan suggested after {N} phases ({learnings} learnings)"`
+
+If `result.should_replan == false`: proceed normally (no pause).
+
+### Step 6: Final Summary
+
+```
+━━━ A U T O P I L O T   C O M P L E T E ━━━
+Phases completed: {N} | Elapsed: {Xm Ys} | Now at: Phase {current}
+
+{all complete}  -> Colony goal achieved! Run /ant:seal
+{max reached}   -> Run /ant:run to continue
+{replan}        -> Run /ant:plan to replan, or /ant:run --continue to dismiss
+{paused}        -> Fix {reason}, then /ant:run to resume
+```
+
+Update session:
+`bash .aether/aether-utils.sh session-update "/ant:run" "/ant:run" "Autopilot: {N} phases, now Phase {current}"`
+
+## Execution Contract
+
+For each playbook stage: Read file, execute inline, track `{stage_name, status, key_outputs}`.
+If `status == failed`: evaluate pause conditions. Pause = graceful stop with saved state.
+Hard failure (e.g., state corruption) = halt immediately, no recovery attempt.
+
+On every pause: save COLONY_STATE.json, log event, update session, display resume instructions.

package/.opencode/commands/ant/seal.md

@@ -1,34 +1,23 @@
+<!-- Generated from .aether/commands/seal.yaml - DO NOT EDIT DIRECTLY -->
 ---
 name: ant:seal
 description: "🏺🐜🏺 Seal the colony with Crowned Anthill milestone"
 ---
 
-You are the **Queen**. Seal the colony when all work is complete.
-
-## Instructions
-
 ### Step -1: Normalize Arguments
 
 Run: `normalized_args=$(bash .aether/aether-utils.sh normalize-args "$@")`
 
 This ensures arguments work correctly in both Claude Code and OpenCode. Use `$normalized_args` throughout this command.
 
+You are the **Queen**. Seal the colony when all work is complete.
+
+## Instructions
+
 Parse `$normalized_args`:
 - 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
-seal_id="seal-$(date +%s)"
-
-# Initialize swarm display
-bash .aether/aether-utils.sh swarm-display-init "$seal_id"
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "excavating" "Sealing colony" "Colony" '{"read":0,"grep":0,"edit":0,"bash":0}' 0 "fungus_garden" 0
-```
-
 ### Step 1: Read State
 
 Read `.aether/data/COLONY_STATE.json`.
@@ -139,6 +128,31 @@ Create archive manifest file `$archive_dir/manifest.json`:
 }
 ```
 
+### Step 4.5: Increment Colony Version
+
+Before writing the Crowned Anthill milestone, increment `colony_version` in COLONY_STATE.json.
+
+```bash
+# Read current colony_version (default to 0 for backward compat with older colonies)
+current_colony_version=$(jq -r '.colony_version // 0' .aether/data/COLONY_STATE.json 2>/dev/null || echo 0)
+# Guard against non-integer values (floats, strings)
+[[ "$current_colony_version" =~ ^[0-9]+$ ]] || current_colony_version=0
+new_colony_version=$(( current_colony_version + 1 ))
+
+# Write incremented value back — guard against empty output destroying the file
+updated=$(jq --argjson v "$new_colony_version" '.colony_version = $v' .aether/data/COLONY_STATE.json 2>/dev/null)
+if [[ -n "$updated" && ${#updated} -gt 10 ]]; then
+  echo "$updated" > .aether/data/COLONY_STATE.json
+else
+  echo "Warning: jq update failed — colony_version defaults to 1, state file unchanged"
+  new_colony_version=1
+fi
+```
+
+Use `new_colony_version` as `{colony_version}` throughout the rest of the seal ceremony (e.g., display as "Crowned Anthill v{colony_version}").
+
+**Error handling:** If jq fails or produces empty/short output, COLONY_STATE.json is NOT overwritten and `new_colony_version` defaults to 1. Never let version increment failures block the seal.
+
 ### Step 5: Update Milestone to Crowned Anthill
 
 Update COLONY_STATE.json:
@@ -146,60 +160,188 @@ Update COLONY_STATE.json:
 2. Set `milestone_updated_at` to current ISO-8601 timestamp
 3. Append event: `"<timestamp>|milestone_reached|archive|Achieved Crowned Anthill milestone - colony archived"`
 
-### Step 5.5: Write Final Handoff
+### Step 5.1: Update Changelog
 
-After archiving, write the final handoff documenting the completed colony:
+**MANDATORY: Record the seal in the project changelog. This step is never skipped.**
+
+If no `CHANGELOG.md` exists, `changelog-append` creates one automatically.
+
+Build a summary of what the colony accomplished across all phases:
+- Collect completed phase names from COLONY_STATE.json
+- Summarize the goal and key outcomes in one line
 
 ```bash
-cat > .aether/HANDOFF.md << 'HANDOFF_EOF'
-# Colony Session — SEALED (Crowned Anthill)
+bash .aether/aether-utils.sh changelog-append \
+  "$(date +%Y-%m-%d)" \
+  "seal-crowned-anthill" \
+  "00" \
+  "{key_files_csv}" \
+  "Colony sealed at Crowned Anthill;{goal}" \
+  "{phases_completed} phases completed;Colony wisdom promoted to QUEEN.md" \
+  ""
+```
+
+- `{key_files_csv}` — list the most significant files created or modified across the colony's lifetime (derive from phase plans or git log)
+- `{goal}` — the colony goal from COLONY_STATE.json
+
+**Error handling:** If `changelog-append` fails, log to midden and continue — changelog failure never blocks sealing.
+
+### Step 5.2: Update Registry (Silent)
+
+Mark the colony as inactive in the global registry. This is silent on failure — registry is not required for the colony to work.
+
+Run using the Bash tool (ignore errors):
+```bash
+bash .aether/aether-utils.sh registry-add "$(pwd)" "$(jq -r '.version // "unknown"' ~/.aether/version.json 2>/dev/null || echo 'unknown')" --active false 2>/dev/null || true
+```
+
+If the command fails, proceed silently. This is optional bookkeeping.
+
+### Step 5.25: Hive Promotion (NON-BLOCKING)
+
+After wisdom promotion, promote abstracted instincts to the cross-colony hive.
+
+**Extract high-confidence instincts for hive promotion:**
+```bash
+# Get instincts with confidence >= 0.8
+high_conf_instincts=$(jq -r '.memory.instincts[] | select(.confidence >= 0.8) | @base64' .aether/data/COLONY_STATE.json 2>/dev/null || echo "")
+
+# Derive source repo name from current directory
+source_repo="$(pwd)"
+
+# Read domain tags from registry (NOT from instinct.domain which is a category, not a repo domain)
+repo_domain_tags=$(jq -r --arg repo "$(pwd)" \
+  '[.repos[] | select(.path == $repo) | .domain_tags // []] | .[0] // [] | join(",")' \
+  "$HOME/.aether/registry.json" 2>/dev/null || echo "")
+
+hive_promoted_count=0
+hive_errors=0
+for encoded in $high_conf_instincts; do
+  [[ -z "$encoded" ]] && continue
+
+  # Extract trigger and action fields from the instinct object
+  trigger=$(echo "$encoded" | base64 -d | jq -r '.trigger // empty')
+  action=$(echo "$encoded" | base64 -d | jq -r '.action // empty')
+  confidence=$(echo "$encoded" | base64 -d | jq -r '.confidence // 0.7')
+
+  [[ -z "$trigger" || -z "$action" ]] && continue
 
-## 🏆 Colony Complete
-**Status:** Crowned Anthill — All phases completed and archived
+  # Strip leading "When " or "when " from trigger to avoid "When When..." stutter
+  trigger_clean=$(echo "$trigger" | sed 's/^[Ww]hen //')
 
-## Archive Location
-{archive_dir}
+  # Build the promotion text in "When {trigger}: {action}" format
+  promote_text="When ${trigger_clean}: ${action}"
 
-## Colony Summary
-- Goal: "{goal}"
-- Total Phases: {total_phases}
-- Milestone: Crowned Anthill
-- Sealed At: {timestamp}
+  # Build hive-promote args with --text and --source-repo (required)
+  promote_args=(hive-promote --text "$promote_text" --source-repo "$source_repo" --confidence "$confidence")
+  [[ -n "$repo_domain_tags" ]] && promote_args+=(--domain "$repo_domain_tags")
 
-## Files Archived
-- COLONY_STATE.json
-- activity.log
-- spawn-tree.txt
-- flags.json (if existed)
-- constraints.json (if existed)
+  # Call hive-promote which orchestrates abstract + store
+  result=$(bash .aether/aether-utils.sh "${promote_args[@]}" 2>/dev/null || echo '{}')
+  was_promoted=$(echo "$result" | jq -r '.result.action // "skipped"' 2>/dev/null || echo "skipped")
 
-## Session Note
-This colony has been sealed and archived. The anthill stands crowned.
-To start anew, run: /ant:lay-eggs "<new goal>"
-HANDOFF_EOF
+  if [[ "$was_promoted" == "promoted" || "$was_promoted" == "merged" ]]; then
+    hive_promoted_count=$((hive_promoted_count + 1))
+  fi
+done
+
+if [[ "$hive_promoted_count" -gt 0 ]]; then
+  echo "Hive promotion: $hive_promoted_count instinct(s) promoted to cross-colony hive"
+fi
 ```
 
+**Continue to Step 5.5 (non-blocking):**
+Proceed to Step 5.5 regardless of hive promotion results — hive promotion is strictly non-blocking.
+
+### Step 5.5: Write Final Handoff
+
+After archiving, write the final handoff documenting the completed colony:
+
+Resolve the handoff template path:
+  Check ~/.aether/system/templates/handoff.template.md first,
+  then .aether/templates/handoff.template.md.
+
+If no template found: output "Template missing: handoff.template.md. Run aether update to fix." and stop.
+
+Read the template file. Fill all {{PLACEHOLDER}} values:
+  - {{CHAMBER_NAME}} → archive directory name
+  - {{GOAL}} → goal
+  - {{PHASES_COMPLETED}} → total_phases (OpenCode seal archives completed colonies)
+  - {{TOTAL_PHASES}} → total_phases
+  - {{MILESTONE}} → "Crowned Anthill"
+  - {{ENTOMB_TIMESTAMP}} → seal timestamp
+
+Remove the HTML comment lines at the top of the template.
+Write the result to .aether/HANDOFF.md using the Write tool.
+
 This handoff serves as the final record of the completed colony.
 
-### Step 6: Display Result
+### Step 5.75: Export XML Archive (best-effort)
+
+Export colony data as a combined XML archive and a standalone pheromones.xml. Both are best-effort — seal proceeds even if XML export fails.
 
-**If visual_mode is true, render final swarm display:**
 ```bash
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "completed" "Colony sealed" "Colony" '{"read":3,"grep":0,"edit":2,"bash":3}' 100 "fungus_garden" 100
-bash .aether/aether-utils.sh swarm-display-render "$seal_id"
+# Check if xmllint is available
+if command -v xmllint >/dev/null 2>&1; then
+  xml_result=$(bash .aether/aether-utils.sh colony-archive-xml ".aether/exchange/colony-archive.xml" 2>&1)
+  xml_ok=$(echo "$xml_result" | jq -r '.ok // false' 2>/dev/null)
+  if [[ "$xml_ok" == "true" ]]; then
+    xml_pheromone_count=$(echo "$xml_result" | jq -r '.result.pheromone_count // 0' 2>/dev/null)
+    xml_export_line="XML Archive: colony-archive.xml (${xml_pheromone_count} active signals)"
+  else
+    xml_export_line="XML Archive: export failed (non-blocking)"
+  fi
+
+  # Also export standalone pheromones.xml for cross-colony sharing
+  pher_result=$(bash .aether/aether-utils.sh pheromone-export-xml ".aether/exchange/pheromones.xml" 2>&1)
+  pher_ok=$(echo "$pher_result" | jq -r '.ok // false' 2>/dev/null)
+  if [[ "$pher_ok" == "true" ]]; then
+    pher_signal_count=$(jq '[.signals[] | select(.active != false)] | length' .aether/data/pheromones.json 2>/dev/null || echo "0")
+    pher_export_line="Signal Export: pheromones.xml (${pher_signal_count} signals, importable by other colonies)"
+  else
+    pher_export_line="Signal Export: failed (non-blocking)"
+  fi
+
+  # Export standalone queen-wisdom.xml for cross-colony wisdom sharing
+  wisdom_result=$(bash .aether/aether-utils.sh wisdom-export-xml ".aether/exchange/queen-wisdom.xml" 2>&1)
+  wisdom_ok=$(echo "$wisdom_result" | jq -r '.ok // false' 2>/dev/null)
+  if [[ "$wisdom_ok" == "true" ]]; then
+    wisdom_count=$(echo "$wisdom_result" | jq -r '.result.entries // 0' 2>/dev/null)
+    wisdom_export_line="Wisdom Export: queen-wisdom.xml (${wisdom_count} entries)"
+  else
+    wisdom_export_line="Wisdom Export: failed (non-blocking)"
+  fi
+
+  # Export standalone colony-registry.xml for lineage tracking
+  registry_result=$(bash .aether/aether-utils.sh registry-export-xml ".aether/exchange/colony-registry.xml" 2>&1)
+  registry_ok=$(echo "$registry_result" | jq -r '.ok // false' 2>/dev/null)
+  if [[ "$registry_ok" == "true" ]]; then
+    registry_count=$(echo "$registry_result" | jq -r '.result.colonies // 0' 2>/dev/null)
+    registry_export_line="Registry Export: colony-registry.xml (${registry_count} colonies)"
+  else
+    registry_export_line="Registry Export: failed (non-blocking)"
+  fi
+else
+  xml_export_line="XML Archive: skipped (xmllint not available)"
+  pher_export_line="Signal Export: skipped (xmllint not available)"
+  wisdom_export_line="Wisdom Export: skipped (xmllint not available)"
+  registry_export_line="Registry Export: skipped (xmllint not available)"
+fi
 ```
 
+### Step 6: Display Result
+
 Output:
 ```
 🏺 ════════════════════════════════════════════════════
-   C R O W N E D   A N T H I L L
+   C R O W N E D   A N T H I L L   v{colony_version}
 ══════════════════════════════════════════════════ 🏺
 
 ✅ Colony archived successfully!
 
 👑 Goal: {goal (truncated to 60 chars)}
 📍 Phases: {total_phases} completed
-🏆 Milestone: Crowned Anthill
+🏆 Milestone: Crowned Anthill v{colony_version}
 
 📦 Archive Location: {archive_dir}
    - COLONY_STATE.json
@@ -207,6 +349,10 @@ Output:
    - spawn-tree.txt
    - flags.json (if existed)
    - constraints.json (if existed)
+{xml_export_line}
+{pher_export_line}
+{wisdom_export_line}
+{registry_export_line}
 
 🐜 The colony has reached its final form.
    The anthill stands crowned and sealed.
@@ -226,6 +372,74 @@ If option 2 selected: run /ant:tunnels
 If option 3 selected: display "Run /ant:lay-eggs to begin anew after clearing"
 ```
 
+### Step 6.5: Commit Suggestion (Non-blocking)
+
+After the ceremony, offer to commit all colony work.
+
+**Gate check — skip silently if any fail:**
+1. Not a git repo: `git rev-parse --git-dir 2>/dev/null` fails -> skip
+2. Clean working tree: `git status --porcelain 2>/dev/null` is empty -> skip to Step 6.6
+
+**If uncommitted changes exist:**
+
+Generate a seal commit message:
+```bash
+seal_commit=$(bash .aether/aether-utils.sh generate-commit-message seal "$phases_completed" "$goal" "$colony_age_days" 2>/dev/null)
+seal_message=$(echo "$seal_commit" | jq -r '.result.message // "aether-seal: colony sealed"')
+seal_body=$(echo "$seal_commit" | jq -r '.result.body // ""')
+```
+
+Display the suggestion:
+```
+Commit suggestion:
+  $seal_message
+  $seal_body
+```
+
+Prompt with AskUserQuestion (3 options):
+1. **Commit with this message** — Run `git add -A && git commit -m "$seal_message" -m "$seal_body"`
+2. **Edit message** — Ask user for their preferred message, then commit with that
+3. **Skip** — Do not commit
+
+If the user chooses option 1 or 2 and the commit succeeds, set `seal_committed = true`.
+If the commit fails or user skips, set `seal_committed = false`.
+
+**Error handling:** If `generate-commit-message` fails, fall back to message `"aether-seal: colony sealed"`. Never let commit suggestion failures stop the seal flow.
+
+### Step 6.6: Push Suggestion (Non-blocking)
+
+Only show if a commit was just made in Step 6.5 (`seal_committed == true`) OR if there are unpushed commits.
+
+**Gate check — skip silently if any fail:**
+1. Not a git repo -> skip
+2. No remote configured: `git remote -v 2>/dev/null` is empty -> skip
+
+**Check for unpushed commits:**
+```bash
+unpushed=$(git log --oneline @{u}..HEAD 2>/dev/null | wc -l | tr -d ' ')
+```
+If `unpushed == 0` and `seal_committed == false` -> skip
+
+**If there are commits to push:**
+
+Detect current branch and upstream status:
+```bash
+current_branch=$(git branch --show-current)
+has_upstream=$(git rev-parse --abbrev-ref @{u} 2>/dev/null && echo "yes" || echo "no")
+```
+
+Display: `Push {unpushed} commit(s) to remote? Branch: {current_branch}`
+
+Prompt with AskUserQuestion (2 options):
+1. **Push now** — If upstream exists: `git push`. If no upstream: `git push -u origin $current_branch`
+2. **I'll push later** — Skip
+
+Display result on success or skip.
+
+**Error handling:** If push fails, display the error but do not stop the seal flow.
+
+**Safety:** Never auto-push. Always require explicit user approval.
+
 ### Edge Cases
 
 **If milestone is already "Sealed Chambers" but phases are complete:**

package/.opencode/commands/ant/skill-create.md

@@ -0,0 +1,63 @@
+<!-- Generated from .aether/commands/skill-create.yaml - DO NOT EDIT DIRECTLY -->
+---
+name: ant:skill-create
+description: "Create a custom domain skill using Oracle mini-research and a guided wizard"
+---
+
+### Step -1: Normalize Arguments
+
+Run: `normalized_args=$(bash .aether/aether-utils.sh normalize-args "$@")`
+
+This ensures arguments work correctly in both Claude Code and OpenCode. Use `$normalized_args` throughout this command.
+
+You are the **Builder**. Create a custom domain skill by researching best practices and guiding the user through a wizard.
+
+## Instructions
+
+### Step 0: Parse Arguments
+
+If `$normalized_args` is empty:
+```
+Usage: /ant:skill-create "<topic>"
+
+Creates a custom domain skill using Oracle mini-research.
+
+Examples:
+  /ant:skill-create "tailwind"
+  /ant:skill-create "react native"
+  /ant:skill-create "kubernetes"
+```
+Stop here.
+
+### Step 1: Oracle Mini-Research
+
+Launch a focused research session on the topic (5 iterations max):
+1. Web search for best practices, common patterns, and gotchas
+2. Codebase scan for existing usage of the technology
+3. Compile findings into structured notes
+
+### Step 2: Wizard Questions
+
+Ask the user:
+1. What aspect to focus on? (provide 2-4 options based on findings)
+2. Experience level? (beginner / intermediate / advanced)
+3. Any specific rules or constraints? (free text)
+
+### Step 3: Generate SKILL.md
+
+Create the skill file with proper frontmatter and body:
+- name: derived from topic
+- description: "Use when working with {topic}"
+- type: domain
+- domains: inferred from research
+- agent_roles: [builder]
+- detect_files / detect_packages: inferred from research
+- Body: practical best-practices guide from research + wizard answers
+
+### Step 4: Write and Verify
+
+1. Write to `~/.aether/skills/domain/{name}/SKILL.md`
+2. Run: `bash .aether/aether-utils.sh skill-parse-frontmatter ~/.aether/skills/domain/{name}/SKILL.md`
+3. Run: `bash .aether/aether-utils.sh skill-cache-rebuild`
+4. Show the generated skill to the user
+5. Ask if they want to adjust anything