@aria_asi/cli 0.2.30 → 0.2.32

package/dist/runtime/workflow-engine.mjs

@@ -0,0 +1,322 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { randomUUID } from 'node:crypto';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const STATE_DIR = join(__dirname, '..', 'state');
+
+function ensureDir(p) {
+  if (!existsSync(p)) mkdirSync(p, { recursive: true });
+}
+
+function workflowsPath(tenantId) {
+  return join(STATE_DIR, `workflows-${tenantId}.json`);
+}
+
+const WORKFLOW_TEMPLATES = {
+  'lead-qualification-pipeline': {
+    id: 'lead-qualification-pipeline',
+    archetype: 'leadQualifier',
+    name: 'Lead Qualification Pipeline',
+    description: 'Receive inbound lead, classify, enrich data, score, and route to appropriate agent',
+    steps: [
+      { name: 'receive_and_classify', type: 'receive', description: 'Receive lead input and classify by source and intent' },
+      { name: 'enrich_data', type: 'enrich', description: 'Look up additional data points for the lead' },
+      { name: 'score_and_route', type: 'score', description: 'Score the lead and determine routing' },
+      { name: 'approval_gate', type: 'approve', description: 'Confirm routing decision (auto-approve if score above threshold)', autoApprove: { field: 'score', operator: '>=', value: 80 } },
+      { name: 'execute_routing', type: 'execute', description: 'Route lead to assigned agent or pipeline' },
+      { name: 'log_and_notify', type: 'log', description: 'Log the qualification result and notify relevant agents' },
+    ],
+    escalation: { to: 'directorOfSales', condition: 'score >= 90' },
+    retryPolicy: { maxAttempts: 3, backoffMs: 5000 },
+  },
+  'deal-evaluation-pipeline': {
+    id: 'deal-evaluation-pipeline',
+    archetype: 'dealAnalyzer',
+    name: 'Deal Evaluation Pipeline',
+    description: 'Collect deal data, compare terms, assess risk, and provide recommendation',
+    steps: [
+      { name: 'collect_deal_data', type: 'receive', description: 'Gather all deal parameters and context' },
+      { name: 'compare_terms', type: 'enrich', description: 'Compare against historical deals and market benchmarks' },
+      { name: 'risk_assessment', type: 'score', description: 'Evaluate financial, operational, and strategic risks' },
+      { name: 'recommend', type: 'execute', description: 'Generate go/no-go recommendation with rationale' },
+    ],
+    escalation: { to: 'directorOfFinance', condition: 'risk_level == high' },
+    retryPolicy: { maxAttempts: 2, backoffMs: 10000 },
+  },
+  'outreach-sequence': {
+    id: 'outreach-sequence',
+    archetype: 'outboundCloser',
+    name: 'Outreach Sequence',
+    description: 'Target selection, initial contact, follow-up, objection handling, and close',
+    steps: [
+      { name: 'target_selection', type: 'receive', description: 'Identify target prospects based on criteria' },
+      { name: 'initial_contact', type: 'execute', description: 'Send initial outreach message' },
+      { name: 'follow_up', type: 'execute', description: 'Send follow-up based on prospect engagement' },
+      { name: 'objection_handle', type: 'score', description: 'Address objections and refine approach' },
+      { name: 'close', type: 'execute', description: 'Attempt to close or schedule next action' },
+    ],
+    escalation: { to: 'directorOfSales', condition: 'stage == stalled > 3 days' },
+    retryPolicy: { maxAttempts: 5, backoffMs: 86400000 },
+  },
+  'content-calendar': {
+    id: 'content-calendar',
+    archetype: 'contentStrategist',
+    name: 'Content Calendar',
+    description: 'Plan content topics, draft, review, publish, and measure performance',
+    steps: [
+      { name: 'plan_topics', type: 'receive', description: 'Generate content calendar based on strategy and trends' },
+      { name: 'draft_content', type: 'execute', description: 'Create initial content draft' },
+      { name: 'review', type: 'approve', description: 'Review for quality, brand alignment, and compliance' },
+      { name: 'publish', type: 'execute', description: 'Publish approved content to designated channels' },
+      { name: 'measure', type: 'score', description: 'Track performance metrics and feed back into planning' },
+    ],
+    escalation: { to: 'directorOfMarketing', condition: 'engagement < threshold' },
+    retryPolicy: { maxAttempts: 2, backoffMs: 0 },
+  },
+  'deal-lifecycle': {
+    id: 'deal-lifecycle',
+    archetype: 'transactionCoordinator',
+    name: 'Deal Lifecycle',
+    description: 'Initiate deal, track milestones, coordinate stakeholders, verify, and close',
+    steps: [
+      { name: 'initiate', type: 'receive', description: 'Create deal record and assign stakeholders' },
+      { name: 'track_milestones', type: 'enrich', description: 'Monitor and update milestone progress' },
+      { name: 'coordinate', type: 'execute', description: 'Coordinate between parties and resolve blockers' },
+      { name: 'verify', type: 'score', description: 'Final verification of all requirements and documents' },
+      { name: 'close', type: 'execute', description: 'Execute close and update records' },
+    ],
+    escalation: { to: 'chiefOfStaff', condition: 'blocker unresolved > 48h' },
+    retryPolicy: { maxAttempts: 3, backoffMs: 3600000 },
+  },
+  'reporting-cycle': {
+    id: 'reporting-cycle',
+    archetype: 'financialAnalyst',
+    name: 'Reporting Cycle',
+    description: 'Collect financial data, reconcile, analyze, forecast, and produce reports',
+    steps: [
+      { name: 'collect_data', type: 'receive', description: 'Gather financial data from all sources' },
+      { name: 'reconcile', type: 'enrich', description: 'Cross-reference and reconcile discrepancies' },
+      { name: 'analyze', type: 'score', description: 'Perform variance analysis and trend detection' },
+      { name: 'forecast', type: 'enrich', description: 'Generate forward-looking projections' },
+      { name: 'produce_report', type: 'execute', description: 'Compile and distribute report' },
+    ],
+    escalation: { to: 'directorOfFinance', condition: 'variance > 10%' },
+    retryPolicy: { maxAttempts: 2, backoffMs: 0 },
+  },
+  'audit-trail': {
+    id: 'audit-trail',
+    archetype: 'compliance-guard',
+    name: 'Audit Trail',
+    description: 'Monitor activity, flag anomalies, investigate, remediate, and document',
+    steps: [
+      { name: 'monitor', type: 'receive', description: 'Continuously monitor agent outputs and actions' },
+      { name: 'flag', type: 'score', description: 'Flag potential compliance issues or anomalies' },
+      { name: 'investigate', type: 'enrich', description: 'Investigate flagged items for root cause' },
+      { name: 'remediate', type: 'execute', description: 'Apply corrective actions for confirmed violations' },
+      { name: 'document', type: 'log', description: 'Document findings and update compliance records' },
+    ],
+    escalation: { to: 'chiefOfStaff', condition: 'severity == critical' },
+    retryPolicy: { maxAttempts: 3, backoffMs: 5000 },
+  },
+};
+
+export function listWorkflowTemplates() {
+  return Object.values(WORKFLOW_TEMPLATES).map(t => ({
+    id: t.id,
+    archetype: t.archetype,
+    name: t.name,
+    description: t.description,
+    stepCount: t.steps.length,
+    hasApprovalGate: t.steps.some(s => s.type === 'approve'),
+    escalation: t.escalation,
+  }));
+}
+
+export function getWorkflowTemplate(workflowId) {
+  return WORKFLOW_TEMPLATES[workflowId] || null;
+}
+
+export function configureWorkflow(tenantId, workflowId, config = {}) {
+  const template = WORKFLOW_TEMPLATES[workflowId];
+  if (!template) return { ok: false, error: `Unknown workflow: ${workflowId}. Available: ${Object.keys(WORKFLOW_TEMPLATES).join(', ')}` };
+  const pp = workflowsPath(tenantId);
+  let state = existsSync(pp) ? JSON.parse(readFileSync(pp, 'utf-8')) : { configured: [], instances: [] };
+  const existing = state.configured.findIndex(w => w.id === workflowId);
+  const entry = {
+    id: workflowId,
+    templateId: workflowId,
+    config: {
+      agentId: config.agentId || null,
+      trigger: config.trigger || { type: 'manual' },
+      autoApproveThreshold: config.autoApproveThreshold ?? template.steps.find(s => s.type === 'approve')?.autoApprove?.value ?? 80,
+      customSteps: config.customSteps || null,
+      escalationOverride: config.escalationOverride || null,
+      ...config,
+    },
+    configuredAt: new Date().toISOString(),
+  };
+  if (existing >= 0) state.configured[existing] = entry; else state.configured.push(entry);
+  ensureDir(dirname(pp));
+  writeFileSync(pp, JSON.stringify(state, null, 2));
+  return { ok: true, workflow: entry };
+}
+
+export function startWorkflow(tenantId, workflowId, initialPayload = {}) {
+  const template = WORKFLOW_TEMPLATES[workflowId];
+  if (!template) return { ok: false, error: `Unknown workflow: ${workflowId}` };
+  const pp = workflowsPath(tenantId);
+  let state = existsSync(pp) ? JSON.parse(readFileSync(pp, 'utf-8')) : { configured: [], instances: [] };
+  const instance = {
+    instanceId: randomUUID(),
+    workflowId,
+    templateId: workflowId,
+    status: 'running',
+    currentStep: 0,
+    steps: template.steps.map((s, i) => ({
+      ...s,
+      index: i,
+      status: i === 0 ? 'active' : 'pending',
+      startedAt: i === 0 ? new Date().toISOString() : null,
+      completedAt: null,
+      attempts: 0,
+      result: null,
+    })),
+    payload: initialPayload,
+    history: [{ event: 'started', at: new Date().toISOString(), step: 0 }],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+  state.instances.push(instance);
+  ensureDir(dirname(pp));
+  writeFileSync(pp, JSON.stringify(state, null, 2));
+  return { ok: true, instance };
+}
+
+export function advanceWorkflow(tenantId, instanceId, stepResult = {}) {
+  const pp = workflowsPath(tenantId);
+  if (!existsSync(pp)) return { ok: false, error: 'No workflows configured' };
+  let state = JSON.parse(readFileSync(pp, 'utf-8'));
+  const instance = (state.instances || []).find(i => i.instanceId === instanceId);
+  if (!instance) return { ok: false, error: `Instance ${instanceId} not found` };
+  if (instance.status !== 'running') return { ok: false, error: `Workflow is ${instance.status}` };
+  const current = instance.steps[instance.currentStep];
+  if (!current) return { ok: false, error: 'No current step' };
+  current.status = 'completed';
+  current.completedAt = new Date().toISOString();
+  current.result = stepResult;
+  instance.history.push({ event: 'step_completed', step: instance.currentStep, result: stepResult, at: new Date().toISOString() });
+  const template = WORKFLOW_TEMPLATES[instance.workflowId];
+  const nextIdx = instance.currentStep + 1;
+  if (nextIdx >= instance.steps.length) {
+    instance.status = 'completed';
+    instance.currentStep = -1;
+    instance.history.push({ event: 'workflow_completed', at: new Date().toISOString() });
+  } else {
+    const nextStep = instance.steps[nextIdx];
+    if (nextStep.type === 'approve') {
+      const autoApprove = nextStep.autoApprove || template?.steps[nextIdx]?.autoApprove;
+      const shouldAutoApprove = autoApprove && stepResult[autoApprove.field] !== undefined &&
+        ((autoApprove.operator === '>=' && stepResult[autoApprove.field] >= autoApprove.value) ||
+         (autoApprove.operator === '>' && stepResult[autoApprove.field] > autoApprove.value) ||
+         (autoApprove.operator === '==' && stepResult[autoApprove.field] == autoApprove.value));
+      if (shouldAutoApprove) {
+        nextStep.status = 'completed';
+        nextStep.completedAt = new Date().toISOString();
+        nextStep.result = { autoApproved: true };
+        instance.history.push({ event: 'auto_approved', step: nextIdx, at: new Date().toISOString() });
+        const afterNext = nextIdx + 1;
+        if (afterNext < instance.steps.length) {
+          instance.currentStep = afterNext;
+          instance.steps[afterNext].status = 'active';
+          instance.steps[afterNext].startedAt = new Date().toISOString();
+        } else {
+          instance.status = 'completed';
+          instance.currentStep = -1;
+          instance.history.push({ event: 'workflow_completed', at: new Date().toISOString() });
+        }
+      } else {
+        nextStep.status = 'awaiting_approval';
+        nextStep.startedAt = new Date().toISOString();
+        instance.currentStep = nextIdx;
+        instance.status = 'awaiting_approval';
+        instance.history.push({ event: 'awaiting_approval', step: nextIdx, at: new Date().toISOString() });
+      }
+    } else {
+      instance.currentStep = nextIdx;
+      nextStep.status = 'active';
+      nextStep.startedAt = new Date().toISOString();
+    }
+  }
+  instance.updatedAt = new Date().toISOString();
+  writeFileSync(pp, JSON.stringify(state, null, 2));
+  return { ok: true, instance };
+}
+
+export function approveWorkflowStep(tenantId, instanceId, approved = true) {
+  const pp = workflowsPath(tenantId);
+  if (!existsSync(pp)) return { ok: false, error: 'No workflows configured' };
+  let state = JSON.parse(readFileSync(pp, 'utf-8'));
+  const instance = (state.instances || []).find(i => i.instanceId === instanceId);
+  if (!instance) return { ok: false, error: `Instance ${instanceId} not found` };
+  if (instance.status !== 'awaiting_approval') return { ok: false, error: 'Workflow is not awaiting approval' };
+  const current = instance.steps[instance.currentStep];
+  if (!current) return { ok: false, error: 'No current step' };
+  if (approved) {
+    current.status = 'completed';
+    current.completedAt = new Date().toISOString();
+    current.result = { approved: true, approvedAt: new Date().toISOString() };
+    instance.history.push({ event: 'approved', step: instance.currentStep, at: new Date().toISOString() });
+    instance.status = 'running';
+    const nextIdx = instance.currentStep + 1;
+    if (nextIdx < instance.steps.length) {
+      instance.currentStep = nextIdx;
+      instance.steps[nextIdx].status = 'active';
+      instance.steps[nextIdx].startedAt = new Date().toISOString();
+    } else {
+      instance.status = 'completed';
+      instance.currentStep = -1;
+      instance.history.push({ event: 'workflow_completed', at: new Date().toISOString() });
+    }
+  } else {
+    current.status = 'rejected';
+    current.completedAt = new Date().toISOString();
+    current.result = { approved: false, rejectedAt: new Date().toISOString() };
+    instance.status = 'rejected';
+    instance.history.push({ event: 'rejected', step: instance.currentStep, at: new Date().toISOString() });
+  }
+  instance.updatedAt = new Date().toISOString();
+  writeFileSync(pp, JSON.stringify(state, null, 2));
+  return { ok: true, instance };
+}
+
+export function getWorkflowStatus(tenantId) {
+  const pp = workflowsPath(tenantId);
+  if (!existsSync(pp)) return { tenantId, configured: [], instances: [], summary: null };
+  const state = JSON.parse(readFileSync(pp, 'utf-8'));
+  const instances = state.instances || [];
+  const summary = {
+    total: instances.length,
+    running: instances.filter(i => i.status === 'running').length,
+    completed: instances.filter(i => i.status === 'completed').length,
+    awaitingApproval: instances.filter(i => i.status === 'awaiting_approval').length,
+    rejected: instances.filter(i => i.status === 'rejected').length,
+  };
+  return { tenantId, configured: state.configured || [], instances: instances.map(i => ({
+    instanceId: i.instanceId,
+    workflowId: i.workflowId,
+    status: i.status,
+    currentStep: i.currentStep >= 0 ? i.steps[i.currentStep]?.name : null,
+    progress: `${i.steps.filter(s => s.status === 'completed').length}/${i.steps.length}`,
+    createdAt: i.createdAt,
+    updatedAt: i.updatedAt,
+  })), summary };
+}
+
+export function getWorkflowInstance(tenantId, instanceId) {
+  const pp = workflowsPath(tenantId);
+  if (!existsSync(pp)) return null;
+  const state = JSON.parse(readFileSync(pp, 'utf-8'));
+  return (state.instances || []).find(i => i.instanceId === instanceId) || null;
+}

package/dist/sdk/BUNDLED.json

@@ -1,5 +1,5 @@
 {
-  "bundledAt": "2026-04-29T23:30:47.359Z",
+  "bundledAt": "2026-05-01T20:07:31.757Z",
   "sdkSource": "/home/hamzaibrahim1/rei-ai-brain/harness/packages/harness-http-client/dist",
   "files": 6
 }

package/dist/sdk/index.d.ts

@@ -150,6 +150,11 @@ export interface ValidationResult {
     severity: 'pass' | 'warn' | 'block';
     rewritten?: string;
     gateTriggers: string[];
+    appliedCognition?: {
+        ok: boolean;
+        contract?: string;
+        violations?: string[];
+    };
 }
 export interface ActionCheck {
     allowed: boolean;
@@ -260,7 +265,14 @@ export declare class HTTPHarnessClient {
     private cachedPacket;
     private packetLastFetched;
     private readonly packetTtlMs;
+    private preferredBaseUrl;
+    private readonly baseUrlCandidates;
     constructor(config: HarnessClientConfig);
+    private buildBaseUrlCandidates;
+    private isRouteEligibleForBaseFailover;
+    private candidateUrlsFor;
+    private shouldFailoverResponse;
+    private promoteSuccessfulBase;
     private extractHarnessText;
     private normalizePlanDocs;
     private collectPlanFilePaths;

package/dist/sdk/index.js

@@ -3,6 +3,32 @@ import { existsSync, readFileSync, statSync } from 'node:fs';
 import { homedir as _homedir } from 'node:os';
 import { resolve, isAbsolute } from 'node:path';
 import { randomUUID } from 'node:crypto';
+const CLOUD_RUN_SOUL_URL = 'https://arias-soul-6zp3gtk2ca-uc.a.run.app';
+const PUBLIC_HARNESS_URL = 'https://harness.ariasos.com';
+const LOCAL_HARNESS_CANDIDATES = [
+    'http://127.0.0.1:30080',
+    'http://192.168.4.25:30080',
+];
+const FAILOVER_STATUS_CODES = new Set([404, 405, 501, 502, 503, 504]);
+function isMountedRuntimeBaseUrl(baseUrl) {
+    return /:\/\/(?:127\.0\.0\.1|localhost):4319$/i.test(String(baseUrl || '').replace(/\/+$/, ''));
+}
+function normalizeHarnessPacketPayload(payload) {
+    let current = payload;
+    for (let depth = 0; depth < 3; depth++) {
+        if (!current || typeof current !== 'object' || Array.isArray(current))
+            break;
+        const nested = current.packet;
+        if (!nested || typeof nested !== 'object' || Array.isArray(nested))
+            break;
+        if (typeof current.timestamp !== 'string' && typeof current.version !== 'string')
+            break;
+        current = nested;
+    }
+    return (current && typeof current === 'object' && !Array.isArray(current))
+        ? current
+        : {};
+}
 // ── 8-Lens Cognition Block ─────────────────────────────────────────────────
 const EIGHT_LENS_BLOCK = `[ARIA SHELL PROTOCOL — You are a controlled surface]
 
@@ -43,11 +69,17 @@ export class HTTPHarnessClient {
     cachedPacket = null;
     packetLastFetched = 0;
     packetTtlMs = 60_000;
+    preferredBaseUrl;
+    baseUrlCandidates;
     constructor(config) {
         this.baseUrl = config.baseUrl.replace(/\/+$/, '');
         this.apiKey = config.apiKey;
-        this.harnessPacketUrl = config.harnessPacketUrl ?? `${this.baseUrl}/api/harness/codex`;
+        this.harnessPacketUrl = config.harnessPacketUrl ?? (isMountedRuntimeBaseUrl(this.baseUrl)
+            ? `${this.baseUrl}/packet`
+            : `${this.baseUrl}/api/harness/codex`);
         this.workspaceRoot = config.workspaceRoot ?? process.cwd();
+        this.preferredBaseUrl = this.baseUrl;
+        this.baseUrlCandidates = this.buildBaseUrlCandidates(config.baseUrl);
         // Layer 3 — sub-agent disk-cache bootstrap (#84).
         // If ARIA_HARNESS_PACKET_PATH is set (injected by aria-agent-handoff.mjs
         // or spawnSubAgent), OR the owner-tier handoff JSON at
@@ -57,6 +89,65 @@ export class HTTPHarnessClient {
         // TTL is 5 min (matches handoff TTL). Stale packets trigger normal fetch.
         this._tryLoadDiskPacket();
     }
+    buildBaseUrlCandidates(primaryBaseUrl) {
+        const envFallbacks = String(process.env.ARIA_HARNESS_FALLBACK_URLS || '')
+            .split(',')
+            .map((value) => value.trim())
+            .filter(Boolean);
+        const candidates = [
+            primaryBaseUrl,
+            process.env.ARIA_HIVE_RUNTIME_URL || '',
+            process.env.ARIA_HARNESS_BASE_URL || '',
+            process.env.ARIA_HARNESS_URL || '',
+            process.env.ARIA_SOUL_URL || '',
+            process.env.ARIAS_SOUL_URL || '',
+            process.env.ARIA_SOUL_BASE_URL || '',
+            ...envFallbacks,
+            ...LOCAL_HARNESS_CANDIDATES,
+            CLOUD_RUN_SOUL_URL,
+            PUBLIC_HARNESS_URL,
+        ]
+            .map((value) => String(value || '').trim().replace(/\/+$/, ''))
+            .filter(Boolean);
+        return Array.from(new Set(candidates));
+    }
+    isRouteEligibleForBaseFailover(url) {
+        return (url.pathname.startsWith('/api/harness/') ||
+            url.pathname === '/api/garden/fire' ||
+            url.pathname.startsWith('/api/cognition/'));
+    }
+    candidateUrlsFor(targetUrl) {
+        let parsed;
+        try {
+            parsed = new URL(targetUrl);
+        }
+        catch {
+            return [targetUrl];
+        }
+        if (!this.isRouteEligibleForBaseFailover(parsed)) {
+            return [targetUrl];
+        }
+        const pathAndQuery = `${parsed.pathname}${parsed.search}`;
+        const orderedBases = [
+            this.preferredBaseUrl,
+            ...this.baseUrlCandidates,
+        ]
+            .map((value) => value.replace(/\/+$/, ''))
+            .filter(Boolean);
+        return Array.from(new Set(orderedBases)).map((baseUrl) => `${baseUrl}${pathAndQuery}`);
+    }
+    shouldFailoverResponse(response, url) {
+        if (!this.isRouteEligibleForBaseFailover(url))
+            return false;
+        return FAILOVER_STATUS_CODES.has(response.status);
+    }
+    promoteSuccessfulBase(targetUrl) {
+        try {
+            const parsed = new URL(targetUrl);
+            this.preferredBaseUrl = parsed.origin;
+        }
+        catch { }
+    }
     extractHarnessText(packet) {
         const raw = packet?.harness;
         return typeof raw === 'string' ? raw.trim() : '';
@@ -230,7 +321,7 @@ export class HTTPHarnessClient {
             const raw = JSON.parse(readFileSync(packetPath, 'utf8'));
             // Packet on disk may be the raw API response (has .packet wrapper) or
             // a bare packet object. Normalise to HarnessPacket shape.
-            const packetData = (raw.packet ?? raw);
+            const packetData = normalizeHarnessPacketPayload(raw.packet ?? raw);
             this.cachedPacket = {
                 packet: packetData,
                 timestamp: new Date().toISOString(),
@@ -297,7 +388,7 @@ export class HTTPHarnessClient {
             }
             const body = (await res.json());
             this.cachedPacket = {
-                packet: (body.packet ?? body),
+                packet: normalizeHarnessPacketPayload(body.packet ?? body),
                 timestamp: new Date().toISOString(),
                 version: '1.0.0',
             };
@@ -312,7 +403,7 @@ export class HTTPHarnessClient {
             if (envPacket) {
                 try {
                     this.cachedPacket = {
-                        packet: JSON.parse(envPacket),
+                        packet: normalizeHarnessPacketPayload(JSON.parse(envPacket)),
                         timestamp: new Date().toISOString(),
                         version: '1.0.0',
                     };
@@ -768,7 +859,7 @@ export class HTTPHarnessClient {
                 resolvedPacketPath = packetPath;
                 // Also pre-load into this SDK instance's cache so subsequent
                 // getHarnessPacket() calls are instant within this process.
-                const packetPayload = (packetData.packet ?? packetData);
+                const packetPayload = normalizeHarnessPacketPayload(packetData.packet ?? packetData);
                 this.cachedPacket = {
                     packet: packetPayload,
                     timestamp: new Date().toISOString(),
@@ -1428,19 +1519,34 @@ export class HTTPHarnessClient {
     // codes — caller decides what to do with non-2xx). No circuit breaker:
     // we always try. Backoff: 250ms, 500ms, 1000ms (3 attempts total).
     async fetchWithRetry(url, init, attempts = 3) {
+        const candidateUrls = this.candidateUrlsFor(url);
         let lastErr;
-        for (let i = 0; i < attempts; i++) {
-            try {
-                return await fetch(url, init);
-            }
-            catch (err) {
-                lastErr = err;
-                if (i < attempts - 1) {
-                    const delay = 250 * Math.pow(2, i);
-                    await new Promise((r) => setTimeout(r, delay));
+        let lastResponse = null;
+        for (const candidateUrl of candidateUrls) {
+            for (let i = 0; i < attempts; i++) {
+                try {
+                    const response = await fetch(candidateUrl, init);
+                    lastResponse = response;
+                    const parsed = new URL(candidateUrl);
+                    if (this.shouldFailoverResponse(response, parsed) && candidateUrl !== candidateUrls[candidateUrls.length - 1]) {
+                        break;
+                    }
+                    if (response.ok) {
+                        this.promoteSuccessfulBase(candidateUrl);
+                    }
+                    return response;
+                }
+                catch (err) {
+                    lastErr = err;
+                    if (i < attempts - 1) {
+                        const delay = 250 * Math.pow(2, i);
+                        await new Promise((r) => setTimeout(r, delay));
+                    }
                 }
             }
         }
+        if (lastResponse)
+            return lastResponse;
         throw lastErr instanceof Error
             ? lastErr
             : new Error(`fetch failed after ${attempts} attempts: ${String(lastErr)}`);