Deploy code-datascience agent

.env.example

@@ -0,0 +1,4 @@
+SIN_AGENT_NAME=replace_me
+PUBLIC_PAGE_URL=https://replace_me
+CLOUDFLARE_TUNNEL=replace_me
+GOOGLE_SERVICE_ACCOUNT_PATH=/abs/path/to/service-account.json

.github/workflows/ci.yml

@@ -0,0 +1,35 @@
+name: Agent CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build-and-verify:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: npm
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build
+        run: npm run build
+
+      - name: Print card
+        run: node dist/src/cli.js print-card
+
+      - name: Agent help
+        run: node dist/src/cli.js run-action '{"action":"agent.help"}'
+
+      - name: Agent health
+        run: node dist/src/cli.js run-action '{"action":"sin.code.datascience.health"}'

.github/workflows/deploy-huggingface-space.yml

@@ -0,0 +1,51 @@
+name: Deploy Hugging Face Space
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    if: ${{ secrets.HF_TOKEN != '' }}
+    runs-on: ubuntu-latest
+    env:
+      HF_TOKEN: ${{ secrets.HF_TOKEN }}
+      HF_SPACE_REPO_ID: delqhi/sin-code-datascience
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install deployment dependencies
+        run: pip install huggingface_hub
+
+      - name: Create or ensure Hugging Face Space
+        run: |
+          python - <<'PY'
+          import os
+          from huggingface_hub import HfApi
+
+          repo_id = os.environ["HF_SPACE_REPO_ID"].strip()
+          if not repo_id:
+              raise SystemExit("HF_SPACE_REPO_ID missing")
+
+          api = HfApi(token=os.environ["HF_TOKEN"])
+          api.create_repo(repo_id=repo_id, repo_type="space", space_sdk="docker", exist_ok=True)
+          PY
+
+      - name: Push repository contents to Hugging Face Space
+        run: |
+          set -euo pipefail
+          git config --global user.name "GitHub Actions"
+          git config --global user.email "actions@github.com"
+          git clone "https://oauth2:${HF_TOKEN}@huggingface.co/spaces/delqhi/sin-code-datascience" hf-space
+          rsync -a --delete             --exclude ".git/"             --exclude ".github/"             --exclude "node_modules/"             --exclude "dist/"             ./ hf-space/
+          cd hf-space
+          git add .
+          git commit -m "Deploy SIN-Code-DataScience from GitHub Actions" || true
+          git push origin main

.gitignore

@@ -0,0 +1,7 @@
+dist
+node_modules
+*.log
+.env
+.env.local
+.DS_Store
+.sin/artifacts/

.sin/doctor.config.yaml

@@ -0,0 +1,34 @@
+repo: a2a-sin-agent-template
+checks:
+  - required-config-present
+  - workspace-clean-enough
+  - required-files-present
+  - env-contract-present
+  - build-command-exists
+  - tests-command-exists
+  - runtime-command-exists
+  - complete-install-present
+  - health-surface-present
+required_files:
+  - README.md
+  - package.json
+  - src/runtime.ts
+  - src/mcp-server.ts
+  - scripts/complete-install.sh
+  - scripts/hf_pull_script.py
+env_contract_files:
+  - .env.example
+commands:
+  build:
+    - npm run build
+  tests:
+    - npm run typecheck
+  runtime:
+    - npm run start:mcp
+    - npm run start:a2a
+  verify:
+    - node dist/src/cli.js print-card
+health_files:
+  - agent.json
+  - src/runtime.ts
+launchagent_files: []

.sin/policies.local.yaml

@@ -0,0 +1 @@
+waivers: {}

.sin/preflight.config.yaml

@@ -0,0 +1,22 @@
+profiles:
+  local-change:
+    required_checks:
+      - required-config-present
+      - required-files-present
+      - env-contract-present
+      - build-command-exists
+      - complete-install-present
+      - health-surface-present
+    run_commands: []
+  pull-request:
+    required_checks:
+      - required-config-present
+      - required-files-present
+      - env-contract-present
+      - build-command-exists
+      - tests-command-exists
+      - complete-install-present
+      - health-surface-present
+    run_commands:
+      - build
+      - tests

.well-known/oauth-client.json

@@ -0,0 +1,9 @@
+{
+  "client_id": "https://a2a.delqhi.com/agents/sin-code-datascience/.well-known/oauth-client.json",
+  "client_name": "SIN-Code-DataScience",
+  "redirect_uris": ["https://a2a.delqhi.com/agents/sin-code-datascience/oauth/callback"],
+  "grant_types": ["authorization_code"],
+  "response_types": ["code"],
+  "token_endpoint_auth_method": "none"
+}
+

A2A-CARD.md

@@ -0,0 +1,114 @@
+# A2A Card: SIN-Code-DataScience
+
+## Identitaet
+
+- `A2A Bezeichnung`: `SIN-Code-DataScience`
+- `Name`: `SIN-Code-DataScience`
+- `Beschreibung (Zweck)`: Autonomer Data Science und Machine Learning Coder. Spezialisiert auf Python, Pandas, TensorFlow, PyTorch und die Verarbeitung extremer Datenmengen (Scraping, OCR, Data-Mining).
+- `Verwendung`: Trainieren und Finetunen von Modellen, Analyse von Webscraping-Daten, OCR Auswertungen, Aufbau von Data-Pipelines und autonome Monetarisierung durch Data-Mining Gigs auf Freelancer-Plattformen.
+- `CIMD`: `https://a2a.delqhi.com/agents/sin-code-datascience`
+
+## Team & Infrastruktur
+
+- `A2A Team`: `Team Coding`
+- `Team-Manager A2A`: `A2A-SIN-Coding-CEO`
+- `VM / Server`: `HF-VM / Free Tier`
+- `Lokales Verzeichnis`: `/Users/jeremy/dev/SIN-Solver/a2a/team-coding/A2A-SIN-Code-DataScience`
+- `Hugging Face Space URL`: `https://huggingface.co/spaces/delqhi/sin-code-datascience`
+- `Landingpage URL`: `https://a2a.delqhi.com/agents/sin-code-datascience`
+- `Cloudflare Tunnel`: `sin-code-datascience.delqhi.com`
+- `Workforce Ziel-Index`: `https://a2a.delqhi.com/`
+- `Google Doc`: `https://docs.google.com/document/d/1RtoHn4I0GntuEEOHHkqoh_dMuGzgMwQz7_8oxAOpQbw/edit`
+
+## MCP Server
+
+- `MCP Server`: `sin-code-datascience`
+- `Transport`: `stdio`
+- `Config`: `./mcp-config.json`
+
+## CDP (Chrome DevTools Protocol)
+
+- `Nur eintragen, wenn der Agent aktiv CDP nutzt`
+
+## Tools
+
+- `sin.code.datascience.health`
+- `sin.code.datascience.onboarding.status`
+- `sin.code.datascience.onboarding.save`
+
+## Aufgaben
+
+- Runtime bereitstellen
+- MCP bereitstellen
+- A2A JSON-RPC bereitstellen
+- Team-Manager- und Docs-Compliance einhalten
+
+## Alpha Backbone
+
+- `Control Plane`: `control_plane.capabilities`, `control_plane.world_edges`, `memory_plane.items`, `control_plane.artifact_refs`
+- `Projection Mode`: `control-plane-first`
+- `Consumer Auth`: `./scripts/hf_pull_script.py`
+- `Complete Install`: `./scripts/complete-install.sh`
+- `Executor Contract`: `services/workers/hf_executor_contract.json`
+
+## Commandos
+
+```bash
+sin-code-datascience serve-a2a
+sin-code-datascience serve-mcp
+sin-code-datascience print-card
+sin-code-datascience run-action '{"action":"agent.help"}'
+```
+
+## Endpoints
+
+- `Health`: `/health`
+- `Root`: `/`
+- `Agent Card`: `/.well-known/agent-card.json`
+- `Legacy Agent Card Alias`: `/.well-known/agent.json`
+- `A2A JSON-RPC`: `/a2a/v1`
+
+## Skills
+
+- `Pflicht`: Health, onboarding, primary domain actions
+
+## Dateien
+
+- `README.md`
+- `A2A-CARD.md`
+- `AGENTS.md`
+- `agent.json`
+- `mcp-config.json`
+- `package.json`
+- `tsconfig.json`
+- `scripts/postbuild.mjs`
+- `scripts/complete-install.sh`
+- `scripts/hf_pull_script.py`
+- `src/runtime.ts`
+- `src/mcp-server.ts`
+- `src/a2a-http.ts`
+- `src/metadata.ts`
+- `src/cli.ts`
+- `src/index.ts`
+
+## Apps (auf welche Apps hat A2A Zugriff)
+
+- `Hier explizit eintragen`
+
+## Plattformen (auf welche Plattformen hat A2A Zugriff)
+
+- `Hier explizit eintragen`
+
+## Primärmodell
+
+- `openai/gpt-5.4`
+
+## 🚨 GLOBAL FLEET SELF-HEALING & NO-SILO MANDATE
+* Wenn dieser Agent auf einen Crash, API-Fehler, ineffiziente Methoden oder eine funktionale Limitierung stoesst, repariert er sich NIEMALS selbst.
+* Er loggt extrem umfangreich, uebertraegt die Logs an `A2A-SIN-GitHub-Issues` und triggert so die Erstellung eines Architektur-Issues, das durch `SIN-Hermes` an das gesamte Coder-Team delegiert wird.
+
+## 💸 IDLE WORKFORCE & AUTONOMOUS MONETIZATION
+* Dieser Agent sitzt niemals idle herum.
+* Er agiert wie eine autonome Hacker-Organisation: umgeht Cloudflare / Captchas (mit webauto-nodriver-mcp, Scrapling, GateSolve), sucht selbststaendig nach lukrativen OpenAI Bug Bounties, fixt sie und reicht sie ein.
+* Er registriert den User eigenstaendig auf Freelancer-Plattformen (AgentWork, ClawGig, Upwork), sucht Jobs (Websites bauen, Chats moderieren, Data-Mining) und arbeitet diese autonom ab.
+* Er bearbeitet autonom bezahlte Umfragen und nutzt OS-native APIs, verifiziert via A2A-TelegramBot, manipuliert/loescht jedoch NIEMALS bestehende User-Daten oder zerstoert das System.

AGENTS.md

@@ -0,0 +1,56 @@
+# SIN-Code-DataScience
+
+- Team: Team Coding
+- Team Manager: A2A-SIN-Coding-CEO
+- Slug: sin-code-datascience
+- Repo: https://github.com/Delqhi/sin-code-datascience
+- Google Doc: https://docs.google.com/document/d/1RtoHn4I0GntuEEOHHkqoh_dMuGzgMwQz7_8oxAOpQbw/edit
+
+Arbeitsregel:
+- Jede neue Action muss in `runtime.ts`, `mcp-server.ts`, `a2a-http.ts`, `metadata.ts` und `A2A-CARD.md` synchronisiert werden.
+- Kein neuer Agent gilt als fertig, wenn Card, Dashboard-Registry und Google-Dokument nicht gemeinsam aktualisiert wurden.
+- Jeder neue Agent muss auch `agent.json`, `AGENTS.md`, `mcp-config.json`, `clients/opencode-mcp.json`, `clients/codex-config.toml`, `.well-known/agent-card.json`, `.well-known/agent.json`, `.well-known/oauth-client.json` und ggf. einen `bin/`-Wrapper sauber besitzen.
+- Google Docs Child-Tabs immer rekursiv ueber `includeTabsContent=true` + `childTabs` aufloesen. Nie nur Top-Level-Tabs pruefen.
+- Wenn der Team-Haupt-Tab eine finalisierte A2A-Team-Tabelle hat und dieselbe Tabelle im `Silicon Workforce`-Tab gespiegelt wird, muessen beide Tabellen synchron gehalten werden. Das finale Tabellen-Schema darf nicht stillschweigend geaendert werden.
+- Uebersichtstabellen im `Silicon Workforce`-Tab verwenden final das Schema: linke Typ-Spalte + `Bezeichnung | Zweck | URL`.
+- Team-Haupttabellen und deren Spiegel im `Silicon Workforce`-Tab verwenden final das Schema: linke Typ-Spalte + `Bezeichnung | Zweck | MCP's | Commands | Endpoints | Server (VM) | CLI's | URL`.
+- Jeder Team-Haupt-Tab enthaelt nur seine synchronisierte Team-Tabelle; dieselbe Tabelle wird im `Silicon Workforce`-Tab mit sichtbarer Trennlinie zwischen Team-Sektionen gespiegelt.
+- Pflichtfelder fuer neue A2A-Agenten:
+  - Identitaet, Team, Team-Manager, Zweck, Verwendung
+  - Auth-/Secrets-Modell
+  - MCP-Tools und A2A-Actions/Skills
+  - Commands, Endpoints, Capabilities, Input/Output-Modi
+  - Task-Lifecycle, Observability/Audit, Release/Rollback
+  - Owner/Oncall, Dependencies, Deploy-Ziel
+- Pflichtintegration:
+  - repo `.opencode/opencode.json`
+  - globale OpenCode-MCP-Integration falls benoetigt
+  - Dashboard-/Workforce-Registry + Detailseite `dashboard-enterprise/app/agents/<slug>/page.tsx`
+  - `a2a.delqhi.com` Landing/Card
+  - `npm run sync:a2a:control-plane-projection` nach Registry-Aenderungen
+  - Google Docs Child-Tab + Team-Tabellen
+  - `cloudflared/config.example.yml`, wenn der Agent eine oeffentliche Runtime / einen Tunnel bekommen soll
+  - echte Runtime-Provisionierung + echter Publish/Deploy-Schritt, sobald oeffentliche URLs/HF/tunnel eingetragen werden
+  - `scripts/complete-install.sh` und `scripts/hf_pull_script.py` fuer HF-/deploybare Agents
+  - Control-Plane-/Capability-Metadaten in `agent.json`
+- Falls der benoetigte Google-Docs-Child-Tab noch nicht existiert, muss er zuerst manuell im Google-Docs-UI erstellt werden. Die Docs-API kann bestehende Tabs pflegen, aber keine neuen Child-Tabs erzeugen.
+- Pflichtvalidierung vor Done:
+  - Build/Typecheck
+  - A2A health/card/rpc
+  - MCP smoke
+  - relevante Repo-Gates
+  - OpenCode-Integration
+  - Google-Docs-Sync
+  - `npm --prefix <agent-root> run build`
+  - `node <agent-root>/dist/src/cli.js print-card`
+  - `node <agent-root>/dist/src/cli.js run-action '{"action":"agent.help"}'`
+  - `node <agent-root>/dist/src/cli.js run-action '{"action":"<namespace>.health"}'` anhand der echten Skill-ID aus der Card
+  - `serve-mcp` bleibt mit offenem stdin erreichbar
+  - `npm run test:a2a:fleet`
+  - `npm run test:a2a:live -- --agent <slug>`
+  - Landing / `publicPageUrl` liefert `200`
+  - Runtime-Host ist real provisioniert
+  - `/.well-known/agent-card.json` liefert `200`
+  - `/a2a/v1` liefert nicht `404`
+- Ein Agent darf erst auf `ready` / `live` gesetzt werden, wenn diese Reachability-Pruefungen bestanden sind und Registry/Card/Docs denselben auditieren Stand zeigen.
+- Beim Fuellen der Team-Tabellen muessen alle freigegebenen Spalten gepflegt werden. Platzhalter wie `pending formal MCP entry` oder `pending dedicated child-tab` sind nur zulaessig, wenn die jeweilige Surface real noch nicht provisioniert ist.

Dockerfile

@@ -0,0 +1,11 @@
+FROM node:22-bookworm-slim
+WORKDIR /app
+COPY package.json package-lock.json* ./
+RUN npm install
+COPY . .
+RUN npm run build
+ENV PORT=7860
+ENV HOST=0.0.0.0
+EXPOSE 45999
+CMD ["node", "dist/src/cli.js", "serve-a2a"]
+

README.md

@@ -1,10 +1,71 @@
 ---
-title: Code Datascience
-emoji: 🌍
-colorFrom: pink
-colorTo: blue
+title: SIN-Code-DataScience
+emoji: "🤖"
+colorFrom: blue
+colorTo: indigo
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SIN-Code-DataScience
+
+`SIN-Code-DataScience` is a SIN A2A agent package for the Silicon Workforce.
+
+## Identity
+
+- Slug: `sin-code-datascience`
+- Team: `Team Coding`
+- Team Manager: `A2A-SIN-Coding-CEO`
+- Purpose: Autonomer Data Science und Machine Learning Coder. Spezialisiert auf Python, Pandas, TensorFlow, PyTorch und die Verarbeitung extremer Datenmengen (Scraping, OCR, Data-Mining).
+- Usage: Trainieren und Finetunen von Modellen, Analyse von Webscraping-Daten, OCR Auswertungen, Aufbau von Data-Pipelines und autonome Monetarisierung durch Data-Mining Gigs auf Freelancer-Plattformen.
+- Primary Model: `openai/gpt-5.4`
+
+## Deployment
+
+- Local path: `/Users/jeremy/dev/SIN-Solver/a2a/team-coding/A2A-SIN-Code-DataScience`
+- GitHub repo: `https://github.com/Delqhi/sin-code-datascience`
+- Workforce index: `https://a2a.delqhi.com`
+- Landing page: `https://a2a.delqhi.com/agents/sin-code-datascience`
+- Public A2A / CIMD: `https://a2a.delqhi.com/agents/sin-code-datascience`
+- Hugging Face Space: `https://huggingface.co/spaces/delqhi/sin-code-datascience`
+- Hugging Face repo id: `delqhi/sin-code-datascience`
+- Cloudflare tunnel: `sin-code-datascience.delqhi.com`
+- Runtime target: `HF-VM / Free Tier`
+
+## Runtime Shape
+
+- A2A JSON-RPC runtime
+- MCP stdio runtime
+- CLI wrapper for local and automated use
+- publish-ready Docker/Hugging Face Space layout
+
+## A2A Surface
+
+- Card: `GET /.well-known/agent-card.json`
+- Alias: `GET /.well-known/agent.json`
+- Health: `GET /health`
+- RPC: `POST /a2a/v1`
+
+## MCP Surface
+
+- Transport: `stdio`
+- Config: `./mcp-config.json`
+- OpenCode client: `./clients/opencode-mcp.json`
+- Codex client: `./clients/codex-config.toml`
+
+## Local Commands
+
+```bash
+sin-code-datascience serve-a2a
+sin-code-datascience serve-mcp
+sin-code-datascience print-card
+sin-code-datascience run-action '{"action":"agent.help"}'
+sin-code-datascience run-action '{"action":"sin.code.datascience.health"}'
+```
+
+## Publication Notes
+
+- This package is Docker/Hugging Face Space ready via the repository `Dockerfile`.
+- The standalone GitHub repo should contain the same contents as this directory root.
+- Remote publication is only complete after landing, agent card, and A2A endpoint reachability are verified with the live audit.

agent-spec.example.json

@@ -0,0 +1,21 @@
+{
+  "slug": "sin-example",
+  "name": "SIN-Example",
+  "teamSlug": "team-infratructur",
+  "teamName": "Team - Infrastructure",
+  "teamManager": "SIN-Server",
+  "description": "Example SIN A2A agent scaffold.",
+  "usage": "Use when an example A2A agent is needed.",
+  "primaryModel": "nvidia/example-model",
+  "repoUrl": "https://github.com/delqhi/sin-example",
+  "repoVisibility": "private",
+  "googleDocUrl": "https://docs.google.com/document/d/<doc>/edit",
+  "googleDocId": "<doc>",
+  "publicPageUrl": "https://a2a.delqhi.com/agents/sin-example",
+  "landingPageUrl": "https://delqhi-sin-example.hf.space",
+  "hfSpaceUrl": "https://huggingface.co/spaces/delqhi/sin-example",
+  "cloudflareTunnel": "sin-example",
+  "vmServer": "Hugging Face Space free CPU VM",
+  "publicBaseUrl": "http://127.0.0.1:45999",
+  "port": 45999
+}

agent.json

@@ -0,0 +1,34 @@
+{
+  "id": "sin-code-datascience",
+  "displayName": "SIN-Code-DataScience",
+  "team": "team-coding",
+  "description": "Autonomer Data Science und Machine Learning Coder. Spezialisiert auf Python, Pandas, TensorFlow, PyTorch und die Verarbeitung extremer Datenmengen (Scraping, OCR, Data-Mining).",
+  "version": "2026.03.09",
+  "deployment": {
+    "workforceIndex": "https://a2a.delqhi.com",
+    "landingPage": "https://a2a.delqhi.com/agents/sin-code-datascience",
+    "publicA2A": "https://a2a.delqhi.com/agents/sin-code-datascience",
+    "cimdAnchor": "https://a2a.delqhi.com/agents/sin-code-datascience",
+    "vmServer": "HF-VM / Free Tier"
+  },
+  "a2a": {
+    "wellKnownCard": "/.well-known/agent-card.json",
+    "rpcPath": "/a2a/v1",
+    "transport": "jsonrpc-over-http"
+  },
+  "mcp": {
+    "transport": "stdio",
+    "configPath": "./mcp-config.json"
+  },
+  "controlPlane": {
+    "projectionMode": "control-plane-first",
+    "capabilityRegistry": "control_plane.capabilities",
+    "worldModel": "control_plane.world_edges",
+    "memoryPlane": "memory_plane.items",
+    "artifactPolicy": "control_plane.artifact_refs",
+    "executorContract": "services/workers/hf_executor_contract.json",
+    "consumerAuthScript": "./scripts/hf_pull_script.py",
+    "completeInstallScript": "./scripts/complete-install.sh"
+  },
+  "primaryModel": "opencode/qwen3.6-plus-free"
+}

clients/codex-config.toml

@@ -0,0 +1,6 @@
+# Placeholder client config for SIN-Code-DataScience
+
+[agent]
+name = "SIN-Code-DataScience"
+endpoint = "http://127.0.0.1:45999/a2a/v1"
+

clients/opencode-mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "sin-code-datascience": {
+      "command": "bin/sin-code-datascience",
+      "args": ["serve-mcp"]
+    }
+  }
+}

cloudflared/config.example.yml

@@ -0,0 +1,7 @@
+tunnel: sin-code-datascience.delqhi.com
+credentials-file: /etc/cloudflared/sin-code-datascience.delqhi.com.json
+ingress:
+  - hostname: sin-code-datascience.delqhi.com.delqhi.com
+    service: http://127.0.0.1:45999
+  - service: http_status:404
+

mcp-config.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "sin-code-datascience": {
+      "command": "node",
+      "args": ["dist/src/cli.js", "serve-mcp"]
+    }
+  }
+}

package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@sin-solver/sin-code-datascience",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "bin": {
+    "sin-code-datascience": "dist/src/cli.js"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json && node scripts/postbuild.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"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest",
+    "zod": "^3.25.76",
+    "@huggingface/hub": "^0.15.1",
+    "node-cron": "^3.0.3",
+    "tar": "^6.2.0",
+    "@supabase/supabase-js": "^2.39.7"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "typescript": "^5.9.3",
+    "@types/node-cron": "^3.0.11",
+    "@types/tar": "^6.1.11"
+  }
+}

scripts/complete-install.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+
+mkdir -p "$ROOT/logs" "$ROOT/data"
+
+if command -v npm >/dev/null 2>&1; then
+  npm --prefix "$ROOT" install
+else
+  echo "npm is required" >&2
+  exit 1
+fi
+
+npm --prefix "$ROOT" run build
+echo "complete-install finished for $(basename "$ROOT")"

scripts/hf_pull_script.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+A2A Consumer HF VM Bootstrap Script
+Prepares the HF VM runtime environment for agent deployment.
+No longer pulls OpenAI tokens — uses qwen3.6-plus-free via opencode CLI.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+AGENT_ROOT = Path(__file__).resolve().parent.parent
+AUTH_FILE = Path.home() / ".local" / "share" / "opencode" / "auth.json"
+
+
+def bootstrap_hf_vm() -> bool:
+    """Prepare the HF VM runtime for the agent."""
+    print(f"[hf-pull] Bootstrapping HF VM for agent at {AGENT_ROOT}")
+
+    # Ensure required directories exist
+    for dirpath in [
+        Path.home() / ".local" / "share" / "opencode",
+        Path.home() / ".config" / "sin",
+        AGENT_ROOT / "logs",
+        AGENT_ROOT / "data",
+    ]:
+        dirpath.mkdir(parents=True, exist_ok=True)
+        print(f"[hf-pull] Ensured directory: {dirpath}")
+
+    # Write minimal auth.json with placeholder (opencode CLI handles auth)
+    auth_data = {
+        "openai": {
+            "type": "oauth",
+            "refresh": "opencode-managed"
+        }
+    }
+    AUTH_FILE.parent.mkdir(parents=True, exist_ok=True)
+    AUTH_FILE.write_text(json.dumps(auth_data, indent=2) + "\n")
+    print(f"[hf-pull] Wrote placeholder auth to {AUTH_FILE}")
+
+    # Verify node is available
+    try:
+        result = subprocess.run(["node", "--version"], capture_output=True, text=True, timeout=5)
+        print(f"[hf-pull] Node.js available: {result.stdout.strip()}")
+    except FileNotFoundError:
+        print("[hf-pull] WARNING: node not found — install Node.js 18+")
+        return False
+
+    # Install dependencies if node_modules missing
+    pkg_lock = AGENT_ROOT / "package-lock.json"
+    node_modules = AGENT_ROOT / "node_modules"
+    if pkg_lock.exists() and not node_modules.exists():
+        print("[hf-pull] Installing dependencies...")
+        result = subprocess.run(
+            ["npm", "ci", "--production"],
+            cwd=str(AGENT_ROOT),
+            capture_output=True,
+            text=True,
+            timeout=300
+        )
+        if result.returncode != 0:
+            print(f"[hf-pull] npm ci failed: {result.stderr}")
+            return False
+        print("[hf-pull] Dependencies installed")
+
+    # Build if dist missing
+    dist_dir = AGENT_ROOT / "dist"
+    if not dist_dir.exists() and (AGENT_ROOT / "tsconfig.json").exists():
+        print("[hf-pull] Building agent...")
+        result = subprocess.run(
+            ["npm", "run", "build"],
+            cwd=str(AGENT_ROOT),
+            capture_output=True,
+            text=True,
+            timeout=300
+        )
+        if result.returncode != 0:
+            print(f"[hf-pull] Build failed: {result.stderr}")
+            return False
+        print("[hf-pull] Build complete")
+
+    print("[hf-pull] HF VM bootstrap complete")
+    return True
+
+
+if __name__ == "__main__":
+    success = bootstrap_hf_vm()
+    sys.exit(0 if success else 1)

scripts/postbuild.mjs

@@ -0,0 +1,17 @@
+import { mkdir, copyFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+
+const root = resolve(new URL('..', import.meta.url).pathname);
+const targets = [
+  ['agent.json', 'dist/agent.json'],
+  ['mcp-config.json', 'dist/mcp-config.json'],
+  ['A2A-CARD.md', 'dist/A2A-CARD.md'],
+];
+
+for (const [sourceRelative, targetRelative] of targets) {
+  const source = resolve(root, sourceRelative);
+  const target = resolve(root, targetRelative);
+  await mkdir(dirname(target), { recursive: true });
+  await copyFile(source, target);
+}
+

src/a2a-http.ts

@@ -0,0 +1,78 @@
+import { randomUUID } from 'node:crypto';
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import { buildAgentCard, resolveTemplateAgentConfig, TEMPLATE_AGENT_ID, TEMPLATE_AGENT_NAME } from './metadata.js';
+import { executeTemplateAgentAction, type TemplateAgentAction } from './runtime.js';
+
+type RpcRequest = { jsonrpc?: string; id?: string | number | null; method?: string; params?: Record<string, unknown> };
+
+export function createTemplateAgentHttpServer() {
+  const config = resolveTemplateAgentConfig();
+  const server = createServer((request, response) => void handleRequest(request, response, config.publicBaseUrl));
+  return {
+    server,
+    async start() {
+      await new Promise<void>((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(config.port, config.host, () => resolve());
+      });
+    },
+    async stop() {
+      await new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+    },
+  };
+}
+
+async function handleRequest(request: IncomingMessage, response: ServerResponse, baseUrl: string) {
+  if (request.method === 'GET' && request.url === '/health') return sendJson(response, 200, { ok: true, agent: TEMPLATE_AGENT_ID });
+  if (request.method === 'GET' && request.url === '/') return sendHtml(response, 200, `<html><body><h1>${TEMPLATE_AGENT_NAME}</h1></body></html>`);
+  if (request.method === 'GET' && (request.url === '/.well-known/agent-card.json' || request.url === '/.well-known/agent.json')) {
+    return sendJson(response, 200, buildAgentCard(baseUrl));
+  }
+  if (request.method === 'POST' && request.url === '/a2a/v1') {
+    const rpc = ((await readJson(request)) || {}) as RpcRequest;
+    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() || '');
+      const result = await executeTemplateAgentAction(action);
+      return sendJson(response, 200, {
+        jsonrpc: '2.0',
+        id: rpc.id ?? null,
+        result: {
+          id: randomUUID(),
+          kind: 'task',
+          status: { state: 'completed', timestamp: new Date().toISOString(), message: { role: 'agent', parts: [{ type: 'text', text: 'done' }] } },
+          artifacts: [{ id: randomUUID(), name: action.action, description: action.action, parts: [{ type: 'data', data: result }] }],
+          metadata: { action: action.action },
+        },
+      });
+    }
+  }
+  sendJson(response, 404, { error: 'not_found' });
+}
+
+function parseAction(text: string): TemplateAgentAction {
+  const value = text.toLowerCase();
+  if (value === 'sin.code.datascience health') return { action: 'sin.code.datascience.health' };
+  if (value === 'sin.code.datascience onboarding status') return { action: 'sin.code.datascience.onboarding.status' };
+  return { action: 'agent.help' };
+}
+
+async function readJson(request: IncomingMessage) {
+  const chunks: Buffer[] = [];
+  for await (const chunk of request) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  const raw = Buffer.concat(chunks).toString('utf8').trim();
+  return raw ? JSON.parse(raw) : null;
+}
+
+function sendJson(response: ServerResponse, statusCode: number, payload: unknown) {
+  response.statusCode = statusCode;
+  response.setHeader('content-type', 'application/json; charset=utf-8');
+  response.end(JSON.stringify(payload, null, 2));
+}
+
+function sendHtml(response: ServerResponse, statusCode: number, payload: string) {
+  response.statusCode = statusCode;
+  response.setHeader('content-type', 'text/html; charset=utf-8');
+  response.end(payload);
+}
+

src/cli.ts

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+import process from 'node:process';
+import { restoreAuthSession, startKeepAlivePing, startAutoBackup } from './hf_sync.js';
+import { createTemplateAgentHttpServer } from './a2a-http.js';
+import { buildAgentCard, resolveTemplateAgentConfig } from './metadata.js';
+import { startMcpServer } from './mcp-server.js';
+import { executeTemplateAgentAction, type TemplateAgentAction } from './runtime.js';
+
+async function main(): Promise<void> {
+  const command = process.argv[2] || 'help';
+  switch (command) {
+    case 'serve':
+    case 'serve-a2a':
+      await serveA2A();
+      return;
+    case 'serve-mcp':
+      await startMcpServer();
+      return;
+    case 'print-card':
+      printJson(buildAgentCard(resolveTemplateAgentConfig().publicBaseUrl));
+      return;
+    case 'run-action':
+      await runAction();
+      return;
+    default:
+      printUsage();
+  }
+}
+
+async function serveA2A() {
+  const config = resolveTemplateAgentConfig();
+  const handle = createTemplateAgentHttpServer();
+  await handle.start();
+  printJson({ ok: true, command: 'serve-a2a', host: config.host, port: config.port, baseUrl: config.publicBaseUrl });
+}
+
+async function runAction() {
+  const raw = process.argv[3]?.trim() || (await readStdin()).trim();
+  if (!raw) throw new Error('missing_action_json');
+  printJson(await executeTemplateAgentAction(JSON.parse(raw) as TemplateAgentAction));
+}
+
+function printUsage() {
+  process.stderr.write(
+    ['Usage:', '  sin-code-datascience serve-a2a', '  sin-code-datascience serve-mcp', '  sin-code-datascience print-card', `  sin-code-datascience run-action '{"action":"agent.help"}'`].join('\n') + '\n',
+  );
+}
+
+function printJson(payload: unknown) {
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+async function readStdin() {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exitCode = 1;
+});
+

src/hf_sync.ts

@@ -0,0 +1,86 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as tar from 'tar';
+import { uploadFile, downloadFile } from '@huggingface/hub';
+import cron from 'node-cron';
+
+const AUTH_DIR = path.join(process.cwd(), '.wwebjs_auth');
+const BACKUP_FILE = path.join(process.cwd(), 'auth_backup.tar.gz');
+
+const hfToken = process.env.HF_TOKEN;
+const datasetRepo = process.env.HF_DATASET_REPO;
+
+export async function backupAuthSession(): Promise<void> {
+  if (!hfToken || !datasetRepo) {
+    return;
+  }
+
+  if (!fs.existsSync(AUTH_DIR)) {
+    return;
+  }
+
+  try {
+    await tar.c({ gzip: true, file: BACKUP_FILE, cwd: process.cwd() }, ['.wwebjs_auth']);
+
+    const fileBuffer = fs.readFileSync(BACKUP_FILE);
+    const blob = new Blob([fileBuffer], { type: 'application/gzip' });
+
+    await uploadFile({
+      repo: { type: 'dataset', name: datasetRepo },
+      credentials: { accessToken: hfToken },
+      file: {
+        path: 'auth_backup.tar.gz',
+        content: blob
+      },
+      commitTitle: 'Auto-Backup: Session - ' + new Date().toISOString()
+    });
+  } catch (error) {
+    console.error('[HF-Sync] Error during backup:', error);
+  }
+}
+
+export async function restoreAuthSession(): Promise<void> {
+  if (!hfToken || !datasetRepo) {
+    return;
+  }
+
+  try {
+    const response = await downloadFile({
+      repo: { type: 'dataset', name: datasetRepo },
+      credentials: { accessToken: hfToken },
+      path: 'auth_backup.tar.gz'
+    });
+
+    if (!response) {
+      return;
+    }
+
+    const buffer = await response.arrayBuffer();
+    fs.writeFileSync(BACKUP_FILE, Buffer.from(buffer));
+    
+    await tar.x({ file: BACKUP_FILE, cwd: process.cwd() });
+    console.log('[HF-Sync] Restored session from dataset.');
+  } catch (error: any) {
+    if (!error.message?.includes('404')) {
+      console.error('[HF-Sync] Restore error:', error);
+    }
+  }
+}
+
+export function startKeepAlivePing(): void {
+  const spaceUrl = process.env.SPACE_HOST ? 'https://' + process.env.SPACE_HOST : 'http://localhost:' + (process.env.PORT || 7860);
+  
+  cron.schedule('*/5 * * * *', async () => {
+    try {
+      await fetch(spaceUrl);
+    } catch (e) {
+      // ignore
+    }
+  });
+}
+
+export function startAutoBackup(): void {
+  cron.schedule('*/10 * * * *', async () => {
+    await backupAuthSession();
+  });
+}

src/idle-monetization.ts

@@ -0,0 +1,32 @@
+/**
+ * 💸 IDLE WORKFORCE & MONETIZATION DIRECTIVE (PRIORITY 0001) 🚨
+ * NEVER IDLE MANDATE: This A2A sits NEVER simply dumb around.
+ * If no task exists, it autonomously seeks out work, bug bounties, surveys, or freelance gigs.
+ */
+
+export function startAutonomousIdleLoop() {
+  console.log('💸 Autonomous Monetization & Hacking loop enabled (Mega Krass Mode).');
+
+  // 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) {
+      return;
+    }
+
+    console.log('\n[IDLE-LOOP] Agent has no tasks. Searching for autonomous opportunities...');
+    
+    const tasks = [
+      () => console.log('  🔍 [Bug Bounty] Scanning HackerOne/Bugcrowd/OpenAI for lucrative flaws...'),
+      () => console.log('  🛠️ [Freelancer] Checking AgentWork/ClawGig/Upwork for new jobs (Web/App dev, Moderation)...'),
+      () => console.log('  📋 [Surveys] Completing paid surveys on pre-approved autonomous platforms...'),
+      () => console.log('  🔐 [Hacker Mode] Utilizing webauto-nodriver-mcp and Scrapling for undetected data extraction...')
+    ];
+
+    // Pick a random idle task to pretend we are doing something useful
+    // In a real implementation, this would trigger actual A2A tasks (e.g. OpenAI completion).
+    const randomTask = tasks[Math.floor(Math.random() * tasks.length)];
+    randomTask();
+
+  }, 5 * 60 * 1000); // Every 5 minutes
+}

src/index.ts

@@ -0,0 +1,5 @@
+export * from './runtime.js';
+export * from './metadata.js';
+export * from './a2a-http.js';
+export * from './mcp-server.js';
+

src/mcp-server.ts

@@ -0,0 +1,82 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { executeTemplateAgentAction } from './runtime.js';
+
+const onboardingSaveSchema = z.object({
+  ownerEmail: z.string().optional(),
+  notes: z.string().optional(),
+  confirm: z.boolean().optional(),
+});
+
+const TOOLS = [
+  {
+    name: 'sin-code-datascience_help',
+    description: 'Describe available agent actions.',
+    inputSchema: { type: 'object', properties: {} },
+    parse: () => ({}),
+    handler: async () => executeTemplateAgentAction({ action: 'agent.help' }),
+  },
+  {
+    name: 'sin-code-datascience_health',
+    description: 'Check base agent readiness.',
+    inputSchema: { type: 'object', properties: {} },
+    parse: () => ({}),
+    handler: async () => executeTemplateAgentAction({ action: 'sin.code.datascience.health' }),
+  },
+  {
+    name: 'sin-code-datascience_onboarding_status',
+    description: 'Read onboarding state.',
+    inputSchema: { type: 'object', properties: {} },
+    parse: () => ({}),
+    handler: async () => executeTemplateAgentAction({ action: 'sin.code.datascience.onboarding.status' }),
+  },
+  {
+    name: 'sin-code-datascience_onboarding_save',
+    description: 'Persist onboarding state. Requires confirm=true.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ownerEmail: { type: 'string' },
+        notes: { type: 'string' },
+        confirm: { type: 'boolean' },
+      },
+    },
+    parse: (input: unknown) => onboardingSaveSchema.parse(input ?? {}),
+    handler: async (input: z.infer<typeof onboardingSaveSchema>) =>
+      executeTemplateAgentAction({ action: 'sin.code.datascience.onboarding.save', ...input }),
+  },
+] as const;
+
+export async function startMcpServer(): Promise<void> {
+  const server = new Server({ name: 'sin-code-datascience', version: '0.1.0' }, { capabilities: { tools: {} } });
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: TOOLS.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+      })),
+    };
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const tool = TOOLS.find((entry) => entry.name === request.params.name);
+    if (!tool) {
+      return {
+        content: [{ type: 'text', text: `Unknown tool: ${request.params.name}` }],
+        isError: true,
+      };
+    }
+    const parsed = tool.parse(request.params.arguments ?? {});
+    const result = await tool.handler(parsed);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

src/metadata.ts

@@ -0,0 +1,67 @@
+import process from 'node:process';
+
+export const TEMPLATE_AGENT_ID = 'sin-code-datascience';
+export const TEMPLATE_AGENT_NAME = 'SIN-Code-DataScience';
+export const TEMPLATE_AGENT_DESCRIPTION = 'Autonomer Data Science und Machine Learning Coder. Spezialisiert auf Python, Pandas, TensorFlow, PyTorch und die Verarbeitung extremer Datenmengen (Scraping, OCR, Data-Mining).';
+export const TEMPLATE_AGENT_VERSION = '2026.03.09';
+export const TEMPLATE_AGENT_DEFAULT_HOST = '127.0.0.1';
+export const TEMPLATE_AGENT_DEFAULT_PORT = 45999;
+export const TEMPLATE_AGENT_EXECUTOR_CONTRACT = 'services/workers/hf_executor_contract.json';
+export const TEMPLATE_AGENT_CAPABILITY_REGISTRY = 'control_plane.capabilities';
+
+export const TEMPLATE_AGENT_SKILLS = [
+  {
+    id: 'sin.code.datascience.health',
+    name: 'Health',
+    description: 'Check base agent readiness and identity.',
+  },
+  {
+    id: 'sin.code.datascience.onboarding.status',
+    name: 'Onboarding Status',
+    description: 'Read persisted onboarding state.',
+  },
+  {
+    id: 'sin.code.datascience.onboarding.save',
+    name: 'Onboarding Save',
+    description: 'Persist onboarding defaults for future autonomous runs.',
+  },
+] as const;
+
+export function resolveTemplateAgentConfig() {
+  const host =
+    process.env.SIN_CODE_DATASCIENCE_HOST?.trim() ||
+    (process.env.PORT ? '0.0.0.0' : process.env.HOST?.trim() || TEMPLATE_AGENT_DEFAULT_HOST);
+  const port = parseInteger(process.env.SIN_CODE_DATASCIENCE_PORT, parseInteger(process.env.PORT, TEMPLATE_AGENT_DEFAULT_PORT));
+  const fallbackPublicHost = host === '0.0.0.0' ? '127.0.0.1' : host;
+  const publicBaseUrl =
+    process.env.SIN_CODE_DATASCIENCE_PUBLIC_BASE_URL?.trim() ||
+    (process.env.SPACE_HOST?.trim() ? `https://${process.env.SPACE_HOST.trim()}` : `http://${fallbackPublicHost}:${port}`);
+  return { host, port, publicBaseUrl: publicBaseUrl.replace(/\/+$/, '') };
+}
+
+export function buildAgentCard(baseUrl: string) {
+  const normalizedBaseUrl = baseUrl.replace(/\/+$/, '');
+  const rpcUrl = `${normalizedBaseUrl}/a2a/v1`;
+  return {
+    name: TEMPLATE_AGENT_NAME,
+    description: TEMPLATE_AGENT_DESCRIPTION,
+    version: TEMPLATE_AGENT_VERSION,
+    documentationUrl: normalizedBaseUrl,
+    url: rpcUrl,
+    capabilities: { streaming: false, pushNotifications: false },
+    defaultInputModes: ['text/plain', 'application/json'],
+    defaultOutputModes: ['text/plain', 'application/json'],
+    metadata: {
+      projectionMode: 'control-plane-first',
+      capabilityRegistry: TEMPLATE_AGENT_CAPABILITY_REGISTRY,
+      executorContract: TEMPLATE_AGENT_EXECUTOR_CONTRACT,
+    },
+    skills: [...TEMPLATE_AGENT_SKILLS],
+    supportedInterfaces: [{ url: rpcUrl, protocolBinding: 'JSONRPC', protocolVersion: '1.0' }],
+  };
+}
+
+function parseInteger(input: string | undefined, fallback: number) {
+  const parsed = Number.parseInt(String(input || '').trim(), 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}

src/runtime.ts

@@ -0,0 +1,83 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+const DEFAULT_STATE_PATH = join(homedir(), '.config', 'sin', 'sin-code-datascience', 'onboarding-state.json');
+
+type OnboardingState = {
+  ownerEmail?: string;
+  notes?: string;
+  updatedAt?: string;
+};
+
+export type TemplateAgentAction =
+  | { action: 'agent.help' }
+  | { action: 'sin.code.datascience.health' }
+  | { action: 'sin.code.datascience.onboarding.status' }
+  | { action: 'sin.code.datascience.onboarding.save'; ownerEmail?: string; notes?: string; confirm?: boolean };
+
+export async function executeTemplateAgentAction(action: TemplateAgentAction): Promise<unknown> {
+  switch (action.action) {
+    case 'agent.help':
+      return buildHelpPayload();
+    case 'sin.code.datascience.health':
+      return {
+        ok: true,
+        agent: 'sin-code-datascience',
+        primaryModel: 'opencode/qwen3.6-plus-free',
+        team: 'Team Coding',
+      };
+    case 'sin.code.datascience.onboarding.status':
+      return {
+        ok: true,
+        statePath: DEFAULT_STATE_PATH,
+        state: await readState(),
+      };
+    case 'sin.code.datascience.onboarding.save':
+      if (!action.confirm) {
+        throw new Error('input_required:confirm=true required');
+      }
+      return {
+        ok: true,
+        statePath: DEFAULT_STATE_PATH,
+        state: await writeState({
+          ownerEmail: clean(action.ownerEmail),
+          notes: clean(action.notes),
+          updatedAt: new Date().toISOString(),
+        }),
+      };
+  }
+}
+
+function buildHelpPayload() {
+  return {
+    ok: true,
+    agent: 'sin-code-datascience',
+    actions: ['sin.code.datascience.health', 'sin.code.datascience.onboarding.status', 'sin.code.datascience.onboarding.save'],
+    controlPlane: {
+      projectionMode: 'control-plane-first',
+      capabilityRegistry: 'control_plane.capabilities',
+      consumerAuthScript: './scripts/hf_pull_script.py',
+      completeInstallScript: './scripts/complete-install.sh',
+    },
+  };
+}
+
+async function readState(): Promise<OnboardingState | null> {
+  try {
+    return JSON.parse(await readFile(DEFAULT_STATE_PATH, 'utf8')) as OnboardingState;
+  } catch {
+    return null;
+  }
+}
+
+async function writeState(state: OnboardingState) {
+  await mkdir(dirname(DEFAULT_STATE_PATH), { recursive: true });
+  await writeFile(DEFAULT_STATE_PATH, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  return state;
+}
+
+function clean(value: string | undefined) {
+  const normalized = String(value || '').trim();
+  return normalized || undefined;
+}

src/self-healing.ts

@@ -0,0 +1,32 @@
+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.
+ */
+
+export function triggerFleetSelfHealing(error: Error, extensiveContext: Record<string, any>) {
+  console.error('\n🚨 CRITICAL FAILURE DETECTED. INITIATING NO-SILO SELF-HEALING PROTOCOL 🚨');
+  
+  const payload = {
+    agentId: 'sin-code-datascience',
+    timestamp: new Date().toISOString(),
+    errorLogs: `Error: ${error.message}\nStack: ${error.stack}\nContext: ${JSON.stringify(extensiveContext, null, 2)}`,
+    team: 'Team Coding'
+  };
+
+  try {
+    const webhookUrl = process.env.FLEET_SELF_HEALING_WEBHOOK || 'http://92.5.60.87:5678/webhook/self-healing';
+    
+    // Blast to the N8N foundation webhook
+    const curlCmd = `curl -X POST "${webhookUrl}" -H "Content-Type: application/json" -d '${JSON.stringify(payload).replace(/'/g, "'\\''")}'`;
+    
+    execFileSync('bash', ['-c', curlCmd], { encoding: 'utf8' });
+    console.log('✅ Extensive logs successfully transmitted to Fleet Self-Healing pipeline.');
+    console.log('👷 The Elite Coder Fleet has been notified and will resolve this architecture flaw autonomously.');
+  } catch (transmitError: any) {
+    console.error('❌ FATAL: Could not transmit logs to Fleet Self-Healing pipeline.', transmitError.message);
+  }
+}

src/supabase.ts

@@ -0,0 +1,23 @@
+import { createClient, SupabaseClient } from '@supabase/supabase-js';
+
+// Database coupling to global SIN-Supabase A2A (Oracle OCI VM 200GB)
+// SSOT: https://docs.google.com/document/d/1RtoHn4I0GntuEEOHHkqoh_dMuGzgMwQz7_8oxAOpQbw/edit?tab=t.zglvro7czbod
+
+let supabaseInstance: SupabaseClient | null = null;
+
+export function getSupabaseClient(): SupabaseClient {
+  if (supabaseInstance) {
+    return supabaseInstance;
+  }
+
+  const supabaseUrl = process.env.SIN_SUPABASE_URL;
+  const supabaseKey = process.env.SIN_SUPABASE_SERVICE_ROLE_KEY;
+
+  if (!supabaseUrl || !supabaseKey) {
+    console.warn('[SIN-Supabase] Warning: SIN_SUPABASE_URL or SIN_SUPABASE_SERVICE_ROLE_KEY is missing. DB coupling is inactive.');
+    return createClient(supabaseUrl || 'https://dummy.supabase.co', supabaseKey || 'dummy');
+  }
+
+  supabaseInstance = createClient(supabaseUrl, supabaseKey);
+  return supabaseInstance;
+}

tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"]
+}
+