@mizyoel/mercury-mesh 0.9.4

package/.mesh/templates/workflows/mesh-heartbeat.yml

@@ -0,0 +1,237 @@
+name: Mercury Mesh Heartbeat (Ralph)
+# ⚠️ SYNC: This workflow is maintained in 4 locations. Changes must be applied to all:
+#   - templates/workflows/mesh-heartbeat.yml (source template)
+#   - packages/mesh-cli/templates/workflows/mesh-heartbeat.yml (CLI package)
+#   - .mesh/templates/workflows/mesh-heartbeat.yml (installed template)
+#   - .github/workflows/mesh-heartbeat.yml (active workflow)
+
+on:
+  schedule:
+    # Every 30 minutes — adjust via cron expression as needed
+    - cron: '*/30 * * * *'
+
+  # React to completed work or new bridge work
+  issues:
+    types: [closed, labeled]
+  pull_request:
+    types: [closed]
+
+  # Manual trigger
+  workflow_dispatch:
+
+permissions:
+  issues: write
+  contents: read
+  pull-requests: read
+
+jobs:
+  heartbeat:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Resolve runtime
+        id: resolve-runtime
+        run: |
+          runtime_dir=""
+          for candidate in .mesh .mercury; do
+            if [ -f "$candidate/templates/ralph-triage.js" ]; then
+              runtime_dir="$candidate"
+              break
+            fi
+          done
+
+          if [ -n "$runtime_dir" ]; then
+            echo "runtime_dir=$runtime_dir" >> $GITHUB_OUTPUT
+            echo "templates_dir=$runtime_dir/templates" >> $GITHUB_OUTPUT
+            echo "runtime_arg=--mesh-dir" >> $GITHUB_OUTPUT
+            echo "has_script=true" >> $GITHUB_OUTPUT
+            if [ -f "$runtime_dir/templates/org-runtime-reconcile.js" ] && [ -f "$runtime_dir/org/structure.json" ]; then
+              echo "has_org_runtime=true" >> $GITHUB_OUTPUT
+            else
+              echo "has_org_runtime=false" >> $GITHUB_OUTPUT
+            fi
+            if [ -f "$runtime_dir/templates/org-backlog-from-triage.js" ] && [ -f "$runtime_dir/org/structure.json" ]; then
+              echo "has_backlog_bridge=true" >> $GITHUB_OUTPUT
+            else
+              echo "has_backlog_bridge=false" >> $GITHUB_OUTPUT
+            fi
+          else
+            echo "has_script=false" >> $GITHUB_OUTPUT
+            echo "has_org_runtime=false" >> $GITHUB_OUTPUT
+            echo "has_backlog_bridge=false" >> $GITHUB_OUTPUT
+            echo "⚠️ ralph-triage.js not found — ensure .mesh/templates/ is populated"
+          fi
+
+      - name: Ralph — Smart triage
+        if: steps.resolve-runtime.outputs.has_script == 'true'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          node ${{ steps.resolve-runtime.outputs.templates_dir }}/ralph-triage.js \
+            ${{ steps.resolve-runtime.outputs.runtime_arg }} ${{ steps.resolve-runtime.outputs.runtime_dir }} \
+            --output triage-results.json
+
+      - name: Ralph — Org runtime reconcile report
+        if: steps.resolve-runtime.outputs.has_org_runtime == 'true'
+        run: |
+          node ${{ steps.resolve-runtime.outputs.templates_dir }}/org-runtime-reconcile.js \
+            ${{ steps.resolve-runtime.outputs.runtime_arg }} ${{ steps.resolve-runtime.outputs.runtime_dir }} \
+            --output org-runtime-results.json
+
+      - name: Ralph — Show org runtime reconcile report
+        if: hashFiles('org-runtime-results.json') != ''
+        run: |
+          echo "Org runtime reconcile results:"
+          cat org-runtime-results.json
+
+      - name: Ralph — Org backlog packet preview
+        if: steps.resolve-runtime.outputs.has_backlog_bridge == 'true' && hashFiles('triage-results.json') != ''
+        run: |
+          node ${{ steps.resolve-runtime.outputs.templates_dir }}/org-backlog-from-triage.js \
+            ${{ steps.resolve-runtime.outputs.runtime_arg }} ${{ steps.resolve-runtime.outputs.runtime_dir }} \
+            --triage-file triage-results.json \
+            --output org-backlog-results.json
+
+      - name: Ralph — Show org backlog packet preview
+        if: hashFiles('org-backlog-results.json') != ''
+        run: |
+          echo "Org backlog packet preview:"
+          cat org-backlog-results.json
+
+      - name: Ralph — Apply triage decisions
+        if: steps.resolve-runtime.outputs.has_script == 'true' && hashFiles('triage-results.json') != ''
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const path = 'triage-results.json';
+            if (!fs.existsSync(path)) {
+              core.info('No triage results — board is clear');
+              return;
+            }
+            
+            const results = JSON.parse(fs.readFileSync(path, 'utf8'));
+            if (results.length === 0) {
+              core.info('📋 Board is clear — Ralph found no untriaged issues');
+              return;
+            }
+            
+            for (const decision of results) {
+              try {
+                const labels = Array.isArray(decision.labels) && decision.labels.length > 0
+                  ? decision.labels
+                  : [decision.label];
+                await github.rest.issues.addLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: decision.issueNumber,
+                  labels
+                });
+                
+                await github.rest.issues.createComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: decision.issueNumber,
+                  body: [
+                    '### 🔄 Ralph — Auto-Triage',
+                    '',
+                    `**Assigned to:** ${decision.assignTo}`,
+                    decision.departmentName ? `**Department:** ${decision.departmentName}` : '',
+                    `**Reason:** ${decision.reason}`,
+                    `**Source:** ${decision.source}`,
+                    '',
+                    '> Ralph auto-triaged this issue using Mercury Mesh routing rules.',
+                    '> To reassign, swap the assigned `mesh:*` label. Keep any `dept:*` labels aligned with the new routing.'
+                  ].join('\n')
+                });
+                
+                  core.info(`Triaged #${decision.issueNumber} → ${decision.assignTo} (${decision.source}${decision.departmentId ? `, dept:${decision.departmentId}` : ''})`);
+              } catch (e) {
+                core.warning(`Failed to triage #${decision.issueNumber}: ${e.message}`);
+              }
+            }
+            
+            core.info(`🔄 Ralph triaged ${results.length} issue(s)`);
+
+      # Copilot auto-assign step (uses PAT if available)
+      - name: Ralph — Assign @copilot issues
+        if: success()
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.COPILOT_ASSIGN_TOKEN || secrets.GITHUB_TOKEN }}
+          script: |
+            const fs = require('fs');
+            const runtimeCandidates = ['.mesh', '.mercury', '.ai-team'];
+            const stateCandidates = ['.mesh', '.mercury'];
+            const findFirst = (candidates) => candidates.find((candidate) => fs.existsSync(candidate)) || null;
+
+            const teamFile = findFirst(runtimeCandidates.map((candidate) => `${candidate}/team.md`));
+            if (!teamFile || !fs.existsSync(teamFile)) return;
+
+            const runtimeDir = teamFile.slice(0, teamFile.lastIndexOf('/'));
+            const stateDir = runtimeDir !== '.ai-team'
+              ? runtimeDir
+              : (findFirst(stateCandidates.map((candidate) => `${candidate}/config.json`)) || '.mesh/config.json').replace(/\/config\.json$/, '');
+            const routingFile = findFirst([`${runtimeDir}/routing.md`, '.ai-team/routing.md']) || `${runtimeDir}/routing.md`;
+            const structurePath = `${stateDir}/org/structure.json`;
+
+            const content = fs.readFileSync(teamFile, 'utf8');
+
+            // Check if @copilot is on the team with auto-assign
+            const hasCopilot = content.includes('🤖 Coding Agent') || content.includes('@copilot');
+            const autoAssign = content.includes('<!-- copilot-auto-assign: true -->');
+            if (!hasCopilot || !autoAssign) return;
+
+            // Find issues labeled mesh:copilot with no assignee.
+            try {
+              const { data: openIssues } = await github.rest.issues.listForRepo({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                state: 'open',
+                per_page: 100
+              });
+
+              const copilotIssues = openIssues.filter((issue) => {
+                const labels = Array.isArray(issue.labels)
+                  ? issue.labels.map((item) => typeof item === 'string' ? item : item && item.name).filter(Boolean)
+                  : [];
+                return labels.includes('mesh:copilot');
+              });
+
+              const unassigned = copilotIssues.filter(i =>
+                !i.assignees || i.assignees.length === 0
+              );
+
+              if (unassigned.length === 0) {
+                core.info('No unassigned mesh:copilot issues');
+                return;
+              }
+
+              // Get repo default branch
+              const { data: repoData } = await github.rest.repos.get({
+                owner: context.repo.owner,
+                repo: context.repo.repo
+              });
+
+              for (const issue of unassigned) {
+                try {
+                  await github.request('POST /repos/{owner}/{repo}/issues/{issue_number}/assignees', {
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    issue_number: issue.number,
+                    assignees: ['copilot-swe-agent[bot]'],
+                    agent_assignment: {
+                      target_repo: `${context.repo.owner}/${context.repo.repo}`,
+                      base_branch: repoData.default_branch,
+                       custom_instructions: `Read ${teamFile} for team context, ${routingFile} for routing rules, and if orgMode is enabled read ${structurePath} for department context.`
+                     }
+                   });
+                  core.info(`Assigned copilot-swe-agent[bot] to #${issue.number}`);
+                } catch (e) {
+                  core.warning(`Failed to assign @copilot to #${issue.number}: ${e.message}`);
+                }
+              }
+            } catch (e) {
+              core.info(`No compatible copilot label found or error: ${e.message}`);
+            }

package/.mesh/templates/workflows/mesh-insider-release.yml

@@ -0,0 +1,61 @@
+name: Mercury Mesh Insider Release
+
+on:
+  push:
+    branches: [insider]
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Run tests
+        run: node --test test/*.test.js
+
+      - name: Read version from package.json
+        id: version
+        run: |
+          VERSION=$(node -e "console.log(require('./package.json').version)")
+          SHORT_SHA=$(git rev-parse --short HEAD)
+          INSIDER_VERSION="${VERSION}-insider+${SHORT_SHA}"
+          INSIDER_TAG="v${INSIDER_VERSION}"
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "short_sha=$SHORT_SHA" >> "$GITHUB_OUTPUT"
+          echo "insider_version=$INSIDER_VERSION" >> "$GITHUB_OUTPUT"
+          echo "insider_tag=$INSIDER_TAG" >> "$GITHUB_OUTPUT"
+          echo "📦 Base Version: $VERSION (Short SHA: $SHORT_SHA)"
+          echo "🏷️ Insider Version: $INSIDER_VERSION"
+          echo "🔖 Insider Tag: $INSIDER_TAG"
+
+      - name: Create git tag
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag -a "${{ steps.version.outputs.insider_tag }}" -m "Insider Release ${{ steps.version.outputs.insider_tag }}"
+          git push origin "${{ steps.version.outputs.insider_tag }}"
+
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create "${{ steps.version.outputs.insider_tag }}" \
+            --title "${{ steps.version.outputs.insider_tag }}" \
+            --notes "This is an insider/development build of Mercury Mesh. Install or upgrade with:\`\`\`bash\nnpm install -g @f-os/mercury-mesh-cli@${{ steps.version.outputs.insider_tag }}\n\`\`\`\n\n**Note:** Insider builds may be unstable and are intended for early adopters and testing only." \
+            --prerelease
+
+      - name: Verify release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release view "${{ steps.version.outputs.insider_tag }}"
+          echo "✅ Insider Release ${{ steps.version.outputs.insider_tag }} created and verified."

package/.mesh/templates/workflows/mesh-issue-assign.yml

@@ -0,0 +1,243 @@
+name: Mercury Mesh Issue Assign
+
+on:
+  issues:
+    types: [labeled]
+
+permissions:
+  issues: write
+  contents: read
+
+jobs:
+  assign-work:
+    # Trigger on mesh: label family.
+    if: startsWith(github.event.label.name, 'mesh:')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Identify assigned member and trigger work
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const issue = context.payload.issue;
+            const label = context.payload.label.name;
+            const runtimeCandidates = ['.mesh', '.mercury', '.ai-team'];
+            const stateCandidates = ['.mesh', '.mercury'];
+            const findFirst = (candidates) => candidates.find((candidate) => fs.existsSync(candidate)) || null;
+
+            const labelPrefix = 'mesh';
+            const memberName = label.replace(/^mesh:/, '').toLowerCase();
+
+            const teamFile = findFirst(runtimeCandidates.map((candidate) => `${candidate}/team.md`));
+            if (!teamFile || !fs.existsSync(teamFile)) {
+              core.warning('No .mesh/team.md, .mercury/team.md, or .ai-team/team.md found — cannot route Mercury Mesh work');
+              return;
+            }
+
+            const runtimeDir = teamFile.slice(0, teamFile.lastIndexOf('/'));
+            const stateDir = runtimeDir !== '.ai-team'
+              ? runtimeDir
+              : (findFirst(stateCandidates.map((candidate) => `${candidate}/config.json`)) || '.mesh/config.json').replace(/\/config\.json$/, '');
+
+            const content = fs.readFileSync(teamFile, 'utf8');
+            const lines = content.split('\n');
+            const members = [];
+            let inMembersTable = false;
+            for (const line of lines) {
+              if (line.match(/^##\s+(Members|Team Roster)/i)) {
+                inMembersTable = true;
+                continue;
+              }
+              if (inMembersTable && line.startsWith('## ')) {
+                break;
+              }
+              if (inMembersTable && line.startsWith('|') && !line.includes('---') && !line.includes('Name')) {
+                const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+                if (cells.length >= 2) {
+                  members.push({
+                    name: cells[0],
+                    role: cells[1]
+                  });
+                }
+              }
+            }
+            const normalize = (value = '') => String(value).trim().toLowerCase();
+            const memberByName = new Map(members.map(member => [normalize(member.name), member]));
+
+            let orgConfig = null;
+            let orgStructure = null;
+            try {
+              if (fs.existsSync(`${stateDir}/config.json`)) {
+                orgConfig = JSON.parse(fs.readFileSync(`${stateDir}/config.json`, 'utf8'));
+              }
+            } catch (err) {
+              core.warning(`Could not parse ${stateDir}/config.json: ${err.message}`);
+            }
+            try {
+              if (fs.existsSync(`${stateDir}/org/structure.json`)) {
+                orgStructure = JSON.parse(fs.readFileSync(`${stateDir}/org/structure.json`, 'utf8'));
+              }
+            } catch (err) {
+              core.warning(`Could not parse ${stateDir}/org/structure.json: ${err.message}`);
+            }
+
+            const orgModeEnabled = !!(orgConfig && orgConfig.orgMode && orgStructure && Array.isArray(orgStructure.departments));
+            const findDepartmentForMember = (name) => {
+              if (!orgModeEnabled) return null;
+              const key = normalize(name);
+              return orgStructure.departments.find(dept =>
+                [dept.lead, ...(dept.members || [])]
+                  .filter(Boolean)
+                  .some(candidate => normalize(candidate) === key)
+              ) || null;
+            };
+            const issueLabels = Array.isArray(issue.labels)
+              ? issue.labels.map(item => typeof item === 'string' ? item : item && item.name).filter(Boolean)
+              : [];
+            const deptLabel = issueLabels.find(name => name.startsWith('dept:'));
+            let assignedDepartment = null;
+            if (deptLabel) {
+              const deptId = deptLabel.replace('dept:', '').toLowerCase();
+              assignedDepartment = orgModeEnabled
+                ? orgStructure.departments.find(dept => normalize(dept.id) === deptId) || null
+                : { id: deptId, name: deptId, lead: null };
+            }
+            const formatMemberName = (name) => memberByName.get(normalize(name))?.name || name;
+
+            // Check if this is a coding agent assignment
+            const isCopilotAssignment = memberName === 'copilot';
+
+            let assignedMember = null;
+            if (isCopilotAssignment) {
+              assignedMember = { name: '@copilot', role: 'Coding Agent' };
+            } else {
+              assignedMember = memberByName.get(memberName) || null;
+              if (!assignedDepartment && assignedMember) {
+                assignedDepartment = findDepartmentForMember(assignedMember.name);
+              }
+            }
+
+            if (!assignedMember) {
+              core.warning(`No member found matching label "${label}"`);
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issue.number,
+                body: `⚠️ No Mercury Mesh member found matching label \`${label}\`. Check \`${teamFile}\` for valid member names.`
+              });
+              return;
+            }
+
+            // Post assignment acknowledgment
+            const departmentLine = assignedDepartment
+              ? `**Department:** ${assignedDepartment.name}${assignedDepartment.lead ? ` (lead: ${formatMemberName(assignedDepartment.lead)})` : ''}`
+              : '';
+            let comment;
+            if (isCopilotAssignment) {
+              comment = [
+                `### 🤖 Routed to @copilot (Coding Agent)`,
+                '',
+                `**Issue:** #${issue.number} — ${issue.title}`,
+                departmentLine,
+                '',
+                `@copilot has been assigned and will pick this up automatically on the bridge.`,
+                '',
+                `> The coding agent will create a \`copilot/*\` branch and open a draft PR.`,
+                `> Review the PR as you would any Mercury Mesh specialist's work.`,
+              ].join('\n');
+            } else {
+              comment = [
+                `### 📋 Assigned to ${assignedMember.name} (${assignedMember.role})`,
+                '',
+                `**Issue:** #${issue.number} — ${issue.title}`,
+                departmentLine,
+                '',
+                `${assignedMember.name} will pick this up in the next Copilot session on the bridge.`,
+                '',
+                `> **For Copilot coding agent:** If enabled, this issue will be worked automatically.`,
+                `> Otherwise, start a Copilot session and say:`,
+                `> \`${assignedMember.name}, work on issue #${issue.number}\``,
+              ].join('\n');
+            }
+
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issue.number,
+              body: comment
+            });
+
+            core.info(`Issue #${issue.number} assigned to ${assignedMember.name} (${assignedMember.role})`);
+
+      # Separate step: assign @copilot using PAT (required for coding agent)
+      - name: Assign @copilot coding agent
+        if: github.event.label.name == 'mesh:copilot'
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.COPILOT_ASSIGN_TOKEN }}
+          script: |
+            const fs = require('fs');
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+            const issue_number = context.payload.issue.number;
+            const issue = context.payload.issue;
+            const runtimeCandidates = ['.mesh', '.mercury', '.ai-team'];
+            const stateCandidates = ['.mesh', '.mercury'];
+            const findFirst = (candidates) => candidates.find((candidate) => fs.existsSync(candidate)) || null;
+            const teamFile = findFirst(runtimeCandidates.map((candidate) => `${candidate}/team.md`));
+            const runtimeDir = teamFile ? teamFile.slice(0, teamFile.lastIndexOf('/')) : '.mesh';
+            const stateDir = runtimeDir !== '.ai-team'
+              ? runtimeDir
+              : (findFirst(stateCandidates.map((candidate) => `${candidate}/config.json`)) || '.mesh/config.json').replace(/\/config\.json$/, '');
+            const routingFile = findFirst([`${runtimeDir}/routing.md`, '.ai-team/routing.md']) || `${runtimeDir}/routing.md`;
+            const structurePath = `${stateDir}/org/structure.json`;
+            const labels = Array.isArray(issue.labels)
+              ? issue.labels.map(item => typeof item === 'string' ? item : item && item.name).filter(Boolean)
+              : [];
+            const deptLabel = labels.find(name => name.startsWith('dept:'));
+            let customInstructions = `Read ${teamFile || '.mesh/team.md'} for team context and ${routingFile} for routing rules.`;
+            if (deptLabel) {
+              const deptId = deptLabel.replace('dept:', '');
+              customInstructions += ` This issue is tagged to department "${deptId}".`;
+              if (fs.existsSync(structurePath)) {
+                customInstructions += ` Read ${structurePath} for hierarchy context before starting.`;
+              }
+            }
+
+            // Get the default branch name (main, master, etc.)
+            const { data: repoData } = await github.rest.repos.get({ owner, repo });
+            const baseBranch = repoData.default_branch;
+
+            try {
+              await github.request('POST /repos/{owner}/{repo}/issues/{issue_number}/assignees', {
+                owner,
+                repo,
+                issue_number,
+                assignees: ['copilot-swe-agent[bot]'],
+                agent_assignment: {
+                  target_repo: `${owner}/${repo}`,
+                  base_branch: baseBranch,
+                  custom_instructions: customInstructions,
+                  custom_agent: '',
+                  model: ''
+                },
+                headers: {
+                  'X-GitHub-Api-Version': '2022-11-28'
+                }
+              });
+              core.info(`Assigned copilot-swe-agent to issue #${issue_number} (base: ${baseBranch})`);
+            } catch (err) {
+              core.warning(`Assignment with agent_assignment failed: ${err.message}`);
+              // Fallback: try without agent_assignment
+              try {
+                await github.rest.issues.addAssignees({
+                  owner, repo, issue_number,
+                  assignees: ['copilot-swe-agent']
+                });
+                core.info(`Fallback assigned copilot-swe-agent to issue #${issue_number}`);
+              } catch (err2) {
+                core.warning(`Fallback also failed: ${err2.message}`);
+              }
+            }