@tangle-network/starter-foundry 0.7.2 → 0.13.0

package/registry/layers/agent-base/secure/files/lib/secure/webhook-in.ts

@@ -0,0 +1,125 @@
+// webhook-in — HMAC-SHA256 signed inbound webhooks with replay-window
+// + schema validation. Reject-loud on any failure; never silently
+// accept unsigned/malformed traffic.
+//
+// Threat: attacker tries to inject a fake "PT session ingested"
+// payload to corrupt the doctor agent's record. They lack the shared
+// secret so HMAC fails; signature mismatch is audit-logged with the
+// claimed sender id.
+
+import { createHmac, timingSafeEqual } from 'node:crypto'
+import { audit } from './audit.js'
+import { requireSecret } from './secrets.js'
+
+const SIGNATURE_HEADER = 'x-tangle-signature'
+const TIMESTAMP_HEADER = 'x-tangle-timestamp'
+const SENDER_HEADER = 'x-tangle-sender'
+const REPLAY_WINDOW_MS = 5 * 60_000
+
+// H4 fix: case-insensitive header lookup. Different runtimes normalize
+// differently (Hono → lowercase, raw http.IncomingMessage → preserves case,
+// CF Workers → lowercase). Build a one-shot lowercase view at function
+// entry so downstream lookups are deterministic.
+function lowercaseHeaders(headers: Record<string, string>): Record<string, string> {
+  const out: Record<string, string> = {}
+  for (const k of Object.keys(headers)) {
+    out[k.toLowerCase()] = headers[k]!
+  }
+  return out
+}
+
+export interface WebhookSpec<TBody = unknown> {
+  path: string
+  /** Optional schema validator. Receives parsed JSON body, returns null on
+   * success or an error string on failure. Bundles can plug zod / typebox /
+   * hand-written checks in here. */
+  schema?: (body: unknown) => null | string
+  /** Hard-required: the env var that holds the HMAC secret for THIS
+   * webhook. Different webhooks should NOT share secrets. */
+  secretName: string
+  handler: (body: TBody, ctx: { sender: string; receivedAt: number }) => Promise<void> | void
+}
+
+const registry = new Map<string, WebhookSpec>()
+
+export function defineWebhook<TBody = unknown>(spec: WebhookSpec<TBody>): void {
+  if (registry.has(spec.path)) {
+    throw new Error(`webhook already defined at ${spec.path}`)
+  }
+  registry.set(spec.path, spec as WebhookSpec)
+  audit.log({ event: 'webhook.in.define', target: spec.path })
+}
+
+export interface WebhookRequest {
+  path: string
+  headers: Record<string, string>
+  rawBody: string
+}
+
+export interface WebhookResponse {
+  status: number
+  body: string
+}
+
+async function dispatchOne(spec: WebhookSpec, req: WebhookRequest): Promise<WebhookResponse> {
+  const headers = lowercaseHeaders(req.headers)
+  const sig = headers[SIGNATURE_HEADER]
+  const tsHeader = headers[TIMESTAMP_HEADER]
+  if (!sig || !tsHeader) {
+    audit.log({ event: 'webhook.in.reject', target: req.path, payload: { reason: 'missing-headers' } })
+    return { status: 401, body: 'missing signature/timestamp' }
+  }
+
+  const ts = Number(tsHeader)
+  if (!Number.isFinite(ts) || Math.abs(Date.now() - ts) > REPLAY_WINDOW_MS) {
+    audit.log({ event: 'webhook.in.reject', target: req.path, payload: { reason: 'replay-window', tsHeader } })
+    return { status: 401, body: 'timestamp outside replay window' }
+  }
+
+  const secret = requireSecret(spec.secretName).unsafeReveal('webhook-in HMAC verification')
+  const expected = createHmac('sha256', secret).update(`${tsHeader}.${req.rawBody}`).digest('hex')
+  const sigBuf = Buffer.from(sig, 'hex')
+  const expBuf = Buffer.from(expected, 'hex')
+  if (sigBuf.length !== expBuf.length || !timingSafeEqual(sigBuf, expBuf)) {
+    audit.log({ event: 'webhook.in.reject', target: req.path, payload: { reason: 'signature-mismatch' } })
+    return { status: 401, body: 'signature mismatch' }
+  }
+
+  let body: unknown
+  try {
+    body = JSON.parse(req.rawBody)
+  } catch {
+    audit.log({ event: 'webhook.in.reject', target: req.path, payload: { reason: 'invalid-json' } })
+    return { status: 400, body: 'invalid JSON' }
+  }
+
+  if (spec.schema) {
+    const err = spec.schema(body)
+    if (err) {
+      audit.log({ event: 'webhook.in.reject', target: req.path, payload: { reason: 'schema', error: err.slice(0, 200) } })
+      return { status: 422, body: `schema: ${err}` }
+    }
+  }
+
+  const sender = headers[SENDER_HEADER] ?? 'unknown'
+  audit.log({ event: 'webhook.in.accept', target: req.path, payload: { sender, bytes: req.rawBody.length } })
+  try {
+    await spec.handler(body, { sender, receivedAt: Date.now() })
+    return { status: 200, body: 'ok' }
+  } catch (err) {
+    audit.log({ event: 'webhook.in.handler-error', target: req.path, payload: { error: (err as Error).message.slice(0, 200) } })
+    return { status: 500, body: 'handler error' }
+  }
+}
+
+/** Mount registered webhooks against an HTTP framework. The framework
+ * adapter passes WebhookRequest in; this returns a WebhookResponse to
+ * serialize to the client. The function does NOT bind to a specific
+ * server (Express/Hono/Cloudflare-Workers) — the runtime layer adapts. */
+export async function mountWebhooks(req: WebhookRequest): Promise<WebhookResponse> {
+  const spec = registry.get(req.path)
+  if (!spec) {
+    return { status: 404, body: 'no webhook defined' }
+  }
+  return dispatchOne(spec, req)
+}

package/registry/layers/agent-base/secure/files/lib/secure/webhook-out.ts

@@ -0,0 +1,137 @@
+// webhook-out — HMAC-signed outbound webhooks with retry + circuit
+// breaker + outbound URL whitelist.
+//
+// Threat: an agent author writes code that beacons to attacker.example.
+// The whitelist (driven by manifest.defaults.outboundDomains) blocks
+// non-listed hosts. Repeated failures to a target trip the circuit
+// breaker, so a single misbehaving target can't burn the agent's
+// retry budget.
+
+import { createHmac } from 'node:crypto'
+import { audit } from './audit.js'
+import { identity } from './identity.js'
+import { requireSecret } from './secrets.js'
+
+const MAX_RETRIES = 3
+const CIRCUIT_BREAKER_THRESHOLD = 5
+const CIRCUIT_BREAKER_COOLDOWN_MS = 60_000
+
+interface BreakerState {
+  consecutiveFailures: number
+  openUntilMs: number
+}
+
+const breakers = new Map<string, BreakerState>()
+
+function host(url: string): string {
+  try {
+    return new URL(url).host
+  } catch {
+    return ''
+  }
+}
+
+function isAllowed(url: string, allowedDomains: string[]): boolean {
+  const h = host(url)
+  if (!h) return false
+  return allowedDomains.some((d) => h === d || h.endsWith(`.${d}`))
+}
+
+export interface WebhookOutOptions {
+  /** Name of the secret that holds this target's HMAC signing key. */
+  secretName: string
+  /** Required: the manifest's allowedDomains for this bundle. */
+  allowedDomains: string[]
+  /** Override max retries. */
+  maxRetries?: number
+  /** Headers passed through verbatim. */
+  headers?: Record<string, string>
+}
+
+export interface WebhookOutResult {
+  ok: boolean
+  status: number
+  attempts: number
+  error?: string
+}
+
+async function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export async function webhookOut(
+  target: string,
+  payload: unknown,
+  opts: WebhookOutOptions,
+): Promise<WebhookOutResult> {
+  if (!isAllowed(target, opts.allowedDomains)) {
+    audit.log({ event: 'webhook.out.reject', target, payload: { reason: 'not-in-allowedDomains' } })
+    return { ok: false, status: 0, attempts: 0, error: 'target not in allowedDomains' }
+  }
+
+  const breakerKey = host(target)
+  const breaker = breakers.get(breakerKey)
+  if (breaker && breaker.openUntilMs > Date.now()) {
+    audit.log({ event: 'webhook.out.circuit-open', target, payload: { until: breaker.openUntilMs } })
+    return { ok: false, status: 0, attempts: 0, error: 'circuit breaker open' }
+  }
+
+  const body = JSON.stringify(payload)
+  const ts = Date.now().toString()
+  const secret = requireSecret(opts.secretName).unsafeReveal('webhook-out HMAC signing')
+  const sig = createHmac('sha256', secret).update(`${ts}.${body}`).digest('hex')
+  const id = identity.current()
+  const headers: Record<string, string> = {
+    'content-type': 'application/json',
+    'x-tangle-signature': sig,
+    'x-tangle-timestamp': ts,
+    'x-tangle-sender': id.agentId,
+    ...opts.headers,
+  }
+
+  const maxRetries = opts.maxRetries ?? MAX_RETRIES
+  let lastStatus = 0
+  let lastError = ''
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const res = await fetch(target, { method: 'POST', headers, body })
+      lastStatus = res.status
+      if (res.status < 500) {
+        // 2xx/3xx/4xx — terminal. Don't retry on client errors.
+        const ok = res.ok
+        audit.log({
+          event: ok ? 'webhook.out.success' : 'webhook.out.fail',
+          target,
+          payload: { status: res.status, attempt },
+        })
+        if (ok) {
+          breakers.delete(breakerKey)
+          return { ok: true, status: res.status, attempts: attempt }
+        }
+        recordFailure(breakerKey)
+        return { ok: false, status: res.status, attempts: attempt }
+      }
+      lastError = `5xx (${res.status})`
+    } catch (err) {
+      lastError = (err as Error).message
+      lastStatus = 0
+    }
+    if (attempt < maxRetries) {
+      await delay(2 ** attempt * 250) // 500ms, 1s, 2s
+    }
+  }
+
+  recordFailure(breakerKey)
+  audit.log({ event: 'webhook.out.exhausted', target, payload: { attempts: maxRetries, lastStatus, lastError: lastError.slice(0, 200) } })
+  return { ok: false, status: lastStatus, attempts: maxRetries, error: lastError }
+}
+
+function recordFailure(key: string): void {
+  const cur = breakers.get(key) ?? { consecutiveFailures: 0, openUntilMs: 0 }
+  cur.consecutiveFailures += 1
+  if (cur.consecutiveFailures >= CIRCUIT_BREAKER_THRESHOLD) {
+    cur.openUntilMs = Date.now() + CIRCUIT_BREAKER_COOLDOWN_MS
+    audit.log({ event: 'webhook.out.circuit-trip', target: key, payload: { failures: cur.consecutiveFailures } })
+  }
+  breakers.set(key, cur)
+}

package/registry/layers/agent-base/secure/files/lib/secure/workspace.ts

@@ -0,0 +1,123 @@
+// workspace — sandboxed filesystem per agent. All paths are resolved
+// under /workspace/<agent-id>/. Path-traversal rejected. /sensitive/
+// requires a read capability; other paths are agent-local read/write.
+//
+// Threat: an agent author writes `workspace.read('../../etc/passwd')`.
+// The path canonicalizer rejects any resolved path that escapes the
+// agent root, with an audit-logged event.
+
+import { createHash } from 'node:crypto'
+import { mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs'
+import { join, normalize, relative, resolve } from 'node:path'
+import { audit } from './audit.js'
+import { identity } from './identity.js'
+
+// Read env at call time so tests can configure per-test workspace roots.
+// In production this is set once at process start.
+function workspaceRoot(): string {
+  return process.env.AGENT_WORKSPACE_ROOT ?? '/workspace'
+}
+
+const SENSITIVE_PREFIX = 'sensitive/'
+
+// H2 fix: freeze the resolved agent root on first call. After that, mutating
+// process.env.TANGLE_AGENT_IDENTITY_JSON does NOT change which workspace this
+// process can see. The one-agent-per-process invariant is enforced here.
+// If the agent's identity changes mid-process (rotation), tests can call
+// `workspace._resetForTest()` — outside of tests, the workspace root is
+// frozen for the lifetime of the process.
+let frozenRoot: string | null = null
+
+function agentRoot(): string {
+  if (frozenRoot !== null) return frozenRoot
+  const id = identity.current().agentId
+  const root = resolve(workspaceRoot(), id)
+  mkdirSync(root, { recursive: true })
+  frozenRoot = root
+  return root
+}
+
+function resolveSafe(rel: string): string {
+  const root = agentRoot()
+  const normalized = normalize(rel.replace(/^\/+/, ''))
+  const target = resolve(root, normalized)
+  // Path-traversal check: target must remain inside agentRoot.
+  const between = relative(root, target)
+  if (between.startsWith('..') || between === '..' || between.startsWith('/')) {
+    audit.log({ event: 'workspace.escape-attempt', target: rel })
+    throw new Error(`path-traversal rejected: ${rel}`)
+  }
+  return target
+}
+
+function isSensitive(rel: string): boolean {
+  return normalize(rel.replace(/^\/+/, '')).startsWith(SENSITIVE_PREFIX)
+}
+
+function checkSensitiveCapability(rel: string, op: 'read' | 'write'): void {
+  if (!isSensitive(rel)) return
+  // Sensitive zone requires the agent to have the 'sensitive-fs' capability.
+  // We check the current identity's claims; in production this comes from
+  // the signed identity's capability list.
+  const id = identity.current()
+  const caps = id.capabilities ?? []
+  if (!caps.includes('sensitive-fs')) {
+    audit.log({ event: 'workspace.sensitive-denied', target: rel, payload: { op } })
+    throw new Error(`sensitive zone access denied: ${rel} (agent lacks 'sensitive-fs' capability)`)
+  }
+}
+
+function hashContent(content: string | Uint8Array): string {
+  return createHash('sha256').update(content).digest('hex').slice(0, 16)
+}
+
+export const workspace = {
+  read(rel: string): string {
+    checkSensitiveCapability(rel, 'read')
+    const abs = resolveSafe(rel)
+    const content = readFileSync(abs, 'utf8')
+    audit.log({ event: 'workspace.read', target: rel, payload: { hash: hashContent(content), bytes: content.length } })
+    return content
+  },
+
+  write(rel: string, content: string): void {
+    checkSensitiveCapability(rel, 'write')
+    const abs = resolveSafe(rel)
+    mkdirSync(join(abs, '..'), { recursive: true })
+    writeFileSync(abs, content)
+    audit.log({ event: 'workspace.write', target: rel, payload: { hash: hashContent(content), bytes: content.length } })
+  },
+
+  list(prefix: string = ''): string[] {
+    checkSensitiveCapability(prefix, 'read')
+    const base = prefix ? resolveSafe(prefix) : agentRoot()
+    if (!statSync(base, { throwIfNoEntry: false })?.isDirectory()) return []
+    const out: string[] = []
+    function walk(dir: string, relPath: string): void {
+      for (const name of readdirSync(dir)) {
+        const abs = join(dir, name)
+        const rel = relPath ? `${relPath}/${name}` : name
+        const st = statSync(abs)
+        if (st.isDirectory()) walk(abs, rel)
+        else out.push(rel)
+      }
+    }
+    walk(base, prefix.replace(/\/$/, ''))
+    audit.log({ event: 'workspace.list', target: prefix || '/', payload: { count: out.length } })
+    return out
+  },
+
+  /** Internal — used by audit module to write its own log without recursing. */
+  _rawWrite(rel: string, content: string): void {
+    const abs = resolveSafe(rel)
+    mkdirSync(join(abs, '..'), { recursive: true })
+    writeFileSync(abs, content)
+  },
+
+  /** TEST-ONLY — release the frozen root so the next agentRoot() re-reads
+   * identity. Production code should never call this; the one-agent-per-
+   * process invariant is the whole point of freezing. */
+  _resetForTest(): void {
+    frozenRoot = null
+  },
+}

package/registry/layers/agent-base/secure/manifest.json

@@ -0,0 +1,174 @@
+{
+  "id": "secure",
+  "slot": "agent-base",
+  "description": "Security floor for every agent-runtime bundle: dotenvx-backed secrets, sandboxed workspace with sensitive-zone ACL, HMAC-signed webhooks (in + out), schedule trigger registry with signed identity, Ed25519 ephemeral identity, append-only signed audit log. Composes with agent-base:tangle. Bundles inherit the security guarantees automatically; opting out is explicit and audit-logged. See docs/specs/agent-base-secure.md.",
+  "appliesTo": [
+    "agent-runtime-account-executive-ts",
+    "agent-runtime-architect-ts",
+    "agent-runtime-auditor-ts",
+    "agent-runtime-biology-research-ts",
+    "agent-runtime-business-partner-ts",
+    "agent-runtime-career-coach-ts",
+    "agent-runtime-chef-ts",
+    "agent-runtime-chemistry-research-ts",
+    "agent-runtime-cmo-advisor-ts",
+    "agent-runtime-college-counselor-ts",
+    "agent-runtime-cs-research-ts",
+    "agent-runtime-cs-tutor-ts",
+    "agent-runtime-customer-success-ts",
+    "agent-runtime-data-analyst-ts",
+    "agent-runtime-designer-ts",
+    "agent-runtime-devops-ts",
+    "agent-runtime-doctor-ts",
+    "agent-runtime-engineering-manager-ts",
+    "agent-runtime-essay-coach-ts",
+    "agent-runtime-financial-analyst-ts",
+    "agent-runtime-fitness-coach-ts",
+    "agent-runtime-friend-ts",
+    "agent-runtime-game-designer-ts",
+    "agent-runtime-grant-writer-ts",
+    "agent-runtime-history-tutor-ts",
+    "agent-runtime-illustrator-ts",
+    "agent-runtime-language-tutor-ts",
+    "agent-runtime-legal-counsel-ts",
+    "agent-runtime-math-research-ts",
+    "agent-runtime-math-tutor-ts",
+    "agent-runtime-mediator-ts",
+    "agent-runtime-meditation-coach-ts",
+    "agent-runtime-ml-research-ts",
+    "agent-runtime-music-producer-ts",
+    "agent-runtime-novelist-coach-ts",
+    "agent-runtime-nutritionist-ts",
+    "agent-runtime-pentester-ts",
+    "agent-runtime-pharmacist-ts",
+    "agent-runtime-photographer-ts",
+    "agent-runtime-physics-research-ts",
+    "agent-runtime-product-manager-ts",
+    "agent-runtime-real-estate-ts",
+    "agent-runtime-recruiter-ts",
+    "agent-runtime-relationship-coach-ts",
+    "agent-runtime-research",
+    "agent-runtime-sales-engineer-ts",
+    "agent-runtime-screenwriter-ts",
+    "agent-runtime-security-engineer-ts",
+    "agent-runtime-tax-ts",
+    "agent-runtime-therapist-ts",
+    "agent-runtime-travel-planner-ts",
+    "agent-runtime-veterinarian-ts",
+    "agent-runtime-wealth-manager-ts",
+    "multi-agent-creative-studio-ts",
+    "multi-agent-legal-ops-ts",
+    "multi-agent-product-ops-ts",
+    "multi-agent-research-lab-ts",
+    "multi-agent-startup-team-ts",
+    "agent-eval-harness-ts",
+    "agent-research-harness-ts"
+  ],
+  "provides": [
+    "secure:secrets",
+    "secure:workspace",
+    "secure:webhook-in",
+    "secure:webhook-out",
+    "secure:schedule",
+    "secure:identity",
+    "secure:audit"
+  ],
+  "requires": [
+    "tangle:base"
+  ],
+  "defaults": {
+    "secureLayer": true,
+    "secretsBackend": "dotenvx",
+    "workspaceRoot": "/workspace",
+    "auditDir": ".audit",
+    "identityAlgorithm": "Ed25519",
+    "identityTtlSec": 3600,
+    "webhookSignatureHeader": "X-Tangle-Signature",
+    "webhookReplayWindowSec": 300,
+    "webhookOutMaxRetries": 3,
+    "webhookOutCircuitBreakerThreshold": 5,
+    "webhookOutCircuitBreakerCooldownSec": 60
+  },
+  "files": [
+    {
+      "source": "files/lib/secure/index.ts",
+      "target": "src/lib/secure/index.ts"
+    },
+    {
+      "source": "files/lib/secure/secrets.ts",
+      "target": "src/lib/secure/secrets.ts"
+    },
+    {
+      "source": "files/lib/secure/workspace.ts",
+      "target": "src/lib/secure/workspace.ts"
+    },
+    {
+      "source": "files/lib/secure/webhook-in.ts",
+      "target": "src/lib/secure/webhook-in.ts"
+    },
+    {
+      "source": "files/lib/secure/webhook-out.ts",
+      "target": "src/lib/secure/webhook-out.ts"
+    },
+    {
+      "source": "files/lib/secure/schedule.ts",
+      "target": "src/lib/secure/schedule.ts"
+    },
+    {
+      "source": "files/lib/secure/identity.ts",
+      "target": "src/lib/secure/identity.ts"
+    },
+    {
+      "source": "files/lib/secure/audit.ts",
+      "target": "src/lib/secure/audit.ts"
+    },
+    {
+      "source": "files/lib/secure/index.test.ts",
+      "target": "src/lib/secure/index.test.ts"
+    },
+    {
+      "source": "files/lib/secure/README.md",
+      "target": "src/lib/secure/README.md"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "src/lib/secure/index.ts"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/lib/secure/secrets.ts"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/lib/secure/workspace.ts"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/lib/secure/webhook-in.ts"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/lib/secure/webhook-out.ts"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/lib/secure/schedule.ts"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/lib/secure/identity.ts"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/lib/secure/audit.ts"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "src/lib/secure/"
+    ],
+    "commands": []
+  }
+}

package/registry/layers/agent-base/tangle/files/lib/tangle.ts

@@ -0,0 +1,56 @@
+// Tangle floor — every agent-runtime bundle wires LLM calls through
+// router.tangle.tools, executes tools through @tangle-network/sandbox,
+// and has @tangle-network/tcloud available for image/video/speech work.
+//
+// Bundles import from this module rather than reaching for the underlying
+// SDKs directly so the router URL + auth wiring stays consistent. The
+// bundle-check validator rejects any LLM call that doesn't go through
+// `chatViaRouter` or an OpenAI-compatible client whose `baseURL` is
+// `process.env.LLM_ROUTER_URL`.
+
+export const LLM_ROUTER_URL = process.env['LLM_ROUTER_URL'] ?? 'https://router.tangle.tools'
+
+export interface RouterChatOptions {
+  model: string
+  messages: Array<{ role: 'system' | 'user' | 'assistant'; content: string }>
+  stream?: boolean
+  temperature?: number
+}
+
+export async function chatViaRouter(opts: RouterChatOptions): Promise<Response> {
+  const apiKey = process.env['TANGLE_API_KEY']
+  if (!apiKey) throw new Error('TANGLE_API_KEY not set — bundles must route LLM calls through router.tangle.tools')
+  return fetch(`${LLM_ROUTER_URL}/v1/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'authorization': `Bearer ${apiKey}`,
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: opts.model,
+      messages: opts.messages,
+      stream: opts.stream ?? false,
+      temperature: opts.temperature ?? 0.2,
+    }),
+  })
+}
+
+export interface SandboxSpawnOptions {
+  bundleDir: string
+  tenantId: string
+  envVars?: Record<string, string>
+  ttlSec?: number
+}
+
+export interface SandboxHandle {
+  id: string
+  endpoint: string
+  destroy: () => Promise<void>
+}
+
+export async function spawnAgentSandbox(_opts: SandboxSpawnOptions): Promise<SandboxHandle> {
+  // Implementation imports @tangle-network/sandbox at runtime; this
+  // module declares the contract so the bundle's compose-time validators
+  // can assert the shape without needing the SDK on the classpath.
+  throw new Error('spawnAgentSandbox: import @tangle-network/sandbox and wire its createSandbox() here')
+}