pull in the new changes from orginal goose repo

.cargo/config.toml

@@ -0,0 +1,5 @@
+[target.x86_64-pc-windows-msvc]
+rustflags = ["-C", "link-args=/FORCE:MULTIPLE"]
+
+[target.aarch64-pc-windows-msvc]
+rustflags = ["-C", "link-args=/FORCE:MULTIPLE"]

.github/CODEOWNERS

@@ -1,6 +1,6 @@
 # CODEOWNERS file for block/goose repository
 # See: https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners
 
-# Documentation owned by DevRel team
-/documentation/ @block/goose-devrel
+# Documentation owned by DevRel
+/documentation/ @blackgirlbytes
 

.github/copilot-instructions.md

@@ -34,8 +34,8 @@
 - Async/await misuse or blocking operations in async contexts
 - Improper trait implementations
 
-### No Prerelease Docs
-- If the PR contains both code changes to features/functionality AND updates in `/documentation`: Documentation updates must be separated to keep public docs in sync with released versions. Either mark new topics with `unlisted: true` or remove/hide the documentation.
+### No Doc Updates with Code Changes
+- PRs with code changes shouldn't update `/documentation` - docs deploy on merge, code on release. Use `unlisted: true` or remove/hide docs.
 
 ## Project-Specific Context
 

.github/workflows/goose-release-notes.yml

@@ -0,0 +1,350 @@
+# goose Release Notes Generator
+#
+# Automatically generates release notes using goose AI agent when a new release is published.
+# Updates the GitHub release with AI-generated categorized notes and posts to Discord.
+#
+# Uses workflow_run instead of release:published because GitHub doesn't trigger
+# workflows for events created by GITHUB_TOKEN (to prevent infinite loops).
+
+name: goose Release Notes Generator
+
+on:
+  # Trigger when Release workflow completes (works around GITHUB_TOKEN limitation)
+  workflow_run:
+    workflows:
+      - Release
+    types:
+      - completed
+
+  # Allow manual trigger for testing
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Release tag to generate notes for (e.g., v1.25.0)'
+        required: true
+        type: string
+
+env:
+  GOOSE_RECIPE: |
+    version: "1.0.0"
+    title: "Release Notes Generator"
+    description: "Generate release notes for ${RELEASE_TAG}"
+
+    extensions:
+      - type: builtin
+        name: developer
+
+    instructions: |
+      Generate release notes for the goose release.
+
+      ## Process
+      1. You are already in the goose repository. Do NOT clone or checkout anything.
+      2. Get the previous release tag by running: git describe --tags --abbrev=0 ${RELEASE_TAG}^
+      3. Get commits between tags: git log <previous_tag>..${RELEASE_TAG} --oneline --no-merges
+      4. Analyze the commits and categorize changes
+
+      ## Output Format
+      Categorize changes into these sections (skip empty sections):
+      - ✨ **Features** - New functionality
+      - 🐛 **Bug Fixes** - Bug fixes
+      - 🔧 **Improvements** - Enhancements to existing features
+      - 📚 **Documentation** - Documentation updates
+
+      Format each item as:
+      - Concise description [#XXXX](https://github.com/block/goose/pull/XXXX)
+
+      Rules:
+      - Extract PR numbers from commit messages (look for (#XXXX) pattern)
+      - Remove redundant words like "Added", "Fixed", "Documented" - the category headers make these clear
+      - Keep descriptions user-friendly and concise
+      - Order: Features → Bug Fixes → Improvements → Documentation
+
+      ## Final Step
+      Write ONLY the release notes content to /tmp/release_notes.md (no extra commentary)
+
+    prompt: |
+      Generate release notes for ${RELEASE_TAG} in the goose repository.
+
+permissions:
+  contents: write
+
+concurrency:
+  group: release-notes-${{ github.event.workflow_run.head_branch || inputs.tag }}
+  cancel-in-progress: true
+
+jobs:
+  generate-release-notes:
+    name: Generate Release Notes
+    runs-on: ubuntu-latest
+    # For workflow_run: only run if Release succeeded and tag is not 'stable'
+    # For workflow_dispatch: only run if tag is not 'stable'
+    if: |
+      (github.event_name == 'workflow_dispatch' && inputs.tag != 'stable') ||
+      (github.event_name == 'workflow_run' && 
+       github.event.workflow_run.conclusion == 'success' &&
+       github.event.workflow_run.head_branch != 'stable')
+
+    container:
+      image: ghcr.io/block/goose:latest
+      options: --user root
+      env:
+        GOOSE_PROVIDER: ${{ vars.GOOSE_PROVIDER || 'anthropic' }}
+        GOOSE_MODEL: ${{ vars.GOOSE_MODEL || 'claude-opus-4-5' }}
+        ANTHROPIC_API_KEY: ${{ secrets.RELEASE_BOT_ANTHROPIC_KEY }}
+        HOME: /tmp/goose-home
+
+    outputs:
+      release_notes: ${{ steps.read-notes.outputs.notes }}
+      notes_length: ${{ steps.read-notes.outputs.length }}
+      release_tag: ${{ steps.get-tag.outputs.tag }}
+
+    steps:
+      - name: Get release tag
+        id: get-tag
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          INPUT_TAG: ${{ inputs.tag }}
+          WORKFLOW_RUN_BRANCH: ${{ github.event.workflow_run.head_branch }}
+        run: |
+          if [ "$EVENT_NAME" = "workflow_dispatch" ]; then
+            echo "tag=$INPUT_TAG" >> $GITHUB_OUTPUT
+          else
+            echo "tag=$WORKFLOW_RUN_BRANCH" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Checkout repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  # v4.2.2
+        with:
+          fetch-depth: 0
+          fetch-tags: true
+
+      - name: Install tools
+        run: |
+          apt-get update
+          apt-get install -y gettext curl ripgrep git jq
+
+      - name: Run goose to generate release notes
+        env:
+          RELEASE_TAG: ${{ steps.get-tag.outputs.tag }}
+        run: |
+          mkdir -p $HOME/.local/share/goose/sessions
+          mkdir -p $HOME/.config/goose
+          git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
+          # Checkout the release tag
+          git checkout "${RELEASE_TAG}"
+
+          # Create recipe from env var with variable substitution
+          echo "$GOOSE_RECIPE" | envsubst '$RELEASE_TAG' > /tmp/recipe.yaml
+
+          goose run --recipe /tmp/recipe.yaml
+
+      - name: Read release notes
+        id: read-notes
+        run: |
+          if [ -f /tmp/release_notes.md ]; then
+            # Use random delimiter to prevent injection
+            DELIMITER="EOF_$(openssl rand -hex 8)"
+            echo "notes<<$DELIMITER" >> $GITHUB_OUTPUT
+            cat /tmp/release_notes.md >> $GITHUB_OUTPUT
+            echo "" >> $GITHUB_OUTPUT
+            echo "$DELIMITER" >> $GITHUB_OUTPUT
+
+            LENGTH=$(wc -c < /tmp/release_notes.md)
+            echo "length=$LENGTH" >> $GITHUB_OUTPUT
+
+            echo "::notice::Release notes generated successfully (${LENGTH} chars)"
+          else
+            echo "::error::Release notes file not found at /tmp/release_notes.md"
+            echo "notes=Release notes generation failed." >> $GITHUB_OUTPUT
+            echo "length=0" >> $GITHUB_OUTPUT
+            exit 1
+          fi
+
+  update-github-release:
+    name: Update GitHub Release
+    runs-on: ubuntu-latest
+    needs: generate-release-notes
+    permissions:
+      contents: write
+
+    steps:
+      - name: Update release body
+        uses: ncipollo/release-action@b7eabc95ff50cbeeedec83973935c8f306dfcd0b  # v1.20.0
+        with:
+          tag: ${{ needs.generate-release-notes.outputs.release_tag }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+          body: ${{ needs.generate-release-notes.outputs.release_notes }}
+          allowUpdates: true
+          omitNameDuringUpdate: true
+          omitPrereleaseDuringUpdate: true
+
+  post-to-discord:
+    name: Post to Discord
+    runs-on: ubuntu-latest
+    needs: generate-release-notes
+
+    steps:
+      - name: Post release announcement
+        env:
+          DISCORD_BOT_TOKEN: ${{ secrets.DISCORD_RELEASE_BOT_TOKEN }}
+          DISCORD_CHANNEL_ID: ${{ secrets.DISCORD_RELEASE_BOT_CHANNEL_ID }}
+          RELEASE_TAG: ${{ needs.generate-release-notes.outputs.release_tag }}
+          RELEASE_URL: https://github.com/block/goose/releases/tag/${{ needs.generate-release-notes.outputs.release_tag }}
+          RELEASE_NOTES: ${{ needs.generate-release-notes.outputs.release_notes }}
+          NOTES_LENGTH: ${{ needs.generate-release-notes.outputs.notes_length }}
+        shell: bash
+        run: |
+          # Skip if Discord is not configured
+          if [ -z "$DISCORD_CHANNEL_ID" ] || [ -z "$DISCORD_BOT_TOKEN" ]; then
+            echo "::notice::Discord not configured, skipping"
+            exit 0
+          fi
+
+          # Discord message character limit is ~2000 for regular messages
+          SAFE_LIMIT=1800
+
+          # Function to send Discord message via bot API, returns message ID
+          send_discord() {
+            local content="$1"
+            local channel="$2"
+
+            content=$(echo "$content" | jq -Rs .)
+
+            response=$(curl -s -X POST "https://discord.com/api/v10/channels/${channel}/messages" \
+              -H "Authorization: Bot ${DISCORD_BOT_TOKEN}" \
+              -H "Content-Type: application/json" \
+              -d "{\"content\": $content, \"flags\": 4}")
+
+            # Debug: show response if there's an error
+            if echo "$response" | jq -e '.code' > /dev/null 2>&1; then
+              echo "::warning::Discord API error: $(echo "$response" | jq -c '.')" >&2
+            fi
+
+            echo "$response" | jq -r '.id // empty'
+          }
+
+          # Function to create a thread from a message
+          create_thread() {
+            local channel="$1"
+            local message_id="$2"
+            local thread_name="$3"
+
+            response=$(curl -s -X POST "https://discord.com/api/v10/channels/${channel}/messages/${message_id}/threads" \
+              -H "Authorization: Bot ${DISCORD_BOT_TOKEN}" \
+              -H "Content-Type: application/json" \
+              -d "{\"name\": \"${thread_name}\"}")
+
+            echo "$response" | jq -r '.id // empty'
+          }
+
+          # Build the announcement header
+          HEADER="## 🎉 goose ${RELEASE_TAG} is here!
+
+          📦 **Release:** ${RELEASE_URL}"
+
+          FOOTER="
+
+          @everyone
+          📝 *More in thread...*"
+          HEADER_LEN=${#HEADER}
+          FOOTER_LEN=${#FOOTER}
+          AVAILABLE=$((SAFE_LIMIT - HEADER_LEN - FOOTER_LEN - 10))
+
+          # Check if everything fits in one message (no thread needed)
+          FULL_MSG="${HEADER}
+
+          ${RELEASE_NOTES}"
+          if [ ${#FULL_MSG} -le "$SAFE_LIMIT" ]; then
+            send_discord "$FULL_MSG" "$DISCORD_CHANNEL_ID"
+            echo "::notice::Discord notification sent successfully"
+            exit 0
+          fi
+
+          # Need to split - use awk to fit complete lines in main vs thread
+          echo "$RELEASE_NOTES" > /tmp/release_notes_full.txt
+
+          awk -v avail="$AVAILABLE" '
+          BEGIN { main_len = 0; in_thread = 0 }
+          {
+            line_len = length($0) + 1  # +1 for newline
+            if (!in_thread && (main_len + line_len) <= avail) {
+              print > "/tmp/main_content.txt"
+              main_len += line_len
+            } else {
+              in_thread = 1
+              print > "/tmp/thread_content.txt"
+            }
+          }
+          ' /tmp/release_notes_full.txt
+
+          # Read the split content
+          MAIN_CONTENT=""
+          [ -f /tmp/main_content.txt ] && MAIN_CONTENT=$(cat /tmp/main_content.txt)
+
+          THREAD_CONTENT=""
+          [ -f /tmp/thread_content.txt ] && THREAD_CONTENT=$(cat /tmp/thread_content.txt)
+
+          # Build and send main message
+          MAIN_MESSAGE="${HEADER}
+
+          ${MAIN_CONTENT}
+          ${FOOTER}"
+
+          MESSAGE_ID=$(send_discord "$MAIN_MESSAGE" "$DISCORD_CHANNEL_ID")
+
+          if [ -z "$MESSAGE_ID" ]; then
+            echo "::error::Failed to send Discord message"
+            exit 1
+          fi
+
+          echo "Created message $MESSAGE_ID, creating thread..."
+          sleep 1
+
+          # Create thread
+          THREAD_ID=$(create_thread "$DISCORD_CHANNEL_ID" "$MESSAGE_ID" "Release Notes ${RELEASE_TAG}")
+          if [ -z "$THREAD_ID" ]; then
+            echo "::warning::Failed to create thread"
+            THREAD_ID="$DISCORD_CHANNEL_ID"
+          fi
+          sleep 1
+
+          # Post thread content in chunks (by complete lines)
+          if [ -n "$THREAD_CONTENT" ]; then
+            # Split thread content into chunks using awk
+            awk -v limit="$SAFE_LIMIT" '
+            BEGIN { chunk = ""; chunk_len = 0; chunk_num = 0 }
+            {
+              line_len = length($0) + 1
+              if (chunk_len + line_len > limit && chunk_len > 0) {
+                # Save current chunk and start new one
+                print chunk > "/tmp/chunk_" chunk_num ".txt"
+                chunk_num++
+                chunk = $0 "\n"
+                chunk_len = line_len
+              } else {
+                chunk = chunk $0 "\n"
+                chunk_len += line_len
+              }
+            }
+            END {
+              if (chunk_len > 0) {
+                print chunk > "/tmp/chunk_" chunk_num ".txt"
+              }
+            }
+            ' /tmp/thread_content.txt
+
+            # Send each chunk
+            for chunk_file in /tmp/chunk_*.txt; do
+              [ -f "$chunk_file" ] || continue
+              CHUNK=$(cat "$chunk_file")
+              [ -n "$CHUNK" ] && send_discord "$CHUNK" "$THREAD_ID"
+              sleep 1
+              rm -f "$chunk_file"
+            done
+          fi
+
+          # Cleanup
+          rm -f /tmp/release_notes_full.txt /tmp/main_content.txt /tmp/thread_content.txt
+
+          echo "::notice::Discord notification sent successfully"

.goosehints

@@ -14,5 +14,5 @@ that you can call the functionality from the server from the typescript.
 
 tips: 
 - can look at unstaged changes for what is being worked on if starting
-- always check rust compiles, cargo fmt etc and `./scripts/clippy-lint.sh` (as well as run tests in files you are working on)
+- always check rust compiles, cargo fmt etc and `cargo clippy --all-targets -- -D warnings` (as well as run tests in files you are working on)
 - in ui/desktop, look at how you can run lint checks and if other tests can run