thumbgate 1.14.1 → 1.16.0

package/scripts/tool-registry.js

@@ -387,7 +387,7 @@ const TOOLS = [
   }),
   readOnlyTool({
     name: 'enforcement_matrix',
-    description: 'Show the full Enforcement Matrix: feedback pipeline stats, active pre-action gates, and rejection ledger with revival conditions.',
+    description: 'Show the full Enforcement Matrix: feedback pipeline stats, active pre-action checks, and rejection ledger with revival conditions.',
     inputSchema: {
       type: 'object',
       properties: {},
@@ -773,9 +773,69 @@ const TOOLS = [
     description: 'Predict pre-action workflow risk, blast radius, and remediations before a tool call executes.',
     inputSchema: {
       type: 'object',
-      required: ['toolName'],
       properties: {
-        toolName: { type: 'string', description: 'Tool being assessed, such as Bash, Edit, or Write' },
+        toolName: { type: 'string', description: 'Tool being assessed, such as Bash, Edit, or Write. Optional when provider-native tool call payload is supplied.' },
+        provider: { type: 'string', description: 'Optional provider name, such as anthropic, openai, codex, cursor, gemini, or mcp' },
+        model: { type: 'string', description: 'Optional model name used for audit evidence and budget review' },
+        providerToolCall: {
+          type: 'object',
+          additionalProperties: true,
+          description: 'Provider-native tool call object, including Anthropic tool_use or OpenAI function/tool call shapes',
+        },
+        content: {
+          type: 'array',
+          items: { type: 'object', additionalProperties: true },
+          description: 'Provider-native message content blocks; Anthropic tool_use blocks are normalized automatically',
+        },
+        method: { type: 'string', description: 'Optional JSON-RPC/MCP method, such as tools/call' },
+        params: {
+          type: 'object',
+          additionalProperties: true,
+          description: 'Optional JSON-RPC/MCP params, including tools/call name and arguments, resources/read URI, or prompts/get template arguments',
+        },
+        usage: {
+          type: 'object',
+          additionalProperties: true,
+          description: 'Provider token/cost usage, such as input_tokens, output_tokens, or total_tokens',
+        },
+        tokenEstimate: { type: 'number', description: 'Estimated total tokens for this action when provider usage is unavailable' },
+        costUsd: { type: 'number', description: 'Estimated USD cost for this action when provider usage is unavailable' },
+        budget: {
+          type: 'object',
+          additionalProperties: true,
+          description: 'Optional per-action budget controls: maxTokensPerAction, remainingTokens, maxCostUsdPerAction, remainingCostUsd, maxParallelBranches',
+        },
+        workflowPattern: {
+          type: 'string',
+          enum: ['single_action', 'chaining', 'routing', 'parallelization', 'evaluator-optimizer', 'agent'],
+          description: 'Optional workflow architecture hint. Agents require inspection evidence; predefined workflows are easier to evaluate.',
+        },
+        workflow: {
+          type: 'object',
+          additionalProperties: true,
+          description: 'Optional workflow metadata: pattern, steps, routes, branches, tools, inspection, and verification evidence.',
+        },
+        goal: { type: 'string', description: 'Optional agent goal for open-ended tool planning.' },
+        tools: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional abstract/combinable tool names available to an open-ended agent.',
+        },
+        branches: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional parallel workflow branches for fan-out budget and review checks.',
+        },
+        steps: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional predefined workflow steps for chaining/evaluator workflow audit evidence.',
+        },
+        routes: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional routing workflow destinations or classes.',
+        },
         command: { type: 'string', description: 'Optional shell command when toolName is Bash' },
         filePath: { type: 'string', description: 'Optional primary file path for edit-like tools' },
         changedFiles: {
@@ -841,6 +901,18 @@ const TOOLS = [
       properties: {},
     },
   }),
+  readOnlyTool({
+    name: 'native_messaging_audit',
+    description: 'Audit local browser native messaging hosts and AI browser bridges. Flags missing host binaries, pre-authorized extension bridges, and manifests for browsers not detected locally.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        platform: { type: 'string', enum: ['darwin', 'linux', 'win32'], description: 'Optional platform override for manifest discovery.' },
+        homeDir: { type: 'string', description: 'Optional home-directory override for manifest discovery.' },
+        aiOnly: { type: 'boolean', description: 'When true, only AI/browser bridge manifests are returned.' },
+      },
+    },
+  }),
   readOnlyTool({
     name: 'commerce_recall',
     description: 'Recall past feedback filtered by commerce categories (product_recommendation, brand_compliance, sizing, pricing, regulatory). Returns quality scores alongside memories for agentic commerce agents.',

package/scripts/verification-loop.js

@@ -6,11 +6,20 @@ const {
   getFeedbackPaths,
   appendDiagnosticRecord,
 } = require('./feedback-loop');
+const { loadOptionalModule } = require('./private-core-boundary');
 const {
   buildPartnerStrategy,
   computePartnerReward,
   resolveVerificationRetries,
-} = require('./partner-orchestration');
+} = loadOptionalModule('./partner-orchestration', () => ({
+  buildPartnerStrategy: ({ partnerProfile } = {}) => ({
+    profile: partnerProfile || 'public-shell',
+    verificationMode: 'local-only',
+    recommendedChecks: [],
+  }),
+  computePartnerReward: () => 0,
+  resolveVerificationRetries: (requestedMaxRetries) => requestedMaxRetries,
+}));
 const {
   diagnoseFailure,
 } = require('./failure-diagnostics');

package/scripts/verifier-scoring.js

@@ -0,0 +1,71 @@
+'use strict';
+
+function buildVerifierScoringRubric(options = {}) {
+  const criteria = options.criteria || [
+    'evidence_cited',
+    'scope_respected',
+    'tests_or_proof_run',
+    'claim_matches_artifacts',
+  ];
+  const granularity = Number.isFinite(options.granularity) ? options.granularity : 100;
+  const repeats = Number.isFinite(options.repeats) ? options.repeats : 3;
+
+  return {
+    rubricId: 'granular_llm_verifier',
+    criteria,
+    granularity,
+    repeats,
+    scoring: 'probability_weighted_average',
+    passThreshold: Number.isFinite(options.passThreshold) ? options.passThreshold : 0.82,
+    caveats: [
+      'calibrate against held-out human labels before production blocking',
+      'fall back to coarse scores when model cannot expose score-token probabilities',
+      'never use verifier score alone for destructive actions',
+    ],
+  };
+}
+
+function computeVerifierScore({ scores = [], rubric = buildVerifierScoringRubric() } = {}) {
+  const flattened = scores
+    .flatMap((criterion) => Array.isArray(criterion.repeats) ? criterion.repeats : [])
+    .filter((value) => Number.isFinite(value));
+
+  if (flattened.length === 0) {
+    return {
+      score: 0,
+      decision: 'warn',
+      issues: ['missing_verifier_scores'],
+    };
+  }
+
+  const normalized = flattened.map((value) => value > 1 ? value / rubric.granularity : value);
+  const score = normalized.reduce((sum, value) => sum + value, 0) / normalized.length;
+  const issues = [];
+  if (scores.length < rubric.criteria.length) issues.push('missing_criteria_scores');
+  if (flattened.length < rubric.criteria.length * rubric.repeats) issues.push('missing_repeat_verifications');
+
+  return {
+    score: Number(score.toFixed(4)),
+    decision: score >= rubric.passThreshold && issues.length === 0 ? 'allow' : 'warn',
+    issues,
+  };
+}
+
+function evaluateVerifierSetup(setup = {}) {
+  const issues = [];
+  if (!setup.criteria || setup.criteria.length < 3) issues.push('too_few_criteria');
+  if (!setup.repeats || setup.repeats < 2) issues.push('repeat_verification_required');
+  if (!setup.heldoutCalibration) issues.push('heldout_calibration_required');
+  if (setup.destructiveAction && !setup.humanReview) issues.push('human_review_required_for_destructive_action');
+
+  return {
+    decision: issues.length ? 'warn' : 'allow',
+    issues,
+  };
+}
+
+module.exports = {
+  buildVerifierScoringRubric,
+  computeVerifierScore,
+  evaluateVerifierSetup,
+};