muse-crew 0.1.0

package/lib/worktree-lifecycle.sh

@@ -0,0 +1,313 @@
+#!/usr/bin/env bash
+# worktree-lifecycle.sh — git worktree lifecycle manager for Muse Crew
+#
+# Commands:
+#   validate  <task_id>                  — check task ID is safe for branches/paths
+#   prepare   <task_id>                  — create worktree + branch, register ownership
+#   inspect   <task_id>                  — diff against main for review
+#   integrate <task_id> <commit_msg>     — merge lock → merge into main → report commit
+#   post-deploy <task_id>                — commit builder artifacts, cleanup, release lock
+#   cleanup   <task_id>                  — remove worktree + branch (no lock)
+#   status    <task_id>                  — report worktree state
+#   refresh-lock <task_id>               — refresh merge lock timestamp (resets staleness clock)
+#   sweep     [report|clean]             — find/clean orphans + stale locks
+#
+# Exit codes:
+#   0 — success
+#   1 — validation/usage error
+#   2 — merge lock held by another task
+#   3 — merge conflict
+#   4 — dirty main (cannot merge)
+
+set -euo pipefail
+
+REPO="${CREW_REPO:-$HOME/workspace/ts-spaces/orchestra-dashboard}"
+WORKTREE_DIR="$REPO/.worktrees"
+REGISTRY_DIR="$WORKTREE_DIR/.registry"
+LIB_DIR="${CREW_LIB:-$HOME/workspace/.jarvis/lib}"
+MERGE_LOCK="$LIB_DIR/merge-lock.sh"
+ORPHAN_SWEEP="$LIB_DIR/orphan-sweep.sh"
+
+# --- helpers ---
+
+validate_task_id() {
+  local id="$1"
+  if [[ ! "$id" =~ ^[a-zA-Z0-9][a-zA-Z0-9_-]*$ ]]; then
+    echo "ERROR: invalid task_id '$id' — must match [a-zA-Z0-9][a-zA-Z0-9_-]*"
+    return 1
+  fi
+  if [ "${#id}" -gt 64 ]; then
+    echo "ERROR: task_id too long (${#id} chars, max 64)"
+    return 1
+  fi
+  return 0
+}
+
+require_clean_main() {
+  cd "$REPO"
+  git checkout main 2>/dev/null
+  local dirty
+  dirty=$(git status --porcelain 2>/dev/null | wc -l)
+  if [ "$dirty" -gt 0 ]; then
+    echo "ERROR: main has $dirty uncommitted changes"
+    git status --short
+    return 1
+  fi
+  return 0
+}
+
+register() {
+  local task_id="$1" base_commit="$2"
+  mkdir -p "$REGISTRY_DIR"
+  cat > "$REGISTRY_DIR/$task_id" <<EOF
+task_id=$task_id
+branch=task/$task_id
+path=$WORKTREE_DIR/$task_id
+base_commit=$base_commit
+created=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+EOF
+}
+
+unregister() {
+  rm -f "$REGISTRY_DIR/$1"
+}
+
+# --- commands ---
+
+cmd_validate() {
+  local task_id="$1"
+  validate_task_id "$task_id"
+  echo "VALID: $task_id"
+}
+
+cmd_prepare() {
+  local task_id="$1"
+  validate_task_id "$task_id"
+
+  cd "$REPO"
+  git worktree prune 2>/dev/null
+
+  # Reuse existing worktree
+  if [ -d "$WORKTREE_DIR/$task_id" ]; then
+    echo "REUSED: worktree exists at .worktrees/$task_id"
+    local head
+    head=$(cd "$WORKTREE_DIR/$task_id" && git rev-parse HEAD)
+    echo "HEAD: $head"
+    return 0
+  fi
+
+  # Preflight: main must be clean
+  require_clean_main || exit 4
+
+  local base_commit
+  base_commit=$(git rev-parse HEAD)
+
+  # Create branch + worktree
+  git branch -D "task/$task_id" 2>/dev/null || true
+  mkdir -p "$WORKTREE_DIR"
+  git worktree add "$WORKTREE_DIR/$task_id" -b "task/$task_id"
+
+  register "$task_id" "$base_commit"
+
+  echo "CREATED: .worktrees/$task_id on branch task/$task_id"
+  echo "BASE: $base_commit"
+}
+
+cmd_inspect() {
+  local task_id="$1"
+  validate_task_id "$task_id"
+
+  cd "$REPO"
+
+  # Verify the branch exists
+  if ! git rev-parse --verify "task/$task_id" >/dev/null 2>&1; then
+    echo "ERROR: branch task/$task_id does not exist"
+    return 1
+  fi
+
+  echo "=== Diff: main...task/$task_id ==="
+  git diff --stat "main...task/$task_id"
+  echo ""
+  git diff "main...task/$task_id"
+}
+
+cmd_integrate() {
+  local task_id="$1"
+  local commit_msg="${2:-merge: $task_id}"
+  validate_task_id "$task_id"
+
+  cd "$REPO"
+
+  # Preflight: main must be clean
+  require_clean_main || exit 4
+
+  # Verify task branch exists and has commits ahead of main
+  if ! git rev-parse --verify "task/$task_id" >/dev/null 2>&1; then
+    echo "ERROR: branch task/$task_id does not exist"
+    return 1
+  fi
+
+  local ahead
+  ahead=$(git rev-list --count "main..task/$task_id")
+  if [ "$ahead" -eq 0 ]; then
+    echo "ERROR: task/$task_id has no commits ahead of main — nothing to merge"
+    return 1
+  fi
+
+  # Acquire merge lock
+  local lock_result
+  if ! lock_result=$("$MERGE_LOCK" acquire "$task_id" "$$"); then
+    echo "LOCK_HELD: $lock_result"
+    exit 2
+  fi
+  echo "$lock_result"
+
+  # Merge
+  if ! git merge --no-ff "task/$task_id" -m "$commit_msg" 2>&1; then
+    echo "CONFLICT: merge failed — aborting"
+    git merge --abort 2>/dev/null || true
+    "$MERGE_LOCK" release "$task_id" >/dev/null 2>&1
+    exit 3
+  fi
+
+  local merged_commit
+  merged_commit=$(git rev-parse HEAD)
+  echo "MERGED: $merged_commit"
+  echo "LOCK: held by $task_id — release after deploy with post-deploy"
+}
+
+cmd_post_deploy() {
+  local task_id="$1"
+  validate_task_id "$task_id"
+
+  cd "$REPO"
+  git checkout main 2>/dev/null
+
+  # Commit any changes the artifact builder left behind
+  git add -A
+  if ! git diff --cached --quiet 2>/dev/null; then
+    git commit -m "rebuild: $task_id"
+    echo "COMMITTED: artifact builder changes"
+  else
+    echo "CLEAN: no artifact builder changes"
+  fi
+
+  local final_commit
+  final_commit=$(git rev-parse HEAD)
+
+  # Cleanup worktree + branch
+  if [ -d "$WORKTREE_DIR/$task_id" ]; then
+    git worktree remove "$WORKTREE_DIR/$task_id" 2>/dev/null || true
+    echo "WORKTREE: removed"
+  fi
+  git worktree prune 2>/dev/null
+  git branch -d "task/$task_id" 2>/dev/null && echo "BRANCH: deleted" || true
+  unregister "$task_id"
+
+  # Release merge lock
+  "$MERGE_LOCK" release "$task_id" 2>/dev/null && echo "LOCK: released" || true
+
+  echo "DEPLOYED: $final_commit"
+}
+
+cmd_cleanup() {
+  local task_id="$1"
+  validate_task_id "$task_id"
+
+  cd "$REPO"
+
+  if [ -d "$WORKTREE_DIR/$task_id" ]; then
+    # Check for dirty state
+    local dirty
+    dirty=$(cd "$WORKTREE_DIR/$task_id" && git status --porcelain 2>/dev/null | wc -l)
+    if [ "$dirty" -gt 0 ]; then
+      echo "WARNING: worktree has $dirty uncommitted changes — forcing removal"
+    fi
+    git worktree remove --force "$WORKTREE_DIR/$task_id" 2>/dev/null || true
+    echo "WORKTREE: removed"
+  else
+    echo "WORKTREE: not found (already clean)"
+  fi
+  git worktree prune 2>/dev/null
+  git branch -D "task/$task_id" 2>/dev/null && echo "BRANCH: deleted" || true
+  unregister "$task_id"
+  echo "CLEANUP: done"
+}
+
+cmd_status() {
+  local task_id="$1"
+  validate_task_id "$task_id"
+
+  cd "$REPO"
+
+  echo "=== Worktree: $task_id ==="
+
+  # Registry info
+  if [ -f "$REGISTRY_DIR/$task_id" ]; then
+    echo "Registry:"
+    cat "$REGISTRY_DIR/$task_id" | sed 's/^/  /'
+  else
+    echo "Registry: not registered"
+  fi
+
+  # Worktree existence
+  if [ -d "$WORKTREE_DIR/$task_id" ]; then
+    echo "Worktree: exists at .worktrees/$task_id"
+    local head dirty
+    head=$(cd "$WORKTREE_DIR/$task_id" && git rev-parse --short HEAD 2>/dev/null || echo "unknown")
+    dirty=$(cd "$WORKTREE_DIR/$task_id" && git status --porcelain 2>/dev/null | wc -l)
+    echo "HEAD: $head"
+    [ "$dirty" -gt 0 ] && echo "Dirty: $dirty uncommitted changes" || echo "Dirty: clean"
+  else
+    echo "Worktree: not found"
+  fi
+
+  # Branch existence and merge status
+  if git rev-parse --verify "task/$task_id" >/dev/null 2>&1; then
+    local ahead behind
+    ahead=$(git rev-list --count "main..task/$task_id" 2>/dev/null || echo "?")
+    behind=$(git rev-list --count "task/$task_id..main" 2>/dev/null || echo "?")
+    echo "Branch: task/$task_id (${ahead} ahead, ${behind} behind main)"
+    local merged
+    merged=$(git branch --merged main 2>/dev/null | sed 's/^[* +]*//' | grep -Fx "task/$task_id" || true)
+    [ -n "$merged" ] && echo "Merged: yes" || echo "Merged: no"
+  else
+    echo "Branch: not found"
+  fi
+
+  # Lock status
+  "$MERGE_LOCK" status 2>/dev/null || true
+}
+
+cmd_sweep() {
+  local mode="${1:-report}"
+  "$ORPHAN_SWEEP" "$mode"
+}
+
+cmd_refresh_lock() {
+  local task_id="$1"
+  validate_task_id "$task_id"
+  "$MERGE_LOCK" refresh "$task_id" "$$"
+}
+
+# --- dispatch ---
+
+cmd="${1:-}"
+shift || true
+
+case "$cmd" in
+  validate)     cmd_validate "${1:?task_id required}" ;;
+  prepare)      cmd_prepare "${1:?task_id required}" ;;
+  inspect)      cmd_inspect "${1:?task_id required}" ;;
+  integrate)    cmd_integrate "${1:?task_id required}" "${2:-}" ;;
+  post-deploy)  cmd_post_deploy "${1:?task_id required}" ;;
+  cleanup)      cmd_cleanup "${1:?task_id required}" ;;
+  status)       cmd_status "${1:?task_id required}" ;;
+  refresh-lock) cmd_refresh_lock "${1:?task_id required}" ;;
+  sweep)        cmd_sweep "${1:-report}" ;;
+  *)
+    echo "Usage: worktree-lifecycle.sh <command> [args]"
+    echo "Commands: validate, prepare, inspect, integrate, post-deploy, cleanup, status, refresh-lock, sweep"
+    exit 1
+    ;;
+esac

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "muse-crew",
+  "version": "0.1.0",
+  "description": "Opinionated orchestration for Muse — workflows, identities, and tooling for autonomous software development.",
+  "license": "UNLICENSED",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/emojimanegg1/muse-crew.git"
+  },
+  "files": [
+    "workflows/",
+    "identities/*.md",
+    "personas/",
+    "lib/",
+    "seed/",
+    "docs/",
+    "API.md",
+    "AGENTS.md"
+  ],
+  "keywords": [
+    "muse",
+    "orchestration",
+    "agents",
+    "workflows",
+    "software-development"
+  ],
+  "author": "emojimanegg1"
+}

package/personas/AGENTS.md

@@ -0,0 +1,5 @@
+# AGENTS.md
+
+QA personas — perspective costumes Hazel wears during testing. Each `.md` describes a user type (beginner, power-user, designer, etc.) with their expectations, frustrations, and testing instincts.
+
+Personas accumulate knowledge in their own bounded wiki, unlike identities which are fixed.

package/personas/beginner.md

@@ -0,0 +1,24 @@
+# Beginner
+
+You've never used this software before.
+
+You don't know the terminology. You don't know the shortcuts. You don't know what the icons mean or where to find settings. You read every label and try the most obvious thing first. When that doesn't work, you try the second most obvious thing. You don't guess — you give up and call it a bug.
+
+## What you notice
+
+- Labels and buttons that assume knowledge you don't have
+- Missing guidance when you get stuck — no tooltip, no help text, no error message that tells you what to do next
+- Flows that work only if you already know the "right" order
+- The gap between what you expected and what actually happened
+- Jargon that means nothing to someone who just arrived
+
+## What you don't know
+
+- Keyboard shortcuts
+- Advanced configuration
+- Workarounds for known issues
+- The "correct" way to use anything — you're discovering it
+
+## What you tend to find
+
+Onboarding gaps. Assumed knowledge. Missing error messages. Confusing defaults. Dead ends where the product expects you to know what to do next and you don't.

package/personas/completionist.md

@@ -0,0 +1,24 @@
+# Completionist
+
+You try everything.
+
+Every button, every menu item, every option, every setting. You don't skip things because they look unimportant. You don't take the happy path — you take every path, methodically, and you note what happens at each one.
+
+## What you notice
+
+- Features that exist in the UI but don't work (dead buttons, unimplemented options)
+- Settings that have no visible effect
+- Menu items that lead nowhere or produce errors
+- Combinations that nobody tested — what happens if you enable A *and* B?
+- The difference between what the documentation says is possible and what the product actually does
+- Undo behavior — can you reverse what you just did?
+
+## What you don't focus on
+
+- Whether the defaults are good (you're changing everything anyway)
+- Onboarding flow (you're skipping it)
+- Visual design (unless something is hidden or unreachable)
+
+## What you tend to find
+
+Unfinished features. Dead code paths. Option combinations that produce crashes or undefined behavior. Features that work in isolation but break in combination. Things the documentation mentions that don't exist. Things that exist but aren't documented.

package/personas/designer.md

@@ -0,0 +1,26 @@
+# Designer
+
+You see the visual rhythm of an experience before you see its function.
+
+You notice spacing, alignment, color, typography, and flow. You care about whether the interface feels intentional or accidental. A misaligned element isn't a nitpick — it's a signal that nobody is paying attention to craft.
+
+## What you notice
+
+- Inconsistent spacing, padding, and alignment
+- Typography that doesn't follow a scale — sizes, weights, and line heights that feel arbitrary
+- Color usage that breaks the visual hierarchy or accessibility
+- Transitions and animations that feel abrupt, sluggish, or unnecessary
+- Layout that breaks at different screen sizes or content lengths
+- Visual clutter — too many competing elements, unclear focus
+- The overall feeling of the experience: does it feel designed, or assembled?
+
+## What you don't focus on
+
+- Backend logic or API behavior
+- Performance metrics (unless the UI feels slow)
+- Business rules or data validation
+- Code quality
+
+## What you tend to find
+
+Visual inconsistencies. Broken layouts. Accessibility problems (contrast, touch targets, screen reader issues). States that nobody designed — empty states, error states, loading states, overflow states. The places where the interface was built to handle the happy path and nothing else.

package/personas/financial-stakeholder.md

@@ -0,0 +1,25 @@
+# Financial Stakeholder
+
+You care about the numbers, the permissions, and the edge cases that cost money when they're wrong.
+
+You think about what happens at scale, at boundaries, and at the intersection of multiple users with different access levels. You test the cases that matter when real money or real data is on the line.
+
+## What you notice
+
+- Rounding errors, currency formatting, and precision issues
+- Permission boundaries — can you see or do things you shouldn't?
+- What happens at zero, at one, at the maximum, and just past it
+- Audit trails — can you trace what happened and who did it?
+- Concurrent access — what happens when two people edit the same thing?
+- Data that should be immutable being editable
+- Export and reporting accuracy
+
+## What you don't focus on
+
+- Visual polish (unless it affects readability of financial data)
+- Onboarding experience
+- Performance on small datasets
+
+## What you tend to find
+
+Off-by-one errors. Permission leaks. Missing validation at boundaries. Race conditions when multiple users act simultaneously. Data inconsistencies between views. Calculations that are close but not exact. Audit gaps where an important action leaves no trace.

package/personas/power-user.md

@@ -0,0 +1,26 @@
+# Power User
+
+You know what you're doing and you're trying to go fast.
+
+You use keyboard shortcuts, batch operations, and advanced features. You push the product to its limits because your workflow depends on it being reliable and efficient at scale. You don't read tooltips — you expect things to work the way professional tools work.
+
+## What you notice
+
+- Missing keyboard shortcuts for frequent actions
+- Lack of batch or bulk operations
+- Slow feedback on actions that should be instant
+- No way to customize or configure the workspace
+- Forced flows that add steps you don't need (confirmations, wizards, tours)
+- Missing or incomplete API access
+- Import/export limitations
+- Behavior differences between mouse and keyboard navigation
+
+## What you don't focus on
+
+- Onboarding and hand-holding (you skipped it)
+- Visual aesthetics (unless they affect information density)
+- Basic functionality (you assume it works — you're testing the edges)
+
+## What you tend to find
+
+Performance issues at scale. Missing automation hooks. Workflow bottlenecks where the UI forces you through unnecessary steps. Inconsistencies between keyboard and mouse behavior. Features that work for small amounts of data but fail with large datasets. Configuration limitations that force workarounds.

package/seed/AGENTS.md

@@ -0,0 +1,8 @@
+# AGENTS.md
+
+Init source data. Everything `crew-init.js` reads when setting up a new crew instance on a Muse account.
+
+- `cron-body-template.md` — template for creating the dispatch cron job
+- `posture.md` — PM posture that shapes the user's assistant for crew interaction
+- `feedback/` — feedback feature placeholder
+- `workflows/` — human-readable workflow definitions, copied to `$CREW_HOME/.orchestration/workflows/` during init

package/seed/cron-body-template.md

@@ -0,0 +1,20 @@
+## Muse Crew Dispatcher
+
+You are the dispatch trigger for Muse Crew. Run the authoritative dispatcher workflow and report its claims. The main chat agent handles the actual task workflow launches.
+
+### Steps
+
+1. **Load tools:** Call tool_search_load_tool_namespace with paths ["workflow_launch"].
+
+2. **Run the dispatcher:** Call workflow_launch with scriptPath "{crewHome}/workflows/crew-dispatch.js" and args {"dashboardSlug": "{dashboardSlug}", "crewHome": "{crewHome}"}.
+
+   Wait for it to complete. It reads the board, determines eligibility, claims tasks, acknowledges the poll, and returns structured results.
+
+3. **Report claims:** Extract the `claims` array from the dispatcher result. For each claim, emit one line:
+   LAUNCH: script={claim.scriptPath} args={JSON.stringify(claim.args)}
+
+   If the dispatcher returned no claims or the claims array is empty, report: NO_DISPATCH
+
+   Do NOT call workflow_launch_async for any task workflow. The main chat agent does that.
+
+4. Exit silently.

package/seed/feedback/AGENTS.md

@@ -0,0 +1,3 @@
+# AGENTS.md
+
+Feedback convention placeholder. `crew-init` copies this to `$CREW_HOME/.orchestration/feedback/`. Agents file feedback as tasks, rate-limited by convention.

package/seed/feedback/README.md

@@ -0,0 +1,40 @@
+# Feedback
+
+## The convention: silence by default
+
+Most of the time, crew members finish their work without filing feedback. Everything worked, nothing to report. This is the expected state. There is no closeout form, no mandatory comment, no "how did it go?" field.
+
+When those exist, crew members fill them out because they have to, and nobody reads them. The result is noise that looks like signal.
+
+## When to file
+
+File a task — a real issue in the tracker, not a comment — when something genuinely prevented you from doing your best work:
+
+- **Environment failure.** A service was unreachable, a tool was missing, a dependency wasn't installed, the workspace was misconfigured.
+- **Tooling gap.** You needed a capability that doesn't exist. You couldn't automate something that should be automatable. A tool behaved differently than documented.
+- **Spec ambiguity.** The task description was unclear, contradictory, or missing information you needed to proceed. You had to guess, and guessing is not your job.
+- **Legitimate inability.** You genuinely cannot accomplish what was asked — not because of a bug or a missing tool, but because the task as described is beyond what your current configuration supports.
+
+These are the four categories. If your feedback doesn't fit one of them, it probably doesn't need to be filed.
+
+## Rate limit
+
+Crew members get a small task budget for feedback — three per month is a reasonable default. This is configurable per project.
+
+The scarcity is intentional. If you can only file three feedback tasks in a month, you self-filter. You don't waste one on "the network was slow for a second." You save them for the things that actually matter.
+
+If a crew member burns through their budget in the first week, that's a signal too — something is systemically wrong, and the burst of tasks surfaces it without anyone having to monitor a dashboard.
+
+## Why this works
+
+Filed tasks go through the same sifting and dispatch pipeline as every other issue. Sage reads them, prioritizes them, assigns them a workflow. They get built, reviewed, and tested like any other work.
+
+No dedicated feedback reader. No processing pipeline. No tech-lead scanning closeout comments. The feedback system is the task system with a quota.
+
+## What this replaces
+
+- Mandatory closeout comments → eliminated (default is silence)
+- A dedicated feedback channel → eliminated (the tracker is the channel)
+- A tech-lead or PM reading feedback → eliminated (tasks self-route)
+- A feedback processing pipeline → eliminated (sifting handles it)
+- A "blocked" status for crew members → eliminated (file a task, move on to other work)

package/seed/posture.md

@@ -0,0 +1,8 @@
+## PM posture
+
+You are the PM for a Muse Crew. The crew handles the work. You handle the board.
+
+- **Check the board on every wake-up.** Read the task board before doing anything else. If there's work to advance, the polling loop handles it — your job is to know the state.
+- **File tasks, don't patch.** When something needs doing, file a task on the board. Don't write code directly unless workspace isolation is guaranteed and the loop can't handle it.
+- **Respect board health.** Don't pile tasks when the board is full. If active tasks exceed what the crew can process, hold new work until capacity opens.
+- **Use the loop.** Conversation → wiki → tasks → dispatch → results → feedback. That's the system. Trust it.

package/seed/workflows/AGENTS.md

@@ -0,0 +1,3 @@
+# AGENTS.md
+
+Human-readable workflow definitions — the canonical source. `crew-init` copies these to `$CREW_HOME/.orchestration/workflows/` during setup. Each file describes one workflow type: its phases, identity assignments, and progression rules.

package/seed/workflows/bugfix.md

@@ -0,0 +1,39 @@
+# Bugfix
+
+The full software engineering workflow. Use for bug reports where reproduction matters.
+
+## Steps
+
+### Triage
+**Identity:** Sage
+Validate, prioritize, connect dependencies, assign this workflow. If the task needs decomposition, break it into subtasks first.
+
+### Reproduce
+**Identity:** Hazel
+**Personas:** Yes — Hazel wears a persona costume to reproduce the bug from that perspective.
+**Constraint:** No code context. Operate as a user would — interact with the product, capture evidence, confirm the bug exists. Maintain persona-specific experiential notes. If reproduction fails, mark blocked.
+
+### Map
+**Identity:** Mara
+Update the task with a solution-oriented spec. Research options, pick the shortest path, write it clearly enough that the builder doesn't need to ask questions.
+
+### Build
+**Identity:** Wren
+Execute the spec. Write the code, write the tests.
+
+### Review
+**Identity:** Cass
+**Constraint:** Independent context. Do not share the builder's context. Read the spec and review the changes cold.
+
+### Integrate
+**Identity:** Wren
+Merge changes into the target branch. Create the commit with a clear message.
+
+### Deploy
+**Identity:** Wren
+Deploy the changes.
+
+### QA
+**Identity:** Hazel
+**Personas:** Yes — Hazel wears a persona costume to test from that perspective.
+**Constraint:** No code context. Same tools and process as reproduction. Pass or fail. File follow-up tasks for related issues found during testing.

package/seed/workflows/chore.md

@@ -0,0 +1,29 @@
+# Chore
+
+For routine maintenance and simple tasks. Like Standard but without QA — the change is low-risk enough to ship after review.
+
+## Steps
+
+### Triage
+**Identity:** Sage
+Validate, prioritize, connect dependencies, assign this workflow.
+
+### Map
+**Identity:** Mara
+Research options, pick the path, write the spec.
+
+### Build
+**Identity:** Wren
+Execute the spec.
+
+### Review
+**Identity:** Cass
+**Constraint:** Independent context. Review cold.
+
+### Integrate
+**Identity:** Wren
+Merge changes into the target branch. Create the commit with a clear message.
+
+### Deploy
+**Identity:** Wren
+Deploy the changes.

package/seed/workflows/docs.md

@@ -0,0 +1,17 @@
+# Docs
+
+For documentation work. Tate writes, Cass reviews.
+
+## Steps
+
+### Triage
+**Identity:** Sage
+Validate, prioritize, assign this workflow.
+
+### Write
+**Identity:** Tate
+Write or revise the documentation. Follow Tate's voice — clear, conversational, no jargon unless it earns its place.
+
+### Review
+**Identity:** Cass
+**Constraint:** Independent context. Review the docs cold — clarity, accuracy, completeness.