@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/domains/swarm/swarm_types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Swarm Types — Parallel Swarm Reasoning type definitions
+ *
+ * Types for Blue/Red adversarial inference, consensus voting,
+ * and parallel dispatch via Semaphore.
+ *
+ * @since v1.9.0
+ */
+/** Blue = Implementer (fix/improve), Red = Critic (find flaws) */
+export type SwarmRole = 'BLUE' | 'RED';
+export interface SwarmRequest {
+    /** Target files under analysis */
+    files: string[];
+    /** Assembled code context (from ContextAssembler) */
+    context: string;
+    /** Blue's patch description for Red to evaluate */
+    patchDescription?: string;
+    /** Reason for this swarm dispatch */
+    reason: string;
+}
+/**
+ * Parsed inference output (judgement_output.v2 schema).
+ * Same schema used by existing NativeInference.
+ */
+export interface SwarmParsedOutput {
+    verdict: 'OK' | 'WARN' | 'STOP';
+    rationale: Array<{
+        code: string;
+        message: string;
+        severity: number;
+    }>;
+    confidence: number;
+}
+export interface SwarmVote {
+    role: SwarmRole;
+    /** Raw inference output text */
+    output: string;
+    /** Parsed JSON output (null if unparseable) */
+    parsed: SwarmParsedOutput | null;
+    /** Inference latency in milliseconds */
+    latencyMs: number;
+    /** Error message if inference failed */
+    error?: string;
+}
+/** EXECUTE = proceed, WARNING = proceed with caution, ABORT = cancel */
+export type ConsensusVerdict = 'EXECUTE' | 'WARNING' | 'ABORT';
+export interface ConsensusResult {
+    verdict: ConsensusVerdict;
+    /** Risk score from Red's evaluation (0.0 = safe, 1.0 = dangerous) */
+    riskScore: number;
+    blueVote: SwarmVote;
+    redVote: SwarmVote;
+    /** Human-readable reason for the verdict */
+    reason: string;
+}

package/build/domains/swarm/swarm_types.js

@@ -0,0 +1,9 @@
+/**
+ * Swarm Types — Parallel Swarm Reasoning type definitions
+ *
+ * Types for Blue/Red adversarial inference, consensus voting,
+ * and parallel dispatch via Semaphore.
+ *
+ * @since v1.9.0
+ */
+export {};

package/build/domains/swarm/swarm_verdict_router.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Swarm Verdict Router — ConsensusResult → AntLane action routing
+ *
+ * Routes Swarm verdicts to AntLane remediation actions:
+ *   EXECUTE → add task + execute immediately
+ *   WARNING → add task only (pending manual review)
+ *   ABORT   → reject, no task created
+ *
+ * Records swarm context in RemediationLog for audit trail.
+ *
+ * @since v1.11.0
+ */
+import type { AntLane } from '../ant/ant_lane.js';
+import type { BlockStore } from '../../kernel/blocks/store.js';
+import type { ChainManager } from '../../kernel/blocks/chain.js';
+import type { ConsensusResult } from './swarm_types.js';
+import type { RemediationPayload, SurgeryResult } from '../ant/ant_remediator.js';
+export interface SwarmRemediationRequest {
+    /** Swarm consensus result from SwarmDispatcher.dispatch() */
+    consensus: ConsensusResult;
+    /** Pre-computed remediation payload (patch to apply if approved) */
+    remediation: RemediationPayload;
+}
+export type SwarmAction = 'EXECUTED' | 'QUEUED' | 'REJECTED';
+export interface SwarmRemediationResult {
+    /** Action taken based on the verdict */
+    action: SwarmAction;
+    /** Original consensus for reference */
+    consensus: ConsensusResult;
+    /** AntLane task ID (present for EXECUTED and QUEUED) */
+    taskId?: string;
+    /** Surgery result (present only for EXECUTED) */
+    surgeryResult?: SurgeryResult;
+    /** Reason for rejection (present only for REJECTED) */
+    rejectReason?: string;
+}
+/**
+ * Route a Swarm verdict to AntLane action.
+ *
+ * - EXECUTE: add REMEDIATION task → processNextTask → execute surgery
+ * - WARNING: add REMEDIATION task only (queued for manual review)
+ * - ABORT: no task created, returns REJECTED
+ */
+export declare function routeSwarmVerdict(request: SwarmRemediationRequest, lane: AntLane, store: BlockStore, chainManager: ChainManager): Promise<SwarmRemediationResult>;
+/**
+ * Record swarm remediation to JSONL log (best-effort).
+ *
+ * For EXECUTED: records surgery result with swarm context.
+ * For REJECTED: records rejection for audit trail.
+ * For QUEUED: no record (task not yet executed).
+ *
+ * Note: executeRemediationTask() already records a detailed delta entry.
+ * This adds a second entry with swarm-specific metadata for tracing.
+ */
+export declare function recordSwarmRemediation(basePath: string, result: SwarmRemediationResult, request: SwarmRemediationRequest): Promise<void>;

package/build/domains/swarm/swarm_verdict_router.js

@@ -0,0 +1,129 @@
+/**
+ * Swarm Verdict Router — ConsensusResult → AntLane action routing
+ *
+ * Routes Swarm verdicts to AntLane remediation actions:
+ *   EXECUTE → add task + execute immediately
+ *   WARNING → add task only (pending manual review)
+ *   ABORT   → reject, no task created
+ *
+ * Records swarm context in RemediationLog for audit trail.
+ *
+ * @since v1.11.0
+ */
+import { addRemediationTask, executeRemediationTask } from '../ant/ant_lane_remediation.js';
+import { recordRemediation } from '../ant/remediation_log.js';
+// ============================================================================
+// Verdict Router
+// ============================================================================
+/**
+ * Route a Swarm verdict to AntLane action.
+ *
+ * - EXECUTE: add REMEDIATION task → processNextTask → execute surgery
+ * - WARNING: add REMEDIATION task only (queued for manual review)
+ * - ABORT: no task created, returns REJECTED
+ */
+export async function routeSwarmVerdict(request, lane, store, chainManager) {
+    const { consensus, remediation } = request;
+    switch (consensus.verdict) {
+        case 'EXECUTE':
+            return executeRoute(consensus, remediation, lane, store, chainManager);
+        case 'WARNING':
+            return queueRoute(consensus, remediation, lane);
+        case 'ABORT':
+            return {
+                action: 'REJECTED',
+                consensus,
+                rejectReason: consensus.reason,
+            };
+    }
+}
+async function executeRoute(consensus, remediation, lane, store, chainManager) {
+    const task = addRemediationTask(lane, remediation);
+    await lane.processNextTask();
+    const surgeryResult = await executeRemediationTask(lane, store, chainManager, task.id);
+    return {
+        action: 'EXECUTED',
+        consensus,
+        taskId: task.id,
+        surgeryResult,
+    };
+}
+function queueRoute(consensus, remediation, lane) {
+    const task = addRemediationTask(lane, remediation);
+    return {
+        action: 'QUEUED',
+        consensus,
+        taskId: task.id,
+    };
+}
+// ============================================================================
+// Swarm Remediation Log
+// ============================================================================
+const EMPTY_DELTA = {
+    blocksAdded: 0,
+    blocksRemoved: 0,
+    blocksUnchanged: 0,
+    oldBlockCount: 0,
+    newBlockCount: 0,
+};
+/**
+ * Record swarm remediation to JSONL log (best-effort).
+ *
+ * For EXECUTED: records surgery result with swarm context.
+ * For REJECTED: records rejection for audit trail.
+ * For QUEUED: no record (task not yet executed).
+ *
+ * Note: executeRemediationTask() already records a detailed delta entry.
+ * This adds a second entry with swarm-specific metadata for tracing.
+ */
+export async function recordSwarmRemediation(basePath, result, request) {
+    const { consensus, remediation } = request;
+    const swarmContext = {
+        verdict: consensus.verdict,
+        riskScore: consensus.riskScore,
+        reason: consensus.reason,
+        blueLatencyMs: consensus.blueVote.latencyMs,
+        redLatencyMs: consensus.redVote.latencyMs,
+    };
+    if (result.action === 'EXECUTED' && result.surgeryResult) {
+        const sr = result.surgeryResult;
+        try {
+            await recordRemediation(basePath, {
+                remediation_id: `swarm_${result.taskId}`,
+                timestamp: new Date().toISOString(),
+                task_id: result.taskId,
+                filePath: remediation.filePath,
+                reason: remediation.reason,
+                status: sr.status,
+                oldRootHash: sr.oldRootHash ?? '',
+                newRootHash: sr.newRootHash ?? '',
+                snapshotId: sr.snapshotId ?? '',
+                delta: EMPTY_DELTA,
+                swarm: swarmContext,
+            });
+        }
+        catch {
+            // Best-effort: never fail the caller
+        }
+    }
+    else if (result.action === 'REJECTED') {
+        try {
+            await recordRemediation(basePath, {
+                remediation_id: `swarm_rejected_${Date.now()}`,
+                timestamp: new Date().toISOString(),
+                task_id: '',
+                filePath: remediation.filePath,
+                reason: result.rejectReason ?? consensus.reason,
+                status: 'BLOCKED',
+                oldRootHash: '',
+                newRootHash: '',
+                snapshotId: '',
+                delta: EMPTY_DELTA,
+                swarm: swarmContext,
+            });
+        }
+        catch {
+            // Best-effort: never fail the caller
+        }
+    }
+}

package/build/evidence-report.d.ts

@@ -115,7 +115,7 @@ export declare class EvidenceReportGenerator {
 /**
  * JSON 파일에서 Evidence Report 생성
  */
-export declare function generateEvidenceReport(runsDir: string, runId: string, metadata?: Partial<EvidenceMetadata>): string;
+export declare function generateEvidenceReport(runsDir: string, runId: string, metadata?: Partial<EvidenceMetadata>): Promise<string>;
 /**
  * Evidence Report 생성 (runDir = `.vibe/runs/<run_id>`; legacy read-fallback: `runs/<run_id>`)
  *
@@ -125,7 +125,7 @@ export declare function generateEvidenceReportFromRunDir(runDir: string, runId:
 /**
  * Evidence Report를 파일로 저장
  */
-export declare function saveEvidenceReport(runsDir: string, runId: string, metadata?: Partial<EvidenceMetadata>): string;
+export declare function saveEvidenceReport(runsDir: string, runId: string, metadata?: Partial<EvidenceMetadata>): Promise<string>;
 /**
  * Evidence Report 저장 (runDir = `.vibe/runs/<run_id>`)
  * 산출물 SSOT: `.vibe/runs/<run_id>/ci/evidence_report.md`

package/build/evidence-report.js

@@ -3,9 +3,10 @@
  *
  * spec_gate_result.json + clinic_result.json을 마크다운 리포트로 합성
  */
-import * as fs from "node:fs";
 import * as path from "node:path";
+import { readJsonFileAsync } from "./kernel/async-fs.js";
 import { VERDICT_TO_SIGNAL, SIGNAL_EMOJI } from "./reviewer-ux-types.js";
+import { loadRunDiagnostics, loadSkeletonSummary, writeRunMarkdown, } from "./reporting/run_artifacts.js";
 // ============================================================
 // Report Templates
 // ============================================================
@@ -420,29 +421,15 @@ export class EvidenceReportGenerator {
 /**
  * JSON 파일에서 Evidence Report 생성
  */
-export function generateEvidenceReport(runsDir, runId, metadata = {}) {
+export async function generateEvidenceReport(runsDir, runId, metadata = {}) {
     const generator = new EvidenceReportGenerator();
     // 파일 읽기
     const gatePath = path.join(runsDir, runId, "gate", "spec_gate_result.json");
     const clinicPath = path.join(runsDir, runId, "clinic", "clinic_result.json");
-    let specGate = null;
-    let clinic = null;
-    if (fs.existsSync(gatePath)) {
-        try {
-            specGate = JSON.parse(fs.readFileSync(gatePath, "utf-8"));
-        }
-        catch {
-            // ignore
-        }
-    }
-    if (fs.existsSync(clinicPath)) {
-        try {
-            clinic = JSON.parse(fs.readFileSync(clinicPath, "utf-8"));
-        }
-        catch {
-            // ignore
-        }
-    }
+    const [specGate, clinic] = await Promise.all([
+        readJsonFileAsync(gatePath),
+        readJsonFileAsync(clinicPath),
+    ]);
     const fullMetadata = {
         run_id: runId,
         timestamp: new Date().toISOString(),
@@ -457,26 +444,7 @@ export function generateEvidenceReport(runsDir, runId, metadata = {}) {
  */
 export function generateEvidenceReportFromRunDir(runDir, runId, metadata = {}) {
     const generator = new EvidenceReportGenerator();
-    const gatePath = path.join(runDir, "gate", "spec_gate_result.json");
-    const clinicPath = path.join(runDir, "clinic", "clinic_result.json");
-    let specGate = null;
-    let clinic = null;
-    if (fs.existsSync(gatePath)) {
-        try {
-            specGate = JSON.parse(fs.readFileSync(gatePath, "utf-8"));
-        }
-        catch {
-            // ignore
-        }
-    }
-    if (fs.existsSync(clinicPath)) {
-        try {
-            clinic = JSON.parse(fs.readFileSync(clinicPath, "utf-8"));
-        }
-        catch {
-            // ignore
-        }
-    }
+    const { specGate, clinic } = loadRunDiagnostics(runDir);
     const fullMetadata = {
         run_id: runId,
         timestamp: new Date().toISOString(),
@@ -487,12 +455,9 @@ export function generateEvidenceReportFromRunDir(runDir, runId, metadata = {}) {
 /**
  * Evidence Report를 파일로 저장
  */
-export function saveEvidenceReport(runsDir, runId, metadata = {}) {
-    const report = generateEvidenceReport(runsDir, runId, metadata);
-    const outputPath = path.join(runsDir, runId, "ci", "evidence_report.md");
-    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-    fs.writeFileSync(outputPath, report);
-    return outputPath;
+export async function saveEvidenceReport(runsDir, runId, metadata = {}) {
+    const report = await generateEvidenceReport(runsDir, runId, metadata);
+    return writeRunMarkdown(path.join(runsDir, runId), path.join("ci", "evidence_report.md"), report);
 }
 /**
  * Evidence Report 저장 (runDir = `.vibe/runs/<run_id>`)
@@ -500,66 +465,16 @@ export function saveEvidenceReport(runsDir, runId, metadata = {}) {
  */
 export function saveEvidenceReportFromRunDir(runDir, runId, metadata = {}) {
     const report = generateEvidenceReportFromRunDir(runDir, runId, metadata);
-    const outputPath = path.join(runDir, "ci", "evidence_report.md");
-    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-    fs.writeFileSync(outputPath, report);
-    return outputPath;
+    return writeRunMarkdown(runDir, path.join("ci", "evidence_report.md"), report);
 }
 /**
  * PR 코멘트용 간략 요약 생성
  */
 export function generatePrComment(runsDir, runId, metadata = {}, skeleton, decisionLog, hotspots) {
     const generator = new EvidenceReportGenerator();
-    const gatePath = path.join(runsDir, runId, "gate", "spec_gate_result.json");
-    const clinicPath = path.join(runsDir, runId, "clinic", "clinic_result.json");
-    const skeletonPath = path.join(runsDir, runId, "ci", "skeleton_map_summary.json");
-    let specGate = null;
-    let clinic = null;
-    let skeletonData = skeleton;
-    if (fs.existsSync(gatePath)) {
-        try {
-            specGate = JSON.parse(fs.readFileSync(gatePath, "utf-8"));
-        }
-        catch {
-            // ignore
-        }
-    }
-    if (fs.existsSync(clinicPath)) {
-        try {
-            clinic = JSON.parse(fs.readFileSync(clinicPath, "utf-8"));
-        }
-        catch {
-            // ignore
-        }
-    }
-    // Skeleton 자동 읽기 (명시적으로 전달되지 않은 경우)
-    if (!skeletonData) {
-        if (fs.existsSync(skeletonPath)) {
-            try {
-                const rawSkeleton = JSON.parse(fs.readFileSync(skeletonPath, "utf-8"));
-                skeletonData = {
-                    status: "PRESENT",
-                    artifact_path: skeletonPath,
-                    saved_by_skeleton: rawSkeleton.saved_by_skeleton,
-                    focus: rawSkeleton.focus ?? null,
-                };
-            }
-            catch {
-                skeletonData = {
-                    status: "ERROR",
-                    artifact_path: null,
-                    focus: null,
-                };
-            }
-        }
-        else {
-            skeletonData = {
-                status: "MISSING",
-                artifact_path: null,
-                focus: null,
-            };
-        }
-    }
+    const runDir = path.join(runsDir, runId);
+    const { specGate, clinic } = loadRunDiagnostics(runDir);
+    const skeletonData = (skeleton ?? loadSkeletonSummary(runDir));
     const fullMetadata = {
         run_id: runId,
         timestamp: new Date().toISOString(),
@@ -572,55 +487,8 @@ export function generatePrComment(runsDir, runId, metadata = {}, skeleton, decis
  */
 export function generatePrCommentFromRunDir(runDir, runId, metadata = {}, skeleton, decisionLog, hotspots) {
     const generator = new EvidenceReportGenerator();
-    const gatePath = path.join(runDir, "gate", "spec_gate_result.json");
-    const clinicPath = path.join(runDir, "clinic", "clinic_result.json");
-    const skeletonPath = path.join(runDir, "ci", "skeleton_map_summary.json");
-    let specGate = null;
-    let clinic = null;
-    let skeletonData = skeleton;
-    if (fs.existsSync(gatePath)) {
-        try {
-            specGate = JSON.parse(fs.readFileSync(gatePath, "utf-8"));
-        }
-        catch {
-            // ignore
-        }
-    }
-    if (fs.existsSync(clinicPath)) {
-        try {
-            clinic = JSON.parse(fs.readFileSync(clinicPath, "utf-8"));
-        }
-        catch {
-            // ignore
-        }
-    }
-    if (!skeletonData) {
-        if (fs.existsSync(skeletonPath)) {
-            try {
-                const rawSkeleton = JSON.parse(fs.readFileSync(skeletonPath, "utf-8"));
-                skeletonData = {
-                    status: "PRESENT",
-                    artifact_path: skeletonPath,
-                    saved_by_skeleton: rawSkeleton.saved_by_skeleton,
-                    focus: rawSkeleton.focus ?? null,
-                };
-            }
-            catch {
-                skeletonData = {
-                    status: "ERROR",
-                    artifact_path: null,
-                    focus: null,
-                };
-            }
-        }
-        else {
-            skeletonData = {
-                status: "MISSING",
-                artifact_path: null,
-                focus: null,
-            };
-        }
-    }
+    const { specGate, clinic } = loadRunDiagnostics(runDir);
+    const skeletonData = (skeleton ?? loadSkeletonSummary(runDir));
     const fullMetadata = {
         run_id: runId,
         timestamp: new Date().toISOString(),
@@ -641,8 +509,5 @@ export function savePrComment(runsDir, runId, metadata = {}, skeleton, decisionL
  */
 export function savePrCommentFromRunDir(runDir, runId, metadata = {}, skeleton, decisionLog, hotspots) {
     const comment = generatePrCommentFromRunDir(runDir, runId, metadata, skeleton, decisionLog, hotspots);
-    const outputPath = path.join(runDir, "ci", "pr_comment.md");
-    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-    fs.writeFileSync(outputPath, comment);
-    return outputPath;
+    return writeRunMarkdown(runDir, path.join("ci", "pr_comment.md"), comment);
 }

package/build/gateway/client.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Gateway Client
+ * ==============
+ * HTTP client for Prime gateway registration and heartbeat.
+ *
+ * Uses native fetch + AbortController (same pattern as coordinator/client.ts).
+ * All functions are fire-and-forget: network failures never break the caller.
+ *
+ * @module gateway/client
+ */
+import type { GatewayConfig } from './config.js';
+export interface RegistrationResult {
+    ok: boolean;
+    message: string;
+}
+export interface HeartbeatResult {
+    ok: boolean;
+    ttlSecs?: number;
+}
+/**
+ * Register this Vibe PM instance with the Prime gateway.
+ * Returns { ok: true } on success, { ok: false } on any error.
+ */
+export declare function registerWithGateway(config: GatewayConfig): Promise<RegistrationResult>;
+/**
+ * Send heartbeat to Prime gateway.
+ * Returns { ok: true } on success.
+ */
+export declare function sendHeartbeat(config: GatewayConfig): Promise<HeartbeatResult>;
+/**
+ * Deregister from gateway. Currently a no-op: the server relies on heartbeat
+ * TTL expiry (60s) rather than an explicit DELETE route. Stopping heartbeats
+ * is sufficient for the node to be purged from the registry.
+ */
+export declare function deregisterFromGateway(_config: GatewayConfig): Promise<void>;

package/build/gateway/client.js

@@ -0,0 +1,98 @@
+/**
+ * Gateway Client
+ * ==============
+ * HTTP client for Prime gateway registration and heartbeat.
+ *
+ * Uses native fetch + AbortController (same pattern as coordinator/client.ts).
+ * All functions are fire-and-forget: network failures never break the caller.
+ *
+ * @module gateway/client
+ */
+import { fetchWithTimeout } from '../shared/http_client.js';
+import { logger } from '../shared/logger.js';
+const debug = process.env.VIBECODE_DEBUG === '1';
+// ============================================================================
+// Internal Helpers
+// ============================================================================
+function authHeaders(config) {
+    const headers = { 'Content-Type': 'application/json' };
+    if (config.authToken) {
+        headers['Authorization'] = `Bearer ${config.authToken}`;
+    }
+    return headers;
+}
+// ============================================================================
+// API Functions
+// ============================================================================
+/** Vibe PM capabilities registered with the gateway. */
+const CAPABILITIES = ['code_inspection', 'gate', 'briefing'];
+/**
+ * Register this Vibe PM instance with the Prime gateway.
+ * Returns { ok: true } on success, { ok: false } on any error.
+ */
+export async function registerWithGateway(config) {
+    const url = `${config.primeUrl}/v1/gateway/register`;
+    const body = JSON.stringify({
+        node_id: config.nodeId,
+        address: config.hubUrl,
+        port: config.hubPort,
+        capabilities: [...CAPABILITIES],
+        metadata: {
+            product: 'vibe-pm',
+            callback_url: `${config.hubUrl}/v1/callback/dispatch`,
+        },
+    });
+    try {
+        const resp = await fetchWithTimeout(url, {
+            method: 'POST',
+            headers: authHeaders(config),
+            body,
+        }, config.timeoutMs);
+        if (resp.ok) {
+            if (debug)
+                logger.error(`[gateway] Registered with Prime (${config.primeUrl})`);
+            return { ok: true, message: 'registered' };
+        }
+        const text = await resp.text().catch(() => '');
+        if (debug)
+            logger.error(`[gateway] Registration rejected: ${resp.status} ${text}`);
+        return { ok: false, message: `status ${resp.status}` };
+    }
+    catch (e) {
+        if (debug) {
+            logger.error(`[gateway] Registration error: ${e instanceof Error ? e.message : e}`);
+        }
+        return { ok: false, message: e instanceof Error ? e.message : String(e) };
+    }
+}
+/**
+ * Send heartbeat to Prime gateway.
+ * Returns { ok: true } on success.
+ */
+export async function sendHeartbeat(config) {
+    const url = `${config.primeUrl}/v1/gateway/heartbeat`;
+    const body = JSON.stringify({ node_id: config.nodeId });
+    try {
+        const resp = await fetchWithTimeout(url, {
+            method: 'POST',
+            headers: authHeaders(config),
+            body,
+        }, config.timeoutMs);
+        if (resp.ok) {
+            const data = await resp.json().catch(() => ({}));
+            return { ok: true, ttlSecs: data.ttl_secs };
+        }
+        return { ok: false };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+/**
+ * Deregister from gateway. Currently a no-op: the server relies on heartbeat
+ * TTL expiry (60s) rather than an explicit DELETE route. Stopping heartbeats
+ * is sufficient for the node to be purged from the registry.
+ */
+export async function deregisterFromGateway(_config) {
+    // Intentional no-op — heartbeat TTL expiry handles deregistration.
+}

package/build/gateway/config.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Gateway Config
+ * ==============
+ * Environment variable resolution for Prime gateway registration.
+ *
+ * Activation: Set MUSU_PRIME_URL to enable gateway registration.
+ * If not set, all gateway functions gracefully no-op.
+ *
+ * @module gateway/config
+ */
+export declare const GW_ENV: {
+    /** Prime gateway base URL. If unset, gateway is disabled. */
+    readonly PRIME_URL: "MUSU_PRIME_URL";
+    /** Override node ID (default: vibe-pm-<hostname>) */
+    readonly NODE_ID: "VIBE_GATEWAY_NODE_ID";
+    /** Heartbeat interval in seconds (default: 30) */
+    readonly HEARTBEAT_SECS: "VIBE_GATEWAY_HEARTBEAT_SECS";
+    /** HTTP request timeout in ms (default: 5000) */
+    readonly TIMEOUT_MS: "VIBE_GATEWAY_TIMEOUT_MS";
+    /** Bearer token for gateway auth (optional) */
+    readonly AUTH_TOKEN: "MUSU_SHARED_SECRET";
+};
+export interface GatewayConfig {
+    primeUrl: string;
+    nodeId: string;
+    heartbeatSecs: number;
+    timeoutMs: number;
+    authToken: string | null;
+    /** Hub server URL that Prime can call back to */
+    hubUrl: string;
+    hubPort: number;
+}
+/**
+ * Returns true if gateway registration is enabled (MUSU_PRIME_URL is set).
+ */
+export declare function isGatewayEnabled(): boolean;
+/**
+ * Build gateway config from environment.
+ * Only call after checking `isGatewayEnabled()`.
+ */
+export declare function getGatewayConfig(hubUrl: string, hubPort: number): GatewayConfig;