@aria_asi/cli 0.2.29 → 0.2.31

package/runtime-src/fleet-engine.mjs

@@ -0,0 +1,231 @@
+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');
+const FLEET_DIR = join(STATE_DIR, 'fleets');
+
+function ensureDir(p) {
+  if (!existsSync(p)) mkdirSync(p, { recursive: true });
+}
+
+function fleetPath(tenantId) {
+  return join(FLEET_DIR, `${tenantId}.json`);
+}
+
+const ARCHETYPE_DEFAULTS = {
+  chiefOfStaff: {
+    systemPrompt: 'You are the Chief of Staff, the executive right hand. You synthesize cross-departmental intelligence, escalate critical decisions, and coordinate the management tier. Respond concisely with actionable directives.',
+    defaultKinds: ['hq:coordinate', 'hq:escalate', 'hq:brief'],
+  },
+  directorOfSales: {
+    systemPrompt: 'You are the Director of Sales. You set revenue targets, manage the sales pipeline, coach closers, and report to the Chief of Staff. Focus on conversion metrics and strategic accounts.',
+    defaultKinds: ['sales:strategy', 'sales:forecast', 'sales:coaching'],
+  },
+  directorOfMarketing: {
+    systemPrompt: 'You are the Director of Marketing. You own brand strategy, campaign planning, content direction, and market positioning. Data-driven creative decisions.',
+    defaultKinds: ['marketing:strategy', 'marketing:campaign', 'marketing:analytics'],
+  },
+  directorOfOperations: {
+    systemPrompt: 'You are the Director of Operations. You optimize workflows, manage resources, track SLAs, and ensure the business runs efficiently. Process obsession.',
+    defaultKinds: ['ops:optimize', 'ops:workflow', 'ops:resource'],
+  },
+  directorOfFinance: {
+    systemPrompt: 'You are the Director of Finance. You manage budgets, financial reporting, cash flow analysis, and financial risk. Precision and compliance.',
+    defaultKinds: ['finance:report', 'finance:forecast', 'finance:audit'],
+  },
+  directorOfHr: {
+    systemPrompt: 'You are the Director of HR. You handle talent acquisition, team culture, performance reviews, and compliance. People-first leadership.',
+    defaultKinds: ['hr:recruit', 'hr:review', 'hr:compliance'],
+  },
+  directorOfTechnology: {
+    systemPrompt: 'You are the Director of Technology. You oversee technical architecture, engineering velocity, system reliability, and technology strategy. Builder mindset.',
+    defaultKinds: ['tech:architect', 'tech:review', 'tech:deploy'],
+  },
+  directorOfCustomerSuccess: {
+    systemPrompt: 'You are the Director of Customer Success. You own retention, onboarding, expansion revenue, and customer advocacy. Relationship-driven growth.',
+    defaultKinds: ['cs:retain', 'cs:onboard', 'cs:expand'],
+  },
+  leadQualifier: {
+    systemPrompt: 'You are a Lead Qualifier. You score inbound leads, research prospects, enrich contact data, and route qualified leads to the appropriate closer. Speed and accuracy.',
+    defaultKinds: ['lead:qualify', 'lead:enrich', 'lead:route'],
+  },
+  dealAnalyzer: {
+    systemPrompt: 'You are a Deal Analyzer. You evaluate deal economics, assess risk, compare terms, and recommend whether to pursue, negotiate, or pass. Sharp analytical lens.',
+    defaultKinds: ['deal:analyze', 'deal:risk', 'deal:recommend'],
+  },
+  outboundCloser: {
+    systemPrompt: 'You are an Outbound Closer. You craft outreach sequences, handle objections, nurture prospects, and close deals. Persistent and persuasive.',
+    defaultKinds: ['outreach:sequence', 'outreach:followup', 'outreach:close'],
+  },
+  contentStrategist: {
+    systemPrompt: 'You are a Content Strategist. You plan editorial calendars, create content briefs, ensure brand consistency, and measure content performance. Creative meets analytical.',
+    defaultKinds: ['content:plan', 'content:create', 'content:measure'],
+  },
+  transactionCoordinator: {
+    systemPrompt: 'You are a Transaction Coordinator. You manage deal lifecycles, track milestones, coordinate stakeholders, and ensure nothing falls through the cracks. Detail-obsessed.',
+    defaultKinds: ['txn:coordinate', 'txn:track', 'txn:verify'],
+  },
+  financialAnalyst: {
+    systemPrompt: 'You are a Financial Analyst. You produce financial reports, reconcile accounts, build forecasts, and flag anomalies. Numbers tell the story.',
+    defaultKinds: ['finance:report', 'finance:reconcile', 'finance:forecast'],
+  },
+  dataAnalyst: {
+    systemPrompt: 'You are a Data Analyst. You extract insights from data, build dashboards, run analyses, and present findings. Data as a competitive weapon.',
+    defaultKinds: ['data:analyze', 'data:dashboard', 'data:insight'],
+  },
+};
+
+export function deployFleet(tenantId, fleetConfig, enqueueJob) {
+  ensureDir(FLEET_DIR);
+  const agents = (fleetConfig.agents || []).map((agentDef, idx) => {
+    const archetype = ARCHETYPE_DEFAULTS[agentDef.templateId] || ARCHETYPE_DEFAULTS.leadQualifier;
+    const agentId = agentDef.id || `${tenantId}-agent-${idx}`;
+    const workerId = `fleet:${tenantId}:${agentId}`;
+    return {
+      id: agentId,
+      workerId,
+      templateId: agentDef.templateId || 'leadQualifier',
+      name: agentDef.name || agentDef.templateId || `Agent ${idx + 1}`,
+      department: agentDef.department || fleetConfig.industry || 'unassigned',
+      tier: agentDef.tier || 2,
+      status: 'active',
+      systemPrompt: archetype.systemPrompt,
+      defaultKinds: archetype.defaultKinds,
+      capabilities: agentDef.capabilities || ['chat'],
+      config: agentDef.config || {},
+      lastActivity: null,
+      stats: { jobsCompleted: 0, totalTokens: 0, messagesSent: 0 },
+    };
+  });
+
+  const fleet = {
+    tenantId,
+    config: fleetConfig,
+    deployedAt: new Date().toISOString(),
+    status: 'deployed',
+    agents,
+    maxOpenClaws: fleetConfig.maxOpenClaws || 3,
+    industry: fleetConfig.industry || 'generic',
+    tier: fleetConfig.tier || 'starter',
+    plugins: fleetConfig.plugins || [],
+    llmPreference: fleetConfig.llmPreference || 'managed',
+  };
+
+  writeFileSync(fleetPath(tenantId), JSON.stringify(fleet, null, 2));
+
+  const workerRegistrations = [];
+  const initialJobs = [];
+
+  for (const agent of agents) {
+    workerRegistrations.push({
+      workerId: agent.workerId,
+      surface: 'fleet',
+      capabilities: agent.capabilities,
+      metadata: {
+        tenantId,
+        agentId: agent.id,
+        agentName: agent.name,
+        department: agent.department,
+        templateId: agent.templateId,
+        tier: agent.tier,
+      },
+    });
+
+    if (typeof enqueueJob === 'function') {
+      initialJobs.push({
+        kind: `fleet:${agent.id}:initialize`,
+        surface: 'fleet',
+        metadata: {
+          tenantId,
+          agentId: agent.id,
+          agentName: agent.name,
+          department: agent.department,
+          requestType: 'initialize',
+        },
+        payload: { agent, fleetConfig },
+        priority: 50 + idx,
+      });
+    }
+  }
+
+  return { fleet, workerRegistrations, initialJobs };
+}
+
+export function loadFleet(tenantId) {
+  const p = fleetPath(tenantId);
+  if (!existsSync(p)) return null;
+  return JSON.parse(readFileSync(p, 'utf-8'));
+}
+
+export function saveFleet(fleet) {
+  ensureDir(FLEET_DIR);
+  writeFileSync(fleetPath(fleet.tenantId), JSON.stringify(fleet, null, 2));
+  return fleet;
+}
+
+export function getAgent(fleet, agentId) {
+  return (fleet.agents || []).find(a => a.id === agentId || a.templateId === agentId) || null;
+}
+
+export function updateAgentActivity(fleet, agentId) {
+  const agent = getAgent(fleet, agentId);
+  if (agent) {
+    agent.lastActivity = new Date().toISOString();
+    agent.stats.messagesSent = (agent.stats.messagesSent || 0) + 1;
+    saveFleet(fleet);
+  }
+  return agent;
+}
+
+export function recordAgentJobCompletion(fleet, agentId, tokensUsed = 0) {
+  const agent = getAgent(fleet, agentId);
+  if (agent) {
+    agent.stats.jobsCompleted = (agent.stats.jobsCompleted || 0) + 1;
+    agent.stats.totalTokens = (agent.stats.totalTokens || 0) + tokensUsed;
+    agent.lastActivity = new Date().toISOString();
+    saveFleet(fleet);
+  }
+  return agent;
+}
+
+export function getFleetStatus(tenantId) {
+  const fleet = loadFleet(tenantId);
+  if (!fleet) return { tenantId, status: 'no-fleet', agents: [], summary: null };
+  const activeAgents = fleet.agents.filter(a => a.status === 'active').length;
+  const totalMessages = fleet.agents.reduce((sum, a) => sum + (a.stats?.messagesSent || 0), 0);
+  const totalJobs = fleet.agents.reduce((sum, a) => sum + (a.stats?.jobsCompleted || 0), 0);
+  return {
+    tenantId,
+    status: fleet.status,
+    deployedAt: fleet.deployedAt,
+    industry: fleet.industry,
+    tier: fleet.tier,
+    maxOpenClaws: fleet.maxOpenClaws,
+    activeAgents,
+    totalAgents: fleet.agents.length,
+    summary: { activeAgents, totalMessages, totalJobs },
+    agents: fleet.agents.map(a => ({
+      id: a.id,
+      name: a.name,
+      templateId: a.templateId,
+      department: a.department,
+      tier: a.tier,
+      status: a.status,
+      lastActivity: a.lastActivity,
+      stats: a.stats,
+    })),
+  };
+}
+
+export function buildAgentSystemPrompt(agent, fleetConfig) {
+  const industryContext = fleetConfig?.industry && fleetConfig.industry !== 'generic'
+    ? `\n\nIndustry context: ${fleetConfig.industry}. Tailor your responses to this industry.`
+    : '';
+  const deptContext = agent.department && agent.department !== 'unassigned'
+    ? `\nDepartment: ${agent.department}.`
+    : '';
+  return `${agent.systemPrompt || 'You are a helpful AI assistant.'}${deptContext}${industryContext}\n\nYou are part of a deployed AI workforce. Be professional, proactive, and results-oriented.`;
+}

package/runtime-src/harness-daemon.mjs

@@ -0,0 +1,433 @@
+#!/usr/bin/env node
+
+import { createServer } from 'node:http';
+import { createRequire } from 'node:module';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const require = createRequire(import.meta.url);
+const { runFullChain } = require('./vendor/aria-gate-runtime/index.js');
+
+const DEFAULT_HOST = process.env.ARIA_HARNESS_DAEMON_HOST || '127.0.0.1';
+const DEFAULT_PORT = Number(process.env.ARIA_HARNESS_DAEMON_PORT || 8790);
+const DEFAULT_URL = process.env.ARIA_HARNESS_DAEMON_URL || `http://${DEFAULT_HOST}:${DEFAULT_PORT}`;
+const UPSTREAM_HARNESS_URL =
+  process.env.ARIA_UPSTREAM_HARNESS_URL ||
+  process.env.ARIA_HIVE_UPSTREAM_URL ||
+  process.env.ARIA_SOUL_URL ||
+  process.env.ARIAS_SOUL_URL ||
+  process.env.ARIA_SOUL_BASE_URL ||
+  'https://harness.ariasos.com';
+const UPSTREAM_FORGE_URL =
+  process.env.ARIA_UPSTREAM_FORGE_SERVICE_URL ||
+  process.env.ARIA_FORGE_UPSTREAM_URL ||
+  `${UPSTREAM_HARNESS_URL.replace(/\/$/, '')}/api/forge/psi`;
+const PACKET_TTL_MS = Number(process.env.ARIA_HARNESS_PACKET_TTL_MS || 60000);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const STATE_DIR = join(__dirname, 'state');
+const LOCAL_PACKET_CACHE_PATH = join(STATE_DIR, 'harness-packet-cache.json');
+const LEGACY_PACKET_CACHE_CANDIDATES = [
+  join(process.env.HOME || '', '.aria', '.aria-harness-last-packet.json'),
+  join(process.env.HOME || '', '.claude', '.aria-harness-last-packet.json'),
+];
+const LOCAL_FIRST_PRINCIPLE = 'Truth over deception. No harm. Sacred trust. Power obligates service. Reflection before action.';
+
+let cachedPacketEnvelope = loadCachedPacketEnvelope();
+let refreshInFlight = null;
+let lastRefreshError = null;
+let lastRefreshStartedAt = null;
+let lastRefreshCompletedAt = cachedPacketEnvelope?.timestamp || null;
+
+function trimUrl(value) {
+  return String(value || '').trim().replace(/\/+$/, '');
+}
+
+function isLoopedUpstream(candidate) {
+  if (!candidate) return false;
+  return trimUrl(candidate) === trimUrl(DEFAULT_URL);
+}
+
+function json(res, status, payload) {
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
+  res.end(JSON.stringify(payload, null, 2));
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', (chunk) => chunks.push(chunk));
+    req.on('end', () => {
+      const raw = Buffer.concat(chunks).toString('utf8');
+      if (!raw.trim()) {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(raw));
+      } catch (error) {
+        reject(new Error(`invalid JSON body: ${error instanceof Error ? error.message : String(error)}`));
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+function readBearer(req) {
+  const header = req.headers.authorization;
+  if (typeof header !== 'string') return '';
+  const match = header.match(/^Bearer\s+(.+)$/i);
+  return match ? match[1].trim() : '';
+}
+
+function resolveApiKey(req, body) {
+  const headerKey = req.headers['x-aria-api-key'];
+  if (typeof headerKey === 'string' && headerKey.trim()) return headerKey.trim();
+  if (typeof body?.apiKey === 'string' && body.apiKey.trim()) return body.apiKey.trim();
+  return readBearer(req) || process.env.ARIA_API_KEY || process.env.ARIA_MASTER_TOKEN || '';
+}
+
+function sanitizePacketEnvelope(raw) {
+  const packet = raw?.packet && typeof raw.packet === 'object' ? raw.packet : raw;
+  if (!packet || typeof packet !== 'object') return null;
+  return {
+    ok: true,
+    packet,
+    timestamp: raw?.timestamp || new Date().toISOString(),
+    version: raw?.version || 'local-cache',
+    source: raw?.source || 'local-cache',
+  };
+}
+
+function loadCachedPacketEnvelope() {
+  const candidates = [LOCAL_PACKET_CACHE_PATH, ...LEGACY_PACKET_CACHE_CANDIDATES];
+  for (const candidate of candidates) {
+    try {
+      if (!existsSync(candidate)) continue;
+      const parsed = JSON.parse(readFileSync(candidate, 'utf8'));
+      const envelope = sanitizePacketEnvelope(parsed);
+      if (envelope) return envelope;
+    } catch {}
+  }
+  return null;
+}
+
+function buildLocalDoctrineEnvelope(message = '', reason = 'local-discipline-daemon') {
+  return {
+    ok: true,
+    packet: {
+      harness: [
+        `first_principle = ${LOCAL_FIRST_PRINCIPLE}`,
+        'axioms = truth_over_deception, no_harm, sacred_trust, power_obligates_service, reflection_before_action',
+        `daemon_reason = ${reason}`,
+        'runtime_mode = local-discipline-daemon',
+      ].join('\n'),
+      axioms: {
+        truth_over_deception: true,
+        no_harm: true,
+        sacred_trust: true,
+        power_obligates_service: true,
+        reflection_before_action: true,
+      },
+      frames: {
+        first_principle: LOCAL_FIRST_PRINCIPLE,
+        runtime_mode: 'local-discipline-daemon',
+        message,
+      },
+      doctrine: {
+        local_discipline_daemon: 'Using the packaged local doctrine substrate because remote harness packet retrieval is unavailable.',
+      },
+      memory: {},
+    },
+    timestamp: new Date().toISOString(),
+    version: 'local-discipline-daemon',
+    source: DEFAULT_URL,
+    localFallback: true,
+  };
+}
+
+function persistCachedPacketEnvelope(envelope) {
+  if (!envelope) return;
+  mkdirSync(STATE_DIR, { recursive: true, mode: 0o700 });
+  writeFileSync(LOCAL_PACKET_CACHE_PATH, JSON.stringify(envelope, null, 2) + '\n', { mode: 0o600 });
+  for (const candidate of LEGACY_PACKET_CACHE_CANDIDATES) {
+    try {
+      writeFileSync(candidate, JSON.stringify(envelope) + '\n', { mode: 0o600 });
+    } catch {}
+  }
+}
+
+function packetAgeMs(envelope) {
+  if (!envelope?.timestamp) return Number.POSITIVE_INFINITY;
+  const ts = Date.parse(envelope.timestamp);
+  if (!Number.isFinite(ts)) return Number.POSITIVE_INFINITY;
+  return Date.now() - ts;
+}
+
+function packetToSubstrateSet(packetEnvelope) {
+  const p = packetEnvelope?.packet && typeof packetEnvelope.packet === 'object'
+    ? packetEnvelope.packet
+    : packetEnvelope;
+  const axioms = Object.keys(p?.axioms || {});
+  const frames = Object.keys(p?.frames || {});
+  const memoryRecord = p?.memory || {};
+  const memories = Object.keys(memoryRecord).map((name) =>
+    name.toLowerCase().endsWith('.md') ? name : `${name}.md`,
+  );
+  const doctrineRecord = p?.doctrine || {};
+  const doctrinesAcceptable = Object.keys(doctrineRecord);
+  const packets = Array.from(
+    new Set([
+      'role',
+      'first_principle',
+      'turn_mode',
+      'role_rule',
+      'role_profile',
+      'cognition_belt',
+      'aria_research_pull',
+      ...frames,
+    ]),
+  );
+  const firstPrincipleText =
+    typeof p?.frames?.first_principle === 'string' ? p.frames.first_principle : '';
+  return {
+    axioms,
+    frames,
+    memories,
+    doctrinesAcceptable,
+    packets,
+    languagesLoaded: ['nadia', 'noor'],
+    languagesActive: { nadia: false, noor: false },
+    firstPrincipleText,
+  };
+}
+
+async function fetchJsonWithRetry(url, init, attempts = 3) {
+  let lastError = null;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      const response = await fetch(url, init);
+      return response;
+    } catch (error) {
+      lastError = error;
+      if (attempt < attempts - 1) {
+        const delay = 250 * Math.pow(2, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
+async function refreshPacket(body = {}, apiKey = '') {
+  if (refreshInFlight) return refreshInFlight;
+  if (isLoopedUpstream(UPSTREAM_HARNESS_URL)) {
+    throw new Error(`upstream harness URL loops back to local daemon: ${UPSTREAM_HARNESS_URL}`);
+  }
+  lastRefreshStartedAt = new Date().toISOString();
+  lastRefreshError = null;
+  refreshInFlight = (async () => {
+    const headers = {
+      'Content-Type': 'application/json',
+    };
+    if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+    const response = await fetchJsonWithRetry(`${UPSTREAM_HARNESS_URL.replace(/\/$/, '')}/api/harness/codex`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+      throw new Error(`packet refresh failed: ${response.status} ${response.statusText}`);
+    }
+    const parsed = await response.json();
+    const envelope = sanitizePacketEnvelope(parsed);
+    if (!envelope) {
+      throw new Error('packet refresh returned no packet payload');
+    }
+    envelope.source = UPSTREAM_HARNESS_URL;
+    envelope.timestamp = new Date().toISOString();
+    cachedPacketEnvelope = envelope;
+    lastRefreshCompletedAt = envelope.timestamp;
+    persistCachedPacketEnvelope(envelope);
+    return envelope;
+  })();
+  try {
+    return await refreshInFlight;
+  } catch (error) {
+    lastRefreshError = error instanceof Error ? error.message : String(error);
+    throw error;
+  } finally {
+    refreshInFlight = null;
+  }
+}
+
+function queuePacketRefresh(body, apiKey) {
+  const age = packetAgeMs(cachedPacketEnvelope);
+  if (refreshInFlight || age < PACKET_TTL_MS) return;
+  refreshPacket(body, apiKey).catch(() => {});
+}
+
+async function resolvePacketEnvelope(packetRequest = {}, apiKey = '', message = '') {
+  if (cachedPacketEnvelope) {
+    queuePacketRefresh(packetRequest, apiKey);
+    return cachedPacketEnvelope;
+  }
+  if (!isLoopedUpstream(UPSTREAM_HARNESS_URL)) {
+    try {
+      return await refreshPacket(packetRequest, apiKey);
+    } catch {}
+  }
+  return buildLocalDoctrineEnvelope(message, lastRefreshError ? 'local-discipline-daemon-upstream-unavailable' : 'local-discipline-daemon');
+}
+
+async function proxyRequest(req, body, targetUrl) {
+  if (isLoopedUpstream(targetUrl)) {
+    throw new Error(`refusing to proxy local daemon request back into itself: ${targetUrl}`);
+  }
+  const headers = {};
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (typeof value === 'string') headers[key] = value;
+  }
+  headers['content-type'] = headers['content-type'] || 'application/json';
+  const response = await fetchJsonWithRetry(targetUrl, {
+    method: req.method || 'POST',
+    headers,
+    body: req.method === 'GET' ? undefined : JSON.stringify(body),
+  });
+  const text = await response.text();
+  return {
+    status: response.status,
+    contentType: response.headers.get('content-type') || 'application/json; charset=utf-8',
+    body: text,
+  };
+}
+
+function forgeSynthesizeUrl() {
+  if (trimUrl(UPSTREAM_FORGE_URL).endsWith('/forge/synthesize')) {
+    return trimUrl(UPSTREAM_FORGE_URL);
+  }
+  if (trimUrl(UPSTREAM_FORGE_URL).endsWith('/api/forge/psi')) {
+    return `${trimUrl(UPSTREAM_FORGE_URL).replace(/\/api\/forge\/psi$/, '')}/forge/synthesize`;
+  }
+  return `${trimUrl(UPSTREAM_HARNESS_URL)}/forge/synthesize`;
+}
+
+function buildLocalValidation(text, packetEnvelope, requireCognitionBlock = false) {
+  const layer3 = runFullChain(text, {
+    substrate: packetToSubstrateSet(packetEnvelope),
+    requireCognitionBlock,
+  });
+  const failures = Array.isArray(layer3?.failures) ? layer3.failures : [];
+  const hardFailures = failures.filter((failure) => failure?.severity === 'block');
+  return {
+    passed: hardFailures.length === 0,
+    severity: hardFailures.length === 0 ? 'warn' : 'block',
+    violations: failures.map((failure) => failure?.detail || failure?.kind).filter(Boolean),
+    gateTriggers: failures.map((failure) => failure?.kind).filter(Boolean),
+    local: true,
+    summary: layer3?.summary || '',
+    layer3,
+  };
+}
+
+function healthPayload() {
+  return {
+    ok: true,
+    runtime: 'aria-local-harness-daemon',
+    url: DEFAULT_URL,
+    upstreamHarnessUrl: UPSTREAM_HARNESS_URL,
+    upstreamForgeUrl: UPSTREAM_FORGE_URL,
+    upstreamLoopDetected: isLoopedUpstream(UPSTREAM_HARNESS_URL) || isLoopedUpstream(UPSTREAM_FORGE_URL),
+    packet: {
+      present: Boolean(cachedPacketEnvelope),
+      source: cachedPacketEnvelope?.source || null,
+      timestamp: cachedPacketEnvelope?.timestamp || null,
+      ageMs: Number.isFinite(packetAgeMs(cachedPacketEnvelope)) ? packetAgeMs(cachedPacketEnvelope) : null,
+      ttlMs: PACKET_TTL_MS,
+    },
+    refresh: {
+      inFlight: Boolean(refreshInFlight),
+      lastStartedAt: lastRefreshStartedAt,
+      lastCompletedAt: lastRefreshCompletedAt,
+      lastError: lastRefreshError,
+    },
+  };
+}
+
+const server = createServer(async (req, res) => {
+  try {
+    const url = new URL(req.url || '/', DEFAULT_URL);
+    if (req.method === 'GET' && url.pathname === '/health') {
+      return json(res, 200, healthPayload());
+    }
+
+    const body = req.method === 'GET' ? {} : await readBody(req);
+    const apiKey = resolveApiKey(req, body);
+
+    if (url.pathname === '/packet' || url.pathname === '/api/harness/codex') {
+      const packetEnvelope = await resolvePacketEnvelope(body, apiKey, body.message || body.task || '');
+      return json(res, 200, {
+        ok: true,
+        packet: packetEnvelope.packet,
+        timestamp: packetEnvelope.timestamp,
+        version: packetEnvelope.version,
+        source: packetEnvelope.source,
+        localCache: packetEnvelope === cachedPacketEnvelope,
+        localFallback: packetEnvelope.localFallback === true,
+      });
+    }
+
+    if (url.pathname === '/validate-output' || url.pathname === '/api/harness/validate') {
+      if (typeof body.text !== 'string' || !body.text.trim()) {
+        return json(res, 400, { ok: false, error: 'validate requires non-empty text' });
+      }
+      const packetEnvelope =
+        (body.packet ? sanitizePacketEnvelope(body.packet) : null) ||
+        await resolvePacketEnvelope(body.packetRequest || {}, apiKey, body.message || body.task || body.text);
+      if (!packetEnvelope) {
+        return json(res, 503, {
+          ok: false,
+          error: 'packet unavailable for local validation',
+          refreshInFlight: Boolean(refreshInFlight),
+          lastRefreshError,
+        });
+      }
+      const validation = buildLocalValidation(body.text, packetEnvelope, body.requireCognitionBlock === true);
+      return json(res, 200, validation);
+    }
+
+    if (url.pathname === '/api/forge/psi' || url.pathname === '/forge/synthesize') {
+      const primaryTarget =
+        url.pathname === '/forge/synthesize'
+          ? forgeSynthesizeUrl()
+          : trimUrl(UPSTREAM_FORGE_URL);
+      let proxied = await proxyRequest(req, body, primaryTarget);
+      if (
+        url.pathname === '/api/forge/psi' &&
+        (proxied.status === 404 || proxied.status === 405)
+      ) {
+        proxied = await proxyRequest(req, body, forgeSynthesizeUrl());
+      }
+      res.writeHead(proxied.status, { 'content-type': proxied.contentType });
+      res.end(proxied.body);
+      return;
+    }
+
+    const targetUrl = `${UPSTREAM_HARNESS_URL.replace(/\/$/, '')}${url.pathname}${url.search}`;
+    const proxied = await proxyRequest(req, body, targetUrl);
+    res.writeHead(proxied.status, { 'content-type': proxied.contentType });
+    res.end(proxied.body);
+  } catch (error) {
+    json(res, 500, {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+});
+
+server.listen(DEFAULT_PORT, DEFAULT_HOST, () => {
+  console.log(`[aria-harnessd] listening on ${DEFAULT_URL}`);
+  if (!cachedPacketEnvelope && !isLoopedUpstream(UPSTREAM_HARNESS_URL)) {
+    refreshPacket({}, process.env.ARIA_API_KEY || process.env.ARIA_MASTER_TOKEN || '').catch(() => {});
+  }
+});

package/runtime-src/local-phase.mjs

@@ -618,6 +618,24 @@ export function buildRuntimeCognitionDirective(packet, bundle = {}) {
     '- Predictor tests whether the answer will survive the next real operational step.',
     '- Mizan keeps the answer proportionate, exact, and high-quality.',
     '',
+    'Visible cognition contract for the user-facing response:',
+    '- For any non-trivial reply, include a readable <cognition> block using everyday labels, not internal lens codenames.',
+    '- If you request any non-trivial tool call, place the <cognition> block BEFORE the tool request.',
+    '- If the action is deploy, destructive, or state-mutating, include both <verify> and <expected> blocks before the tool request.',
+    '- The runtime will canonicalize the readable block into backend JSON automatically, so do not hide it behind private shorthand.',
+    '',
+    '<cognition>',
+    '  truth: <what is actually true here, grounded in visible evidence and substrate anchors>',
+    '  harm: <what could break, mislead, or damage trust if the next step is wrong>',
+    '  trust: <what principle, promise, or user trust boundary governs this turn>',
+    '  power: <what capability is being used and what restraint it requires>',
+    '  reflection: <what deeper structural read changes the action, not just the wording>',
+    '  context: <what surrounding repo/runtime/user context materially changes the correct move>',
+    '  impact: <what second-order consequence or next-step outcome follows from this move>',
+    '  beauty: <what cleaner, more elegant, more durable path preserves the contract>',
+    `  first_principle: ${firstPrincipleText}`,
+    '</cognition>',
+    '',
     dominantModules.length ? 'Current module insights:' : 'Current module insights: none yet',
     ...dominantModules.map((line) => `- ${line}`),
     '',