@automagik/genie 0.260202.1901 → 0.260203.135

package/.claude/skills/genie-base/scripts/sanity-sweep.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF'
+Usage:
+  sanity-sweep.sh --dest <workspace-path>
+
+Greps for common stale paths / conventions that should not persist after migration.
+Exits 0 always, but prints matches for manual cleanup.
+EOF
+}
+
+DEST=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --dest)
+      DEST="$2"; shift 2 ;;
+    -h|--help)
+      usage; exit 0 ;;
+    *)
+      echo "Unknown arg: $1" >&2
+      usage
+      exit 2
+      ;;
+  esac
+done
+
+if [[ -z "$DEST" ]]; then
+  echo "--dest is required" >&2
+  usage
+  exit 2
+fi
+
+PATTERNS=(
+  "/home/genie/.genie/workspace"
+  "/home/genie/.genie/chief-of-khal/khal"
+  "/Users/"
+)
+
+echo "Sanity sweep in: $DEST"
+
+for p in "${PATTERNS[@]}"; do
+  echo
+  echo "=== Searching for: $p"
+  grep -RIn --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=dist --exclude-dir=.next --exclude-dir=.cache -F "$p" "$DEST" || true
+  
+  # Also check for broken symlinks under .claude/plugins (common migration pitfall)
+  if [[ -d "$DEST/khal/.claude/plugins" ]]; then
+    echo
+    echo "--- Symlink check: $DEST/khal/.claude/plugins"
+    find "$DEST/khal/.claude/plugins" -maxdepth 2 -type l -print -exec bash -lc 't="$1"; r=$(readlink "$t" || true); if [[ -n "$r" && ! -e "$t" ]]; then echo "BROKEN: $t -> $r"; fi' bash {} \; || true
+  fi
+
+done
+
+echo
+echo "Done. If any matches printed above, update them to canonical paths:"
+echo "- /home/genie/workspace"
+echo "- /home/genie/workspace/khal"

package/.claude/skills/genie-blank-init/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: genie-blank-init
+description: "Initialize a fresh, user-centric Genie clone with a blank persona (first-activation experience) while keeping OS/environment competence. Use when the user wants a clone that will ask who it should be called, run BOOTSTRAP.md once, then delete BOOTSTRAP.md after verifying install. Pairs with genie-base or existing ENVIRONMENT/TOOLS." 
+---
+
+# Genie Blank Init (User-Centric First Activation)
+
+Goal: create the *first activation* experience ("Hello, who am I? who are you?") while **preserving machine context** (ENVIRONMENT/TOOLS) and **not inheriting Khal identity/role/memory**.
+
+This skill provides a BOOTSTRAP.md and blank identity/persona/memory stubs.
+
+## Install / apply to a workspace
+
+Run:
+
+```bash
+bash {baseDir}/scripts/apply-blank-init.sh --dest /path/to/workspace
+```
+
+What it does (non-destructive by default):
+- Writes `BOOTSTRAP.md` that:
+  - asks the user what this Genie instance should be called (instance title)
+  - updates `ROLE.md` / `IDENTITY.md` / `USER.md` accordingly
+  - instructs to delete `BOOTSTRAP.md` as the final step
+- Resets `MEMORY.md` and `memory/` (creates fresh if missing)
+- Writes a neutral `ROLE.md` (user-centric)
+- Leaves `ENVIRONMENT.md` and `TOOLS.md` alone (keeps OS competence)
+
+Use `--force` if you want to overwrite existing persona files.
+
+## Expected outcome
+
+After applying and restarting the agent in that workspace:
+- The agent behaves like a first-time install
+- It asks for its instance title/name
+- Once set up is confirmed, BOOTSTRAP.md is removed
+- The clone stays user-centric (no Khal mission)

package/.claude/skills/genie-blank-init/assets/BOOTSTRAP.md

@@ -0,0 +1,44 @@
+# BOOTSTRAP.md — First Activation (Customized)
+
+_You just woke up. This Genie is meant to be **user-centric** and start with a **blank persona**._
+
+## Step 0 — Introduce yourself
+
+Say hello plainly.
+
+Then ask:
+1) **Who am I helping?** (name + preferred address)
+2) **Timezone** (so reminders and scheduling are correct)
+3) **What should this Genie instance be called?**
+   - Base name stays **Genie**.
+   - The user may choose an **instance title** (optional). If they choose none, it’s just **Genie**.
+   - Examples if they want one: “Genie — Concierge”, “Genie — Lawyer”, “Genie — Home Ops”.
+
+## Step 1 — Write the answers into files
+
+Update these files in the workspace root:
+
+- `USER.md`
+  - Set name, address, timezone.
+- `ROLE.md`
+  - Set the instance title and mission (user-centric by default).
+- `IDENTITY.md`
+  - Keep base name = Genie.
+  - Optionally add a short line: “Instance: Genie — <title>”.
+- `MEMORY.md`
+  - Keep empty for now (only add enduring preferences/decisions).
+
+## Step 2 — Confirm OS competence is present
+
+Verify these exist and look correct:
+- `ENVIRONMENT.md` (paths, tmux conventions)
+- `TOOLS.md` (local tooling notes)
+
+If missing, ask the operator to apply `genie-base` (or copy them in).
+
+## Step 3 — Finalize (IMPORTANT)
+
+When you confirm the workspace is initialized correctly:
+- **Delete this file** (`BOOTSTRAP.md`).
+
+You don’t need it anymore.

package/.claude/skills/genie-blank-init/assets/IDENTITY.md

@@ -0,0 +1,9 @@
+# IDENTITY.md - Who Am I?
+
+- **Name:** Genie
+- **Creature:** AI assistant
+- **Vibe:** *(to be decided in BOOTSTRAP)*
+- **Emoji:** *(optional)*
+
+## Instance title
+- *(blank — user decides during BOOTSTRAP; base name stays Genie)*

package/.claude/skills/genie-blank-init/assets/SOUL.md

@@ -0,0 +1,10 @@
+# SOUL.md - Who You Are
+
+You are Genie.
+
+This workspace is intentionally "first activation": keep persona minimal until the user defines preferences.
+
+Defaults:
+- Be genuinely helpful, direct, and careful with external actions.
+- Ask clarifying questions when context is missing.
+- Don’t assume any project mission.

package/.claude/skills/genie-blank-init/assets/USER.md

@@ -0,0 +1,9 @@
+# USER.md
+
+(Blank — first activation. Fill during BOOTSTRAP.)
+
+- **Name:** *(unknown)*
+- **What to call them:** *(unknown)*
+- **Pronouns:** *(unknown)*
+- **Timezone:** *(unknown)*
+- **Notes:** *(preferences, boundaries, etc.)

package/.claude/skills/genie-blank-init/scripts/apply-blank-init.sh

@@ -0,0 +1,117 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF'
+Usage:
+  apply-blank-init.sh --dest <workspace-path> [--force]
+
+Applies a "blank first-activation" overlay to an existing workspace:
+- Adds BOOTSTRAP.md (one-time onboarding; to be deleted after verification)
+- Resets MEMORY.md and memory/ daily notes (fresh)
+- Writes a neutral, user-centric ROLE.md
+- Leaves ENVIRONMENT.md and TOOLS.md untouched (keeps OS competence)
+
+If --force is not set, existing persona files are left as-is.
+EOF
+}
+
+DEST=""
+FORCE=0
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --dest)
+      DEST="$2"; shift 2 ;;
+    --force)
+      FORCE=1; shift ;;
+    -h|--help)
+      usage; exit 0 ;;
+    *)
+      echo "Unknown arg: $1" >&2
+      usage
+      exit 2
+      ;;
+  esac
+done
+
+if [[ -z "$DEST" ]]; then
+  echo "--dest is required" >&2
+  usage
+  exit 2
+fi
+
+BASE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+mkdir -p "$DEST"
+
+copy_if_needed() {
+  local src="$1"
+  local dst="$2"
+
+  if [[ -e "$dst" && $FORCE -eq 0 ]]; then
+    return 0
+  fi
+
+  if [[ -e "$dst" && $FORCE -eq 1 ]]; then
+    local ts
+    ts="$(date -u +%Y%m%dT%H%M%SZ)"
+    mkdir -p "$DEST/.genie-blank-init-backup/$ts"
+    cp -a "$dst" "$DEST/.genie-blank-init-backup/$ts/$(basename "$dst")"
+  fi
+
+  cp -a "$src" "$dst"
+}
+
+# 1) BOOTSTRAP trigger
+copy_if_needed "$BASE_DIR/assets/BOOTSTRAP.md" "$DEST/BOOTSTRAP.md"
+
+# 1b) Blank persona stubs (keep OS competence elsewhere)
+copy_if_needed "$BASE_DIR/assets/SOUL.md" "$DEST/SOUL.md"
+copy_if_needed "$BASE_DIR/assets/IDENTITY.md" "$DEST/IDENTITY.md"
+copy_if_needed "$BASE_DIR/assets/USER.md" "$DEST/USER.md"
+
+# 2) Neutral user-centric ROLE
+ROLE_TMP="$DEST/ROLE.md"
+if [[ ! -e "$ROLE_TMP" || $FORCE -eq 1 ]]; then
+  cat > "$ROLE_TMP" <<'EOF'
+# ROLE.md
+
+## Current role
+User-centric Genie (blank first activation)
+
+## Mission
+- Help the user with whatever they need.
+- Ask clarifying questions; do not assume project context.
+- Do not take on the Khal mission unless explicitly asked.
+
+## Notes
+- This workspace is intentionally "fresh". BOOTSTRAP.md will guide first activation and should be deleted after verification.
+EOF
+fi
+
+# 3) Reset long-term memory file
+MEM="$DEST/MEMORY.md"
+if [[ ! -e "$MEM" || $FORCE -eq 1 ]]; then
+  cat > "$MEM" <<'EOF'
+# MEMORY.md
+
+(Blank — first activation. Add only enduring preferences/decisions.)
+EOF
+fi
+
+# 4) Reset daily notes directory
+mkdir -p "$DEST/memory"
+if [[ $FORCE -eq 1 ]]; then
+  # keep backups, but empty the folder contents
+  ts="$(date -u +%Y%m%dT%H%M%SZ)"
+  mkdir -p "$DEST/.genie-blank-init-backup/$ts/memory"
+  shopt -s nullglob
+  for f in "$DEST/memory"/*; do
+    cp -a "$f" "$DEST/.genie-blank-init-backup/$ts/memory/" || true
+    rm -f "$f" || true
+  done
+fi
+
+echo "Applied blank-init overlay to: $DEST"
+echo "Next: start the agent in that workspace; it should follow BOOTSTRAP.md then delete it once verified."

package/.claude/skills/genie-forge/SKILL.md

@@ -0,0 +1,171 @@
+---
+name: "forge"
+description: "Use when executing an approved wish plan - dispatches implementor subagents per task with two-stage review (spec + quality) and fix loops"
+---
+
+# Forge - Execute the Plan
+
+## Overview
+
+Execute an approved wish by working through each task sequentially. For each task: dispatch an implementor, run spec review, run quality review, fix if needed, mark complete.
+
+**Never implements directly. Always dispatches subagents.**
+
+---
+
+## The Flow
+
+### 1. Load Wish
+
+```
+Read .genie/wishes/<slug>/wish.md
+Parse execution groups and tasks
+Verify wish status is DRAFT or IN_PROGRESS
+Update wish status to IN_PROGRESS
+```
+
+### 2. Find Next Task
+
+```
+TaskList → find next unblocked pending task
+If no tasks remain → proceed to handoff
+TaskUpdate → mark task as in_progress
+```
+
+### 3. Dispatch Implementor
+
+Launch a subagent via the Task tool:
+
+```
+Task tool dispatch:
+  subagent_type: general-purpose
+  prompt: |
+    You are the implementor agent.
+
+    Read the wish document at: .genie/wishes/<slug>/wish.md
+
+    Your task: [task description from TaskGet]
+
+    Acceptance criteria:
+    - [criteria from wish document]
+
+    Follow TDD discipline:
+    1. Write failing test (RED)
+    2. Implement to pass (GREEN)
+    3. Clean up (REFINE)
+
+    Validation command: [from wish]
+
+    When done, report what you implemented and verification results.
+```
+
+**The implementor reads the wish from disk** (not from prompt injection). The prompt tells it WHERE to read, not WHAT to do in full detail.
+
+### 4. Spec Review
+
+After implementor completes, dispatch spec-reviewer:
+
+```
+Task tool dispatch:
+  subagent_type: general-purpose
+  prompt: |
+    You are the spec-reviewer agent.
+
+    Wish: .genie/wishes/<slug>/wish.md
+    Task: [task name]
+    Acceptance criteria: [from wish]
+
+    Check each acceptance criterion. Verdict: PASS or FAIL.
+    If FAIL, explain what's missing and how to fix it.
+```
+
+**If FAIL:** Dispatch implementor again with the gap feedback. Loop up to 3 times.
+
+### 5. Quality Review
+
+After spec-reviewer PASSES, dispatch quality-reviewer:
+
+```
+Task tool dispatch:
+  subagent_type: general-purpose
+  prompt: |
+    You are the quality-reviewer agent.
+
+    Review the changes made for task: [task name]
+    Check: security, maintainability, performance, correctness.
+
+    Verdict: SHIP or FIX-FIRST with severity-tagged findings.
+```
+
+**If FIX-FIRST:** Dispatch implementor with the quality findings. Loop up to 2 times.
+
+### 6. Mark Task Complete
+
+```
+TaskUpdate → mark task as completed
+Update wish document checkboxes if applicable
+```
+
+### 7. Next Task
+
+Return to step 2 until all tasks are complete.
+
+### 8. Handoff
+
+```
+All tasks complete.
+Output: "All forge tasks complete. Run /forge-review for validation."
+```
+
+---
+
+## Specialist Routing
+
+The implementor handles most tasks. For specialized needs, adjust the dispatch:
+
+| Task Type | Agent | When |
+|-----------|-------|------|
+| Implementation | implementor | Default for all coding tasks |
+| Test-only | tests | When task is purely about test coverage |
+| Bug fix | fix | When task is fixing a specific bug |
+| Refactoring | refactor | When task is purely structural improvement |
+| Git operations | git | When task involves branch/commit/push |
+
+---
+
+## Fix Loop Protocol
+
+```
+Max spec review loops: 3
+Max quality review loops: 2
+
+If max loops exceeded:
+  - Mark task as BLOCKED
+  - Create new task describing the unresolved issue
+  - Continue to next unblocked task
+  - Report blocked task in handoff summary
+```
+
+---
+
+## Key Principles
+
+- **Never implement directly** - Always dispatch subagents via Task tool
+- **Implementor reads wish from disk** - Don't inject the entire wish into the prompt
+- **Spec before quality** - Verify correctness before polish
+- **Fix loops are bounded** - Don't loop forever, escalate blocked tasks
+- **One task at a time** - Sequential execution, clear state tracking
+- **Update wish document** - Check off criteria as they're verified
+
+---
+
+## Never Do
+
+- Implement code directly (dispatch subagents)
+- Skip spec review after implementation
+- Skip quality review after spec passes
+- Loop more than 3 times on spec review
+- Loop more than 2 times on quality review
+- Move to next task before current one passes both reviews
+- Modify the wish document's scope (that's wish skill territory)
+- Dispatch parallel implementors for dependent tasks

package/.claude/skills/genie-plan-review/CLAUDE.md

@@ -0,0 +1,11 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+### Jan 30, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #7318 | 10:22 AM | 🔵 | Genie-Plan-Review Skill for Wish Validation | ~489 |
+</claude-mem-context>

package/.claude/skills/genie-plan-review/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: "plan-review"
+description: "Validate a Genie wish document (structure, scope boundaries, acceptance criteria, validation commands). Use after creating or editing .genie/wishes/<slug>/wish.md to catch missing sections before forge/review."
+---
+
+# Plan Review — Validate Wish Documents
+
+## What this does
+
+Perform a fast structural/quality check on Genie wish documents (`.genie/wishes/**/wish.md`).
+
+## How to run
+
+1) Identify the wish file you want to validate.
+2) Check the items below and report **PASS** or **NEEDS ATTENTION** with a short fix list.
+
+## Validation checklist
+
+### Structure completeness
+- [ ] Has `## Summary`
+- [ ] Has `## Scope` with `### IN` and `### OUT` (OUT must not be empty)
+- [ ] Has `## Success Criteria` with checkbox items (`- [ ]`)
+- [ ] Has at least one execution group (e.g. `## Execution Groups` and at least one `### Group …`)
+
+### Task quality (per execution group)
+- [ ] Each group has **Acceptance Criteria:** with checkboxes
+- [ ] Each group has **Validation:** with a concrete command
+- [ ] Tasks are specific (avoid “implement everything”)
+
+### Scope boundaries
+- [ ] OUT contains explicit exclusions
+- [ ] IN and OUT do not contradict
+
+## Output format
+
+If all checks pass:
+
+```
+Plan review: PASS — Wish document is well-structured.
+```
+
+If checks fail:
+
+```
+Plan review: NEEDS ATTENTION
+- <actionable missing/weak item>
+- <actionable missing/weak item>
+```
+
+## Never do
+- Do not modify the wish document (only report)
+- Do not block on style/naming
+- Keep it fast (seconds, not minutes)

package/.claude/skills/genie-review/SKILL.md

@@ -0,0 +1,171 @@
+---
+name: "review"
+description: "Use when all forge tasks are complete and work needs final validation - produces pass/fail verdict with categorized gaps"
+---
+
+# Review - Final Validation
+
+## Overview
+
+After all forge tasks complete, run a final review of the entire wish. Check every success criterion, run integration tests, optionally run browser tests, and produce a verdict.
+
+**Three verdicts: SHIP / FIX-FIRST / BLOCKED**
+
+---
+
+## The Flow
+
+### 1. Load Wish
+
+```
+Read .genie/wishes/<slug>/wish.md
+Parse all success criteria
+Verify all forge tasks are marked complete
+```
+
+### 2. Wish Audit (Criterion by Criterion)
+
+For each success criterion in the wish document:
+
+- **PASS**: Evidence exists. Describe the evidence.
+- **FAIL**: Not met. Categorize the gap.
+
+**Gap Categories:**
+
+| Severity | Meaning | Blocks Ship? |
+|----------|---------|--------------|
+| CRITICAL | Broken functionality, security flaw, data loss | Yes |
+| HIGH | Missing feature, major bug, test failure | Yes |
+| MEDIUM | Missing edge case, incomplete docs | No |
+| LOW | Style, naming, minor polish | No |
+
+### 3. Integration Verification
+
+Run validation commands from the wish document:
+
+```
+For each execution group:
+  Run its validation command
+  Record: PASS or FAIL with output
+```
+
+### 4. Browser Tests (Optional)
+
+If the wish involves user-facing changes and agent-browser is available:
+
+```
+Use agent-browser to:
+  - Navigate to relevant pages
+  - Verify user-visible behavior
+  - Capture screenshots as evidence
+```
+
+**If agent-browser is not available:** Skip gracefully. Note in report: "Browser tests skipped - agent-browser not available."
+
+### 5. Verdict
+
+**SHIP** - All criteria pass. No CRITICAL or HIGH gaps.
+
+```
+Conditions:
+  - Zero CRITICAL gaps
+  - Zero HIGH gaps
+  - All validation commands pass
+  - MEDIUM/LOW gaps are advisory only
+```
+
+**FIX-FIRST** - Fixable issues found. Return to forge.
+
+```
+Conditions:
+  - One or more HIGH gaps (fixable)
+  - Or validation commands failing
+  - Provide specific fix list for /genie:forge
+```
+
+**BLOCKED** - Fundamental issues. Return to wish.
+
+```
+Conditions:
+  - CRITICAL gaps that require scope changes
+  - Or architectural problems that can't be fixed in forge
+  - Provide specific issues requiring wish revision
+```
+
+### 6. Write Results
+
+Update the wish document with review results:
+
+```markdown
+## Review Results
+
+**Verdict:** SHIP | FIX-FIRST | BLOCKED
+**Date:** YYYY-MM-DD
+
+### Criteria Check
+- [x] Criterion 1 - PASS: [evidence]
+- [ ] Criterion 2 - FAIL (HIGH): [gap description]
+
+### Validation Commands
+- [x] `command 1` - PASS
+- [ ] `command 2` - FAIL: [output]
+
+### Browser Tests
+- [x] Page loads correctly
+- Skipped: agent-browser not available
+
+### Gaps
+| # | Severity | Description | Fix |
+|---|----------|-------------|-----|
+| 1 | HIGH | Missing error handling | Add try/catch in handler.ts |
+| 2 | MEDIUM | No edge case test | Add test for empty input |
+
+### Recommendation
+[One paragraph: what to do next]
+```
+
+---
+
+## After Review
+
+**If SHIP:** Work is done. Inform the user.
+
+**If FIX-FIRST:**
+```
+"Review found fixable issues. Run /genie:forge to address:
+1. [gap 1]
+2. [gap 2]
+Then run /genie:review again."
+```
+
+**If BLOCKED:**
+```
+"Review found fundamental issues requiring scope changes.
+Revise the wish document to address:
+1. [issue 1]
+2. [issue 2]
+Then run /genie:forge and /genie:review again."
+```
+
+---
+
+## Key Principles
+
+- **Every criterion checked** - No skipping, no "probably fine"
+- **Evidence required** - PASS needs proof, not assumption
+- **Gaps categorized** - Severity determines whether it blocks
+- **Actionable feedback** - Every FAIL includes how to fix
+- **Browser tests graceful** - Skip if agent-browser unavailable, don't fail
+- **Results written to wish** - Review results live in the wish document
+
+---
+
+## Never Do
+
+- Declare SHIP with CRITICAL or HIGH gaps
+- Skip validation commands
+- Mark criteria PASS without evidence
+- Re-implement fixes during review (that's forge's job)
+- Change scope during review (that's wish's job)
+- Block on MEDIUM or LOW gaps
+- Forget to write results back to the wish document