thumbgate 1.14.1 → 1.16.0

package/public/pro.html

@@ -7,14 +7,14 @@ __GOOGLE_SITE_VERIFICATION_META__
 <title>ThumbGate Pro | Personal local dashboard and proof for AI agent reliability</title>
 <meta name="description" content="ThumbGate Pro is the paid lane for individual operators who want a personal local dashboard, DPO export, review-ready evidence, and founder support for risky AI coding workflows.">
 <meta property="og:title" content="ThumbGate Pro | Personal local dashboard and proof for AI agent reliability">
-<meta property="og:description" content="Move from free local gates to a paid operator workflow with a personal local dashboard, DPO export, and review-ready evidence for repeated AI coding failures.">
+<meta property="og:description" content="Move from free local checks to a paid operator workflow with a personal local dashboard, DPO export, and review-ready evidence for repeated AI coding failures.">
 <meta property="og:type" content="website">
 <meta property="og:url" content="__APP_ORIGIN__/pro">
 <link rel="canonical" href="__APP_ORIGIN__/pro">
 <link rel="icon" type="image/png" href="/thumbgate-icon.png">
 <link rel="apple-touch-icon" href="/assets/brand/thumbgate-mark.svg">
 <meta property="og:image" content="/og.png">
-<meta name="keywords" content="ThumbGate Pro, AI agent reliability, pre-action gates, DPO export, local dashboard, review-ready evidence, Claude Code reliability, Codex reliability, Cursor reliability">
+<meta name="keywords" content="ThumbGate Pro, AI agent reliability, pre-action checks, DPO export, local dashboard, review-ready evidence, Claude Code reliability, Codex reliability, Cursor reliability">
 
 <script defer data-domain="thumbgate-production.up.railway.app" src="https://plausible.io/js/script.js"></script>
 __GA_BOOTSTRAP__
@@ -38,14 +38,19 @@ __GA_BOOTSTRAP__
   "description": "Paid ThumbGate lane for individual operators who want a personal local dashboard, DPO export, review-ready evidence, and founder support for risky AI coding workflows.",
   "url": "__APP_ORIGIN__/pro",
   "downloadUrl": "https://www.npmjs.com/package/thumbgate",
+  "dateModified": "2026-04-20",
   "creator": {
     "@type": "Person",
     "name": "Igor Ganapolsky",
-    "url": "https://github.com/IgorGanapolsky"
+    "url": "https://github.com/IgorGanapolsky",
+    "sameAs": [
+      "https://github.com/IgorGanapolsky",
+      "https://www.linkedin.com/in/igorganapolsky"
+    ]
   },
   "featureList": [
     "Personal local dashboard",
-    "Visual gate debugger",
+    "Visual check debugger",
     "DPO export from real thumbs-down corrections",
     "Auto-connect running agents after activation",
     "Founder support on risky workflows",
@@ -82,7 +87,7 @@ __GA_BOOTSTRAP__
       "name": "How is Pro different from the free install?",
       "acceptedAnswer": {
         "@type": "Answer",
-        "text": "Free keeps the local recall, gates, and MCP workflow. Pro adds a personal local dashboard, DPO export, auto-connect for running agents, and founder support for risky workflows."
+        "text": "Free keeps the local recall, checks, and MCP workflow. Pro adds a personal local dashboard, DPO export, auto-connect for running agents, and founder support for risky workflows."
       }
     },
     {
@@ -801,8 +806,9 @@ __GA_BOOTSTRAP__
     <div class="panel hero-copy">
       <div class="eyebrow">Agent governance for engineering teams</div>
       <h1>One correction protects every agent on your team.</h1>
+      <p style="font-size:13px;opacity:0.8;margin-bottom:0.5rem;">Updated: <time datetime="2026-04-20">2026-04-20</time> · by <a href="https://github.com/IgorGanapolsky" style="color:inherit;">Igor Ganapolsky</a></p>
       <p>ThumbGate prevents unsafe AI agent actions before they hit shared repos, CI pipelines, and production. When one developer flags a bad pattern, every agent on the team is permanently blocked from repeating it.</p>
-      <p>Open-source core for individuals. Team plan for shared enforcement, CI gates, approval policies, and audit trails across your engineering org.</p>
+      <p>Open-source core for individuals. Team plan for shared enforcement, CI checks, approval policies, and audit trails across your engineering org.</p>
       <div class="hero-proof">
         <div class="proof-pill">Personal local dashboard</div>
         <div class="proof-pill">DPO export from real corrections</div>
@@ -814,14 +820,14 @@ __GA_BOOTSTRAP__
         <a class="btn-secondary btn-demo" href="/dashboard?utm_source=website&utm_medium=pro_page&utm_campaign=pro_pack">Open dashboard demo</a>
         <a class="btn-ghost btn-free-path" href="/guide?utm_source=website&utm_medium=pro_page&utm_campaign=free_install">Stay on Free and install locally</a>
       </div>
-      <p class="hero-note"><strong>Honest split:</strong> if local recall and gates are enough, stay on Free. Go Pro when you want your own dashboard, DPO training data export, and proof you can show on the next risky workflow review.</p>
+      <p class="hero-note"><strong>Honest split:</strong> if local recall and checks are enough, stay on Free. Go Pro when you want your own dashboard, DPO training data export, and proof you can show on the next risky workflow review.</p>
     </div>
 
     <div class="panel hero-aside">
       <div class="aside-card">
         <div class="aside-kicker">What you are buying</div>
         <h2>A faster operator loop</h2>
-        <p>See every blocked action, the gate that fired, the lesson behind it, and the export path that turns real thumbs-downs into reusable DPO pairs.</p>
+        <p>See every blocked action, the check that fired, the lesson behind it, and the export path that turns real thumbs-downs into reusable DPO pairs.</p>
         <div class="price-stack">
           <div class="price-line">
             <div>
@@ -843,7 +849,7 @@ __GA_BOOTSTRAP__
       <div class="aside-card">
         <div class="aside-kicker">Proof-backed, not vibes</div>
         <h3>Specific paid outcomes</h3>
-        <p>Visual gate debugger, DPO export, auto-connect after activation, Model Hardening Advisor, and founder support for the risky flow you need to harden first.</p>
+        <p>Visual check debugger, DPO export, auto-connect after activation, Model Hardening Advisor, and founder support for the risky flow you need to harden first.</p>
       </div>
 
       <div class="aside-card">
@@ -881,7 +887,7 @@ __GA_BOOTSTRAP__
       </a>
       <a href="/dashboard?utm_source=website&utm_medium=pro_page_proof&utm_campaign=pro_pack">
         <strong>Live dashboard demo</strong>
-        <span>Inspect lessons, gates, and blocked actions before you buy.</span>
+        <span>Inspect lessons, checks, and blocked actions before you buy.</span>
       </a>
     </div>
   </div>
@@ -895,9 +901,9 @@ __GA_BOOTSTRAP__
     <div class="grid-3">
       <div class="feature-card">
         <h3>Debug the exact block in minutes</h3>
-        <p>The visual gate debugger shows every blocked action and the gate that fired, so you stop guessing whether the Reliability Gateway is actually working.</p>
+        <p>The visual check debugger shows every blocked action and the check that fired, so you stop guessing whether the Reliability Gateway is actually working.</p>
         <ul>
-          <li>See the gate, evidence, and lesson behind each deny.</li>
+          <li>See the check, evidence, and lesson behind each deny.</li>
           <li>Trust the system faster on deploys, migrations, and CI.</li>
         </ul>
       </div>
@@ -924,12 +930,12 @@ __GA_BOOTSTRAP__
 <section class="section">
   <div class="container">
     <div class="section-label">Honest packaging</div>
-    <h2 class="section-title">Stay on Free when recall and gates are enough. Go Pro when you need proof and operator speed.</h2>
+    <h2 class="section-title">Stay on Free when recall and checks are enough. Go Pro when you need proof and operator speed.</h2>
     <div class="split-grid">
       <div class="split-card free">
         <div class="split-kicker">Stay on Free</div>
         <h3>The local install is still the right first step</h3>
-        <p>If you only need local recall, Pre-Action Gates, MCP setup, and a way to stop repeated mistakes on one machine, keep the free install and move fast.</p>
+        <p>If you only need local recall, Pre-Action Checks, MCP setup, and a way to stop repeated mistakes on one machine, keep the free install and move fast.</p>
         <ul>
           <li>Local-first recall, lessons, and enforcement.</li>
           <li>No cloud account required.</li>
@@ -957,14 +963,14 @@ __GA_BOOTSTRAP__
       <h3>ThumbGate Team — Agent Governance</h3>
       <div class="price">$49<span>/seat/mo</span></div>
       <div class="annual">Billed monthly or annually · Starts with a 30-min pilot call</div>
-      <p class="pricing-note">Shared enforcement memory, CI gates, approval policies, sandbox routing, and a full audit trail of every blocked agent action across your team.</p>
+      <p class="pricing-note">Shared enforcement memory, CI checks, approval policies, sandbox routing, and a full audit trail of every blocked agent action across your team.</p>
       <ul>
         <li><strong>Shared enforcement</strong> — one developer's correction blocks that pattern for every agent on the team.</li>
-        <li><strong>CI gate integration</strong> — block unsafe merges, enforce test requirements, prevent PRs with unresolved threads.</li>
+        <li><strong>CI check integration</strong> — block unsafe merges, enforce test requirements, prevent PRs with unresolved threads.</li>
         <li><strong>Approval policies</strong> — require human sign-off for high-risk actions (production deploys, schema migrations, destructive SQL).</li>
         <li><strong>Audit trail</strong> — every blocked action logged with timestamp, agent, context, and the rule that fired.</li>
         <li><strong>Sandbox routing</strong> — route risky agent runs into isolated execution environments.</li>
-        <li><strong>Org dashboard</strong> — active agents, gate hit rates, risk scores, and proof-backed team metrics.</li>
+        <li><strong>Org dashboard</strong> — active agents, check hit rates, risk scores, and proof-backed team metrics.</li>
       </ul>
       <div class="pricing-actions">
         <a class="btn-primary" href="/#workflow-sprint-intake">Book a Team Pilot Call</a>
@@ -985,7 +991,7 @@ __GA_BOOTSTRAP__
       <div class="team-card">
         <div class="section-label" style="text-align:left;margin-bottom:8px;">Free path</div>
         <h3>Prefer the local install first?</h3>
-        <p class="comparison-note">Install with <code style="font-family:var(--mono);color:var(--cyan);">npx thumbgate init</code>, keep the free local gates, and come back to Pro once the workflow owner asks for your own dashboard, exports, or review-ready proof.</p>
+        <p class="comparison-note">Install with <code style="font-family:var(--mono);color:var(--cyan);">npx thumbgate init</code>, keep the free local checks, and come back to Pro once the workflow owner asks for your own dashboard, exports, or review-ready proof.</p>
       </div>
     </div>
   </div>
@@ -998,7 +1004,7 @@ __GA_BOOTSTRAP__
     <div class="faq-list">
       <div class="faq-item open">
         <button class="faq-q" type="button" onclick="toggleFaq(this)" onkeydown="handleFaqKeydown(event)" aria-expanded="true">How is Pro different from the free install?</button>
-        <div class="faq-a">Free keeps the local recall, Pre-Action Gates, and MCP setup. Pro adds the personal local dashboard, DPO export, auto-connect after activation, and founder support when one risky workflow keeps repeating the same failure mode.</div>
+        <div class="faq-a">Free keeps the local recall, Pre-Action Checks, and MCP setup. Pro adds the personal local dashboard, DPO export, auto-connect after activation, and founder support when one risky workflow keeps repeating the same failure mode.</div>
       </div>
       <div class="faq-item">
         <button class="faq-q" type="button" onclick="toggleFaq(this)" onkeydown="handleFaqKeydown(event)" aria-expanded="false">Does Pro require a cloud account?</button>
@@ -1044,6 +1050,46 @@ __GA_BOOTSTRAP__
 
 <script src="/js/buyer-intent.js"></script>
 <script>
+function readMarketingParam(name) {
+  var params = new URLSearchParams(window.location.search);
+  return params.get(name);
+}
+
+function sendFirstPartyTelemetry(eventType, props) {
+  var payload = Object.assign({
+    eventType: eventType,
+    clientType: 'web',
+    acquisitionId: serverAcquisitionId,
+    visitorId: serverVisitorId,
+    sessionId: serverSessionId,
+    source: readMarketingParam('utm_source') || readMarketingParam('source') || 'website',
+    utmSource: readMarketingParam('utm_source') || 'website',
+    utmMedium: readMarketingParam('utm_medium') || 'pro_page',
+    utmCampaign: readMarketingParam('utm_campaign') || 'pro_pack',
+    utmContent: readMarketingParam('utm_content'),
+    utmTerm: readMarketingParam('utm_term'),
+    creator: readMarketingParam('creator') || readMarketingParam('creator_handle'),
+    community: readMarketingParam('community') || readMarketingParam('subreddit'),
+    postId: readMarketingParam('post_id'),
+    commentId: readMarketingParam('comment_id'),
+    campaignVariant: readMarketingParam('campaign_variant'),
+    offerCode: readMarketingParam('offer_code'),
+    page: '/pro',
+    landingPath: '/pro'
+  }, props || {});
+  var body = JSON.stringify(payload);
+  if (navigator.sendBeacon) {
+    navigator.sendBeacon('/v1/telemetry/ping', new Blob([body], { type: 'application/json' }));
+    return;
+  }
+  fetch('/v1/telemetry/ping', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: body,
+    keepalive: true,
+  }).catch(function() {});
+}
+
 function initializeBuyerIntent() {
   globalThis.ThumbGateBuyerIntent.initializeBuyerIntent({
     page: 'pro',
@@ -1060,6 +1106,11 @@ function trackClick(selector, eventName, props) {
   document.querySelectorAll(selector).forEach(function(el) {
     el.addEventListener('click', function() {
       if (typeof plausible === 'function') plausible(eventName, { props: props || {} });
+      sendFirstPartyTelemetry(eventName, Object.assign({}, props || {}, {
+        ctaId: (props && props.ctaId) || eventName,
+        ctaPlacement: (props && props.ctaPlacement) || 'pro_page',
+        planId: (props && props.planId) || null,
+      }));
     });
   });
 }
@@ -1081,6 +1132,25 @@ trackClick('.btn-demo', 'pro_demo_click', { page: 'pro' });
 trackClick('.btn-free-path', 'pro_free_path_click', { page: 'pro' });
 trackClick('.proof-links a', 'pro_proof_click', { page: 'pro' });
 initializeBuyerIntent();
+globalThis.buyerJourney = globalThis.ThumbGateBuyerIntent.initializeBehaviorAnalytics({
+  pageType: 'marketing',
+  pagePath: '/pro',
+  landingPath: '/pro',
+  sendTelemetry: sendFirstPartyTelemetry,
+  emailSelector: '[data-buyer-email]',
+  sections: [
+    { selector: '.hero', sectionId: 'hero', sectionLabel: 'Hero' },
+    { selector: '#proof', sectionId: 'proof', sectionLabel: 'Proof' },
+    { selector: '#why-pay', sectionId: 'why_pay', sectionLabel: 'Why Pay' },
+    { selector: '#pricing', sectionId: 'pricing', sectionLabel: 'Pricing' },
+    { selector: '#faq', sectionId: 'faq', sectionLabel: 'FAQ' }
+  ],
+  ctaImpressions: [
+    { selector: '.btn-pro-checkout', ctaId: 'pro_checkout', ctaPlacement: 'pro_page', planId: 'pro' },
+    { selector: '.btn-demo', ctaId: 'pro_demo', ctaPlacement: 'pro_page', planId: 'proof' },
+    { selector: '.btn-free-path', ctaId: 'pro_free_path', ctaPlacement: 'pro_page', planId: 'free' }
+  ]
+});
 
 document.querySelectorAll('.faq-q').forEach(function(el) {
   el.addEventListener('click', function() {

package/scripts/agent-audit-trace.js

@@ -0,0 +1,55 @@
+'use strict';
+
+function buildAgentAuditSpan(input = {}) {
+  return {
+    runId: input.runId || null,
+    spanId: input.spanId || null,
+    parentSpanId: input.parentSpanId || null,
+    stage: input.stage || 'unknown',
+    promptHash: input.promptHash || null,
+    model: input.model || null,
+    reasoningSummary: input.reasoningSummary || null,
+    dataAccessed: Array.isArray(input.dataAccessed) ? input.dataAccessed : [],
+    toolsUsed: Array.isArray(input.toolsUsed) ? input.toolsUsed : [],
+    decision: input.decision || null,
+    evidenceIds: Array.isArray(input.evidenceIds) ? input.evidenceIds : [],
+    safetyEvents: Array.isArray(input.safetyEvents) ? input.safetyEvents : [],
+    cost: {
+      inputTokens: Number(input.inputTokens || 0),
+      outputTokens: Number(input.outputTokens || 0),
+      latencyMs: Number(input.latencyMs || 0),
+    },
+  };
+}
+
+function evaluateAgentAuditTrace(trace = {}) {
+  const spans = Array.isArray(trace.spans) ? trace.spans : [];
+  const issues = [];
+
+  if (!trace.runId) issues.push('missing_run_id');
+  if (spans.length === 0) issues.push('missing_spans');
+  if (!spans.some((span) => span.stage === 'input')) issues.push('missing_input_span');
+  if (!spans.some((span) => span.stage === 'decision')) issues.push('missing_decision_span');
+  if (spans.some((span) => !span.promptHash && span.stage === 'input')) issues.push('input_prompt_hash_required');
+  if (spans.some((span) => span.toolsUsed?.length && !span.evidenceIds?.length)) issues.push('tool_span_requires_evidence_ids');
+  if (spans.some((span) => span.dataAccessed?.length && !span.evidenceIds?.length)) issues.push('data_access_requires_evidence_ids');
+
+  const totalTokens = spans.reduce((sum, span) => sum + (span.cost?.inputTokens || 0) + (span.cost?.outputTokens || 0), 0);
+  const totalLatencyMs = spans.reduce((sum, span) => sum + (span.cost?.latencyMs || 0), 0);
+
+  return {
+    decision: issues.length ? 'warn' : 'allow',
+    issues,
+    totals: {
+      spans: spans.length,
+      totalTokens,
+      totalLatencyMs,
+      safetyEvents: spans.reduce((sum, span) => sum + (span.safetyEvents?.length || 0), 0),
+    },
+  };
+}
+
+module.exports = {
+  buildAgentAuditSpan,
+  evaluateAgentAuditTrace,
+};

package/scripts/agent-memory-lifecycle.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+'use strict';
+
+const MEMORY_TYPES = new Set(['episodic', 'semantic', 'procedural', 'preference', 'working']);
+
+function normalizeText(value) {
+  if (value === undefined || value === null) return '';
+  return String(value).trim();
+}
+
+function normalizeMemoryType(value) {
+  const normalized = normalizeText(value).toLowerCase();
+  return MEMORY_TYPES.has(normalized) ? normalized : 'episodic';
+}
+
+function buildMemoryLifecyclePolicy(input = {}) {
+  return {
+    generatedAt: normalizeText(input.generatedAt) || new Date().toISOString(),
+    memoryTypes: [
+      {
+        type: 'working',
+        purpose: 'Short-lived task context.',
+        retention: 'session',
+        promotionGate: 'discard unless referenced by outcome evidence',
+      },
+      {
+        type: 'episodic',
+        purpose: 'Specific agent actions, feedback, and outcomes.',
+        retention: 'bounded_history',
+        promotionGate: 'requires actionable context and source trace',
+      },
+      {
+        type: 'semantic',
+        purpose: 'Consolidated facts, standards, and reusable lessons.',
+        retention: 'durable',
+        promotionGate: 'requires deduplication and contradiction check',
+      },
+      {
+        type: 'procedural',
+        purpose: 'Reusable workflows, prompt programs, and gates.',
+        retention: 'durable',
+        promotionGate: 'requires test or replay evidence',
+      },
+      {
+        type: 'preference',
+        purpose: 'Operator style and decision preferences.',
+        retention: 'durable_redactable',
+        promotionGate: 'requires explicit user signal',
+      },
+    ],
+    retrieval: {
+      defaultTopK: 8,
+      recencyWeight: 0.25,
+      semanticWeight: 0.5,
+      outcomeWeight: 0.25,
+      requireSourceAnchors: true,
+    },
+    privacy: {
+      piiScanRequired: true,
+      secretScanRequired: true,
+      exportRequiresRedaction: true,
+    },
+  };
+}
+
+function evaluateMemoryPromotion(memory = {}, policy = buildMemoryLifecyclePolicy()) {
+  const type = normalizeMemoryType(memory.type);
+  const content = normalizeText(memory.content);
+  const source = normalizeText(memory.source);
+  const outcome = normalizeText(memory.outcome);
+  const issues = [];
+
+  if (!content) issues.push('missing_content');
+  if (!source) issues.push('missing_source_anchor');
+  if (type !== 'preference' && !outcome) issues.push('missing_outcome');
+  if (/api[_-]?key|secret|password|token|bearer\s+[a-z0-9._-]+/i.test(content)) {
+    issues.push('secret_like_content');
+  }
+  if (type === 'preference' && memory.explicitUserSignal !== true) {
+    issues.push('preference_without_explicit_signal');
+  }
+
+  return {
+    type,
+    decision: issues.length === 0 ? 'promote' : 'hold',
+    issues,
+    retrievalEligible: issues.length === 0 || !issues.includes('secret_like_content'),
+    policyVersion: policy.generatedAt,
+  };
+}
+
+module.exports = {
+  buildMemoryLifecyclePolicy,
+  evaluateMemoryPromotion,
+  normalizeMemoryType,
+};

package/scripts/agent-readiness-plan.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const DEFAULT_CHECKS = [
+  {
+    id: 'robots_ai_rules',
+    category: 'discoverability',
+    artifact: 'public/robots.txt',
+    requirement: 'Declare sitemap and AI bot access policy.',
+  },
+  {
+    id: 'sitemap',
+    category: 'discoverability',
+    artifact: 'public/sitemap.xml',
+    requirement: 'Expose canonical public pages for crawlers and AI agents.',
+  },
+  {
+    id: 'markdown_negotiation',
+    category: 'content_accessibility',
+    artifact: 'public/llm-context.md',
+    requirement: 'Offer dense Markdown context for agents that prefer text-first retrieval.',
+  },
+  {
+    id: 'mcp_server_card',
+    category: 'protocol_discovery',
+    artifact: 'public/.well-known/mcp-server.json',
+    requirement: 'Publish MCP discovery metadata for agent tools.',
+  },
+  {
+    id: 'agent_skills',
+    category: 'protocol_discovery',
+    artifact: 'public/.well-known/agent-skills.json',
+    requirement: 'Describe callable skills and evidence requirements.',
+  },
+  {
+    id: 'oauth_protected_resource',
+    category: 'api_auth',
+    artifact: 'public/.well-known/oauth-protected-resource',
+    requirement: 'Advertise protected API resource metadata when authenticated tools exist.',
+  },
+  {
+    id: 'agentic_commerce',
+    category: 'commerce',
+    artifact: 'public/.well-known/agentic-commerce.json',
+    requirement: 'Expose paid plan, checkout, refund, and support metadata for commerce agents.',
+  },
+];
+
+function normalizeExisting(existing = []) {
+  if (Array.isArray(existing)) return new Set(existing);
+  return new Set(Object.entries(existing).filter(([, present]) => present).map(([id]) => id));
+}
+
+function buildAgentReadinessPlan(options = {}) {
+  const baseUrl = options.baseUrl || 'https://thumbgate-production.up.railway.app';
+  const existing = normalizeExisting(options.existing);
+  const checks = (options.checks || DEFAULT_CHECKS).map((check) => {
+    const present = existing.has(check.id) || existing.has(check.artifact);
+    return {
+      ...check,
+      status: present ? 'present' : 'missing',
+      url: check.artifact.startsWith('public/')
+        ? `${baseUrl}/${check.artifact.replace(/^public\//, '')}`
+        : `${baseUrl}/${check.artifact}`,
+    };
+  });
+  const missing = checks.filter((check) => check.status === 'missing');
+
+  return {
+    baseUrl,
+    score: Math.round(((checks.length - missing.length) / checks.length) * 100),
+    checks,
+    quickWins: missing
+      .filter((check) => ['discoverability', 'content_accessibility', 'protocol_discovery'].includes(check.category))
+      .slice(0, 5)
+      .map((check) => ({
+        id: check.id,
+        action: `publish ${check.artifact}`,
+        reason: check.requirement,
+      })),
+    promotionAngles: [
+      'agent-ready pre-action gates',
+      'MCP-discoverable reliability gateway',
+      'machine-readable evidence before agent actions',
+      'commerce metadata for paid operator lanes',
+    ],
+  };
+}
+
+function evaluateAgentReadinessPlan(plan) {
+  const issues = [];
+  const required = [
+    'robots_ai_rules',
+    'sitemap',
+    'markdown_negotiation',
+    'mcp_server_card',
+  ];
+  const byId = new Map((plan.checks || []).map((check) => [check.id, check]));
+
+  for (const id of required) {
+    if (byId.get(id)?.status !== 'present') issues.push(`missing_${id}`);
+  }
+
+  if (!plan.baseUrl?.startsWith('https://')) {
+    issues.push('https_base_url_required');
+  }
+
+  return {
+    decision: issues.length ? 'warn' : 'allow',
+    issues,
+    score: plan.score || 0,
+  };
+}
+
+module.exports = {
+  DEFAULT_CHECKS,
+  buildAgentReadinessPlan,
+  evaluateAgentReadinessPlan,
+};

package/scripts/agentic-data-pipeline.js

@@ -17,7 +17,27 @@ const {
   serializeAnalyticsWindow,
 } = require('./analytics-window');
 const { appendWorkflowRun } = require('./workflow-runs');
-const { buildPredictiveInsights } = require('./predictive-insights');
+const {
+  createUnavailableReport,
+  loadOptionalModule,
+} = require('./private-core-boundary');
+const { buildPredictiveInsights } = loadOptionalModule('./predictive-insights', () => ({
+  buildPredictiveInsights: () => ({
+    opportunitySummary: [],
+    anomalySummary: { count: 0, severity: 'none' },
+    topCreators: [],
+    topSources: [],
+    upgradePropensity: {
+      pro: { band: 'unavailable', score: 0 },
+      team: { band: 'unavailable', score: 0 },
+    },
+    revenueForecast: {
+      predictedBookedRevenueCents: 0,
+      incrementalOpportunityCents: 0,
+    },
+    ...createUnavailableReport('Predictive insights'),
+  }),
+}));
 const { ensureDir } = require('./fs-utils');
 
 const PIPELINE_DIRNAME = 'agentic-data-pipeline';

package/scripts/agents-sdk-sandbox-plan.js

@@ -0,0 +1,57 @@
+'use strict';
+
+function buildAgentsSdkSandboxPlan(options = {}) {
+  const provider = options.provider || 'unix_local';
+  const mounts = options.mounts || [{ name: 'data', mode: 'read_only' }];
+  const outputDir = options.outputDir || 'outputs';
+
+  return {
+    harness: 'openai_agents_sdk_sandbox',
+    provider,
+    manifest: {
+      mounts,
+      outputDir,
+      network: options.network || 'disabled_by_default',
+      allowedCommands: options.allowedCommands || ['npm test', 'npm run test:coverage'],
+    },
+    separation: {
+      credentialsInSandbox: false,
+      toolBrokerOwnsSecrets: true,
+      sandboxGetsScopedFilesOnly: true,
+    },
+    durability: {
+      externalState: true,
+      checkpoints: ['manifest_loaded', 'tools_completed', 'patch_written', 'tests_run'],
+      rehydrateOnSandboxLoss: true,
+    },
+    gates: [
+      'read manifest before file access',
+      'write only under declared output or scoped repo path',
+      'cite source filenames for data-room answers',
+      'run configured verification before completion claim',
+      'persist decision journal outside sandbox',
+    ],
+  };
+}
+
+function evaluateSandboxPlan(plan = {}) {
+  const issues = [];
+  if (!plan.manifest?.mounts?.length) issues.push('missing_manifest_mounts');
+  if (!plan.manifest?.outputDir) issues.push('missing_output_dir');
+  if (plan.separation?.credentialsInSandbox !== false) issues.push('credentials_must_stay_outside_sandbox');
+  if (!plan.durability?.externalState) issues.push('external_state_required');
+  if (!plan.durability?.rehydrateOnSandboxLoss) issues.push('rehydration_required');
+  if (!Array.isArray(plan.gates) || !plan.gates.some((gate) => /verification/i.test(gate))) {
+    issues.push('verification_gate_required');
+  }
+
+  return {
+    decision: issues.length ? 'warn' : 'allow',
+    issues,
+  };
+}
+
+module.exports = {
+  buildAgentsSdkSandboxPlan,
+  evaluateSandboxPlan,
+};