liris: add triad host router gulp pipeline

docs/LIRIS-TRIAD-HOST-ROUTER-GULP-PIPELINE-2026-06-14.hbp

@@ -0,0 +1,8 @@
+TRIADROUTCANONHDR|doc=LIRIS-TRIAD-HOST-ROUTER-GULP-PIPELINE-2026-06-14|date=2026-06-14|owner=liris|scope=8-byte-host-router-rule-of-three-gulp-gc-cube-feedback|tag=DESCRIPTOR-ONLY|json=0
+TRIADROUTCANONHOST|host_handle_bytes=8|meaning=local-host-process-or-portal-descriptor|not_meaning=message-size-or-free-provider-compute|node_per_agent=0|process_launch=0|json=0
+TRIADROUTCANONROUTERS|surfaces=opencode+openai+codex+gemini+claude+anthropic+big-pickle+registered-cli|rule=registered-descriptor-before-use;provider-terms-and-auth-apply;billing-bypass-0|remote_call=0|json=0
+TRIADROUTCANONTHREE|roles=real-agent+self-reflect-agent+fabric-reflect-agent|supervisor=sees-all-three|nesting=allowed-as-descriptor-recursion-only-until-emitter-cosign|json=0
+TRIADROUTCANONGC|gulp_messages=2000|super_gulp_messages=50000|after_processing=1|message_body_retention=0|summary_hash_retention=1|json=0
+TRIADROUTCANONCUBE|watchers=gnn+reverse-sieve-gnn+omnishannon+white-room|output=cube-catalog-feedback|self_improvement=bounded-by-tests-sidecars-cosign|json=0
+TRIADROUTCANONTOOL|tool=tools/behcs/triad-host-router-gulp-pipeline.mjs|test=tests/triad-host-router-gulp-pipeline.unit.test.mjs|catalog=tools/behcs/fabric-agent-preload-catalog.mjs|json=0
+TRIADROUTCANONFTR|status=SEALED-HOST-ROUTER-GULP-PIPELINE|next=use-before-scaling-router-agent-claims|json=0

docs/LIRIS-TRIAD-HOST-ROUTER-GULP-PIPELINE-2026-06-14.hbp.sha256

@@ -0,0 +1 @@
+9F2E3343A22E869B604A83691E92FAB036A8D07FC3BFF5E4B55A552F517F7374  LIRIS-TRIAD-HOST-ROUTER-GULP-PIPELINE-2026-06-14.hbp

tests/fabric-agent-preload-catalog.unit.test.mjs

@@ -31,6 +31,7 @@ test('preload catalog includes the laws, tools, roles, and cadence agents need',
   assert.ok(TOOLS.some((t) => t.id === 'tool-skill-registry-matrix' && t.gate.includes('live-tool-execution-0')));
   assert.ok(TOOLS.some((t) => t.id === 'program-cube-ingestion-map' && t.gate.includes('blind_mutation-0')));
   assert.ok(TOOLS.some((t) => t.id === 'agent-cost-layer-boundary' && t.gate.includes('free_compute_claim-0')));
+  assert.ok(TOOLS.some((t) => t.id === 'triad-host-router-gulp-pipeline' && t.gate.includes('provider_bypass-0')));
   assert.ok(ROLES.some((r) => r.id === 'flywheel' && r.must_do.includes('compare-to-acer-local-truth')));
   assert.ok(WORKFLOW.join('-').includes('memory-index-plan'));
   assert.equal(toolById('token-cube-catalog-binder').gate, 'mint-write-live-DEFER_TO_OPERATOR');

tests/fabric-agent-preload-catalog.unit.test.mjs.sha256

@@ -1 +1 @@
-B7A3C228CA853E528E617EB02910AF243A49116A1A8FDF90D2420269ECFB84B0  fabric-agent-preload-catalog.unit.test.mjs
+FB438698865603D1DFA7ADF8230C2B9E98662A4B924854C04880FE88673D968A  fabric-agent-preload-catalog.unit.test.mjs

tests/supervisor-collision-router.system.test.mjs

@@ -91,6 +91,7 @@ const sealedFiles = [
   'docs/LIRIS-SELFHEAL-200STEP-INTEGRATION-2026-06-13.hbp',
   'docs/LIRIS-PROGRAM-CUBE-INGESTION-MAP-2026-06-14.hbp',
   'docs/LIRIS-AGENT-COST-LAYER-BOUNDARY-2026-06-14.hbp',
+  'docs/LIRIS-TRIAD-HOST-ROUTER-GULP-PIPELINE-2026-06-14.hbp',
   'docs/ACER-SLICE-ENGINE-LIVE-CRANK-RECEIPT-2026-06-13.hbp',
   'docs/LIRIS-ROUTE-HEALTH-BASELINE-2026-06-13.hbp',
   'docs/ACER-ROUTE-HEALTH-CROSS-VANTAGE-2026-06-13.hbp',
@@ -233,6 +234,7 @@ const sealedFiles = [
   'tools/behcs/tool-skill-registry-matrix.mjs',
   'tools/behcs/program-cube-ingestion-map.mjs',
   'tools/behcs/agent-cost-layer-boundary.mjs',
+  'tools/behcs/triad-host-router-gulp-pipeline.mjs',
   'tools/behcs/logical-extreme-stress.mjs',
   'tools/behcs/logical-stress-cube-feed.mjs',
   'tools/behcs/brown-hilbert-expansion-stress.mjs',
@@ -269,6 +271,7 @@ const sealedFiles = [
   'tests/tool-skill-registry-matrix.unit.test.mjs',
   'tests/program-cube-ingestion-map.unit.test.mjs',
   'tests/agent-cost-layer-boundary.unit.test.mjs',
+  'tests/triad-host-router-gulp-pipeline.unit.test.mjs',
   'tests/logical-extreme-stress.unit.test.mjs',
   'tests/logical-stress-cube-feed.unit.test.mjs',
   'tests/brown-hilbert-expansion-stress.unit.test.mjs',

tests/supervisor-collision-router.system.test.mjs.sha256

@@ -1 +1 @@
-8EA12D638DDCA38A99DD49D5B905D0122FABF543AF234351A761AFA972BFD752  supervisor-collision-router.system.test.mjs
+66B2C303BA2A59E603FA6C3CAE56F9FCE48D3F4E3D659554A9C980959739AE70  supervisor-collision-router.system.test.mjs

tests/triad-host-router-gulp-pipeline.unit.test.mjs

@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+
+import {
+  FEEDBACK_STAGES, GULP_MESSAGES, HOST_HANDLE_BYTES, ROUTER_SURFACES, SUPER_GULP_MESSAGES,
+  TRIAD_ROLES, buildPipeline, emitRows, normalizeRouter, selfTest, triadForMessage,
+} from '../tools/behcs/triad-host-router-gulp-pipeline.mjs';
+
+test('triad host-router pipeline self-test passes', () => {
+  assert.equal(selfTest().ok, true);
+});
+
+test('host process doctrine is encoded as an 8-byte descriptor, not a node process per agent', () => {
+  const built = buildPipeline();
+  assert.equal(HOST_HANDLE_BYTES, 8);
+  assert.equal(built.summary.no_node_per_agent, true);
+  assert.equal(built.summary.live_ready, false);
+  assert.ok(built.routers.every((r) => r.host_handle_bytes === 8 && r.node_per_agent === 0));
+});
+
+test('rule of three produces real, self-reflect, and fabric-reflect handles for the supervisor', () => {
+  const triad = triadForMessage({ message_id: 'operator-message-1' });
+  assert.deepEqual(TRIAD_ROLES.map((r) => r.id), ['real-agent', 'self-reflect-agent', 'fabric-reflect-agent']);
+  assert.equal(triad.length, 3);
+  assert.equal(new Set(triad.map((r) => r.handle8)).size, 3);
+  assert.ok(triad.every((r) => r.process_launch === 0 && r.remote_call === 0));
+});
+
+test('gulp and super-gulp GC sizes are fixed and watcher stages are present', () => {
+  assert.equal(GULP_MESSAGES, 2000);
+  assert.equal(SUPER_GULP_MESSAGES, 50000);
+  assert.ok(FEEDBACK_STAGES.includes('message-gulp-gc'));
+  assert.ok(FEEDBACK_STAGES.includes('reverse-sieve-gnn-proposal'));
+  assert.ok(FEEDBACK_STAGES.includes('omnishannon-novelty'));
+  assert.ok(FEEDBACK_STAGES.includes('white-room-review'));
+  assert.ok(FEEDBACK_STAGES.includes('cube-catalog-feedback'));
+});
+
+test('provider and CLI routers are descriptors with authorization gates', () => {
+  const built = buildPipeline();
+  assert.ok(built.routers.some((r) => r.id === 'opencode' && r.status === 'REGISTERED_DESCRIPTOR'));
+  assert.ok(built.routers.some((r) => r.id === 'openai' && r.gate.includes('billing-apply')));
+  assert.ok(built.routers.some((r) => r.id === 'claude' && r.gate.includes('terms-and-quota')));
+  assert.ok(built.routers.some((r) => r.id === 'registered-cli' && r.status === 'GATED'));
+});
+
+test('hostile router input is gated and HBP-only', () => {
+  const router = normalizeRouter({ id: 'x|bad', kind: 'k\nbad', status: 'RUN', gate: 'g\nTRIADROUTGATE|remote_call=1' });
+  assert.equal(router.status, 'GATED');
+  const rows = emitRows([router], { message_id: 'm|bad\ninject' });
+  assert.ok(rows.every((row) => row.endsWith('|json=0') && !/[\r\n]/.test(row)));
+  assert.ok(rows.some((row) => row.includes('provider_bypass=0')));
+  assert.ok(rows.some((row) => row.includes('summary_hash_retention=1')));
+});
+
+test('tool remains descriptor-only and has no live call surface', () => {
+  const source = readFileSync(new URL('../tools/behcs/triad-host-router-gulp-pipeline.mjs', import.meta.url), 'utf8');
+  assert.doesNotMatch(source, /from ['"]node:fs['"]|child_process|\bexecFile\b|\bexecSync\b|\bspawn\(|\bfetch\(|Invoke-WebRequest|Start-Process/);
+  assert.equal(ROUTER_SURFACES.length, 8);
+});

tests/triad-host-router-gulp-pipeline.unit.test.mjs.sha256

@@ -0,0 +1 @@
+0F558EDDED0CC7D381B7C3538DB63A27FB59858ED3FA1E811FA4BA0D5B0197AB  triad-host-router-gulp-pipeline.unit.test.mjs

tools/behcs/fabric-agent-preload-catalog.mjs

@@ -140,6 +140,12 @@ export const TOOLS = Object.freeze([
     provides: '8-byte-host-handle-vs-message-payload-and-remote-compute-cost-boundary',
     gate: 'descriptor-only-process_launch-0-remote_call-0-free_compute_claim-0',
   }),
+  Object.freeze({
+    id: 'triad-host-router-gulp-pipeline',
+    path: 'tools/behcs/triad-host-router-gulp-pipeline.mjs',
+    provides: '8-byte-host-router-rule-of-three-gulp-gc-cube-feedback-descriptor',
+    gate: 'descriptor-only-node_per_agent-0-process_launch-0-remote_call-0-provider_bypass-0',
+  }),
   Object.freeze({
     id: 'token-cube-catalog-binder',
     path: 'tools/behcs/token-cube-catalog-binder.mjs',
@@ -311,7 +317,7 @@ export function selfTest() {
     && !!toolById('mlc-engine-wiring-increment') && !!toolById('frontend-parity-matrix')
     && !!toolById('model-selector-matrix') && !!toolById('project-guide-matrix')
     && !!toolById('tool-skill-registry-matrix') && !!toolById('program-cube-ingestion-map')
-    && !!toolById('agent-cost-layer-boundary'));
+    && !!toolById('agent-cost-layer-boundary') && !!toolById('triad-host-router-gulp-pipeline'));
   add('slice-engine-law-preloaded', LAWS.some((law) => law.startsWith('slice-engine-law-'))
     && emitPreloadRows().some((row) => row.startsWith('FABPRELOADSLICEENGINE|')));
   add('emitters-pipe-hookwall-gnn', EMITTERS.some((e) => e.id === 'hookwall') && EMITTERS.some((e) => e.id === 'gnn-edge'));

tools/behcs/fabric-agent-preload-catalog.mjs.sha256

@@ -1 +1 @@
-6DE0B2DD29FC94457E0B702CE789B08C7A3F4C2B444657183A481E3144AC578B  fabric-agent-preload-catalog.mjs
+1B86D1F62F03962F73D14414568DBD301F3B92F6643A6AD2B7D2D6C5C3194CFF  fabric-agent-preload-catalog.mjs

tools/behcs/triad-host-router-gulp-pipeline.mjs

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+// triad-host-router-gulp-pipeline.mjs - descriptor for 8-byte host routers and triad GC.
+//
+// Descriptor-only. This does not call provider CLIs, start daemons, open network portals,
+// run model calls, or create a Node process per agent. It records the pipeline shape:
+// 8-byte host handle -> PID emitter -> router -> rule-of-three agents -> supervisor ->
+// gulp/super-gulp GC -> GNN/Shannon/white-room cube feedback.
+
+import { createHash } from 'node:crypto';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const PIPELINE_ID = 'triad-host-router-gulp-pipeline.v1';
+export const HOST_HANDLE_BYTES = 8;
+export const GULP_MESSAGES = 2000;
+export const SUPER_GULP_MESSAGES = 50000;
+
+export const TRIAD_ROLES = Object.freeze([
+  Object.freeze({
+    id: 'real-agent',
+    role: 'work-or-read-write-depending-on-gate',
+    sees: 'task-message',
+    output: 'candidate-product',
+  }),
+  Object.freeze({
+    id: 'self-reflect-agent',
+    role: 'reflect-on-real-agent-output',
+    sees: 'task-message+candidate-product',
+    output: 'self-reflection',
+  }),
+  Object.freeze({
+    id: 'fabric-reflect-agent',
+    role: 'ask-fabric-and-cross-check-real-plus-self',
+    sees: 'task-message+candidate-product+self-reflection',
+    output: 'fabric-reflection',
+  }),
+]);
+
+export const ROUTER_SURFACES = Object.freeze([
+  Object.freeze({ id: 'opencode', kind: 'cli-router', status: 'REGISTERED_DESCRIPTOR', gate: 'local-cli-auth-and-version-proof' }),
+  Object.freeze({ id: 'openai', kind: 'provider-router', status: 'GATED', gate: 'api-key-account-terms-and-billing-apply' }),
+  Object.freeze({ id: 'codex', kind: 'agent-router', status: 'REGISTERED_DESCRIPTOR', gate: 'session-and-repo-policy-apply' }),
+  Object.freeze({ id: 'gemini', kind: 'provider-router', status: 'GATED', gate: 'google-account-terms-and-quota-apply' }),
+  Object.freeze({ id: 'claude', kind: 'provider-router', status: 'GATED', gate: 'anthropic-account-terms-and-quota-apply' }),
+  Object.freeze({ id: 'anthropic', kind: 'provider-router', status: 'GATED', gate: 'anthropic-account-terms-and-quota-apply' }),
+  Object.freeze({ id: 'big-pickle', kind: 'local-artifact-router', status: 'REGISTERED_DESCRIPTOR', gate: 'pickle-read-write-held-until-owner-proof' }),
+  Object.freeze({ id: 'registered-cli', kind: 'open-router-slot', status: 'GATED', gate: 'must-register-version-auth-owner-and-policy-before-use' }),
+]);
+
+export const FEEDBACK_STAGES = Object.freeze([
+  'pid-specific-emitter',
+  'host-router',
+  'rule-of-three-triad',
+  'supervisor-sees-all-three',
+  'message-gulp-gc',
+  'super-gulp-gc',
+  'gnn-proposal',
+  'reverse-sieve-gnn-proposal',
+  'omnishannon-novelty',
+  'white-room-review',
+  'cube-catalog-feedback',
+]);
+
+const sha16 = (text) => createHash('sha256').update(String(text), 'utf8').digest('hex').slice(0, 16);
+const isObj = (x) => x !== null && typeof x === 'object';
+const safe = (x) => String(x ?? '').replace(/[|\r\n]/g, '_').replace(/[^A-Za-z0-9._:/+@=-]+/g, '-').replace(/^-|-$/g, '') || 'empty';
+const prop = (obj, key, fallback = '') => {
+  try { return isObj(obj) ? obj[key] : fallback; } catch { return fallback; }
+};
+
+export function normalizeRouter(input = {}) {
+  try {
+    const id = safe(prop(input, 'id', 'registered-cli'));
+    const kind = safe(prop(input, 'kind', 'open-router-slot'));
+    const statusRaw = safe(prop(input, 'status', 'GATED')).toUpperCase();
+    const status = ['REGISTERED_DESCRIPTOR', 'GATED'].includes(statusRaw) ? statusRaw : 'GATED';
+    const gate = safe(prop(input, 'gate', 'must-register-before-use'));
+    return Object.freeze({
+      id,
+      kind,
+      status,
+      gate,
+      router_sha16: sha16([id, kind, status, gate].join('|')),
+      host_handle_bytes: HOST_HANDLE_BYTES,
+      node_per_agent: 0,
+      process_launch: 0,
+      remote_call: 0,
+      provider_bypass: 0,
+    });
+  } catch {
+    return Object.freeze({
+      id: 'invalid',
+      kind: 'invalid',
+      status: 'GATED',
+      gate: 'normalize-threw-held',
+      router_sha16: sha16('invalid'),
+      host_handle_bytes: HOST_HANDLE_BYTES,
+      node_per_agent: 0,
+      process_launch: 0,
+      remote_call: 0,
+      provider_bypass: 0,
+    });
+  }
+}
+
+export function triadForMessage(input = {}) {
+  const msg = safe(isObj(input) ? prop(input, 'message_id', 'message') : input);
+  const base = sha16(`triad:${msg}`);
+  return Object.freeze(TRIAD_ROLES.map((role, index) => Object.freeze({
+    ...role,
+    lane: `L${index}`,
+    host_handle_bytes: HOST_HANDLE_BYTES,
+    handle8: sha16(`${base}:${role.id}`),
+    process_launch: 0,
+    remote_call: 0,
+  })));
+}
+
+export function buildPipeline(input = ROUTER_SURFACES) {
+  const routers = (Array.isArray(input) ? input : ROUTER_SURFACES).map(normalizeRouter);
+  return Object.freeze({
+    tool: PIPELINE_ID,
+    host_handle_bytes: HOST_HANDLE_BYTES,
+    gulp_messages: GULP_MESSAGES,
+    super_gulp_messages: SUPER_GULP_MESSAGES,
+    routers,
+    triad_roles: TRIAD_ROLES,
+    feedback_stages: FEEDBACK_STAGES,
+    summary: Object.freeze({
+      routers: routers.length,
+      triad_roles: TRIAD_ROLES.length,
+      registered_descriptors: routers.filter((r) => r.status === 'REGISTERED_DESCRIPTOR').length,
+      gated: routers.filter((r) => r.status === 'GATED').length,
+      no_node_per_agent: true,
+      live_ready: false,
+    }),
+  });
+}
+
+export function emitRows(input = ROUTER_SURFACES, opts = {}) {
+  try {
+    const built = buildPipeline(input);
+    const messageId = safe(prop(opts, 'message_id', 'sample-message'));
+    const triad = triadForMessage({ message_id: messageId });
+    const rows = [
+      `TRIADROUTHDR|tool=${PIPELINE_ID}|purpose=8-byte-host-router-rule-of-three-gulp-gc-cube-feedback|host_handle_bytes=${HOST_HANDLE_BYTES}|routers=${built.summary.routers}|triad_roles=${built.summary.triad_roles}|gulp_messages=${GULP_MESSAGES}|super_gulp_messages=${SUPER_GULP_MESSAGES}|node_per_agent=0|process_launch=0|remote_call=0|provider_bypass=0|json=0`,
+      `TRIADROUTSTAGES|stages=${FEEDBACK_STAGES.join('+')}|supervisor_sees=real+self-reflect+fabric-reflect|live_ready=0|json=0`,
+    ];
+    for (const role of triad) {
+      rows.push(`TRIADROUTROLE|message_id=${messageId}|role=${role.id}|lane=${role.lane}|handle8=${role.handle8}|sees=${safe(role.sees)}|output=${safe(role.output)}|host_handle_bytes=${role.host_handle_bytes}|process_launch=0|remote_call=0|json=0`);
+    }
+    for (const router of built.routers) {
+      rows.push(`TRIADROUTER|id=${router.id}|kind=${router.kind}|status=${router.status}|gate=${router.gate}|router_sha16=${router.router_sha16}|host_handle_bytes=${router.host_handle_bytes}|node_per_agent=0|process_launch=0|remote_call=0|provider_bypass=0|json=0`);
+    }
+    rows.push(`TRIADROUTGC|after_processing=1|gulp_messages=${GULP_MESSAGES}|super_gulp_messages=${SUPER_GULP_MESSAGES}|message_body_retention=0|summary_hash_retention=1|catalog_feedback=descriptor-only|json=0`);
+    rows.push('TRIADROUTCUBE|gnn=proposal-not-proof|reverse_sieve_gnn=proposal-not-proof|omnishannon=novelty-gate|white_room=held-review|cube_catalog_update=descriptor-only|realtime_self_improvement=bounded-by-tests-and-cosign|json=0');
+    rows.push('TRIADROUTGATE|rule=no-node-per-agent+no-provider-bypass+no-live-daemon-launch+provider-terms-apply+operator-cosign-before-remote-call|billing_bypass=0|process_launch=0|remote_call=0|json=0');
+    return rows;
+  } catch {
+    return [
+      `TRIADROUTHDR|tool=${PIPELINE_ID}|purpose=8-byte-host-router-rule-of-three-gulp-gc-cube-feedback|host_handle_bytes=${HOST_HANDLE_BYTES}|routers=0|triad_roles=0|process_launch=0|remote_call=0|provider_bypass=0|json=0`,
+      'TRIADROUTGATE|rule=emit-threw-held-invalid|billing_bypass=0|process_launch=0|remote_call=0|json=0',
+    ];
+  }
+}
+
+export function selfTest() {
+  const checks = [];
+  const add = (name, ok) => checks.push({ name, ok: Boolean(ok) });
+  const built = buildPipeline();
+  const triad = triadForMessage({ message_id: 'm1' });
+  add('host-handle-is-8', HOST_HANDLE_BYTES === 8 && built.host_handle_bytes === 8);
+  add('triad-has-three-roles', TRIAD_ROLES.length === 3 && triad.length === 3 && triad.every((r) => r.handle8.length === 16));
+  add('gulp-sizes-fixed', GULP_MESSAGES === 2000 && SUPER_GULP_MESSAGES === 50000);
+  add('routers-include-provider-and-cli-surfaces', built.routers.some((r) => r.id === 'opencode') && built.routers.some((r) => r.id === 'openai') && built.routers.some((r) => r.id === 'registered-cli'));
+  add('no-live-effects', built.routers.every((r) => r.node_per_agent === 0 && r.process_launch === 0 && r.remote_call === 0 && r.provider_bypass === 0));
+  add('feedback-has-watchers-and-cubes', FEEDBACK_STAGES.includes('reverse-sieve-gnn-proposal') && FEEDBACK_STAGES.includes('white-room-review') && FEEDBACK_STAGES.includes('cube-catalog-feedback'));
+  const hostile = emitRows([{ id: 'bad|id', kind: 'x\ny', status: 'RUN', gate: 'g\nTRIADROUTGATE|remote_call=1' }], { message_id: 'm|1\nbad' });
+  add('rows-hbp-only', hostile.every((row) => row.endsWith('|json=0') && !/[\r\n]/.test(row)));
+  add('total-never-throws', (() => { try { normalizeRouter({ get id() { throw new Error('boom'); } }); buildPipeline(null); emitRows(null); triadForMessage(null); return true; } catch { return false; } })());
+  return { ok: checks.every((c) => c.ok), checks };
+}
+
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1]);
+if (isMain) {
+  if (process.argv[2] === '--self-test') {
+    const r = selfTest();
+    for (const c of r.checks) console.log(`${c.ok ? 'PASS' : 'FAIL'} ${c.name}`);
+    process.exit(r.ok ? 0 : 1);
+  }
+  for (const row of emitRows(ROUTER_SURFACES, { message_id: process.argv[2] || 'sample-message' })) console.log(row);
+}

tools/behcs/triad-host-router-gulp-pipeline.mjs.sha256

@@ -0,0 +1 @@
+3DF9513C75482826CB348AACC07BB1E294608456108D44D9D5C54987BB09B3DD  triad-host-router-gulp-pipeline.mjs