trellis 3.1.20 → 3.1.30

package/dist/{index-3qrxzwe4.js → index-ncckgtrk.js}

@@ -619,6 +619,44 @@ var init_profile = () => {};
 // src/scaffold/write.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync3 } from "fs";
 import { join as join4 } from "path";
+function writeTrellisHooks(rootPath, ide) {
+  const hooksDir = join4(rootPath, ".cursor", "hooks");
+  const trellisHarnessDir = join4(hooksDir, "trellis-harness");
+  const adaptersDir = join4(hooksDir, "adapters");
+  if (!existsSync3(trellisHarnessDir)) {
+    mkdirSync2(trellisHarnessDir, { recursive: true });
+  }
+  if (!existsSync3(adaptersDir)) {
+    mkdirSync2(adaptersDir, { recursive: true });
+  }
+  writeFileSync2(join4(trellisHarnessDir, "pre-prompt-recall.sh"), renderPrePromptRecallScript(), "utf-8");
+  writeFileSync2(join4(trellisHarnessDir, "post-tool-oplog.sh"), renderPostToolOplogScript(), "utf-8");
+  writeFileSync2(join4(trellisHarnessDir, "post-tool-memory-capture.sh"), renderPostToolMemoryCaptureScript(), "utf-8");
+  writeFileSync2(join4(trellisHarnessDir, "stop-triage.sh"), renderStopTriageScript(), "utf-8");
+  writeFileSync2(join4(trellisHarnessDir, "bug-intake.sh"), renderBugIntakeScript(), "utf-8");
+  writeFileSync2(join4(trellisHarnessDir, "bug-investigate.sh"), renderBugInvestigateScript(), "utf-8");
+  writeFileSync2(join4(trellisHarnessDir, "milestone-triage.sh"), renderMilestoneTriageScript(), "utf-8");
+  writeFileSync2(join4(trellisHarnessDir, "cycle-planning.sh"), renderCyclePlanningScript(), "utf-8");
+  const adapterName = ide === "windsurf" ? "cascade-adapter.sh" : `${ide}-adapter.sh`;
+  writeFileSync2(join4(adaptersDir, adapterName), renderAdapterScript(ide), "utf-8");
+  switch (ide) {
+    case "cursor":
+      writeFileSync2(join4(rootPath, ".cursor", "hooks.json"), JSON.stringify(renderCursorHooksConfig(), null, 2), "utf-8");
+      break;
+    case "windsurf":
+      writeFileSync2(join4(rootPath, ".windsurf", "hooks.json"), JSON.stringify(renderWindsurfHooksConfig(), null, 2), "utf-8");
+      break;
+    case "claude":
+      writeFileSync2(join4(rootPath, ".claude", "settings.local.json"), JSON.stringify(renderClaudeHooksConfig(), null, 2), "utf-8");
+      break;
+    case "codex":
+      writeFileSync2(join4(rootPath, ".codex", "hooks.json"), JSON.stringify(renderCodexHooksConfig(), null, 2), "utf-8");
+      break;
+    case "gemini":
+      writeFileSync2(join4(rootPath, ".gemini", "settings.json"), JSON.stringify(renderGeminiHooksConfig(), null, 2), "utf-8");
+      break;
+  }
+}
 function renderAgentsMd(profile, context) {
   const userName = profile?.name ?? "the user";
   const userBio = profile?.bio || "(No bio provided \u2014 run `trellis season` to set up your profile.)";
@@ -899,6 +937,800 @@ function renderGeminiConfig(input) {
     features: input.plugins
   };
 }
+function renderPrePromptRecallScript() {
+  return `#!/usr/bin/env bash
+# Pre-prompt memory and context recall for Trellis integration
+# Normalized contract: TRELLIS_ORIGIN, TRELLIS_DESK_ROOT, TRELLIS_HOOK_OUTPUT
+set -euo pipefail
+
+# Import desk root detection
+source "$(dirname "$0")/../../desk-root.sh"
+
+# Environment variables from contract
+ORIGIN="\${TRELLIS_ORIGIN:-unknown}"
+OUTPUT="\${TRELLIS_HOOK_OUTPUT:-stdout}"
+
+# Only run if we're in a Trellis workspace
+if ! command -v trellis >/dev/null 2>&1; then
+  exit 0
+fi
+
+# Try to get Trellis context (non-blocking)
+if [ -f ".trellis/config.json" ]; then
+  # Query recent memories and entities for context
+  CONTEXT_OUTPUT=$(trellis query --limit 5 --format json 2>/dev/null || echo '{"entities":[],"relations":[]}')
+
+  # Query recent operations for context
+  OPS_OUTPUT=$(trellis log --limit 3 --format json 2>/dev/null || echo '{"operations":[]}')
+
+  # Query active issues
+  ISSUES_OUTPUT=$(trellis issue list --status active --format json 2>/dev/null || echo '{"issues":[]}')
+
+  # Format output based on hook type
+  case "$OUTPUT" in
+    "agent-stop")
+      # For Codex/Gemini blocking hooks
+      echo "{}"
+      ;;
+    "gemini")
+      # For Gemini CLI format
+      cat << EOF
+{
+  "decision": "allow",
+  "context": {
+    "memories": $CONTEXT_OUTPUT,
+    "operations": $OPS_OUTPUT,
+    "issues": $ISSUES_OUTPUT,
+    "origin": "$ORIGIN"
+  }
+}
+EOF
+      ;;
+    *)
+      # Default stdout for Cursor/Windsurf/Claude
+      echo ""
+      echo "\uD83C\uDF3F Trellis Context ($ORIGIN):"
+      echo "  Recent memories: $(echo "$CONTEXT_OUTPUT" | jq -r '.entities | length' 2>/dev/null || echo "0")"
+      echo "  Recent ops: $(echo "$OPS_OUTPUT" | jq -r '.operations | length' 2>/dev/null || echo "0")"
+      echo "  Active issues: $(echo "$ISSUES_OUTPUT" | jq -r '.issues | length' 2>/dev/null || echo "0")"
+      echo ""
+      ;;
+  esac
+fi
+
+exit 0`;
+}
+function renderPostToolOplogScript() {
+  return `#!/usr/bin/env bash
+# Post-tool operation logging for Trellis integration
+# Normalized contract: TRELLIS_ORIGIN, TRELLIS_DESK_ROOT, stdin with tool data
+set -euo pipefail
+
+# Import desk root detection
+source "$(dirname "$0")/../../desk-root.sh"
+
+# Environment variables from contract
+ORIGIN="\${TRELLIS_ORIGIN:-unknown}"
+
+# Read tool data from stdin (normalized format)
+TOOL_DATA=$(cat)
+
+# Extract relevant information from tool data
+# Expected format: JSON with tool, action, file_path, etc.
+TOOL_NAME=$(echo "$TOOL_DATA" | jq -r '.tool // "unknown"' 2>/dev/null || echo "unknown")
+ACTION=$(echo "$TOOL_DATA" | jq -r '.action // "unknown"' 2>/dev/null || echo "unknown")
+FILE_PATH=$(echo "$TOOL_DATA" | jq -r '.file_path // .filePath // .path // ""' 2>/dev/null || echo "")
+
+# Only run if we're in a Trellis workspace
+if ! command -v trellis >/dev/null 2>&1; then
+  exit 0
+fi
+
+if [ -f ".trellis/config.json" ]; then
+  # Create operation log entry
+  OP_ENTRY=$(cat << EOF
+{
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)",
+  "origin": "$ORIGIN",
+  "tool": "$TOOL_NAME",
+  "action": "$ACTION",
+  "target": "$FILE_PATH",
+  "type": "agent-operation"
+}
+EOF
+  )
+
+  # Try to append to Trellis op log (non-blocking)
+  # Note: This would need a corresponding trellis operation command
+  # For now, we'll create a local log file that can be imported
+  LOG_DIR=".trellis/agent-ops"
+  mkdir -p "$LOG_DIR"
+
+  LOG_FILE="$LOG_DIR/ops-$(date +%Y-%m-%d).jsonl"
+  echo "$OP_ENTRY" >> "$LOG_FILE"
+
+  # Keep only last 7 days of logs
+  find "$LOG_DIR" -name "ops-*.jsonl" -mtime +7 -delete 2>/dev/null || true
+fi
+
+exit 0`;
+}
+function renderPostToolMemoryCaptureScript() {
+  return `#!/usr/bin/env bash
+# Post-tool memory and entity capture for Trellis integration
+# Normalized contract: TRELLIS_ORIGIN, TRELLIS_DESK_ROOT, stdin with tool data
+set -euo pipefail
+
+# Import desk root detection
+source "$(dirname "$0")/../../desk-root.sh"
+
+# Environment variables from contract
+ORIGIN="\${TRELLIS_ORIGIN:-unknown}"
+
+# Read tool data from stdin
+TOOL_DATA=$(cat)
+
+# Extract relevant information
+TOOL_NAME=$(echo "$TOOL_DATA" | jq -r '.tool // "unknown"' 2>/dev/null || echo "unknown")
+ACTION=$(echo "$TOOL_DATA" | jq -r '.action // "unknown"' 2>/dev/null || echo "unknown")
+FILE_PATH=$(echo "$TOOL_DATA" | jq -r '.file_path // .filePath // .path // ""' 2>/dev/null || echo "")
+
+# Only run if we're in a Trellis workspace
+if ! command -v trellis >/dev/null 2>&1; then
+  exit 0
+fi
+
+if [ -f ".trellis/config.json" ]; then
+  # Suggest memory creation for significant operations
+  case "$TOOL_NAME-$ACTION" in
+    "edit-create"|"write-create"|"Edit-create"|"Write-create")
+      # File creation - suggest creating a memory
+      if [ -n "$FILE_PATH" ]; then
+        echo "\uD83E\uDDE0 Consider creating a memory for the new file: $FILE_PATH"
+        echo "   Run: trellis memory create -t "Created $FILE_PATH" -c "Created via $ORIGIN agent""
+      fi
+      ;;
+    "edit-update"|"Edit-update")
+      # File update - suggest updating memory if significant
+      if [ -n "$FILE_PATH" ]; then
+        echo "\uD83D\uDD04 Consider updating relevant memories for: $FILE_PATH"
+        echo "   Run: trellis memory list -q "$FILE_PATH""
+      fi
+      ;;
+    "issue-create"|"issue-update")
+      # Issue operations - always suggest memory
+      echo "\uD83D\uDCDD Consider creating a memory for this issue operation"
+      echo "   Run: trellis memory create -t "Issue $ACTION via $ORIGIN""
+      ;;
+  esac
+
+  # Store potential memory suggestions for later
+  MEMORY_DIR=".trellis/agent-suggestions"
+  mkdir -p "$MEMORY_DIR"
+
+  SUGGESTION=$(cat << EOF
+{
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)",
+  "origin": "$ORIGIN",
+  "tool": "$TOOL_NAME",
+  "action": "$ACTION",
+  "target": "$FILE_PATH",
+  "suggestion_type": "memory-creation"
+}
+EOF
+  )
+
+  SUGGESTIONS_FILE="$MEMORY_DIR/suggestions-$(date +%Y-%m-%d).jsonl"
+  echo "$SUGGESTION" >> "$SUGGESTIONS_FILE"
+
+  # Keep only last 3 days of suggestions
+  find "$MEMORY_DIR" -name "suggestions-*.jsonl" -mtime +3 -delete 2>/dev/null || true
+fi
+
+exit 0`;
+}
+function renderStopTriageScript() {
+  return `#!/usr/bin/env bash
+# Session stop issue triage and workflow suggestions for Trellis integration
+# Normalized contract: TRELLIS_ORIGIN, TRELLIS_DESK_ROOT, TRELLIS_HOOK_OUTPUT
+set -euo pipefail
+
+# Import desk root detection
+source "$(dirname "$0")/../../desk-root.sh"
+
+# Environment variables from contract
+ORIGIN="\${TRELLIS_ORIGIN:-unknown}"
+OUTPUT="\${TRELLIS_HOOK_OUTPUT:-stdout}"
+
+# Only run if we're in a Trellis workspace
+if ! command -v trellis >/dev/null 2>&1; then
+  exit 0
+fi
+
+if [ -f ".trellis/config.json" ]; then
+  # Check for active issues that need attention
+  ACTIVE_ISSUES=$(trellis issue list --status active --format json 2>/dev/null || echo '{"issues":[]}')
+  ACTIVE_COUNT=$(echo "$ACTIVE_ISSUES" | jq -r '.issues | length' 2>/dev/null || echo "0")
+
+  # Check for pending memory suggestions
+  MEMORY_DIR=".trellis/agent-suggestions"
+  SUGGESTION_COUNT=0
+  if [ -d "$MEMORY_DIR" ]; then
+    SUGGESTION_COUNT=$(find "$MEMORY_DIR" -name "suggestions-*.jsonl" -exec wc -l {} ; 2>/dev/null | awk '{sum+=$1} END {print sum}' || echo "0")
+  fi
+
+  # Check for uncommitted changes
+  UNCOMMITTED=0
+  if git rev-parse --git-dir >/dev/null 2>&1; then
+    UNCOMMITTED=$(git status --porcelain 2>/dev/null | wc -l || echo "0")
+  fi
+
+  # Build recommendations
+  RECOMMENDATIONS=()
+
+  if [ "$ACTIVE_COUNT" -gt 0 ]; then
+    RECOMMENDATIONS+=("\uD83C\uDFAF $ACTIVE_COUNT active issues need attention - run 'trellis issue list'")
+  fi
+
+  if [ "$SUGGESTION_COUNT" -gt 0 ]; then
+    RECOMMENDATIONS+=("\uD83E\uDDE0 $SUGGESTION_COUNT memory suggestions pending - review .trellis/agent-suggestions/")
+  fi
+
+  if [ "$UNCOMMITTED" -gt 0 ]; then
+    RECOMMENDATIONS+=("\uD83D\uDCDD $UNCOMMITTED uncommitted changes - consider committing or creating a checkpoint")
+  fi
+
+  # Format output based on hook type
+  case "$OUTPUT" in
+    "agent-stop")
+      # For Codex/Gemini blocking hooks
+      if [ \${#RECOMMENDATIONS[@]} -gt 0 ]; then
+        MESSAGE=$(printf '%s
+' "\${RECOMMENDATIONS[@]}")
+        cat << EOF
+{
+  "decision": "block",
+  "reason": "Trellis workflow items need attention: $MESSAGE"
+}
+EOF
+      else
+        echo "{}"
+      fi
+      ;;
+    "gemini")
+      # For Gemini CLI format
+      if [ \${#RECOMMENDATIONS[@]} -gt 0 ]; then
+        MESSAGE=$(printf '%s\\n' "\${RECOMMENDATIONS[@]}")
+        cat << EOF
+{
+  "decision": "deny",
+  "reason": "Trellis workflow items need attention: $MESSAGE"
+}
+EOF
+      else
+        echo '{"decision": "allow"}'
+      fi
+      ;;
+    *)
+      # Default stdout for Cursor/Windsurf/Claude
+      if [ \${#RECOMMENDATIONS[@]} -gt 0 ]; then
+        echo ""
+        echo "\uD83C\uDF3F Trellis Session Summary ($ORIGIN):"
+        printf '  %s
+' "\${RECOMMENDATIONS[@]}"
+        echo ""
+        echo "Run 'trellis status' for full workspace state"
+      else
+        echo "\uD83C\uDF3F Trellis: All clear! No pending items."
+      fi
+      ;;
+  esac
+fi
+
+exit 0`;
+}
+function renderAdapterScript(ide) {
+  switch (ide) {
+    case "cursor":
+      return `#!/usr/bin/env bash
+# Cursor adapter for Trellis harness
+# Translates Cursor events to normalized contract
+set -euo pipefail
+
+# Import desk root detection
+source "$(dirname "$0")/../desk-root.sh"
+
+# Set origin
+export TRELLIS_ORIGIN="cursor"
+export TRELLIS_DESK_ROOT="$PWD"
+
+# Route based on event type
+EVENT_TYPE="\${1:-unknown}"
+
+case "$EVENT_TYPE" in
+  "session-start")
+    # Cursor sessionStart hook
+    exec "$(dirname "$0")/../trellis-harness/pre-prompt-recall.sh"
+    ;;
+  "post-tool")
+    # Cursor afterFileEdit hook - read stdin for tool data
+    TOOL_DATA=$(cat)
+
+    # Transform Cursor format to normalized format
+    NORMALIZED_DATA=$(cat << EOF
+{
+  "tool": "edit_file",
+  "action": "update",
+  "file_path": $(echo "$TOOL_DATA" | jq -r '.file_path // ""' 2>/dev/null || echo '""'),
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)"
+}
+EOF
+    )
+
+    # Call op logger
+    echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-oplog.sh"
+
+    # Call memory capture
+    echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-memory-capture.sh"
+    ;;
+  "stop")
+    # Cursor stop hook
+    export TRELLIS_HOOK_OUTPUT="stdout"
+    exec "$(dirname "$0")/../trellis-harness/stop-triage.sh"
+    ;;
+  *)
+    echo "Unknown Cursor event: $EVENT_TYPE" >&2
+    exit 1
+    ;;
+esac`;
+    case "windsurf":
+      return `#!/usr/bin/env bash
+# Windsurf Cascade adapter for Trellis harness
+# Translates Cascade events to normalized contract
+set -euo pipefail
+
+# Import desk root detection
+source "$(dirname "$0")/../desk-root.sh"
+
+# Set origin
+export TRELLIS_ORIGIN="windsurf"
+export TRELLIS_DESK_ROOT="$PWD"
+
+# Route based on event type
+EVENT_TYPE="\${1:-unknown}"
+
+case "$EVENT_TYPE" in
+  "pre-prompt")
+    # Cascade pre_user_prompt hook
+    exec "$(dirname "$0")/../trellis-harness/pre-prompt-recall.sh"
+    ;;
+  "post-tool")
+    # Cascade post_write_code hook - read stdin for tool data
+    TOOL_DATA=$(cat)
+
+    # Transform Cascade format to normalized format
+    NORMALIZED_DATA=$(cat << EOF
+{
+  "tool": "write_file",
+  "action": "create",
+  "file_path": $(echo "$TOOL_DATA" | jq -r '.file_path // ""' 2>/dev/null || echo '""'),
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)"
+}
+EOF
+    )
+
+    # Call op logger
+    echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-oplog.sh"
+
+    # Call memory capture
+    echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-memory-capture.sh"
+    ;;
+  "post-response")
+    # Cascade post_cascade_response hook
+    export TRELLIS_HOOK_OUTPUT="stdout"
+    exec "$(dirname "$0")/../trellis-harness/stop-triage.sh"
+    ;;
+  *)
+    echo "Unknown Cascade event: $EVENT_TYPE" >&2
+    exit 1
+    ;;
+esac`;
+    case "claude":
+      return `#!/usr/bin/env bash
+# Claude Code adapter for Trellis harness
+# Translates Claude Code events to normalized contract
+set -euo pipefail
+
+# Import desk root detection
+source "$(dirname "$0")/../desk-root.sh"
+
+# Set origin
+export TRELLIS_ORIGIN="claude"
+export TRELLIS_DESK_ROOT="$PWD"
+
+# Route based on event type
+EVENT_TYPE="\${1:-unknown}"
+
+case "$EVENT_TYPE" in
+  "pre-tool-use")
+    # Claude Code PreToolUse hook
+    exec "$(dirname "$0")/../trellis-harness/pre-prompt-recall.sh"
+    ;;
+  "post-tool-use")
+    # Claude Code PostToolUse hook - read stdin for tool data
+    TOOL_DATA=$(cat)
+
+    # Transform Claude Code format to normalized format
+    NORMALIZED_DATA=$(cat << EOF
+{
+  "tool": $(echo "$TOOL_DATA" | jq -r '.tool_name // "unknown"' 2>/dev/null || echo '"unknown"'),
+  "action": $(echo "$TOOL_DATA" | jq -r '.action // "unknown"' 2>/dev/null || echo '"unknown"'),
+  "file_path": $(echo "$TOOL_DATA" | jq -r '.file_path // .filePath // ""' 2>/dev/null || echo '""'),
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)"
+}
+EOF
+    )
+
+    # Call op logger
+    echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-oplog.sh"
+
+    # Call memory capture
+    echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-memory-capture.sh"
+    ;;
+  "post-tool-batch")
+    # Claude Code PostToolBatch hook - process multiple tools
+    TOOL_DATA=$(cat)
+
+    # Process each tool in the batch
+    echo "$TOOL_DATA" | jq -c '.[]' 2>/dev/null | while read -r tool; do
+      NORMALIZED_DATA=$(cat << EOF
+{
+  "tool": $(echo "$tool" | jq -r '.tool_name // "unknown"' 2>/dev/null || echo '"unknown"'),
+  "action": $(echo "$tool" | jq -r '.action // "unknown"' 2>/dev/null || echo '"unknown"'),
+  "file_path": $(echo "$tool" | jq -r '.file_path // .filePath // ""' 2>/dev/null || echo '""'),
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)"
+}
+EOF
+    )
+
+      # Call op logger
+      echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-oplog.sh"
+
+      # Call memory capture
+      echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-memory-capture.sh"
+    done
+    ;;
+  "permission-denied")
+    # Claude Code PermissionDenied hook
+    NORMALIZED_DATA=$(cat << EOF
+{
+  "tool": "permission_denied",
+  "action": "blocked",
+  "file_path": "",
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)"
+}
+EOF
+    )
+
+    # Call op logger
+    echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-oplog.sh"
+    ;;
+  *)
+    echo "Unknown Claude Code event: $EVENT_TYPE" >&2
+    exit 1
+    ;;
+esac`;
+    case "codex":
+      return `#!/usr/bin/env bash
+# Codex adapter for Trellis harness
+# Translates Codex events to normalized contract
+set -euo pipefail
+
+# Import desk root detection
+source "$(dirname "$0")/../desk-root.sh"
+
+# Set origin
+export TRELLIS_ORIGIN="codex"
+export TRELLIS_DESK_ROOT="$PWD"
+
+# Route based on event type
+EVENT_TYPE="\${1:-unknown}"
+
+case "$EVENT_TYPE" in
+  "session-start")
+    # Codex SessionStart hook
+    exec "$(dirname "$0")/../trellis-harness/pre-prompt-recall.sh"
+    ;;
+  "post-tool")
+    # Codex PostToolUse hook - read stdin for tool data
+    TOOL_DATA=$(cat)
+
+    # Transform Codex format to normalized format
+    NORMALIZED_DATA=$(cat << EOF
+{
+  "tool": $(echo "$TOOL_DATA" | jq -r '.tool_name // "unknown"' 2>/dev/null || echo '"unknown"'),
+  "action": $(echo "$TOOL_DATA" | jq -r '.action // "unknown"' 2>/dev/null || echo '"unknown"'),
+  "file_path": $(echo "$TOOL_DATA" | jq -r '.file_path // .filePath // ""' 2>/dev/null || echo '""'),
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)"
+}
+EOF
+    )
+
+    # Call op logger
+    echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-oplog.sh"
+
+    # Call memory capture
+    echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-memory-capture.sh"
+    ;;
+  "stop")
+    # Codex Stop hook
+    export TRELLIS_HOOK_OUTPUT="agent-stop"
+    exec "$(dirname "$0")/../trellis-harness/stop-triage.sh"
+    ;;
+  *)
+    echo "Unknown Codex event: $EVENT_TYPE" >&2
+    exit 1
+    ;;
+esac`;
+    case "gemini":
+      return `#!/usr/bin/env bash
+# Gemini CLI adapter for Trellis harness
+# Translates Gemini events to normalized contract
+set -euo pipefail
+
+# Import desk root detection
+source "$(dirname "$0")/../desk-root.sh"
+
+# Set origin
+export TRELLIS_ORIGIN="gemini"
+export TRELLIS_DESK_ROOT="$PWD"
+
+# Route based on event type
+EVENT_TYPE="\${1:-unknown}"
+
+case "$EVENT_TYPE" in
+  "session-start"|"before-agent")
+    # Gemini SessionStart or BeforeAgent hook
+    exec "$(dirname "$0")/../trellis-harness/pre-prompt-recall.sh"
+    ;;
+  "post-tool")
+    # Gemini AfterTool hook - read stdin for tool data
+    TOOL_DATA=$(cat)
+
+    # Transform Gemini format to normalized format
+    NORMALIZED_DATA=$(cat << EOF
+{
+  "tool": $(echo "$TOOL_DATA" | jq -r '.tool_name // "unknown"' 2>/dev/null || echo '"unknown"'),
+  "action": $(echo "$TOOL_DATA" | jq -r '.action // "unknown"' 2>/dev/null || echo '"unknown"'),
+  "file_path": $(echo "$TOOL_DATA" | jq -r '.file_path // .filePath // ""' 2>/dev/null || echo '""'),
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)"
+}
+EOF
+    )
+
+    # Call op logger
+    echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-oplog.sh"
+
+    # Call memory capture
+    echo "$NORMALIZED_DATA" | "$(dirname "$0")/../trellis-harness/post-tool-memory-capture.sh"
+    ;;
+  "after-agent")
+    # Gemini AfterAgent hook
+    export TRELLIS_HOOK_OUTPUT="gemini"
+    exec "$(dirname "$0")/../trellis-harness/stop-triage.sh"
+    ;;
+  *)
+    echo "Unknown Gemini event: $EVENT_TYPE" >&2
+    exit 1
+    ;;
+esac`;
+    default:
+      return `#!/usr/bin/env bash
+# Default adapter for Trellis harness
+echo "Unsupported IDE: ${ide}" >&2
+exit 1`;
+  }
+}
+function renderCursorHooksConfig() {
+  return {
+    version: 1,
+    hooks: {
+      sessionStart: [
+        {
+          command: "bash .cursor/hooks/adapters/cursor-adapter.sh session-start",
+          timeout: 15
+        }
+      ],
+      afterFileEdit: [
+        {
+          command: "bash .cursor/hooks/adapters/cursor-adapter.sh post-tool",
+          timeout: 10
+        }
+      ],
+      stop: [
+        {
+          command: "bash .cursor/hooks/adapters/cursor-adapter.sh stop",
+          timeout: 10
+        }
+      ]
+    }
+  };
+}
+function renderWindsurfHooksConfig() {
+  return {
+    hooks: {
+      pre_user_prompt: [
+        {
+          command: "bash .cursor/hooks/adapters/cascade-adapter.sh pre-prompt",
+          show_output: true
+        }
+      ],
+      post_write_code: [
+        {
+          command: "bash .cursor/hooks/adapters/cascade-adapter.sh post-tool",
+          show_output: false
+        }
+      ],
+      post_cascade_response: [
+        {
+          command: "bash .cursor/hooks/adapters/cascade-adapter.sh post-response",
+          show_output: true
+        }
+      ]
+    }
+  };
+}
+function renderClaudeHooksConfig() {
+  return {
+    hooks: {
+      PreToolUse: [
+        {
+          command: "bash .cursor/hooks/adapters/claude-adapter.sh pre-tool-use",
+          timeout: 15
+        }
+      ],
+      PostToolUse: [
+        {
+          command: "bash .cursor/hooks/adapters/claude-adapter.sh post-tool-use",
+          timeout: 10
+        }
+      ],
+      PostToolBatch: [
+        {
+          command: "bash .cursor/hooks/adapters/claude-adapter.sh post-tool-batch",
+          timeout: 15
+        }
+      ],
+      PermissionDenied: [
+        {
+          command: "bash .cursor/hooks/adapters/claude-adapter.sh permission-denied",
+          timeout: 5
+        }
+      ]
+    },
+    permissions: {
+      allow: [
+        "Bash(trellis --version)",
+        "Bash(trellis issue *)",
+        "Bash(trellis --help)",
+        "Bash(trellis search *)",
+        "Bash(trellis entity *)",
+        "Bash(trellis ontology *)",
+        "Bash(trellis query *)",
+        "Bash(lsof -nP -iTCP -sTCP:LISTEN)",
+        "Bash(awk '{print $9, $1, $2}')",
+        "Bash(curl -s --max-time 1 http://localhost:__TRACKED_VAR__/api/graph/health)",
+        "Bash(curl -s --max-time 1 http://localhost:__TRACKED_VAR__/api/graph/health -H 'Accept: application/json')",
+        'Bash(grep -ivE "node_modules|dist|.vercel|.git$|.git/|.logs")'
+      ]
+    },
+    spinnerTipsEnabled: true
+  };
+}
+function renderCodexHooksConfig() {
+  return {
+    hooks: {
+      SessionStart: [
+        {
+          matcher: "startup|resume|clear",
+          hooks: [
+            {
+              type: "command",
+              command: "bash .cursor/hooks/adapters/codex-adapter.sh session-start",
+              timeout: 15,
+              statusMessage: "Loading Trellis desk context"
+            }
+          ]
+        }
+      ],
+      PostToolUse: [
+        {
+          matcher: "apply_patch|Edit|Write",
+          hooks: [
+            {
+              type: "command",
+              command: "bash .cursor/hooks/adapters/codex-adapter.sh post-tool",
+              timeout: 10,
+              statusMessage: "Recording Trellis operation"
+            }
+          ]
+        }
+      ],
+      Stop: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: "bash .cursor/hooks/adapters/codex-adapter.sh stop",
+              timeout: 10,
+              statusMessage: "Checking Trellis workflow status"
+            }
+          ]
+        }
+      ]
+    }
+  };
+}
+function renderGeminiHooksConfig() {
+  return {
+    hooks: {
+      SessionStart: [
+        {
+          matcher: "startup|resume|clear",
+          hooks: [
+            {
+              name: "trellis-desk-context",
+              type: "command",
+              command: "bash .cursor/hooks/adapters/gemini-adapter.sh session-start",
+              timeout: 15000,
+              description: "Refresh pending Trellis context at session start"
+            }
+          ]
+        }
+      ],
+      BeforeAgent: [
+        {
+          hooks: [
+            {
+              name: "trellis-desk-prompt-context",
+              type: "command",
+              command: "bash .cursor/hooks/adapters/gemini-adapter.sh before-agent",
+              timeout: 15000,
+              description: "Mirror Windsurf pre_user_prompt desk context refresh"
+            }
+          ]
+        }
+      ],
+      AfterTool: [
+        {
+          matcher: "write_file|replace|apply_patch",
+          hooks: [
+            {
+              name: "trellis-op-logging",
+              type: "command",
+              command: "bash .cursor/hooks/adapters/gemini-adapter.sh post-tool",
+              timeout: 1e4,
+              description: "Record Trellis operations and suggest memory creation"
+            }
+          ]
+        }
+      ],
+      AfterAgent: [
+        {
+          hooks: [
+            {
+              name: "trellis-workflow-triage",
+              type: "command",
+              command: "bash .cursor/hooks/adapters/gemini-adapter.sh after-agent",
+              timeout: 1e4,
+              description: "Suggest Trellis workflow actions when items need attention"
+            }
+          ]
+        }
+      ]
+    }
+  };
+}
 function writeIdeScaffold(rootPath, input) {
   const { ide, footprint, framework, plugins, context, profile } = input;
   const fullInput = {
@@ -917,6 +1749,9 @@ function writeIdeScaffold(rootPath, input) {
         mkdirSync2(cursorDir, { recursive: true });
       }
       writeFileSync2(join4(cursorDir, "rules.md"), renderCursorRules(fullInput), "utf-8");
+      if (footprint === "full") {
+        writeTrellisHooks(rootPath, "cursor");
+      }
       break;
     }
     case "windsurf": {
@@ -925,6 +1760,9 @@ function writeIdeScaffold(rootPath, input) {
         mkdirSync2(windsurfDir, { recursive: true });
       }
       writeFileSync2(join4(windsurfDir, "rules.md"), renderWindsurfRules(fullInput), "utf-8");
+      if (footprint === "full") {
+        writeTrellisHooks(rootPath, "windsurf");
+      }
       break;
     }
     case "claude": {
@@ -933,6 +1771,9 @@ function writeIdeScaffold(rootPath, input) {
         mkdirSync2(claudeDir, { recursive: true });
       }
       writeFileSync2(join4(claudeDir, "settings.md"), renderClaudeMd(fullInput), "utf-8");
+      if (footprint === "full") {
+        writeTrellisHooks(rootPath, "claude");
+      }
       break;
     }
     case "copilot": {
@@ -950,6 +1791,9 @@ function writeIdeScaffold(rootPath, input) {
         mkdirSync2(codexDir, { recursive: true });
       }
       writeFileSync2(join4(codexDir, "config.json"), JSON.stringify(renderCodexConfig(fullInput), null, 2), "utf-8");
+      if (footprint === "full") {
+        writeTrellisHooks(rootPath, "codex");
+      }
       break;
     }
     case "gemini": {
@@ -958,6 +1802,9 @@ function writeIdeScaffold(rootPath, input) {
         mkdirSync2(geminiDir, { recursive: true });
       }
       writeFileSync2(join4(geminiDir, "config.json"), JSON.stringify(renderGeminiConfig(fullInput), null, 2), "utf-8");
+      if (footprint === "full") {
+        writeTrellisHooks(rootPath, "gemini");
+      }
       break;
     }
     case "none":
@@ -980,6 +1827,356 @@ trellis milestone       # Create narrative checkpoints
     }
   }
 }
+function renderBugIntakeScript() {
+  return `#!/usr/bin/env bash
+# Bug intake and TDD enforcement for Trellis integration
+# Creates structured issues with acceptance criteria and test requirements
+set -euo pipefail
+
+# Import desk root detection
+source "\\$(dirname "\\$0")/../desk-root.sh"
+
+# Environment variables from contract
+ORIGIN="\${TRELLIS_ORIGIN:-unknown}"
+OUTPUT="\${TRELLIS_HOOK_OUTPUT:-stdout}"
+
+# Only run if we're in a Trellis workspace
+if ! command -v trellis >/dev/null 2>&1; then
+  exit 0
+fi
+
+# Read bug description from stdin or environment
+BUG_DATA="\${TRELLIS_BUG_DATA:-}"
+if [ -z "\\$BUG_DATA" ]; then
+  BUG_DATA=$(cat)
+fi
+
+# Extract bug information
+TITLE=$(echo "\\$BUG_DATA" | jq -r '.title // "Untitled Bug"' 2>/dev/null || echo "Untitled Bug")
+DESCRIPTION=$(echo "\\$BUG_DATA" | jq -r '.description // ""' 2>/dev/null || echo "")
+SEVERITY=$(echo "\\$BUG_DATA" | jq -r '.severity // "medium"' 2>/dev/null || echo "medium")
+COMPONENT=$(echo "\\$BUG_DATA" | jq -r '.component // "unknown"' 2>/dev/null || echo "unknown")
+
+# Validate required fields
+if [ -z "\\$DESCRIPTION" ]; then
+  echo "\u274C Bug description is required" >&2
+  exit 1
+fi
+
+# Create the Trellis issue with structured content
+ISSUE_CONTENT="# Bug: \\$TITLE
+
+**Severity:** \\$SEVERITY
+**Component:** \\$COMPONENT
+**Reported by:** \\$ORIGIN
+**Reported at:** $(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)
+
+## Description
+\\$DESCRIPTION
+
+## Acceptance Criteria
+
+### Functional Requirements
+- [ ] **AC-1:** Bug reproduction confirmed in test environment
+- [ ] **AC-2:** Root cause identified and documented
+- [ ] **AC-3:** Fix implemented without breaking existing functionality
+- [ ] **AC-4:** Bug no longer reproducible after fix
+- [ ] **AC-5:** Edge cases covered and tested
+
+### Test Requirements (TDD)
+- [ ] **TEST-1:** Unit tests written for the failing behavior
+- [ ] **TEST-2:** Integration tests cover the bug scenario
+- [ ] **TEST-3:** Regression tests prevent future occurrences
+- [ ] **TEST-4:** Performance tests if applicable
+- [ ] **TEST-5:** Manual testing checklist completed
+
+### Documentation Requirements
+- [ ] **DOC-1:** API documentation updated if behavior changed
+- [ ] **DOC-2:** README updated if user-facing change
+- [ ] **DOC-3:** Changelog entry prepared
+- [ ] **DOC-4:** Technical notes added for future reference
+
+### Code Quality Requirements
+- [ ] **QUALITY-1:** Code follows project style guidelines
+- [ ] **QUALITY-2:** No new linting errors introduced
+- [ ] **QUALITY-3:** Code coverage maintained or improved
+- [ ] **QUALITY-4:** Security review completed if applicable
+- [ ] **QUALITY-5:** Performance impact assessed
+
+## Definition of Done
+
+This bug is considered **DONE** when:
+1. \u2705 All acceptance criteria are met
+2. \u2705 All tests pass (unit, integration, regression)
+3. \u2705 Code review approved
+4. \u2705 Documentation updated
+5. \u2705 No performance regressions
+6. \u2705 Security implications addressed
+7. \u2705 Changelog entry created
+8. \u2705 Release notes prepared
+
+## Labels
+\`bug\`, \`severity-\\$SEVERITY\`, \`component-\\$COMPONENT\`, \`tdd-required\`, \`needs-investigation\`
+
+---
+
+**Generated by:** Trellis Enhanced Hooks
+**Origin:** \\$ORIGIN
+**Template:** bug-intake-v1.0
+"
+
+# Create the Trellis issue
+ISSUE_ID=$(echo "\\$ISSUE_CONTENT" | trellis issue create --title "\\$TITLE" --content-from-stdin --format json 2>/dev/null | jq -r '.id // empty' || echo "")
+
+if [ -n "\\$ISSUE_ID" ]; then
+  # Add labels to the issue
+  trellis issue label "\\$ISSUE_ID" add "bug" "severity-\\$SEVERITY" "component-\\$COMPONENT" "tdd-required" "needs-investigation" 2>/dev/null || true
+
+  echo ""
+  echo "\uD83D\uDC1B Bug Intake Completed (\\$ORIGIN):"
+  echo "  \uD83D\uDCDD Issue: #\\$ISSUE_ID - \\$TITLE"
+  echo "  \uD83D\uDD27 Severity: \\$SEVERITY"
+  echo "  \uD83D\uDCE6 Component: \\$COMPONENT"
+  echo "  \u2705 TDD requirements enforced"
+  echo ""
+  echo "\uD83D\uDCCB Next Steps:"
+  echo "  1. Investigate the bug: trellis issue view \\$ISSUE_ID"
+  echo "  2. Develop tests with TDD approach"
+  echo "  3. Implement fix"
+  echo ""
+else
+  echo "\u274C Failed to create bug issue" >&2
+  exit 1
+fi
+`;
+}
+function renderBugInvestigateScript() {
+  return `#!/usr/bin/env bash
+# Bug investigation and TDD enforcement for Trellis integration
+# Ensures thorough investigation before fix implementation
+set -euo pipefail
+
+# Import desk root detection
+source "\\$(dirname "\\$0")/../desk-root.sh"
+
+# Environment variables from contract
+ORIGIN="\${TRELLIS_ORIGIN:-unknown}"
+OUTPUT="\${TRELLIS_HOOK_OUTPUT:-stdout}"
+ISSUE_ID="\${TRELLIS_ISSUE_ID:-}"
+
+# Only run if we're in a Trellis workspace
+if ! command -v trellis >/dev/null 2>&1; then
+  exit 0
+fi
+
+# Validate issue ID
+if [ -z "\\$ISSUE_ID" ]; then
+  echo "\u274C Issue ID is required for bug investigation" >&2
+  exit 1
+fi
+
+# Get issue details
+ISSUE_DETAILS=$(trellis issue view "\\$ISSUE_ID" --format json 2>/dev/null || echo "{}")
+TITLE=$(echo "\\$ISSUE_DETAILS" | jq -r '.title // "Unknown Issue"' 2>/dev/null || echo "Unknown Issue")
+
+# Create test directory structure
+TEST_DIR="tests/bugs/\\$ISSUE_ID"
+mkdir -p "\\$TEST_DIR"
+
+# Create test template files
+cat > "\\$TEST_DIR/reproduction.test.ts" << 'EOF'
+/**
+ * Bug #\\$ISSUE_ID: \\$TITLE
+ * Reproduction test - This test should fail initially
+ */
+
+import { describe, test, expect } from 'bun:test'
+
+describe('Bug #\\$ISSUE_ID: \\$TITLE', () => {
+  test('should reproduce the reported issue', async () => {
+    // TODO: Implement reproduction steps based on bug description
+    // This test should fail initially
+    expect(true).toBe(false)
+  })
+})
+EOF
+
+cat > "\\$TEST_DIR/fix.test.ts" << 'EOF'
+/**
+ * Bug #\\$ISSUE_ID: \\$TITLE
+ * Fix verification test - This test should pass after implementing the fix
+ */
+
+import { describe, test, expect } from 'bun:test'
+
+describe('Bug #\\$ISSUE_ID: \\$TITLE - Fix Verification', () => {
+  test('should resolve the issue after fix implementation', async () => {
+    // TODO: Implement test that verifies the fix
+    // This test should pass after fix
+    expect(true).toBe(true)
+  })
+})
+EOF
+
+# Create test runner script
+cat > "\\$TEST_DIR/run-tests.sh" << 'EOF'
+#!/usr/bin/env bash
+# Test runner for bug investigation
+
+set -euo pipefail
+
+ISSUE_ID=$(basename "$(pwd)")
+echo "\uD83E\uDDEA Running tests for Bug #\\$ISSUE_ID"
+
+# Run reproduction test (should fail initially)
+echo "\uD83D\uDCCB Running reproduction test..."
+bun run reproduction.test.ts || echo "\u274C Reproduction test failed (expected)"
+
+# Run fix test (should pass after fix)
+echo "\uD83D\uDD27 Running fix verification test..."
+bun run fix.test.ts
+
+echo "\u2705 All tests completed"
+EOF
+
+chmod +x "\\$TEST_DIR/run-tests.sh"
+
+# Update issue labels
+trellis issue label "\\$ISSUE_ID" add "investigating" 2>/dev/null || true
+
+echo ""
+echo "\uD83D\uDD0D Bug Investigation Started (\\$ORIGIN):"
+echo "  \uD83D\uDCDD Issue: #\\$ISSUE_ID - \\$TITLE"
+echo "  \uD83D\uDCC1 Test directory: \\$TEST_DIR"
+echo "  \uD83E\uDDEA Test files created"
+echo ""
+echo "\uD83D\uDCCB Next Steps:"
+echo "  1. Complete investigation: trellis issue view \\$ISSUE_ID"
+echo "  2. Run reproduction test: cd \\$TEST_DIR && ./run-tests.sh"
+echo "  3. Implement fix with TDD approach"
+echo ""
+`;
+}
+function renderMilestoneTriageScript() {
+  return `#!/usr/bin/env bash
+# Milestone and cycle triage for Trellis integration
+# Integrates bugs with project milestones and development cycles
+set -euo pipefail
+
+# Import desk root detection
+source "\\$(dirname "\\$0")/../desk-root.sh"
+
+# Environment variables from contract
+ORIGIN="\${TRELLIS_ORIGIN:-unknown}"
+OUTPUT="\${TRELLIS_HOOK_OUTPUT:-stdout}"
+ISSUE_ID="\${TRELLIS_ISSUE_ID:-}"
+
+# Only run if we're in a Trellis workspace
+if ! command -v trellis >/dev/null 2>&1; then
+  exit 0
+fi
+
+# Validate issue ID
+if [ -z "\\$ISSUE_ID" ]; then
+  echo "\u274C Issue ID is required for milestone triage" >&2
+  exit 1
+fi
+
+# Get issue details and calculate priority
+ISSUE_DETAILS=$(trellis issue view "\\$ISSUE_ID" --format json 2>/dev/null || echo "{}")
+TITLE=$(echo "\\$ISSUE_DETAILS" | jq -r '.title // "Unknown Issue"' 2>/dev/null || echo "Unknown Issue")
+LABELS=$(echo "\\$ISSUE_DETAILS" | jq -r '.labels // []' 2>/dev/null || echo "[]")
+SEVERITY=$(echo "\\$LABELS" | jq -r '.[] | select(startswith("severity-")) | split("-")[1]' 2>/dev/null || echo "medium")
+
+# Get current milestone and cycle info
+CURRENT_MILESTONE=$(trellis milestone current --format json 2>/dev/null || echo "{}")
+MILESTONE_NAME=$(echo "\\$CURRENT_MILESTONE" | jq -r '.name // "current"' 2>/dev/null || echo "current")
+
+CURRENT_CYCLE=$(trellis cycle current --format json 2>/dev/null || echo "{}")
+CYCLE_NAME=$(echo "\\$CURRENT_CYCLE" | jq -r '.name // "current"' 2>/dev/null || echo "current")
+
+# Calculate priority based on severity
+calculate_priority() {
+  local severity="\\$1"
+  case "\\$severity" in
+    "critical") echo "urgent" ;;
+    "high") echo "high" ;;
+    "medium") echo "medium" ;;
+    "low") echo "low" ;;
+    *) echo "medium" ;;
+  esac
+}
+
+PRIORITY=$(calculate_priority "\\$SEVERITY")
+
+# Update issue labels and assign to milestone/cycle
+trellis issue label "\\$ISSUE_ID" add "triaged" "priority-\\$PRIORITY" "milestone-\\$MILESTONE_NAME" "cycle-\\$CYCLE_NAME" 2>/dev/null || true
+
+# Update issue priority
+trellis issue priority "\\$ISSUE_ID" set "\\$PRIORITY" 2>/dev/null || true
+
+echo ""
+echo "\uD83C\uDFAF Milestone & Cycle Triage Completed (\\$ORIGIN):"
+echo "  \uD83D\uDCDD Issue: #\\$ISSUE_ID - \\$TITLE"
+echo "  \uD83D\uDEA6 Priority: \\$PRIORITY"
+echo "  \uD83C\uDFAF Milestone: \\$MILESTONE_NAME"
+echo "  \uD83D\uDD04 Cycle: \\$CYCLE_NAME"
+echo ""
+`;
+}
+function renderCyclePlanningScript() {
+  return `#!/usr/bin/env bash
+# Cycle planning and workload management for Trellis integration
+# Manages development cycles, sprint planning, and resource allocation
+set -euo pipefail
+
+# Import desk root detection
+source "\\$(dirname "\\$0")/../desk-root.sh"
+
+# Environment variables from contract
+ORIGIN="\${TRELLIS_ORIGIN:-unknown}"
+OUTPUT="\${TRELLIS_HOOK_OUTPUT:-stdout}"
+
+# Only run if we're in a Trellis workspace
+if ! command -v trellis >/dev/null 2>&1; then
+  exit 0
+fi
+
+# Get current cycle information
+CURRENT_CYCLE=$(trellis cycle current --format json 2>/dev/null || echo "{}")
+CYCLE_NAME=$(echo "\\$CURRENT_CYCLE" | jq -r '.name // "current"' 2>/dev/null || echo "current")
+
+# Get all issues in current cycle
+CYCLE_ISSUES=$(trellis cycle issues --format json 2>/dev/null || echo "[]")
+
+# Analyze cycle workload
+total_issues=$(echo "\\$CYCLE_ISSUES" | jq 'length' 2>/dev/null || echo "0")
+urgent_issues=$(echo "\\$CYCLE_ISSUES" | jq '[.[] | select(.labels[] | contains("priority-urgent"))] | length' 2>/dev/null || echo "0")
+high_issues=$(echo "\\$CYCLE_ISSUES" | jq '[.[] | select(.labels[] | contains("priority-high"))] | length' 2>/dev/null || echo "0")
+
+# Calculate health score
+health_score=100
+health_score=$((health_score - (urgent_issues * 20)))
+health_score=$((health_score - (high_issues * 10)))
+
+if [ "\\$health_score" -lt 0 ]; then
+  health_score=0
+fi
+
+echo ""
+echo "\uD83D\uDD04 Cycle Planning Completed (\\$ORIGIN):"
+echo "  \uD83D\uDCCA Cycle: \\$CYCLE_NAME"
+echo "  \uD83D\uDCC8 Health Score: \\$health_score/100"
+echo "  \uD83D\uDCDD Total Issues: \\$total_issues"
+echo "  \uD83D\uDEA8 Urgent Issues: \\$urgent_issues"
+echo "  \u26A1 High Priority Issues: \\$high_issues"
+echo ""
+echo "\uD83D\uDCCB Recommendations:"
+echo "  \\$([ "\\$health_score" -lt 60 ] && echo "\uD83D\uDEA8 High workload detected - consider rebalancing" || echo "\u2705 Healthy workload - maintain current pace")"
+echo "  \\$([ "\\$urgent_issues" -gt 0 ] && echo "\u26A0\uFE0F Address urgent issues immediately" || echo "\u2705 No urgent issues")"
+echo ""
+`;
+}
 var init_write = () => {};
 
 // src/garden/cluster.ts
@@ -4868,160 +6065,4 @@ var init_engine = __esm(() => {
   init_write();
 });
 
-// src/scaffold/seed.ts
-init_profile();
-init_infer();
-import { existsSync as existsSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join6 } from "path";
-async function seedContext(opts) {
-  const { rootPath, ide = "none", force = false } = opts;
-  const filesUpdated = [];
-  const timestamp = new Date().toISOString();
-  const profile = loadProfile();
-  const context = await inferProjectContext(rootPath);
-  const agentsDir = join6(rootPath, ".trellis", "agents");
-  if (existsSync5(agentsDir)) {
-    const agentsMdPath = join6(agentsDir, "AGENTS.md");
-    if (existsSync5(agentsMdPath) || force) {
-      const content = renderSeedAgentsMd(profile, context, timestamp);
-      writeFileSync4(agentsMdPath, content, "utf-8");
-      filesUpdated.push(".trellis/agents/AGENTS.md");
-    }
-    const agentContextPath = join6(agentsDir, "agent-context.json");
-    if (existsSync5(agentContextPath) || force) {
-      const config = {
-        domain: context.domain,
-        ecosystem: context.ecosystem,
-        tools: [],
-        ontologies: [],
-        generatedAt: timestamp,
-        confidence: context.confidence,
-        lastSeed: timestamp
-      };
-      writeFileSync4(agentContextPath, JSON.stringify(config, null, 2), "utf-8");
-      filesUpdated.push(".trellis/agents/agent-context.json");
-    }
-  }
-  switch (ide) {
-    case "cursor": {
-      const cursorRulesPath = join6(rootPath, ".cursor", "rules.md");
-      if (existsSync5(cursorRulesPath) || force) {
-        const content = renderSeedIdeRules(profile, context, "cursor", timestamp);
-        writeFileSync4(cursorRulesPath, content, "utf-8");
-        filesUpdated.push(".cursor/rules.md");
-      }
-      break;
-    }
-    case "windsurf": {
-      const windsurfRulesPath = join6(rootPath, ".windsurf", "rules.md");
-      if (existsSync5(windsurfRulesPath) || force) {
-        const content = renderSeedIdeRules(profile, context, "windsurf", timestamp);
-        writeFileSync4(windsurfRulesPath, content, "utf-8");
-        filesUpdated.push(".windsurf/rules.md");
-      }
-      break;
-    }
-    case "claude": {
-      const claudeSettingsPath = join6(rootPath, ".claude", "settings.md");
-      if (existsSync5(claudeSettingsPath) || force) {
-        const content = renderSeedIdeRules(profile, context, "claude", timestamp);
-        writeFileSync4(claudeSettingsPath, content, "utf-8");
-        filesUpdated.push(".claude/settings.md");
-      }
-      break;
-    }
-    case "none":
-      break;
-  }
-  return {
-    success: true,
-    filesUpdated,
-    timestamp
-  };
-}
-function renderSeedAgentsMd(profile, context, timestamp) {
-  const userName = profile?.name ?? "the user";
-  const userBio = profile?.bio ?? "(not provided)";
-  const userSkills = profile?.skills?.length ? profile.skills.join(", ") : "(not specified)";
-  return `# Trellis Agent Context
-
-> This file was seeded by \`trellis seed\` on ${timestamp}
-> Inference confidence: **${context.confidence}**
-
----
-
-## About the User
-
-| Field | Value |
-|-------|-------|
-| **Name** | ${userName} |
-| **Bio** | ${userBio} |
-| **Skills** | ${userSkills} |
-
----
-
-## About This Project
-
-| Field | Value |
-|-------|-------|
-| **Name** | ${context.name ?? "(unnamed)"} |
-| **Domain** | ${context.domain ?? "(not determined)"} |
-| **Description** | ${context.description ?? "(no description found)"} |
-| **Ecosystem** | ${context.ecosystem ?? "unknown"} |
-| **File count** | ~${context.fileCount} |
-
----
-
-## Agent Instructions
-
-You are operating in a Trellis-tracked repository. Follow these guidelines:
-
-1. **Read \`agent-context.json\`** in this directory for registered tools, ontologies, and domain settings.
-2. **Check \`skills/\`** for domain-specific operating instructions relevant to this project.
-3. **Check \`workflows/\`** for repeatable task procedures.
-4. **Run \`trellis seed\`** to refresh this context file when the project evolves.
-
----
-
-## Quick Reference
-
-\`\`\`bash
-trellis status          # Current repo state
-trellis log             # Causal operation history
-trellis seed            # Refresh this context
-trellis milestone       # Create narrative checkpoints
-\`\`\`
-`;
-}
-function renderSeedIdeRules(profile, context, ide, timestamp) {
-  const ideName = ide.charAt(0).toUpperCase() + ide.slice(1);
-  const projectName = context.name ?? "this project";
-  return `# ${ideName} Rules for ${projectName}
-
-> Generated by \`trellis seed\` on ${timestamp}
-
-## Project Context
-- **Domain**: ${context.domain ?? "(not determined)"}
-- **Ecosystem**: ${context.ecosystem ?? "unknown"}
-- **File count**: ~${context.fileCount}
-- **Confidence**: ${context.confidence}
-
-## Agent Instructions
-You are working in a Trellis-tracked repository. See \`.trellis/agents/AGENTS.md\` for full context.
-
-## Commands
-- \`trellis status\` \u2014 Check repo state
-- \`trellis seed\` \u2014 Refresh this context file
-- \`trellis log\` \u2014 View causal history
-
----
-*Auto-generated by Trellis. Run \`trellis seed\` to refresh context.*
-`;
-}
-
-// src/scaffold/index.ts
-init_infer();
-init_profile();
-init_write();
-
-export { FileWatcher, init_fs_watcher, Ingestion, init_ingestion, inferProjectContext, loadProfile, saveProfile, hasProfile, promptForProfile, updateProfile, writeAgentScaffold, writeIdeScaffold, TrellisVcsEngine, init_engine, seedContext };
+export { FileWatcher, init_fs_watcher, Ingestion, init_ingestion, inferProjectContext, init_infer, loadProfile, saveProfile, hasProfile, promptForProfile, updateProfile, init_profile, writeAgentScaffold, writeIdeScaffold, init_write, TrellisVcsEngine, init_engine };