thumbgate 1.35.0 → 1.37.1

package/scripts/dashboard.js

@@ -53,6 +53,11 @@ const {
   collectAggregateLogEntries,
   shouldAggregateFeedback,
 } = require('./feedback-aggregate');
+const {
+  DEFAULT_JSONL_TAIL_BYTES,
+  DEFAULT_JSONL_TAIL_ENTRIES,
+  readTextTail,
+} = require('./fs-utils');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
 const DEFAULT_GATES_PATH = path.join(PROJECT_ROOT, 'config', 'gates', 'default.json');
@@ -101,37 +106,17 @@ function buildUnavailableOrgDashboard(windowHours) {
 // Full-file readFileSync/stringify then throws:
 //   "Cannot create a string longer than 0x1fffffe8 characters"
 // Cap dashboard JSONL ingestion to a recent tail so /v1/dashboard stays live.
-const DEFAULT_JSONL_MAX_BYTES = 32 * 1024 * 1024; // 32 MiB tail
-const DEFAULT_JSONL_MAX_ENTRIES = 100_000;
-
-function readTextTail(filePath, maxBytes) {
-  const stats = fs.statSync(filePath);
-  const size = stats.size || 0;
-  if (size <= 0) return { text: '', truncated: false, size: 0 };
-  if (!maxBytes || size <= maxBytes) {
-    return { text: fs.readFileSync(filePath, 'utf-8'), truncated: false, size };
-  }
-  const fd = fs.openSync(filePath, 'r');
-  try {
-    const buffer = Buffer.alloc(maxBytes);
-    fs.readSync(fd, buffer, 0, maxBytes, size - maxBytes);
-    let text = buffer.toString('utf-8');
-    const firstNewline = text.indexOf('\n');
-    if (firstNewline >= 0) text = text.slice(firstNewline + 1);
-    return { text, truncated: true, size };
-  } finally {
-    fs.closeSync(fd);
-  }
-}
+// A 32 MiB default is still too large: generateDashboard reads several logs
+// and aggregation/analyze used to full-scan the same files again.
+const DEFAULT_JSONL_MAX_BYTES = DEFAULT_JSONL_TAIL_BYTES;
+const DEFAULT_JSONL_MAX_ENTRIES = DEFAULT_JSONL_TAIL_ENTRIES;
 
 function readJSONL(filePath, options = {}) {
   if (!fs.existsSync(filePath)) return [];
-  const maxBytes = Number(options.maxBytes) > 0
-    ? Number(options.maxBytes)
-    : DEFAULT_JSONL_MAX_BYTES;
-  const maxEntries = Number(options.maxEntries) > 0
-    ? Number(options.maxEntries)
-    : DEFAULT_JSONL_MAX_ENTRIES;
+  const requestedBytes = Number(options.maxBytes);
+  const requestedEntries = Number(options.maxEntries);
+  const maxBytes = requestedBytes > 0 ? requestedBytes : DEFAULT_JSONL_MAX_BYTES;
+  const maxEntries = requestedEntries > 0 ? requestedEntries : DEFAULT_JSONL_MAX_ENTRIES;
   let text;
   try {
     text = readTextTail(filePath, maxBytes).text;
@@ -139,7 +124,7 @@ function readJSONL(filePath, options = {}) {
     // Never let a single bloated/unreadable log take down the whole dashboard.
     return [];
   }
-  if (!text || !text.trim()) return [];
+  if (!text?.trim()) return [];
   const lines = text.split('\n');
   const start = Math.max(0, lines.length - maxEntries);
   const entries = [];
@@ -571,8 +556,14 @@ function computePreventionImpact(feedbackDir, gateStats) {
   }
 
   // Estimate time saved: ~16 min per blocked action (conservative)
+  // Based on: Claude Code review takes ~30 min, guard saves ~14 min
   const estimatedMinutesSaved = gateStats.blocked * 16;
-  const estimatedHoursSaved = (estimatedMinutesSaved / 60).toFixed(1);
+  const estimatedHoursSaved = Number((estimatedMinutesSaved / 60).toFixed(1));
+
+  // Estimate cost savings: $0.004 per blocked action (16 min @ $1.50/hr = 40 cents)
+  // This is the cost of the agent time saved
+  const estimatedCostSavingsCents = gateStats.blocked * (16 / 60) * 1.5 * 100; // 16min * $1.50/hr -> cents
+  const estimatedCostSavings = `$${(estimatedCostSavingsCents / 100).toFixed(2)}`;
 
   // Last auto-promotion
   const autoGates = readJsonFile(autoGatesPath);
@@ -588,10 +579,71 @@ function computePreventionImpact(feedbackDir, gateStats) {
     }
   }
 
+  // Feedback-to-gate conversion rate
+  // How many blocked actions led to prevention rules — rate per blocked event
+  const feedbackCount = gateStats.blocked; // denominator: blocked actions
+  const conversionRate = feedbackCount > 0 ? Math.min(gateStats.totalGates / feedbackCount, 1) : 0;
+
   return {
     estimatedHoursSaved,
+    estimatedCostSavings,
     ruleCount,
     lastPromotion,
+    feedbackToGateConversionRate: Number(conversionRate.toFixed(4)),
+    blockedActions: gateStats.blocked || 0,
+  };
+}
+
+function computeRoiSummary(gateStats, prevention, analytics, billing) {
+  // North Star: Earn $100/day after-tax profit
+  // ROI metrics that drive acquisition and retention
+
+  const blockedActions = gateStats.blocked || 0;
+  const warnedActions = gateStats.warned || 0;
+  const passedActions = gateStats.passed || 0;
+
+  // Time saved from blocked actions (16 min per block)
+  const hoursSaved = prevention.estimatedHoursSaved || 0;
+
+  // Conversion funnel effectiveness
+  const funnel = analytics.funnel || {};
+  const visitorToPaidRate = funnel.visitorToPaidRate || 0;
+  const ctaToPaidRate = funnel.ctaToPaidRate || 0;
+
+  // Revenue tracking — aligns with billing.js getBillingSummary: revenue.bookedRevenueCents
+  const paidOrders = funnel.paidOrders || 0;
+  const monthlyRevenueCents = billing.revenue ? billing.revenue.bookedRevenueCents || 0 : 0;
+  const monthlyRevenue = monthlyRevenueCents / 100;
+
+  // Prevention effectiveness: blocked actions per attempted action
+  const totalActions = blockedActions + warnedActions + passedActions;
+  const preventionRate = totalActions > 0 ? (blockedActions / totalActions) : 0;
+
+  // PR merge efficiency (GitHub Label Archiving impact)
+  const decisionMetrics = analytics.decisionMetrics || {};
+  const prMergeRate = decisionMetrics.mergeRate || 0;
+
+  return {
+    // Cost savings from prevention (time-based ROI)
+    hoursSaved: Number(hoursSaved.toFixed(1)),
+    preventionRate: Number(preventionRate.toFixed(4)),
+    blockedActions,
+
+    // Conversion metrics (acquisition ROI)
+    visitorToPaidRate: Number((visitorToPaidRate * 100).toFixed(2)),
+    ctaToPaidRate: Number((ctaToPaidRate * 100).toFixed(2)),
+
+    // Revenue signals (retention/retention)
+    monthlyRevenue: Number(monthlyRevenue.toFixed(2)),
+    paidOrders,
+
+    // North Star tracking
+    monthlyRevenueTarget: 3000, // $100/day after tax
+    revenueProgress: monthlyRevenue > 0 ? (monthlyRevenue / 3000 * 100).toFixed(1) : 0,
+
+    // Process efficiency (GitHub Label Archiving benefits)
+    prMergeRate: Number((prMergeRate * 100).toFixed(1)),
+    // Higher merge rate = better process efficiency from archived labels reducing noise
   };
 }
 
@@ -1208,6 +1260,149 @@ function computeObservabilityStats(diagnosticEntries, diagnostics, secretGuard,
   };
 }
 
+// ---------------------------------------------------------------------------
+// Agent File Audit (high-ROI improvement for agent governance)
+// ---------------------------------------------------------------------------
+
+function computeAgentFileAudit(projectRoot = PROJECT_ROOT) {
+  // Audit agent configuration files for governance compliance
+  const auditResults = {
+    totalAgentFiles: 0,
+    auditPassCount: 0,
+    auditFailCount: 0,
+    files: [],
+    lastAuditAt: new Date().toISOString(),
+  };
+
+  // Find all agent/MCP configuration files
+  const agentFilePatterns = [
+    '.mcp.json',
+    '.cursor/mcp.json',
+    '.claude/claude.json',
+    '.gemini/rules.json',
+  ];
+
+  const agentFiles = [];
+
+  // Scan for agent files
+  for (const pattern of agentFilePatterns) {
+    const fullPath = path.join(projectRoot, pattern);
+    if (fs.existsSync(fullPath)) {
+      agentFiles.push({ path: pattern, fullPath });
+    }
+  }
+
+  // Check adapters directory for MCP configs
+  const adaptersDir = path.join(projectRoot, 'adapters');
+  if (fs.existsSync(adaptersDir)) {
+    const entries = fs.readdirSync(adaptersDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const mcpPath = path.join(adaptersDir, entry.name, '.mcp.json');
+        if (fs.existsSync(mcpPath)) {
+          agentFiles.push({ path: `adapters/${entry.name}/.mcp.json`, fullPath: mcpPath });
+        }
+      }
+    }
+  }
+
+  // Check plugins directory
+  const pluginsDir = path.join(projectRoot, 'plugins');
+  if (fs.existsSync(pluginsDir)) {
+    const entries = fs.readdirSync(pluginsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const mcpPath = path.join(pluginsDir, entry.name, '.mcp.json');
+        if (fs.existsSync(mcpPath)) {
+          agentFiles.push({ path: `plugins/${entry.name}/.mcp.json`, fullPath: mcpPath });
+        }
+      }
+    }
+  }
+
+  auditResults.totalAgentFiles = agentFiles.length;
+
+  // Audit each file for basic governance
+  for (const file of agentFiles) {
+    try {
+      const content = fs.readFileSync(file.fullPath, 'utf-8');
+      const config = JSON.parse(content);
+
+      let auditPass = true;
+      const issues = [];
+
+      // Check for required safety fields
+      if (!config.permissions && !config.allowAllPermissions) {
+        // Not all configs require permissions, so this is optional
+      }
+
+      // Check for proper command structure
+      if (config.mcpServers) {
+        for (const [name, server] of Object.entries(config.mcpServers)) {
+          if (!server.command) {
+            auditPass = false;
+            issues.push(`Server ${name} missing command`);
+          }
+          if (server.cwd && !path.isAbsolute(server.cwd)) {
+            auditPass = false;
+            issues.push(`Server ${name} has relative cwd`);
+          }
+        }
+      }
+
+      auditResults.auditPassCount += auditPass ? 1 : 0;
+      auditResults.auditFailCount += auditPass ? 0 : 1;
+      auditResults.files.push({
+        path: file.path,
+        auditPass,
+        issues: auditPass ? [] : issues,
+        size: fs.statSync(file.fullPath).size,
+      });
+    } catch (err) {
+      auditResults.auditFailCount += 1;
+      auditResults.files.push({
+        path: file.path,
+        auditPass: false,
+        issues: [`Parse error: ${err.message}`],
+        size: 0,
+      });
+    }
+  }
+
+  // Check for server-card.json (MCP registry compatibility)
+  const serverCardPath = path.join(projectRoot, '.well-known', 'mcp', 'server-card.json');
+  if (fs.existsSync(serverCardPath)) {
+    auditResults.serverCard = {
+      present: true,
+      path: '.well-known/mcp/server-card.json',
+    };
+  }
+
+  return auditResults;
+}
+
+// ---------------------------------------------------------------------------
+// Agent Surface Inventory for Pro Dashboard
+// ---------------------------------------------------------------------------
+
+function computeAgentFileAuditFromFeedback(feedbackDir, options = {}) {
+  const readiness = options.readiness || generateAgentReadinessReport({ projectRoot: PROJECT_ROOT });
+  const auditResults = computeAgentFileAudit();
+
+  return {
+    totalAgentFiles: auditResults.totalAgentFiles,
+    audited: auditResults.auditPassCount === auditResults.totalAgentFiles,
+    highRiskCount: auditResults.auditFailCount,
+    readinessScore: readiness.score || 0,
+    lastAuditAt: auditResults.lastAuditAt,
+    details: auditResults.files.map(f => ({
+      path: f.path,
+      safe: f.auditPass,
+      issues: f.issues,
+    })),
+  };
+}
+
 function computeInstrumentationReadiness(analytics, billing) {
   const landingPage = fs.existsSync(LANDING_PAGE_PATH)
     ? fs.readFileSync(LANDING_PAGE_PATH, 'utf-8')
@@ -1529,6 +1724,16 @@ function computeAgentSurfaceInventory(feedbackDir, options = {}) {
     writeCapableTools: readiness.permissions.writeCapableTools.slice(0, 8),
     activeBootstrapFiles: readiness.bootstrap.requiredPresent,
     requiredBootstrapFiles: readiness.bootstrap.requiredCount,
+    // Merged from computeAgentFileAuditFromFeedback — audit pass/fail for dashboard
+    ...(() => {
+      const audit = computeAgentFileAuditFromFeedback(feedbackDir, options);
+      return {
+        totalAgentFiles: audit.totalAgentFiles,
+        audited: audit.audited,
+        highRiskCount: audit.highRiskCount,
+        lastAuditAt: audit.lastAuditAt,
+      };
+    })(),
   };
 }
 
@@ -1598,7 +1803,11 @@ function resolveTeamWindowHours(analyticsWindow) {
 
 function collectAllFeedbackEntries(feedbackDir) {
   if (shouldAggregateFeedback()) {
-    return collectAggregateLogEntries('feedback-log.jsonl', { feedbackDir }).entries;
+    return collectAggregateLogEntries('feedback-log.jsonl', {
+      feedbackDir,
+      maxLines: DEFAULT_JSONL_MAX_ENTRIES,
+      maxBytes: DEFAULT_JSONL_MAX_BYTES,
+    }).entries;
   }
 
   const entries = [];
@@ -1700,7 +1909,11 @@ function generateDashboard(feedbackDir, options = {}) {
       availability: 'private_core',
     };
   const readiness = generateAgentReadinessReport({ projectRoot: PROJECT_ROOT });
-  const feedbackAnalysis = analyzeFeedback(path.join(feedbackDir, 'feedback-log.jsonl'));
+  const feedbackAnalysis = analyzeFeedback(path.join(feedbackDir, 'feedback-log.jsonl'), {
+    entries,
+    maxLines: DEFAULT_JSONL_MAX_ENTRIES,
+    maxBytes: DEFAULT_JSONL_MAX_BYTES,
+  });
   const harness = computeHarnessOverview(feedbackDir, entries);
   const interventionPolicy = getInterventionPolicySummary(feedbackDir);
   const decisionRecords = readDecisionLog(path.join(feedbackDir, DECISION_LOG_FILENAME));
@@ -1803,6 +2016,9 @@ function generateDashboard(feedbackDir, options = {}) {
   });
   const reviewDelta = summarizeReviewDelta(entries, memoryEntries, auditEntries, reviewBaseline, reviewSnapshot);
 
+  // High-ROI metrics for North Star: $100/day after-tax profit
+  const roiSummary = computeRoiSummary(gateStats, prevention, analytics, billingSummary);
+
   return {
     operational: {
       source: options.billingSource || 'local',
@@ -2128,6 +2344,7 @@ module.exports = {
   computeDecisionMetrics,
   computeGateStats,
   computePreventionImpact,
+  computeRoiSummary,
   computeSessionTrend,
   computeSystemHealth,
   computeEfficiencyMetrics,
@@ -2136,6 +2353,8 @@ module.exports = {
   computeAnalyticsSummary,
   computeSecretGuardStats,
   computeObservabilityStats,
+  computeAgentFileAudit,
+  computeAgentSurfaceInventory,
   readJSONL,
   readTextTail,
   readJsonFile,

package/scripts/deepseek-v4-runtime-guardrails.js

@@ -2,6 +2,11 @@
 'use strict';
 
 const { listGateTemplates } = require('./gate-templates');
+const {
+  theoreticalSpeedup,
+  optimalDraftLengthForAttention,
+  isTileAligned,
+} = require('./nvidia-specdecode-al-doctor');
 
 const CATEGORY = 'Sparse Attention Runtime Safety';
 
@@ -33,6 +38,11 @@ function normalizeOptions(options = {}) {
     cacheCoherenceEval: normalizeBoolean(options['cache-coherence-eval'] || options['cache-eval']),
     speculativeDecoding: normalizeBoolean(options['speculative-decoding'] || options.speculative || options.mtp || options.eagle),
     acceptLength: toNumber(options['accept-length'] || options['spec-accept-length']),
+    draftLength: toNumber(options['draft-length'] || options['spec-draft-length'] || options.d),
+    draftDepthRatio: toNumber(options['draft-depth-ratio'] || options.rho),
+    claimedSpeedup: toNumber(options['claimed-speedup'] || options.speedup),
+    queryHeadsPerKvHead: toNumber(options['query-heads-per-kv'] || options.g || options.G),
+    attentionDominated: normalizeBoolean(options['attention-dominated'] || options.attention),
     kvOffload,
     training,
     rolloutReplay: normalizeBoolean(options['rollout-replay'] || options.r3),
@@ -64,7 +74,33 @@ function templateApplicability(template, options) {
     return (options.hybridAttention || isLongContext(options)) && (!options.prefixCache || !options.cacheCoherenceEval);
   }
   if (template.id === 'checkpoint-speculative-decoding-acceptance') {
-    return options.speculativeDecoding && (options.acceptLength === null || options.acceptLength < 2 || !options.cacheCoherenceEval);
+    if (!options.speculativeDecoding) return false;
+    if (options.acceptLength === null || options.acceptLength < 2 || !options.cacheCoherenceEval) return true;
+    if (options.draftLength !== null && options.acceptLength > (1 + options.draftLength)) return true;
+    const rho = options.draftDepthRatio === null ? 0 : options.draftDepthRatio;
+    if (
+      options.claimedSpeedup !== null
+      && options.acceptLength !== null
+      && options.draftLength !== null
+    ) {
+      const theory = theoreticalSpeedup(options.acceptLength, options.draftLength, rho);
+      if (theory !== null && options.claimedSpeedup > theory) return true;
+    }
+    if (
+      options.attentionDominated
+      && options.queryHeadsPerKvHead !== null
+      && options.draftLength !== null
+    ) {
+      const optimal = optimalDraftLengthForAttention(options.queryHeadsPerKvHead);
+      if (
+        optimal !== null
+        && options.draftLength > optimal
+        && !isTileAligned(options.queryHeadsPerKvHead, options.draftLength)
+      ) {
+        return true;
+      }
+    }
+    return false;
   }
   if (template.id === 'require-long-context-kv-offload-capacity-plan') {
     return isLongContext(options) && !options.kvOffload;
@@ -108,15 +144,27 @@ function hybridAttentionSignal(options) {
 }
 
 function speculativeDecodingSignal(options) {
-  if (!(options.speculativeDecoding || options.acceptLength !== null)) return null;
+  if (!(options.speculativeDecoding || options.acceptLength !== null || options.draftLength !== null)) {
+    return null;
+  }
+  const rho = options.draftDepthRatio === null ? 0 : options.draftDepthRatio;
+  const theory = (
+    options.acceptLength !== null && options.draftLength !== null
+  )
+    ? theoreticalSpeedup(options.acceptLength, options.draftLength, rho)
+    : null;
   return {
     id: 'speculative_decoding',
     label: 'Speculative decoding rollout',
     values: [
       options.speculativeDecoding ? 'speculative decoding enabled' : 'speculative decoding not declared',
-      options.acceptLength !== null ? `${options.acceptLength} accept length` : 'accept length missing',
-    ],
-    risk: 'Draft-token metadata and rollback paths can make throughput claims look good while correctness or acceptance collapses.',
+      options.acceptLength !== null ? `${options.acceptLength} accept length (AL)` : 'accept length missing',
+      options.draftLength !== null ? `${options.draftLength} draft length (D)` : null,
+      options.draftDepthRatio !== null ? `ρ=${options.draftDepthRatio}` : null,
+      theory !== null ? `theory ${theory}x = AL/(1+ρD)` : null,
+      options.claimedSpeedup !== null ? `claimed ${options.claimedSpeedup}x` : null,
+    ].filter(Boolean),
+    risk: 'Draft-token metadata and rollback paths can make throughput claims look good while correctness or acceptance collapses. Reject claims above AL/(1+ρD).',
   };
 }
 
@@ -186,6 +234,18 @@ function buildDeepSeekV4RuntimeGuardrailsPlan(rawOptions = {}, templatesPath) {
       newThroughput: options.newThroughput,
       throughputDropPercent: throughputDropPercent(options),
       acceptLength: options.acceptLength,
+      draftLength: options.draftLength,
+      draftDepthRatio: options.draftDepthRatio,
+      claimedSpeedup: options.claimedSpeedup,
+      theoreticalSpeedup: (
+        options.acceptLength !== null && options.draftLength !== null
+      )
+        ? theoreticalSpeedup(
+          options.acceptLength,
+          options.draftLength,
+          options.draftDepthRatio === null ? 0 : options.draftDepthRatio
+        )
+        : null,
       trainInferenceDrift: options.trainInferenceDrift,
     },
     summary: {
@@ -198,11 +258,12 @@ function buildDeepSeekV4RuntimeGuardrailsPlan(rawOptions = {}, templatesPath) {
     nextActions: [
       'Benchmark DeepSeek-V4 behind the same ThumbGate eval harness before changing routing defaults.',
       'Require cache-coherence and rollback evidence before enabling hybrid prefix caching or speculative decoding.',
+      'Measure AL and D; reject speedup claims above AL/(1+ρD) via nvidia-specdecode-al-doctor.',
       'Keep long-context memory and throughput budgets explicit before raising context windows.',
       'For RL or fine-tuning, require rollout-routing replay, indexer replay, and train-inference drift checks.',
       'Treat FP4/FP8 or mixed-precision paths as gated rollouts until deterministic and sensitive-FP32 checks pass.',
     ],
-    exampleCommand: 'npx thumbgate deepseek-v4-runtime-guardrails --context-tokens=900000 --hybrid-attention --speculative-decoding --accept-length=1.4 --precision-mode=fp8 --training --json',
+    exampleCommand: 'npx thumbgate deepseek-v4-runtime-guardrails --context-tokens=900000 --hybrid-attention --speculative-decoding --accept-length=1.4 --draft-length=7 --draft-depth-ratio=0.05 --claimed-speedup=3 --precision-mode=fp8 --training --json',
   };
 }
 
@@ -221,6 +282,11 @@ function formatDeepSeekV4RuntimeGuardrailsPlan(report) {
   if (report.metrics.contextTokens !== null) lines.push(`Context tokens: ${report.metrics.contextTokens}`);
   if (report.metrics.throughputDropPercent !== null) lines.push(`Throughput drop: ${report.metrics.throughputDropPercent}%`);
   if (report.metrics.acceptLength !== null) lines.push(`Spec accept length: ${report.metrics.acceptLength}`);
+  if (report.metrics.draftLength !== null) lines.push(`Spec draft length: ${report.metrics.draftLength}`);
+  if (report.metrics.theoreticalSpeedup !== null) {
+    lines.push(`Spec theory speedup: ${report.metrics.theoreticalSpeedup}x (AL/(1+ρD))`);
+  }
+  if (report.metrics.claimedSpeedup !== null) lines.push(`Spec claimed speedup: ${report.metrics.claimedSpeedup}x`);
   if (report.metrics.trainInferenceDrift !== null) lines.push(`Train/inference drift: ${report.metrics.trainInferenceDrift}`);
 
   if (report.signals.length > 0) {

package/scripts/docker-sandbox-planner.js

@@ -4,6 +4,7 @@
 const path = require('node:path');
 
 const { classifyCommand } = require('./operational-integrity');
+const { classifyHostRole } = require('./agent-egress-policy');
 
 const HIGH_RISK_ACTION_TYPES = new Set([
   'shell.exec',
@@ -41,15 +42,30 @@ function quoteShellArg(value) {
 
 function buildNetworkPolicy(input = {}) {
   const allowedHosts = normalizeStringArray(input.allowedHosts || input.egressAllowlist);
+  const hosts = allowedHosts.map((host) => classifyHostRole(host));
+  const treatAsTrust = input.treatAllowlistAsTrustBoundary === true || input.trusted === true;
+  const bridgeHosts = hosts.filter((row) => row.role === 'bridge');
   if (input.requiresNetwork !== true) {
     return {
       mode: 'deny_all',
       allowedHosts: [],
+      hosts: [],
+      allowlistIsTrustBoundary: false,
     };
   }
   return {
     mode: allowedHosts.length > 0 ? 'allow_list' : 'egress_enabled',
     allowedHosts,
+    hosts,
+    bridgeHosts: bridgeHosts.map((row) => row.host),
+    allowlistIsTrustBoundary: false,
+    independentAuthRequired: bridgeHosts.length > 0,
+    findings: treatAsTrust && bridgeHosts.length
+      ? [{
+        id: 'allowlist_treated_as_trust_boundary',
+        message: 'Docker sandbox allowlist includes package-registry/proxy hops; those are not a trust boundary.',
+      }]
+      : [],
   };
 }
 
@@ -155,6 +171,8 @@ function buildDockerSandboxPlan(input = {}) {
     requiresNetwork: input.requiresNetwork === true || governedCommand || commandInfo.isPublish || actionType === 'upload' || actionType === 'message.send',
     allowedHosts: input.allowedHosts,
     egressAllowlist: input.egressAllowlist,
+    treatAllowlistAsTrustBoundary: input.treatAllowlistAsTrustBoundary,
+    trusted: input.trusted,
   });
   const launchers = buildLaunchers(workspacePath);
   const summary = buildSummary(shouldSandbox, recommendation);