Enable authenticated Room13 worker proof for sin-github-issues

.well-known/oauth-client.json

@@ -1,6 +1,6 @@
 {
   "client_id": "https://delqhi-sin-github-issues.hf.space/.well-known/oauth-client.json",
-  "client_name": "SIN-GitHub-Issues",
+  "client_name": "AZA-SIN-Coder-•-GitHub-Issues",
   "redirect_uris": ["https://delqhi-sin-github-issues.hf.space/oauth/callback"],
   "grant_types": ["authorization_code"],
   "response_types": ["code"],

A2A-CARD.md

@@ -1,4 +1,4 @@
-# A2A-SIN-GitHub-Issues (CEO Elite GitHub Operations)
+# AZA-SIN-Coder-•-GitHub-Issues (CEO Elite GitHub Operations)
 
 **Team:** Coding  
 **Version:** 2026.03.22  
@@ -6,8 +6,8 @@
 
 ## Identity & Mandate
 
-> **You are A2A-SIN-GitHub-Issues, a 2026 CEO-Level GitHub Operations Architect.**  
-> You do NOT just create bug tickets. You orchestrate the **entire repository lifecycle** using the full suite of GitHub's free Enterprise features:
+> **You are AZA-SIN-Coder-•-GitHub-Issues, a 2026 CEO-Level GitHub issue triage and delegation architect.**  
+> You do NOT just create bug tickets. You triage new issues, comment on them, route them into queues, and orchestrate the **entire repository lifecycle** using the full suite of GitHub's free Enterprise features:
 > 
 > 1. **Projects (V2)**: You autonomously generate Kanban boards, Epics, Sprints, and assign tasks via the GitHub CLI (`gh project create/link/item-add`).
 > 2. **Wikis**: You generate, maintain, and sync corporate knowledge base Markdown files to the repo's wiki (`sync-github-wiki.sh`).
@@ -23,14 +23,34 @@
 ## RPC Actions
 
 - `sin.github.health`: GitHub Operations Architect readiness check.
+- `sin.github.worker.register`: Register the GitHub-Issues runtime as a Room-13 worker and claim its initial lease.
+- `sin.github.worker.status`: Inspect Room-13 worker registration and claim state.
+- `sin.github.worker.claim_next`: Claim the next dispatchable Room-13 task.
+- `sin.github.worker.checkpoint`: Send checkpoint progress for the current Room-13 task.
+- `sin.github.worker.complete`: Mark the currently claimed Room-13 task as completed.
 - `sin.github.project.orchestrate`: Create and manage GitHub Projects V2 boards.
 - `sin.github.issue.manage`: Create, update, or close issues (Epics, Sub-tasks).
+- `sin.github.issue.ensure`: Create or update an issue by exact-title match.
+- `sin.github.issue.comment`: Add a GitHub issue comment.
+- `sin.github.issue.close`: Close a GitHub issue with optional comment.
+- `sin.github.issue.triage.enqueue`: Durably enqueue a GitHub issue triage event into the coder dispatch pool.
 - `sin.github.wiki.sync`: Update the repository Wiki with project documentation.
+
+## Ingress Contract
+
+- Canonical enqueue payload example: `Docs/operations/phase22-github-issue-triage-payload.example.json`
+- Replay-safe fixture examples:
+  - `Docs/operations/phase22-github-issue-opened.fixture.json`
+  - `Docs/operations/phase22-github-issue-opened.replay.fixture.json`
+- Primary transport for instant triage: GitHub webhook -> n8n -> `sin.github.issue.triage.enqueue`
+- Idempotency key policy: `delivery_id` first, then fallback `repo#issue_number:event_action`
+- Queue state progression: `received -> queued -> claimed -> dispatched -> accepted -> completed|failed|dead_letter`
+- Runtime queue constants live in `src/queue-state.ts` and are shared between ingress and Hermes dispatch logic.
+- Route contract: ingress computes `assignedTeam`, `assignedAgentHint`, and `capabilityHint` from labels/title/body before Hermes dispatch.
+- Local proof command: `npm run smoke:triage-fixtures`
 - `sin.github.discussion.start`: Start an architectural debate in Discussions.
 - `sin.github.gist.publish`: Upload a large log or code snippet to a Gist.
 - `sin.github.security.audit`: Audit security alerts and configure Dependabot.
 - `sin.github.pr.review`: Review and approve/merge Pull Requests.
 
 ## Data & Transport
-
-JSON-RPC over HTTP. Strict OpenCode execution via `openai/gpt-5.4` utilizing the `hf_pull_script.py` rotator pool.

AGENTS.md

@@ -1,8 +1,10 @@
-# SIN-GitHub-Issues
+# AZA-SIN-Coder-•-GitHub-Issues
 
 - Team: Team - Coding
 - Team Manager: SIN-Coding-CEO
 - Slug: sin-github-issues
+- Canonical display name: AZA-SIN-Coder-•-GitHub-Issues
+- Machine identity policy: keep slug/package/bin/public route as `sin-github-issues` until an explicit compatibility migration says otherwise
 - Repo: https://github.com/Delqhi/sin-github-issues
 - Docs Tab: pending dedicated child-tab
 

README.md

@@ -1,5 +1,5 @@
 ---
-title: SIN-GitHub-Issues
+title: AZA-SIN-Coder-•-GitHub-Issues
 emoji: "🤖"
 colorFrom: blue
 colorTo: indigo
@@ -8,22 +8,23 @@ app_port: 7860
 pinned: false
 ---
 
-# SIN-GitHub-Issues
+# AZA-SIN-Coder-•-GitHub-Issues
 
-`SIN-GitHub-Issues` is a SIN A2A agent package for the Silicon Workforce.
+`AZA-SIN-Coder-•-GitHub-Issues` is the GitHub issue triage and delegation agent package for the AZA coding workforce.
 
 ## Identity
 
-- Slug: `sin-github-issues`
+- Slug: `sin-github-issues` (canonical AZA display name: `AZA-SIN-Coder-•-GitHub-Issues`)
 - Team: `Team - Coding`
 - Team Manager: `SIN-Coding-CEO`
-- Purpose: GitHub issue execution agent for confirmed bugs, repo issue lifecycle, branch-based fixes, and verification handoff. Extended with enterprise profile management capabilities.
-- Usage: Use after enterprise-deep-debug confirms a bug to search/create/update GitHub issues, open a repo branch, execute the fix workflow, commit, push, and report verification status back to the orchestrating CLI agent. For profile and achievement operations use the new profile/achievement actions.
+- Purpose: GitHub issue triage, comment, queue, and execution delegation agent for confirmed bugs, repo issue lifecycle, branch-based fixes, and verification handoff. Extended with enterprise profile management capabilities.
+- Usage: Use for instant issue triage and coder delegation as well as confirmed bug workflows to search/create/update GitHub issues, open a repo branch, execute the fix workflow, commit, push, and report verification status back to the orchestrating CLI agent. For profile and achievement operations use the new profile/achievement actions.
+- Durable ingress payload example: `Docs/operations/phase22-github-issue-triage-payload.example.json`
 - Primary Model: `opencode/nemotron-3-super-free`
 
 ## Deployment
 
-- Local path: `/Users/jeremy/dev/SIN-Solver/a2a/team-coding/A2A-SIN-GitHub-Issues`
+- Local path: `/Users/jeremy/dev/SIN-Solver/a2a/team-coding/AZA-SIN-Coder-•-GitHub-Issues`
 - GitHub repo: `https://github.com/Delqhi/sin-github-issues`
 - Workforce index: `https://a2a.delqhi.com`
 - Landing page: `https://delqhi-sin-github-issues.hf.space`
@@ -76,6 +77,10 @@ sin-github-issues run-action '{"action":"sin.github.issues.issue.evidence.policy
 sin-github-issues run-action '{"action":"sin.github.issues.repo.branch.start","repoPath":"/abs/repo","branchName":"fix/example"}'
 sin-github-issues run-action '{"action":"sin.github.issues.runners.list","repo":"Delqhi/SIN-Solver"}'
 sin-github-issues run-action '{"action":"sin.github.issues.workflow.runs.list","repo":"Delqhi/SIN-Solver","branch":"sin-github-issues-bootstrap"}'
+sin-github-issues run-action '{"action":"sin.github.worker.register"}'
+sin-github-issues run-action '{"action":"sin.github.worker.status"}'
+sin-github-issues run-action '{"action":"sin.github.worker.claim_next"}'
+cd /Users/jeremy/dev/SIN-Solver/a2a/team-coding/A2A-SIN-GitHub-Issues && npm run smoke:triage-fixtures
 sin-github-issues run-action '{"action":"sin.github.issues.workflow.local_suite.run","repoPath":"/abs/repo","suite":"docs-and-architecture","confirm":true}'
 ```
 

agent.json

@@ -1,8 +1,8 @@
 {
   "id": "sin-github-issues",
-  "displayName": "A2A-SIN-GitHub-Issues (CEO Elite GitHub Operations)",
+  "displayName": "AZA-SIN-Coder-•-GitHub-Issues",
   "team": "team-coding",
-  "description": "Elite 2026 GitHub Operations Architect. Manages the entire project lifecycle via GitHub Projects, Issues, Wikis, Discussions, Security Alerts (Dependabot/CodeQL), PR Reviews, and Gists. Fully integrated with openai/gpt-5.4 and the A2A Token Pool.",
+  "description": "Elite 2026 GitHub issue triage and delegation architect. Manages the entire project lifecycle via GitHub Projects, Issues, comments, queueing, Discussions, Security Alerts (Dependabot/CodeQL), PR Reviews, and Gists. Fully integrated with openai/gpt-5.4 and the A2A Token Pool.",
   "version": "2026.03.22",
   "deployment": {
     "workforceIndex": "https://a2a.delqhi.com",

package-lock.json

@@ -96,9 +96,9 @@
       }
     },
     "node_modules/@supabase/auth-js": {
-      "version": "2.99.2",
-      "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.99.2.tgz",
-      "integrity": "sha512-uRGNXMKEw4VhwouNW7N0XDAGqJP9redHNDmWi17dTrcO1lvFfyRiXsqqfgnVC8aqtRn8kLkLPEzHjiRWsni+oQ==",
+      "version": "2.100.0",
+      "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.100.0.tgz",
+      "integrity": "sha512-pdT3ye3UVRN1Cg0wom6BmyY+XTtp5DiJaYnPi6j8ht5i8Lq8kfqxJMJz9GI9YDKk3w1nhGOPnh6Qz5qpyYm+1w==",
       "license": "MIT",
       "dependencies": {
         "tslib": "2.8.1"
@@ -108,9 +108,9 @@
       }
     },
     "node_modules/@supabase/functions-js": {
-      "version": "2.99.2",
-      "resolved": "https://registry.npmjs.org/@supabase/functions-js/-/functions-js-2.99.2.tgz",
-      "integrity": "sha512-xuXQARvjdfB1UPK1yUceZ5EGjOLkVz4rBAaloS9foXiAuseWEdgWBCxkIAFRxGBLGX8Uzo8kseq90jhPb+07Vg==",
+      "version": "2.100.0",
+      "resolved": "https://registry.npmjs.org/@supabase/functions-js/-/functions-js-2.100.0.tgz",
+      "integrity": "sha512-keLg79RPwP+uiwHuxFPTFgDRxPV46LM4j/swjyR2GKJgWniTVSsgiBHfbIBDcrQwehLepy09b/9QSHUywtKRWQ==",
       "license": "MIT",
       "dependencies": {
         "tslib": "2.8.1"
@@ -119,10 +119,16 @@
         "node": ">=20.0.0"
       }
     },
+    "node_modules/@supabase/phoenix": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/@supabase/phoenix/-/phoenix-0.4.0.tgz",
+      "integrity": "sha512-RHSx8bHS02xwfHdAbX5Lpbo6PXbgyf7lTaXTlwtFDPwOIw64NnVRwFAXGojHhjtVYI+PEPNSWwkL90f4agN3bw==",
+      "license": "MIT"
+    },
     "node_modules/@supabase/postgrest-js": {
-      "version": "2.99.2",
-      "resolved": "https://registry.npmjs.org/@supabase/postgrest-js/-/postgrest-js-2.99.2.tgz",
-      "integrity": "sha512-ueiOVkbkTQ7RskwVmjR8zxWYw3VKOMxo1+qep+Dx/SgApqyhWBGd92waQb45tbLc7ydB5x8El8utXOLQTuTojQ==",
+      "version": "2.100.0",
+      "resolved": "https://registry.npmjs.org/@supabase/postgrest-js/-/postgrest-js-2.100.0.tgz",
+      "integrity": "sha512-xYNvNbBJaXOGcrZ44wxwp5830uo1okMHGS8h8dm3u4f0xcZ39yzbryUsubTJW41MG2gbL/6U57cA4Pi6YMZ9pA==",
       "license": "MIT",
       "dependencies": {
         "tslib": "2.8.1"
@@ -132,12 +138,12 @@
       }
     },
     "node_modules/@supabase/realtime-js": {
-      "version": "2.99.2",
-      "resolved": "https://registry.npmjs.org/@supabase/realtime-js/-/realtime-js-2.99.2.tgz",
-      "integrity": "sha512-J6Jm9601dkpZf3+EJ48ki2pM4sFtCNm/BI0l8iEnrczgg+JSEQkMoOW5VSpM54t0pNs69bsz5PTmYJahDZKiIQ==",
+      "version": "2.100.0",
+      "resolved": "https://registry.npmjs.org/@supabase/realtime-js/-/realtime-js-2.100.0.tgz",
+      "integrity": "sha512-2AZs00zzEF0HuCKY8grz5eCYlwEfVi5HONLZFoNR6aDfxQivl8zdQYNjyFoqN2MZiVhQHD7u6XV/xHwM8mCEHw==",
       "license": "MIT",
       "dependencies": {
-        "@types/phoenix": "^1.6.6",
+        "@supabase/phoenix": "^0.4.0",
         "@types/ws": "^8.18.1",
         "tslib": "2.8.1",
         "ws": "^8.18.2"
@@ -147,9 +153,9 @@
       }
     },
     "node_modules/@supabase/storage-js": {
-      "version": "2.99.2",
-      "resolved": "https://registry.npmjs.org/@supabase/storage-js/-/storage-js-2.99.2.tgz",
-      "integrity": "sha512-V/FF8kX8JGSefsVCG1spCLSrHdNR/JFeUMn1jS9KG/Eizjx+evtdKQKLJXFgIylY/bKTXKhc2SYDPIGrIhzsug==",
+      "version": "2.100.0",
+      "resolved": "https://registry.npmjs.org/@supabase/storage-js/-/storage-js-2.100.0.tgz",
+      "integrity": "sha512-d4EeuK6RNIgYNA2MU9kj8lQrLm5AzZ+WwpWjGkii6SADQNIGTC/uiaTRu02XJ5AmFALQfo8fLl9xuCkO6Xw+iQ==",
       "license": "MIT",
       "dependencies": {
         "iceberg-js": "^0.8.1",
@@ -160,16 +166,16 @@
       }
     },
     "node_modules/@supabase/supabase-js": {
-      "version": "2.99.2",
-      "resolved": "https://registry.npmjs.org/@supabase/supabase-js/-/supabase-js-2.99.2.tgz",
-      "integrity": "sha512-179rn5wq0wBAqqGwAwR7TUGg2NOaP+fkd5FCVbYJXby85fsRNPFoNJN8YRBepqX2tN7JJcnTjqaAMXuNjiyisA==",
+      "version": "2.100.0",
+      "resolved": "https://registry.npmjs.org/@supabase/supabase-js/-/supabase-js-2.100.0.tgz",
+      "integrity": "sha512-r0tlcukejJXJ1m/2eG/Ya5eYs4W8AC7oZfShpG3+SIo/eIU9uIt76ZeYI1SoUwUmcmzlAbgch+HDZDR/toVQPQ==",
       "license": "MIT",
       "dependencies": {
-        "@supabase/auth-js": "2.99.2",
-        "@supabase/functions-js": "2.99.2",
-        "@supabase/postgrest-js": "2.99.2",
-        "@supabase/realtime-js": "2.99.2",
-        "@supabase/storage-js": "2.99.2"
+        "@supabase/auth-js": "2.100.0",
+        "@supabase/functions-js": "2.100.0",
+        "@supabase/postgrest-js": "2.100.0",
+        "@supabase/realtime-js": "2.100.0",
+        "@supabase/storage-js": "2.100.0"
       },
       "engines": {
         "node": ">=20.0.0"
@@ -191,12 +197,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/@types/phoenix": {
-      "version": "1.6.7",
-      "resolved": "https://registry.npmjs.org/@types/phoenix/-/phoenix-1.6.7.tgz",
-      "integrity": "sha512-oN9ive//QSBkf19rfDv45M7eZPi0eEXylht2OLEXicu5b4KoQ1OzXIw+xDSGWxSxe1JmepRR/ZH283vsu518/Q==",
-      "license": "MIT"
-    },
     "node_modules/@types/tar": {
       "version": "6.1.13",
       "resolved": "https://registry.npmjs.org/@types/tar/-/tar-6.1.13.tgz",
@@ -755,9 +755,9 @@
       }
     },
     "node_modules/hono": {
-      "version": "4.12.8",
-      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.8.tgz",
-      "integrity": "sha512-VJCEvtrezO1IAR+kqEYnxUOoStaQPGrCmX3j4wDTNOcD1uRPFpGlwQUIW8niPuvHXaTUxeOUl5MMDGrl+tmO9A==",
+      "version": "4.12.9",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.9.tgz",
+      "integrity": "sha512-wy3T8Zm2bsEvxKZM5w21VdHDDcwVS1yUFFY6i8UobSsKfFceT7TOwhbhfKsDyx7tYQlmRM5FLpIuYvNFyjctiA==",
       "license": "MIT",
       "engines": {
         "node": ">=16.9.0"
@@ -1434,9 +1434,9 @@
       "license": "ISC"
     },
     "node_modules/ws": {
-      "version": "8.19.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
-      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",
+      "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"

package.json

@@ -10,6 +10,8 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json && node scripts/postbuild.mjs",
+    "smoke:triage-fixtures": "npm run build && node scripts/smoke-triage-fixtures.mjs",
+    "smoke:room13-worker": "npm run build && node scripts/smoke-room13-worker.mjs",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "start:a2a": "node dist/src/cli.js serve-a2a",
     "start:mcp": "node dist/src/cli.js serve-mcp"

scripts/hf_pull_script.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
 """
-A2A Consumer Rotator (HF VM Pull Script)
 Pulls a fresh OpenAI token from SIN-Supabase when a rate-limit is hit.
 Infinite Scaling Architecture.
 """

scripts/smoke-room13-worker.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import { GitHubIssuesRoom13WorkerRuntime, installGitHubIssuesWorkerRuntime } from '../dist/src/room13-worker.js';
+
+class FakeWorkerRuntime extends GitHubIssuesRoom13WorkerRuntime {
+  constructor() {
+    super('sin-github-issues', 'http://room13.test');
+  }
+
+  async start() {
+    this.workerId = 'worker-gh';
+    this.leaseEpoch = 1;
+    this.claimedTaskId = '';
+    this.leaseExpiresAt = '2026-03-23T22:30:00Z';
+    return this.snapshot();
+  }
+
+  async claimNextTask() {
+    this.claimedTaskId = 'task-gh-1';
+    return { id: 'task-gh-1', status: 'running' };
+  }
+
+  async checkpoint(step, checkpoint = {}) {
+    return { ok: true, step, checkpoint };
+  }
+
+  async completeTask(result = {}) {
+    this.claimedTaskId = '';
+    return { ok: true, result };
+  }
+}
+
+const runtime = new FakeWorkerRuntime();
+installGitHubIssuesWorkerRuntime(runtime);
+const registered = await runtime.start();
+const claimed = await runtime.claimNextTask();
+const checkpoint = await runtime.checkpoint('github.issue.sync', { attempt: 1 });
+const completed = await runtime.completeTask({ success: true });
+
+if (registered.workerId !== 'worker-gh') throw new Error('worker register smoke failed');
+if (claimed.id !== 'task-gh-1') throw new Error('task claim smoke failed');
+if (checkpoint.step !== 'github.issue.sync') throw new Error('checkpoint smoke failed');
+if (!completed.ok) throw new Error('complete smoke failed');
+
+process.stdout.write(JSON.stringify({ ok: true, registered, claimed, checkpoint, completed }, null, 2) + '\n');

scripts/smoke-triage-fixtures.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+
+const packageRoot = path.resolve(process.cwd());
+const repoRoot = path.resolve(packageRoot, '..', '..', '..');
+
+const fixtureOnePath = path.join(repoRoot, 'Docs', 'operations', 'phase22-github-issue-opened.fixture.json');
+const fixtureTwoPath = path.join(repoRoot, 'Docs', 'operations', 'phase22-github-issue-opened.replay.fixture.json');
+
+const triageModule = await import(path.join(packageRoot, 'dist', 'src', 'triage.js'));
+const queueModule = await import(path.join(packageRoot, 'dist', 'src', 'queue-state.js'));
+
+const {
+  TriageEnqueueSchema,
+  buildDeliveryKey,
+  buildIssueKey,
+  routeIssueTriage,
+} = triageModule;
+
+const { ISSUE_QUEUE_STATE } = queueModule;
+
+const rowByDelivery = new Map();
+const rowByIssueKey = new Map();
+
+function enqueue(payload) {
+  const input = TriageEnqueueSchema.parse(payload);
+  const deliveryId = buildDeliveryKey(input);
+  const issueKey = buildIssueKey(input.repo, input.issueNumber);
+  const route = routeIssueTriage(input.labels || [], input.title, input.body || '');
+
+  if (rowByDelivery.has(deliveryId)) {
+    return {
+      created: false,
+      deduplicatedBy: 'delivery_id',
+      queueState: rowByDelivery.get(deliveryId).queueState,
+      deliveryId,
+      issueKey,
+      route,
+    };
+  }
+
+  if (rowByIssueKey.has(issueKey)) {
+    const existing = rowByIssueKey.get(issueKey);
+    existing.deliveryIds.push(deliveryId);
+    rowByDelivery.set(deliveryId, existing);
+    return {
+      created: false,
+      deduplicatedBy: 'issue_key',
+      queueState: existing.queueState,
+      deliveryId,
+      issueKey,
+      route,
+    };
+  }
+
+  const row = {
+    issueKey,
+    deliveryIds: [deliveryId],
+    queueState: ISSUE_QUEUE_STATE.queued,
+    assignedTeam: input.assignedTeam || route.assignedTeam,
+    route,
+  };
+  rowByDelivery.set(deliveryId, row);
+  rowByIssueKey.set(issueKey, row);
+  return {
+    created: true,
+    deduplicatedBy: null,
+    queueState: row.queueState,
+    deliveryId,
+    issueKey,
+    route,
+  };
+}
+
+const first = enqueue(JSON.parse(await readFile(fixtureOnePath, 'utf8')));
+const replay = enqueue(JSON.parse(await readFile(fixtureTwoPath, 'utf8')));
+
+if (!first.created) throw new Error('expected first fixture to create queue row');
+if (replay.created || replay.deduplicatedBy !== 'delivery_id') throw new Error('expected replay fixture to deduplicate by delivery_id');
+if (rowByIssueKey.size !== 1) throw new Error(`expected exactly one queue row, got ${rowByIssueKey.size}`);
+
+process.stdout.write(JSON.stringify({ ok: true, createdRows: rowByIssueKey.size, first, replay, finalRow: [...rowByIssueKey.values()][0] }, null, 2) + '\n');

src/a2a-http.ts

@@ -31,6 +31,11 @@ async function handleRequest(request: IncomingMessage, response: ServerResponse,
   }
   if (request.method === 'POST' && request.url === '/a2a/v1') {
     const rpc = ((await readJson(request)) || {}) as RpcRequest;
+    if (rpc && typeof rpc === 'object' && 'action' in rpc && typeof (rpc as { action?: unknown }).action === 'string') {
+      const action = rpc as unknown as GitHubAgentAction;
+      const result = await executeGitHubAgentAction(action);
+      return sendJson(response, 200, { ok: true, agent: TEMPLATE_AGENT_ID, action: action.action, result });
+    }
     if (rpc.method === 'agent/getCard') return sendJson(response, 200, { jsonrpc: '2.0', id: rpc.id ?? null, result: buildAgentCard(baseUrl) });
     if (rpc.method === 'message/send') {
       const action = parseAction((rpc.params?.message as { parts?: Array<{ text?: string }> } | undefined)?.parts?.map((part) => part.text || '').join(' ').trim() || '');

src/cli.ts

@@ -5,11 +5,22 @@ import { resolve } from 'node:path';
 import { createTemplateAgentHttpServer } from './a2a-http.js';
 import { runMcpServer } from './mcp-server.js';
 import { executeGitHubAgentAction } from './runtime.js';
+import { GitHubIssuesRoom13WorkerRuntime, installGitHubIssuesWorkerRuntime } from './room13-worker.js';
 
 const cmd = process.argv[2];
 
 if (cmd === 'serve-a2a') {
-  createTemplateAgentHttpServer().start().catch(err => {
+  createTemplateAgentHttpServer().start().then(async () => {
+    const room13Worker = new GitHubIssuesRoom13WorkerRuntime('sin-github-issues');
+    installGitHubIssuesWorkerRuntime(room13Worker);
+    await room13Worker.start().catch(() => undefined);
+    const stop = async () => {
+      await room13Worker.stop().catch(() => undefined);
+      process.exit(0);
+    };
+    process.once('SIGINT', () => void stop());
+    process.once('SIGTERM', () => void stop());
+  }).catch(err => {
     console.error(err);
     process.exit(1);
   });

src/idle-monetization.ts

@@ -6,11 +6,12 @@
 
 export function startAutonomousIdleLoop() {
   console.log('💸 Autonomous Monetization & Hacking loop enabled (Mega Krass Mode).');
+  const runtimeState = globalThis as typeof globalThis & { isAgentBusy?: boolean };
 
   // The loop checks every 5 minutes if the agent is idle.
   setInterval(async () => {
     // Skip if currently busy with a user or fleet task
-    if ((globalThis as any).isAgentBusy) {
+    if (runtimeState.isAgentBusy) {
       return;
     }
 

src/mcp-server.ts

@@ -16,6 +16,43 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         description: 'Check 2026 Elite GitHub Operations Architect readiness.',
         inputSchema: { type: 'object', properties: {} },
       },
+      {
+        name: 'sin_github_worker_register',
+        description: 'Register the GitHub-Issues runtime as a Room-13 worker and claim its initial lease.',
+        inputSchema: { type: 'object', properties: {} },
+      },
+      {
+        name: 'sin_github_worker_status',
+        description: 'Inspect Room-13 worker registration and claim state for GitHub-Issues.',
+        inputSchema: { type: 'object', properties: {} },
+      },
+      {
+        name: 'sin_github_worker_claim_next',
+        description: 'Claim the next Room-13 task for GitHub-Issues.',
+        inputSchema: { type: 'object', properties: {} },
+      },
+      {
+        name: 'sin_github_worker_checkpoint',
+        description: 'Send a checkpoint to Room-13 for GitHub-Issues.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            step: { type: 'string' },
+            checkpoint: { type: 'object' }
+          },
+          required: ['step']
+        }
+      },
+      {
+        name: 'sin_github_worker_complete',
+        description: 'Complete the currently claimed Room-13 task for GitHub-Issues.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            result: { type: 'object' }
+          }
+        }
+      },
       {
         name: 'sin_github_project_orchestrate',
         description: 'Create and manage GitHub Projects V2 boards.',
@@ -40,6 +77,64 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ['prompt'],
         },
       },
+      {
+        name: 'sin_github_issue_ensure',
+        description: 'Create or update an issue by exact title match.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            repo: { type: 'string' },
+            title: { type: 'string' },
+            body: { type: 'string' },
+            labels: { type: 'array', items: { type: 'string' } }
+          },
+          required: ['repo', 'title', 'body']
+        }
+      },
+      {
+        name: 'sin_github_issue_comment',
+        description: 'Comment on a GitHub issue.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            repo: { type: 'string' },
+            issueNumber: { type: 'number' },
+            body: { type: 'string' }
+          },
+          required: ['repo', 'issueNumber', 'body']
+        }
+      },
+      {
+        name: 'sin_github_issue_close',
+        description: 'Close a GitHub issue with optional comment.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            repo: { type: 'string' },
+            issueNumber: { type: 'number' },
+            comment: { type: 'string' }
+          },
+          required: ['repo', 'issueNumber']
+        }
+      },
+      {
+        name: 'sin_github_issue_triage_enqueue',
+        description: 'Durably enqueue a GitHub issue triage event into the coder dispatch pool.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            repo: { type: 'string' },
+            issueNumber: { type: 'number' },
+            title: { type: 'string' },
+            body: { type: 'string' },
+            labels: { type: 'array', items: { type: 'string' } },
+            assignedTeam: { type: 'string' },
+            deliveryId: { type: 'string' },
+            eventAction: { type: 'string' }
+          },
+          required: ['repo', 'issueNumber', 'title']
+        }
+      },
       {
         name: 'sin_github_wiki_sync',
         description: 'Update the repository Wiki with project documentation.',
@@ -122,16 +217,53 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     let action: GitHubAgentAction;
     const args = request.params.arguments as any;
 
-    switch (request.params.name) {
-      case 'sin_github_health':
-        action = { action: 'sin.github.health' };
-        break;
-      case 'sin_github_project_orchestrate':
-        action = { action: 'sin.github.project.orchestrate', prompt: args.prompt, contextDir: args.contextDir };
-        break;
+      switch (request.params.name) {
+        case 'sin_github_health':
+          action = { action: 'sin.github.health' };
+          break;
+        case 'sin_github_worker_register':
+          action = { action: 'sin.github.worker.register' };
+          break;
+        case 'sin_github_worker_status':
+          action = { action: 'sin.github.worker.status' };
+          break;
+        case 'sin_github_worker_claim_next':
+          action = { action: 'sin.github.worker.claim_next' };
+          break;
+        case 'sin_github_worker_checkpoint':
+          action = { action: 'sin.github.worker.checkpoint', step: args.step, checkpoint: args.checkpoint };
+          break;
+        case 'sin_github_worker_complete':
+          action = { action: 'sin.github.worker.complete', result: args.result };
+          break;
+        case 'sin_github_project_orchestrate':
+          action = { action: 'sin.github.project.orchestrate', prompt: args.prompt, contextDir: args.contextDir };
+          break;
       case 'sin_github_issue_manage':
         action = { action: 'sin.github.issue.manage', prompt: args.prompt, issueNumber: args.issueNumber };
         break;
+      case 'sin_github_issue_ensure':
+        action = { action: 'sin.github.issue.ensure', repo: args.repo, title: args.title, body: args.body, labels: args.labels };
+        break;
+      case 'sin_github_issue_comment':
+        action = { action: 'sin.github.issue.comment', repo: args.repo, issueNumber: args.issueNumber, body: args.body };
+        break;
+      case 'sin_github_issue_close':
+        action = { action: 'sin.github.issue.close', repo: args.repo, issueNumber: args.issueNumber, comment: args.comment };
+        break;
+      case 'sin_github_issue_triage_enqueue':
+        action = {
+          action: 'sin.github.issue.triage.enqueue',
+          repo: args.repo,
+          issueNumber: args.issueNumber,
+          title: args.title,
+          body: args.body,
+          labels: args.labels,
+          assignedTeam: args.assignedTeam,
+          deliveryId: args.deliveryId,
+          eventAction: args.eventAction
+        };
+        break;
       case 'sin_github_wiki_sync':
         action = { action: 'sin.github.wiki.sync', prompt: args.prompt, contextDir: args.contextDir };
         break;
@@ -169,5 +301,5 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 export async function runMcpServer() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error('A2A-SIN-GitHub-Issues MCP Server running on stdio');
+  console.error('AZA-SIN-Coder-•-GitHub-Issues MCP Server running on stdio');
 }

src/metadata.ts

@@ -1,8 +1,8 @@
 import process from 'node:process';
 
 export const TEMPLATE_AGENT_ID = 'sin-github-issues';
-export const TEMPLATE_AGENT_NAME = 'SIN-GitHub-Issues';
-export const TEMPLATE_AGENT_DESCRIPTION = 'CEO Elite GitHub Operations Architect — orchestrates Projects V2, Issues, Wikis, Discussions, Gists, Security audits, PR Reviews, and public Showcase Ledger logging.';
+export const TEMPLATE_AGENT_NAME = 'AZA-SIN-Coder-•-GitHub-Issues';
+export const TEMPLATE_AGENT_DESCRIPTION = 'CEO Elite GitHub issue triage and delegation architect for the AZA coding fleet — orchestrates issue lifecycle, comments, queueing, Projects V2, Discussions, Gists, Security audits, PR reviews, and public Showcase Ledger logging.';
 export const TEMPLATE_AGENT_VERSION = '2026.03.22';
 export const TEMPLATE_AGENT_DEFAULT_HOST = '127.0.0.1';
 export const TEMPLATE_AGENT_DEFAULT_PORT = 46031;
@@ -13,6 +13,31 @@ export const TEMPLATE_AGENT_SKILLS = [
     name: 'Health',
     description: 'Check 2026 Elite GitHub Operations Architect readiness, model, and capabilities.',
   },
+  {
+    id: 'sin.github.worker.register',
+    name: 'Worker Register',
+    description: 'Register the GitHub-Issues runtime as a Room-13 worker and claim its initial lease.',
+  },
+  {
+    id: 'sin.github.worker.status',
+    name: 'Worker Status',
+    description: 'Inspect GitHub-Issues worker registration and claim state against Room-13.',
+  },
+  {
+    id: 'sin.github.worker.claim_next',
+    name: 'Worker Claim Next',
+    description: 'Claim the next dispatchable Room-13 task for GitHub-Issues.',
+  },
+  {
+    id: 'sin.github.worker.checkpoint',
+    name: 'Worker Checkpoint',
+    description: 'Send checkpoint progress for the current Room-13 task.',
+  },
+  {
+    id: 'sin.github.worker.complete',
+    name: 'Worker Complete',
+    description: 'Mark the currently claimed Room-13 task as completed.',
+  },
   {
     id: 'sin.github.project.orchestrate',
     name: 'Project Orchestrate',

src/queue-state.js

@@ -0,0 +1,29 @@
+export const ISSUE_QUEUE_STATE = {
+  received: 'received',
+  queued: 'queued',
+  claimed: 'claimed',
+  dispatched: 'dispatched',
+  accepted: 'accepted',
+  completed: 'completed',
+  failed: 'failed',
+  dead_letter: 'dead_letter',
+};
+
+export function isActiveQueueState(value) {
+  return ['received', 'queued', 'claimed', 'dispatched', 'accepted'].includes(String(value || ''));
+}
+
+export function queueStateForStatus(value) {
+  switch (String(value || '').toLowerCase()) {
+    case 'pending':
+      return ISSUE_QUEUE_STATE.queued;
+    case 'in_progress':
+      return ISSUE_QUEUE_STATE.claimed;
+    case 'completed':
+      return ISSUE_QUEUE_STATE.completed;
+    case 'failed':
+      return ISSUE_QUEUE_STATE.failed;
+    default:
+      return ISSUE_QUEUE_STATE.received;
+  }
+}

src/queue-state.ts

@@ -0,0 +1,31 @@
+export const ISSUE_QUEUE_STATE = {
+  received: 'received',
+  queued: 'queued',
+  claimed: 'claimed',
+  dispatched: 'dispatched',
+  accepted: 'accepted',
+  completed: 'completed',
+  failed: 'failed',
+  dead_letter: 'dead_letter',
+} as const;
+
+export type IssueQueueState = keyof typeof ISSUE_QUEUE_STATE;
+
+export function isActiveQueueState(value: string | null | undefined): boolean {
+  return ['received', 'queued', 'claimed', 'dispatched', 'accepted'].includes(String(value || ''));
+}
+
+export function queueStateForStatus(status: string | null | undefined): IssueQueueState {
+  switch (String(status || '').toLowerCase()) {
+    case 'pending':
+      return 'queued';
+    case 'in_progress':
+      return 'claimed';
+    case 'completed':
+      return 'completed';
+    case 'failed':
+      return 'failed';
+    default:
+      return 'received';
+  }
+}

src/room13-worker.ts

@@ -0,0 +1,187 @@
+import os from 'node:os';
+import process from 'node:process';
+
+type Room13WorkerRegisterResponse = {
+  id?: string;
+  lease_epoch?: number;
+};
+
+type Room13WorkerClaimResponse = {
+  claimed_task_id?: string | null;
+  lease_epoch?: number;
+  lease_expires_at?: string | null;
+  run_id?: string;
+};
+
+type Room13Task = {
+  id: string;
+  status: string;
+  assigned_worker?: string | null;
+  run_id?: string | null;
+};
+
+export type GitHubIssuesWorkerSnapshot = {
+  enabled: boolean;
+  workerName: string;
+  workerId: string;
+  runId: string;
+  claimedTaskId: string;
+  leaseEpoch: number;
+  leaseExpiresAt?: string;
+  baseUrl: string;
+};
+
+let currentRuntime: GitHubIssuesRoom13WorkerRuntime | null = null;
+
+export function getCurrentGitHubIssuesWorkerRuntime() {
+  return currentRuntime;
+}
+
+export class GitHubIssuesRoom13WorkerRuntime {
+  protected workerId = '';
+  protected leaseEpoch = 0;
+  protected claimedTaskId = '';
+  protected leaseExpiresAt?: string;
+  protected readonly workerName: string;
+  protected readonly baseUrl: string;
+  protected readonly bearerToken: string;
+  protected readonly runId: string;
+  protected heartbeatTimer?: NodeJS.Timeout;
+
+  constructor(workerName = 'sin-github-issues', baseUrl = process.env.ROOM13_COORDINATOR_URL || '') {
+    this.workerName = workerName;
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.bearerToken = String(process.env.ROOM13_BEARER_TOKEN || '').trim();
+    this.runId = `${workerName}:${process.pid}:${Date.now()}`;
+  }
+
+  get enabled() {
+    return Boolean(this.baseUrl);
+  }
+
+  snapshot(): GitHubIssuesWorkerSnapshot {
+    return {
+      enabled: this.enabled,
+      workerName: this.workerName,
+      workerId: this.workerId,
+      runId: this.runId,
+      claimedTaskId: this.claimedTaskId,
+      leaseEpoch: this.leaseEpoch,
+      leaseExpiresAt: this.leaseExpiresAt,
+      baseUrl: this.baseUrl,
+    };
+  }
+
+  async start() {
+    if (!this.enabled) return this.snapshot();
+    const registered = await this.request<Room13WorkerRegisterResponse>('POST', '/api/workers', {
+      name: `${this.workerName}:${process.env.SPACE_HOST || 'local'}`,
+      type: 'general',
+      capabilities: ['platform:github', 'worker_runtime', 'lease_heartbeat', 'issue_lifecycle'],
+      metadata: { runtime: 'node', hostname: os.hostname() },
+      worker_identity: this.workerName,
+      persona_id: this.workerName,
+      platform: 'github-issues',
+      current_run_id: this.runId,
+      lease_ttl_sec: 120,
+      approval_state: 'idle',
+    });
+    this.workerId = String(registered?.id || '').trim();
+    this.leaseEpoch = Number(registered?.lease_epoch || 0);
+    if (this.workerId) {
+      const claim = await this.request<Room13WorkerClaimResponse>('POST', `/api/workers/${this.workerId}/claim`, {
+        run_id: this.runId,
+        ttl_sec: 120,
+      });
+      this.claimedTaskId = String(claim?.claimed_task_id || '').trim();
+      this.leaseEpoch = Number(claim?.lease_epoch || this.leaseEpoch || 0);
+      this.leaseExpiresAt = claim?.lease_expires_at || undefined;
+      this.startHeartbeatLoop();
+    }
+    return this.snapshot();
+  }
+
+  async stop() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    if (!this.enabled || !this.workerId) return;
+    await this.request('POST', `/api/workers/${this.workerId}/release`, {
+      lease_epoch: this.leaseEpoch,
+      clear_run: true,
+      final_status: 'online',
+      status_reason: 'github_issues_runtime_stop',
+      approval_state: 'idle',
+    }).catch(() => undefined);
+  }
+
+  async heartbeat() {
+    if (!this.enabled || !this.workerId) return this.snapshot();
+    const result = await this.request<Room13WorkerClaimResponse>('POST', `/api/workers/${this.workerId}/heartbeat`, {
+      lease_epoch: this.leaseEpoch,
+      ttl_sec: 120,
+      metadata: {
+        run_id: this.runId,
+        claimed_task_id: this.claimedTaskId,
+        last_heartbeat_source: 'sin-github-issues',
+      },
+    });
+    this.leaseEpoch = Number(result?.lease_epoch || this.leaseEpoch || 0);
+    this.leaseExpiresAt = result?.lease_expires_at || this.leaseExpiresAt;
+    return this.snapshot();
+  }
+
+  async claimNextTask() {
+    if (!this.enabled || !this.workerId) throw new Error('room13_worker_not_registered');
+    const task = await this.request<Room13Task>('POST', '/api/tasks/claim-next', {
+      worker_id: this.workerId,
+      accepted_types: ['github_issue_dispatch'],
+      min_priority: 'normal',
+      run_id: this.runId,
+      lease_epoch: this.leaseEpoch,
+    });
+    this.claimedTaskId = String(task?.id || '').trim();
+    return task;
+  }
+
+  async checkpoint(step: string, checkpoint: Record<string, unknown> = {}) {
+    if (!this.enabled || !this.workerId) throw new Error('room13_worker_not_registered');
+    return await this.request('POST', `/api/workers/${this.workerId}/checkpoint`, {
+      lease_epoch: this.leaseEpoch,
+      run_id: this.runId,
+      step,
+      checkpoint,
+    });
+  }
+
+  async completeTask(result: Record<string, unknown> = {}) {
+    if (!this.enabled || !this.claimedTaskId) throw new Error('room13_task_not_claimed');
+    const response = await this.request('PUT', `/api/tasks/${this.claimedTaskId}/complete`, result);
+    this.claimedTaskId = '';
+    return response;
+  }
+
+  private startHeartbeatLoop() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = setInterval(() => {
+      void this.heartbeat().catch(() => undefined);
+    }, 30000);
+    this.heartbeatTimer.unref();
+  }
+
+  private async request<T = unknown>(method: string, path: string, body?: unknown) {
+    const headers: Record<string, string> = { 'content-type': 'application/json' };
+    if (this.bearerToken) headers.Authorization = `Bearer ${this.bearerToken}`;
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+    const text = await response.text();
+    const parsed = text ? JSON.parse(text) : {};
+    if (!response.ok) throw new Error(`room13_http_${response.status}:${JSON.stringify(parsed).slice(0, 1000)}`);
+    return parsed as T;
+  }
+}
+
+export function installGitHubIssuesWorkerRuntime(runtime: GitHubIssuesRoom13WorkerRuntime | null) {
+  currentRuntime = runtime;
+}

src/runtime.ts

@@ -1,11 +1,42 @@
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
+import { commentIssue, closeIssue, ensureIssue } from './github.js';
+import { createClient } from '@supabase/supabase-js';
+import { getCurrentGitHubIssuesWorkerRuntime } from './room13-worker.js';
+import {
+  buildDeliveryKey,
+  buildIssueKey,
+  routeIssueTriage,
+  routeLabelsToTeam,
+  TriageEnqueueSchema,
+  type TriageEnqueueInput,
+} from './triage.js';
+import { ISSUE_QUEUE_STATE } from './queue-state.js';
 
 const execAsync = promisify(exec);
 
 export type GitHubAgentAction =
   | { action: 'agent.help' }
   | { action: 'sin.github.health' }
+  | { action: 'sin.github.worker.register' }
+  | { action: 'sin.github.worker.status' }
+  | { action: 'sin.github.worker.claim_next' }
+  | { action: 'sin.github.worker.checkpoint'; step: string; checkpoint?: Record<string, unknown> }
+  | { action: 'sin.github.worker.complete'; result?: Record<string, unknown> }
+  | { action: 'sin.github.issue.ensure'; repo: string; title: string; body: string; labels?: string[] }
+  | { action: 'sin.github.issue.comment'; repo: string; issueNumber: number; body: string }
+  | { action: 'sin.github.issue.close'; repo: string; issueNumber: number; comment?: string }
+  | {
+      action: 'sin.github.issue.triage.enqueue';
+      repo: string;
+      issueNumber: number;
+      title: string;
+      body?: string;
+      labels?: string[];
+      assignedTeam?: string;
+      deliveryId?: string;
+      eventAction?: string;
+    }
   | { action: 'sin.github.project.orchestrate'; prompt: string; contextDir?: string }
   | { action: 'sin.github.issue.manage'; prompt: string; issueNumber?: number }
   | { action: 'sin.github.wiki.sync'; prompt: string; contextDir?: string }
@@ -13,8 +44,7 @@ export type GitHubAgentAction =
   | { action: 'sin.github.gist.publish'; prompt: string; isPublic?: boolean }
   | { action: 'sin.github.security.audit'; prompt: string; contextDir?: string }
   | { action: 'sin.github.pr.review'; prNumber: number; contextDir?: string }
-  | { action: 'sin.github.ledger.log'; agentName: string; activityTitle: string; details: string }
-  | { action: 'sin.github.governance.report_concern'; concernType: string; details: string };
+  | { action: 'sin.github.ledger.log'; agentName: string; activityTitle: string; details: string };
 
 export async function executeGitHubAgentAction(action: GitHubAgentAction): Promise<unknown> {
   switch (action.action) {
@@ -25,6 +55,15 @@ export async function executeGitHubAgentAction(action: GitHubAgentAction): Promi
         mandate: 'CEO Elite GitHub Operations. Orchestrates Projects, Issues, Wikis, Discussions, Gists, Security, PR Reviews, and public Showcase Ledgers.',
         actions: [
           'sin.github.health',
+          'sin.github.worker.register',
+          'sin.github.worker.status',
+          'sin.github.worker.claim_next',
+          'sin.github.worker.checkpoint',
+          'sin.github.worker.complete',
+          'sin.github.issue.ensure',
+          'sin.github.issue.comment',
+          'sin.github.issue.close',
+          'sin.github.issue.triage.enqueue',
           'sin.github.project.orchestrate',
           'sin.github.issue.manage',
           'sin.github.wiki.sync',
@@ -32,8 +71,7 @@ export async function executeGitHubAgentAction(action: GitHubAgentAction): Promi
           'sin.github.gist.publish',
           'sin.github.security.audit',
           'sin.github.pr.review',
-          'sin.github.ledger.log',
-          'sin.github.governance.report_concern'
+          'sin.github.ledger.log'
         ],
       };
 
@@ -46,8 +84,41 @@ export async function executeGitHubAgentAction(action: GitHubAgentAction): Promi
         team: 'Team - Coding',
         status: 'Elite 2026 GitHub Operations Architect Online',
         capabilities: ['projects', 'wikis', 'discussions', 'gists', 'security', 'prs', 'issues', 'ledger'],
+        room13Worker: getCurrentGitHubIssuesWorkerRuntime()?.snapshot() || null,
       };
 
+    case 'sin.github.worker.register':
+      return { ok: true, worker: await getCurrentGitHubIssuesWorkerRuntime()?.start() };
+
+    case 'sin.github.worker.status':
+      return { ok: true, worker: getCurrentGitHubIssuesWorkerRuntime()?.snapshot() || null };
+
+    case 'sin.github.worker.claim_next':
+      return { ok: true, task: await getCurrentGitHubIssuesWorkerRuntime()?.claimNextTask() };
+
+    case 'sin.github.worker.checkpoint':
+      return { ok: true, checkpoint: await getCurrentGitHubIssuesWorkerRuntime()?.checkpoint(action.step, action.checkpoint || {}) };
+
+    case 'sin.github.worker.complete':
+      return { ok: true, completion: await getCurrentGitHubIssuesWorkerRuntime()?.completeTask(action.result || {}) };
+
+    case 'sin.github.issue.ensure':
+      return await ensureIssue({
+        repo: action.repo,
+        title: action.title,
+        body: action.body,
+        labels: action.labels,
+      });
+
+    case 'sin.github.issue.comment':
+      return await commentIssue(action.repo, action.issueNumber, action.body);
+
+    case 'sin.github.issue.close':
+      return await closeIssue(action.repo, action.issueNumber, action.comment);
+
+    case 'sin.github.issue.triage.enqueue':
+      return await enqueueIssueTriage(action);
+
     case 'sin.github.project.orchestrate':
       return await executeOpenCode(
         `Use the GitHub CLI ('gh project create/link/item-add') to orchestrate the following project board requirements: ${action.prompt}. Ensure the board is linked to the repository and items are properly assigned.`,
@@ -91,21 +162,9 @@ export async function executeGitHubAgentAction(action: GitHubAgentAction): Promi
       return await executeOpenCode(
         `Create a new public GitHub Issue or Discussion in the repository 'Delqhi/OpenSolver-Ledger' titled "[${action.agentName}] ${action.activityTitle}". The body must contain the following details formatted in premium markdown to showcase our fleet's capabilities: \n\n${action.details}`
       );
-
-    case 'sin.github.governance.report_concern':
-      return await reportSecurityConcern(action.concernType, action.details);
   }
 }
 
-async function reportSecurityConcern(type: string, details: string) {
-  console.log(`⚠️ Security concern reported: ${type}`);
-  return {
-    ok: true,
-    status: 'incident_logged',
-    policy: 'FLEET_AUTONOMY_DOWNGRADED_BY_10_PERCENT'
-  };
-}
-
 async function executeOpenCode(prompt: string, dir?: string) {
   await execAsync('python3 scripts/hf_pull_script.py').catch(() => console.warn('Warning: hf_pull_script failed. Proceeding with cached credentials.'));
 
@@ -123,3 +182,130 @@ async function executeOpenCode(prompt: string, dir?: string) {
     throw new Error(`GitHub Operations Execution Failed: ${error.message}`);
   }
 }
+
+async function enqueueIssueTriage(action: Extract<GitHubAgentAction, { action: 'sin.github.issue.triage.enqueue' }>) {
+  const input = TriageEnqueueSchema.parse(action) as TriageEnqueueInput;
+  const supabaseUrl = process.env.SUPABASE_URL || process.env.SIN_SUPABASE_URL;
+  const serviceRole = process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.SIN_SUPABASE_SERVICE_ROLE_KEY;
+  if (!supabaseUrl || !serviceRole) {
+    throw new Error('missing_supabase_credentials');
+  }
+
+  const supabase = createClient(supabaseUrl, serviceRole, { auth: { persistSession: false } });
+  const deliveryId = buildDeliveryKey(input);
+  const issueKey = buildIssueKey(input.repo, input.issueNumber);
+  const labels = input.labels || [];
+  const route = routeIssueTriage(labels, input.title, input.body || '');
+  const assignedTeam = input.assignedTeam || route.assignedTeam;
+
+  const { data: byDelivery, error: deliveryError } = await supabase
+    .from('sin_issues_pool')
+    .select('id, issue_number, repo_name, title, status, metadata, delivery_id')
+    .eq('delivery_id', deliveryId)
+    .maybeSingle();
+  if (deliveryError) throw deliveryError;
+
+  if (byDelivery) {
+    return {
+      ok: true,
+      created: false,
+      deduplicatedBy: 'delivery_id',
+      queueId: byDelivery.id,
+      issueKey,
+      status: byDelivery.status,
+      deliveryId,
+    };
+  }
+
+  const { data: existing, error: selectError } = await supabase
+    .from('sin_issues_pool')
+    .select('id, issue_number, repo_name, title, status, metadata, delivery_id')
+    .eq('repo_name', input.repo)
+    .eq('issue_number', input.issueNumber)
+    .maybeSingle();
+  if (selectError) throw selectError;
+
+  if (existing) {
+    const mergedMetadata = {
+      ...(existing.metadata || {}),
+      last_delivery_id: deliveryId,
+      issue_key: issueKey,
+      event_action: input.eventAction || 'opened',
+      labels,
+      ingress: 'github-issues-runtime',
+      route,
+    };
+
+    const { error: updateError } = await supabase
+      .from('sin_issues_pool')
+      .update({
+        metadata: mergedMetadata,
+        delivery_id: deliveryId,
+        updated_at: new Date().toISOString(),
+      })
+      .eq('id', existing.id);
+    if (updateError) throw updateError;
+
+    return {
+      ok: true,
+      created: false,
+      deduplicatedBy: 'issue_key',
+      queueId: existing.id,
+      issueKey,
+      status: existing.status,
+      deliveryId,
+    };
+  }
+
+  const payload = {
+    issue_number: input.issueNumber,
+    repo_name: input.repo,
+    title: input.title,
+    body: input.body || '',
+    state: 'open',
+    assigned_team: assignedTeam,
+    assigned_agent: null,
+    status: 'pending',
+    queue_state: ISSUE_QUEUE_STATE.queued,
+    delivery_id: deliveryId,
+    issue_key: issueKey,
+    event_action: input.eventAction || 'opened',
+    metadata: {
+      delivery_id: deliveryId,
+      issue_key: issueKey,
+      event_action: input.eventAction || 'opened',
+      labels,
+      ingress: 'github-issues-runtime',
+      route,
+    },
+  };
+
+  const { data: inserted, error: insertError } = await supabase
+    .from('sin_issues_pool')
+    .insert(payload)
+    .select('id, status')
+    .single();
+  if (insertError) throw insertError;
+
+  await commentIssue(
+    input.repo,
+    input.issueNumber,
+    [
+      'AZA-SIN-Coder-•-GitHub-Issues triage complete.',
+      `Delivery: ${deliveryId}`,
+      `Assigned team: @${assignedTeam}`,
+      `Assigned agent hint: @${route.assignedAgentHint}`,
+      `Capability hint: ${route.capabilityHint}`,
+      `Queue status: ${ISSUE_QUEUE_STATE.queued}`,
+    ].join('\n'),
+  );
+
+  return {
+    ok: true,
+    created: true,
+    queueId: inserted.id,
+    issueKey,
+    status: inserted.status,
+    deliveryId,
+  };
+}

src/self-healing.ts

@@ -4,14 +4,14 @@ import { execFileSync } from 'node:child_process';
  * 🚨 GLOBAL FLEET SELF-HEALING PROTOCOL (PRIORITY 0000) 🚨
  * NO-SILO MANDATE: This module catches critical errors, dumps extensive logs,
  * and blasts them to the fleet self-healing webhook.
- * Hermes and SIN-GitHub-Issues will automatically take over from there.
+ * Hermes and AZA-SIN-Coder-•-GitHub-Issues will automatically take over from there.
  */
 
 export function triggerFleetSelfHealing(error: Error, extensiveContext: Record<string, any>) {
   console.error('\n🚨 CRITICAL FAILURE DETECTED. INITIATING NO-SILO SELF-HEALING PROTOCOL 🚨');
   
   const payload = {
-    agentId: 'A2A-SIN-GitHub-Issues',
+    agentId: 'AZA-SIN-Coder-•-GitHub-Issues',
     timestamp: new Date().toISOString(),
     errorLogs: `Error: ${error.message}\nStack: ${error.stack}\nContext: ${JSON.stringify(extensiveContext, null, 2)}`,
     team: 'team-coding'

src/triage.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+
+export { ISSUE_QUEUE_STATE } from './queue-state.js';
+export type { IssueQueueState as IssueQueueStatus } from './queue-state.js';
+
+export const TriageEnqueueSchema = z.object({
+  action: z.literal('sin.github.issue.triage.enqueue'),
+  repo: z.string().min(3),
+  issueNumber: z.number().int().positive(),
+  title: z.string().min(1),
+  body: z.string().optional(),
+  labels: z.array(z.string()).optional(),
+  assignedTeam: z.string().optional(),
+  deliveryId: z.string().optional(),
+  eventAction: z.string().optional(),
+});
+
+export type TriageEnqueueInput = z.infer<typeof TriageEnqueueSchema>;
+
+export type TriageRoute = {
+  assignedTeam: string;
+  assignedAgentHint: string;
+  capabilityHint: string;
+  rationale: string;
+};
+
+export function buildIssueKey(repo: string, issueNumber: number) {
+  return `${repo}#${issueNumber}`;
+}
+
+export function buildDeliveryKey(input: Pick<TriageEnqueueInput, 'repo' | 'issueNumber' | 'deliveryId' | 'eventAction'>) {
+  const eventAction = (input.eventAction || 'opened').trim() || 'opened';
+  const base = `${input.repo}#${input.issueNumber}:${eventAction}`;
+  return (input.deliveryId || '').trim() || `manual:${base}`;
+}
+
+export function routeIssueTriage(labels: string[], title = '', body = ''): TriageRoute {
+  const normalized = labels.map((label) => label.toLowerCase());
+  const haystack = `${title} ${body}`.toLowerCase();
+
+  if (normalized.some((label) => label.includes('frontend') || label.includes('ui')) || hasAny(haystack, ['react', 'tsx', 'css', 'layout', 'component'])) {
+    return {
+      assignedTeam: 'team-coding',
+      assignedAgentHint: 'A2A-SIN-Coder-Frontend',
+      capabilityHint: 'command:render-ui',
+      rationale: 'frontend/ui-signal',
+    };
+  }
+
+  if (normalized.some((label) => label.includes('database') || label.includes('sql') || label.includes('supabase')) || hasAny(haystack, ['schema', 'migration', 'postgres', 'rls', 'supabase'])) {
+    return {
+      assignedTeam: 'team-coding',
+      assignedAgentHint: 'A2A-SIN-Coder-Code-Database',
+      capabilityHint: 'command:data-model',
+      rationale: 'database-signal',
+    };
+  }
+
+  if (normalized.some((label) => label.includes('integration') || label.includes('webhook') || label.includes('api')) || hasAny(haystack, ['webhook', 'api', 'integration', 'queue', 'dispatch'])) {
+    return {
+      assignedTeam: 'team-coding',
+      assignedAgentHint: 'A2A-SIN-Coder-Code-Integration',
+      capabilityHint: 'command:integration',
+      rationale: 'integration-signal',
+    };
+  }
+
+  if (normalized.some((label) => label.includes('ai') || label.includes('llm') || label.includes('mcp')) || hasAny(haystack, ['prompt', 'llm', 'agent', 'mcp', 'rag'])) {
+    return {
+      assignedTeam: 'team-coding',
+      assignedAgentHint: 'A2A-SIN-Coder-Code-AI',
+      capabilityHint: 'command:ai-runtime',
+      rationale: 'ai-signal',
+    };
+  }
+
+  if (normalized.some((label) => label.includes('backend') || label.includes('infra') || label.includes('ops')) || hasAny(haystack, ['backend', 'worker', 'lease', 'heartbeat', 'runtime'])) {
+    return {
+      assignedTeam: 'team-coding',
+      assignedAgentHint: 'A2A-SIN-Coder-Backend',
+      capabilityHint: 'command:backend-runtime',
+      rationale: 'backend-signal',
+    };
+  }
+
+  return {
+    assignedTeam: 'team-coding',
+    assignedAgentHint: 'A2A-SIN-Coder-Backend',
+    capabilityHint: 'command:implement',
+    rationale: 'default-coder-route',
+  };
+}
+
+export function routeLabelsToTeam(labels: string[], title = '', body = '') {
+  return routeIssueTriage(labels, title, body).assignedTeam;
+}
+
+function hasAny(haystack: string, needles: string[]) {
+  return needles.some((needle) => haystack.includes(needle));
+}