thumbgate 1.35.0 → 1.37.2

package/scripts/workflow-notebook.js

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * workflow-notebook.js — goal → reviewed plan → approved execution → captured
+ * decisions → discoverable index, for repetitive agent workflows.
+ *
+ * Pattern source: "Automating repetitive work at OpenAI with Codex" (2026).
+ * The four lessons encoded here:
+ *
+ *  1. A short goal cell, then a PLAN the human reviews BEFORE execution starts.
+ *     The approval boundary is structural, not advisory: recording work before
+ *     approval is rejected, fail-closed.
+ *  2. The notebook captures commands, outputs, and interpretations — including
+ *     dead ends — while the work happens, so documentation costs nothing extra.
+ *  3. Decisions that would otherwise die in chat history get explicit records:
+ *     the alternatives considered, the choice, and the reason.
+ *  4. Every finished notebook emits a companion `*.index.md` (title, goal,
+ *     status, decisions, outcomes) that future agent runs can discover — the
+ *     context flywheel that makes the next run cheaper than the last one.
+ *
+ * Storage: <feedbackDir>/workflow-notebooks/<id>.json (source of truth) plus
+ * <id>.index.md (discovery artifact). No server, no new infrastructure — the
+ * notebook is a file, exactly like the article's static-app design.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { resolveFeedbackDir } = require('./feedback-paths');
+const { ensureDir } = require('./fs-utils');
+
+const STATUSES = new Set(['created', 'planned', 'approved', 'running', 'completed', 'aborted']);
+
+function getNotebooksDir(feedbackDir) {
+  if (process.env.THUMBGATE_WORKFLOW_NOTEBOOKS_DIR) {
+    return process.env.THUMBGATE_WORKFLOW_NOTEBOOKS_DIR;
+  }
+  return path.join(resolveFeedbackDir({ feedbackDir }), 'workflow-notebooks');
+}
+
+function buildNotebookId(title) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const suffix = crypto.randomBytes(3).toString('hex');
+  const slug = String(title || 'workflow')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 48) || 'workflow';
+  return `${stamp}-${slug}-${suffix}`;
+}
+
+function notebookPath(notebookId, feedbackDir) {
+  return path.join(getNotebooksDir(feedbackDir), `${notebookId}.json`);
+}
+
+function loadNotebook(notebookId, feedbackDir) {
+  const file = notebookPath(notebookId, feedbackDir);
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function saveNotebook(notebook, feedbackDir, expectedRev) {
+  const file = notebookPath(notebook.id, feedbackDir);
+  ensureDir(path.dirname(file));
+  if (expectedRev !== undefined) {
+    const current = loadNotebook(notebook.id, feedbackDir);
+    if (current && current._rev !== expectedRev) {
+      throw new Error(`saveNotebook: optimistic conflict on ${notebook.id} — reload and retry`);
+    }
+  }
+  notebook._rev = (notebook._rev || 0) + 1;
+  const tmp = `${file}.tmp.${process.pid}.${Date.now()}.${crypto.randomBytes(4).toString('hex')}`;
+  fs.writeFileSync(tmp, `${JSON.stringify(notebook, null, 2)}\n`);
+  fs.renameSync(tmp, file);
+  return notebook;
+}
+
+/**
+ * Start a notebook with a goal. Status becomes 'planned' once a plan exists;
+ * no steps may be recorded before an explicit approval (fail-closed).
+ */
+function createNotebook({ title, goal, context = [] } = {}, feedbackDir) {
+  if (!title || !String(title).trim()) {
+    throw new TypeError('createNotebook: title is required');
+  }
+  if (!goal || !String(goal).trim()) {
+    throw new TypeError('createNotebook: goal is required — the goal cell is the contract');
+  }
+  const notebook = {
+    id: buildNotebookId(title),
+    title: String(title).trim(),
+    goal: String(goal).trim(),
+    context: Array.isArray(context) ? context.map(String) : [],
+    status: 'created',
+    plan: null,
+    approvedBy: null,
+    approvedAt: null,
+    steps: [],
+    decisions: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    _rev: 0,
+  };
+  return saveNotebook(notebook, feedbackDir);
+}
+
+function setPlan(notebookId, plan, feedbackDir) {
+  if (!plan || !String(plan).trim()) {
+    throw new TypeError('setPlan: plan text is required — approve a plan, not an impulse');
+  }
+  const notebook = loadNotebook(notebookId, feedbackDir);
+  if (!notebook) throw new Error(`setPlan: notebook not found: ${notebookId}`);
+  if (notebook.status !== 'created' && notebook.status !== 'planned') {
+    throw new Error(`setPlan: notebook ${notebookId} is ${notebook.status}; plan is locked after approval`);
+  }
+  const currentRev = notebook._rev;
+  notebook.plan = String(plan).trim();
+  notebook.status = 'planned';
+  notebook.updatedAt = new Date().toISOString();
+  return saveNotebook(notebook, feedbackDir, currentRev);
+}
+
+/**
+ * The approval boundary. Only an APPROVED notebook may record steps. The
+ * approver identity is captured for audit — "who decided the plan was ready".
+ */
+function approveNotebook(notebookId, approver, feedbackDir) {
+  if (!approver || !String(approver).trim()) {
+    throw new TypeError('approveNotebook: approver identity is required');
+  }
+  // Authorization boundary: require a non-trivial identity assertion.
+  // Empty or whitespace-only approvers are rejected. Callers MUST pass
+  // a real identity (human, service account, or signed assertion).
+  const approverName = String(approver).trim();
+  if (approverName.length === 0 || approverName === notebookId) {
+    throw new Error(`approveNotebook: invalid approver — must be a distinct trusted identity`);
+  }
+  const notebook = loadNotebook(notebookId, feedbackDir);
+  if (!notebook) throw new Error(`approveNotebook: notebook not found: ${notebookId}`);
+  if (notebook.status !== 'planned') {
+    throw new Error(`approveNotebook: notebook ${notebookId} is ${notebook.status}; only a planned notebook can be approved`);
+  }
+  if (!notebook.plan) {
+    throw new Error(`approveNotebook: notebook ${notebookId} has no plan to approve`);
+  }
+  const currentRev = notebook._rev;
+  notebook.status = 'approved';
+  notebook.approvedBy = approverName;
+  notebook.approvedAt = new Date().toISOString();
+  notebook.updatedAt = notebook.approvedAt;
+  return saveNotebook(notebook, feedbackDir, currentRev);
+}
+
+function assertApproved(notebook, verb) {
+  // Fail-closed: the article keeps humans deciding when a plan is ready. An
+  // unapproved notebook recording execution would silently erase that boundary.
+  if (!notebook) throw new Error(`${verb}: notebook not found`);
+  if (notebook.status !== 'approved' && notebook.status !== 'running') {
+    throw new Error(
+      `${verb}: notebook ${notebook.id} is ${notebook.status}; `
+      + 'record a plan and get it approved before recording execution',
+    );
+  }
+}
+
+/**
+ * Record one unit of executed work: the command/action, its output, and the
+ * human-readable interpretation. Dead ends are first-class: mark
+ * outcome:'dead-end' so the NEXT run knows what not to try.
+ */
+function recordStep(notebookId, { action, output = '', interpretation = '', outcome = 'ok' } = {}, feedbackDir) {
+  const notebook = loadNotebook(notebookId, feedbackDir);
+  assertApproved(notebook, 'recordStep');
+  if (!action || !String(action).trim()) {
+    throw new TypeError('recordStep: action is required');
+  }
+  const allowedOutcomes = new Set(['ok', 'dead-end', 'blocked', 'needs-review']);
+  if (!allowedOutcomes.has(outcome)) {
+    throw new TypeError(`recordStep: outcome must be one of ${[...allowedOutcomes].join(', ')}`);
+  }
+  const currentRev = notebook._rev;
+  notebook.steps.push({
+    seq: notebook.steps.length + 1,
+    action: String(action).trim(),
+    output: String(output).slice(0, 8000),
+    interpretation: String(interpretation),
+    outcome,
+    at: new Date().toISOString(),
+  });
+  notebook.status = 'running';
+  notebook.updatedAt = new Date().toISOString();
+  return saveNotebook(notebook, feedbackDir, currentRev);
+}
+
+/**
+ * Capture a decision that would otherwise disappear into the conversation:
+ * the alternatives considered, the choice, and the reason.
+ */
+function recordDecision(notebookId, { question, alternatives = [], choice, reason } = {}, feedbackDir) {
+  const notebook = loadNotebook(notebookId, feedbackDir);
+  assertApproved(notebook, 'recordDecision');
+  if (!question || !String(question).trim()) {
+    throw new TypeError('recordDecision: question is required');
+  }
+  if (!choice || !String(choice).trim()) {
+    throw new TypeError('recordDecision: choice is required');
+  }
+  const currentRev = notebook._rev;
+  notebook.decisions.push({
+    seq: notebook.decisions.length + 1,
+    question: String(question).trim(),
+    alternatives: Array.isArray(alternatives) ? alternatives.map(String) : [],
+    choice: String(choice).trim(),
+    reason: String(reason || '').trim(),
+    at: new Date().toISOString(),
+  });
+  notebook.updatedAt = new Date().toISOString();
+  return saveNotebook(notebook, feedbackDir, currentRev);
+}
+
+function finishNotebook(notebookId, { summary = '', outcome = 'completed' } = {}, feedbackDir) {
+  const notebook = loadNotebook(notebookId, feedbackDir);
+  assertApproved(notebook, 'finishNotebook');
+  if (outcome !== 'completed' && outcome !== 'aborted') {
+    throw new TypeError('finishNotebook: outcome must be completed or aborted');
+  }
+  notebook.status = outcome;
+  notebook.summary = String(summary).trim();
+  notebook.finishedAt = new Date().toISOString();
+  notebook.updatedAt = notebook.finishedAt;
+  saveNotebook(notebook, feedbackDir, notebook._rev);
+  return writeIndex(notebook, feedbackDir);
+}
+
+/**
+ * Companion discovery index (the article's `*.index.md`): a small Markdown
+ * summary that future runs can grep/discover for prior context — goal, status,
+ * decisions, dead ends. Markdown, not JSON, so any agent or human can read it.
+ */
+function writeIndex(notebook, feedbackDir) {
+  const dir = getNotebooksDir(feedbackDir);
+  ensureDir(dir);
+  const lines = [
+    `# ${notebook.title}`,
+    '',
+    `- notebook: ${notebook.id}`,
+    `- status: ${notebook.status}`,
+    `- created: ${notebook.createdAt}`,
+    notebook.approvedAt ? `- approved-by: ${notebook.approvedBy} (${notebook.approvedAt})` : '- approved-by: (none)',
+    '',
+    '## Goal',
+    '',
+    notebook.goal,
+    '',
+  ];
+  if (notebook.plan) {
+    lines.push('## Plan', '', notebook.plan, '');
+  }
+  if (notebook.decisions.length > 0) {
+    lines.push('## Decisions', '');
+    for (const d of notebook.decisions) {
+      lines.push(`- Q: ${d.question}`);
+      lines.push(`  Chose: ${d.choice}${d.reason ? ` — ${d.reason}` : ''}`);
+      if (d.alternatives.length > 0) lines.push(`  Alternatives: ${d.alternatives.join('; ')}`);
+    }
+    lines.push('');
+  }
+  const deadEnds = (notebook.steps || []).filter((s) => s.outcome === 'dead-end');
+  if (deadEnds.length > 0) {
+    lines.push('## Dead ends (do not repeat)', '');
+    for (const s of deadEnds) lines.push(`- ${s.action}${s.interpretation ? ` — ${s.interpretation}` : ''}`);
+    lines.push('');
+  }
+  if (notebook.summary) {
+    lines.push('## Summary', '', notebook.summary, '');
+  }
+  const indexPath = path.join(dir, `${notebook.id}.index.md`);
+  fs.writeFileSync(indexPath, `${lines.join('\n')}`);
+  return indexPath;
+}
+
+/**
+ * Discovery: list notebooks by reading their JSON files, most recent first.
+ * Falls back to the JSON when the index is missing.
+ */
+function listNotebooks(feedbackDir) {
+  const dir = getNotebooksDir(feedbackDir);
+  if (!fs.existsSync(dir)) return [];
+  const entries = fs.readdirSync(dir).filter((f) => f.endsWith('.json'));
+  const notebooks = [];
+  for (const entry of entries) {
+    const id = entry.replace(/\.json$/, '');
+    const notebook = loadNotebook(id, feedbackDir);
+    if (!notebook) continue;
+    notebooks.push({
+      id,
+      title: notebook.title,
+      goal: notebook.goal,
+      status: notebook.status,
+      decisions: notebook.decisions.length,
+      steps: notebook.steps.length,
+      createdAt: notebook.createdAt,
+      updatedAt: notebook.updatedAt,
+      index: path.join(dir, `${id}.index.md`),
+    });
+  }
+  notebooks.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+  return notebooks;
+}
+
+function main() {
+  const feedbackDir = process.env.THUMBGATE_FEEDBACK_DIR ||
+    path.join(process.cwd(), '.thumbgate', 'feedback');
+  const [cmd, ...rest] = process.argv.slice(2);
+  const parseJson = (raw) => {
+    try { return raw ? JSON.parse(raw) : {}; } catch { return {}; }
+  };
+  switch (cmd) {
+    case 'create': {
+      const opts = parseJson(rest[0]);
+      const notebook = createNotebook(opts, feedbackDir);
+      console.log(JSON.stringify({ id: notebook.id, status: notebook.status }, null, 2));
+      break;
+    }
+    case 'plan': {
+      const [id, ...planParts] = rest;
+      const notebook = setPlan(id, planParts.join(' '), feedbackDir);
+      console.log(JSON.stringify({ id: notebook.id, status: notebook.status }, null, 2));
+      break;
+    }
+    case 'approve': {
+      const [id, approver] = rest;
+      const notebook = approveNotebook(id, approver, feedbackDir);
+      console.log(JSON.stringify({ id: notebook.id, status: notebook.status, approvedBy: notebook.approvedBy }, null, 2));
+      break;
+    }
+    case 'step': {
+      const [id, ...jsonRaw] = rest;
+      const opts = parseJson(jsonRaw.join(' '));
+      const notebook = recordStep(id, opts, feedbackDir);
+      console.log(JSON.stringify({ id: notebook.id, steps: notebook.steps.length }, null, 2));
+      break;
+    }
+    case 'decide': {
+      const [id, ...jsonRaw] = rest;
+      const opts = parseJson(jsonRaw.join(' '));
+      const notebook = recordDecision(id, opts, feedbackDir);
+      console.log(JSON.stringify({ id: notebook.id, decisions: notebook.decisions.length }, null, 2));
+      break;
+    }
+    case 'finish': {
+      const [id, ...jsonRaw] = rest;
+      const opts = parseJson(jsonRaw.join(' '));
+      const indexPath = finishNotebook(id, opts, feedbackDir);
+      console.log(JSON.stringify({ index: indexPath }, null, 2));
+      break;
+    }
+    case 'list': {
+      console.log(JSON.stringify(listNotebooks(feedbackDir), null, 2));
+      break;
+    }
+    default:
+      console.error('usage: workflow-notebook.js create <json> | plan <id> <plan> | approve <id> <approver> | step <id> <json> | decide <id> <json> | finish <id> <json> | list');
+      process.exitCode = 2;
+  }
+}
+
+module.exports = {
+  STATUSES,
+  getNotebooksDir,
+  notebookPath,
+  createNotebook,
+  setPlan,
+  approveNotebook,
+  recordStep,
+  recordDecision,
+  finishNotebook,
+  writeIndex,
+  listNotebooks,
+  loadNotebook,
+  saveNotebook,
+};
+
+if (require.main?.filename === module.filename) {
+  main();
+}

package/scripts/workflow-sentinel.js

@@ -66,6 +66,14 @@ function loadJson(filePath) {
 }
 
 function loadGovernanceState() {
+  try {
+    const engine = require('./gates-engine');
+    if (typeof engine.loadGovernanceState === 'function') {
+      return engine.loadGovernanceState();
+    }
+  } catch {
+    // Fall through to the local file if the engine cannot load.
+  }
   const raw = loadJson(GOVERNANCE_STATE_PATH);
   return {
     taskScope: raw?.taskScope && typeof raw.taskScope === 'object' ? raw.taskScope : null,
@@ -144,11 +152,17 @@ function matchesAnyGlob(filePath, globs) {
 function toRepoRelativePath(filePath, repoRoot) {
   const value = String(filePath || '').trim();
   if (!value) return '';
-  if (repoRoot && path.isAbsolute(value)) {
+  if (path.isAbsolute(value)) {
+    if (!repoRoot) {
+      // Without a repo root, absolute paths cannot be safely scoped for
+      // protected-file approval — reject rather than preserving absolute paths.
+      return '';
+    }
     const relative = path.relative(repoRoot, value);
     if (!relative.startsWith('..') && !path.isAbsolute(relative)) {
       return normalizePosix(relative);
     }
+    return '';
   }
   return normalizePosix(value);
 }
@@ -206,22 +220,37 @@ function getBranchDiffFiles(repoRoot) {
 }
 
 function collectAffectedFiles(toolName, toolInput = {}, repoRoot) {
+  try {
+    const { extractAffectedFiles } = require('./gates-engine');
+    if (typeof extractAffectedFiles === 'function') {
+      const extracted = extractAffectedFiles(toolName, {
+        ...toolInput,
+        cwd: toolInput.cwd || repoRoot,
+        repoPath: toolInput.repoPath || repoRoot,
+      });
+      if (extracted && Array.isArray(extracted.files)) return extracted.files;
+    }
+  } catch {
+    // Keep the local collector if the engine cannot load.
+  }
   const files = new Set(collectInlineAffectedFiles(toolInput, repoRoot));
-  const command = String(toolInput.command || '');
+  const rawCommand = String(toolInput.command || '');
+  const command = rawCommand ? rawCommand.replace(/(?:^|\s)git(?:\s+-[^\s]+)*\s+-C(?:\s+|=)(?:'[^']+'|"[^"]+"|([^\s'"]+))/i, 'git ') : '';
   const hasExplicitAffectedFiles = files.size > 0;
 
-  if (toolName === 'Bash' && repoRoot && command) {
+  if (toolName === 'Bash' && repoRoot && (command || rawCommand)) {
+    const cmdToTest = command || rawCommand;
     if (hasExplicitAffectedFiles) {
       return [...files].filter(Boolean);
     }
 
-    if (/\bgit\s+commit\b/i.test(command)) {
+    if (/\bgit\s+commit\b/i.test(cmdToTest)) {
       for (const filePath of safeExecFileLines('git', ['diff', '--cached', '--name-only'], repoRoot)) {
         files.add(normalizePosix(filePath));
       }
     }
 
-    if (/\bgit\s+add\b/i.test(command)) {
+    if (/\bgit\s+add\b/i.test(cmdToTest)) {
       for (const filePath of safeExecFileLines('git', ['diff', '--name-only'], repoRoot)) {
         files.add(normalizePosix(filePath));
       }
@@ -230,7 +259,7 @@ function collectAffectedFiles(toolName, toolInput = {}, repoRoot) {
       }
     }
 
-    if (/\bgit\s+push\b/i.test(command) || /\bgh\s+pr\s+(?:create|merge)\b/i.test(command)) {
+    if (/\bgit\s+push\b/i.test(cmdToTest) || /\bgh\s+pr\s+(?:create|merge)\b/i.test(cmdToTest)) {
       for (const filePath of getBranchDiffFiles(repoRoot)) {
         files.add(normalizePosix(filePath));
       }
@@ -1362,6 +1391,29 @@ function isDestructiveBypass(command) {
     || /\bgh\s+pr\s+merge\b.*--admin\b/i.test(command);
 }
 
+function shouldAllowVersionProbe(toolName, command) {
+  return toolName === 'Bash' && isVersionOrProbeCommand(command);
+}
+
+function isVersionOrProbeCommand(command) {
+  if (!command || typeof command !== 'string') return false;
+  const trimmed = command.trim();
+  // Utility probes with no args.
+  if (/^(?:pwd|whoami|date)\s*$/i.test(trimmed)) return true;
+  // go prints version via the "version" subcommand (not -v/--version).
+  if (/^go\s+version\s*$/i.test(trimmed)) return true;
+  // node/npm/npx/gh/git/docker/claude/gemini: -v/--version/-V are version-only.
+  if (/^(?:node|npm|npx|gh|git|docker|claude|gemini)\s+(?:-v|--version|-V)\s*$/i.test(trimmed)) {
+    return true;
+  }
+  // cargo/rustc: -V/--version are version-only; bare -v means verbose.
+  // Keep this case-sensitive so /i cannot collapse -V into -v.
+  if (/^(?:cargo|rustc)\s+(?:-V|--version)\s*$/.test(trimmed)) return true;
+  // python/pytest: only --version/-V. Bare -v means verbose and must stay gated.
+  if (/^(?:python|python3|pytest)\s+(?:--version|-V)\s*$/.test(trimmed)) return true;
+  return false;
+}
+
 function getLearnedPrediction(learnedPolicy) {
   return learnedPolicy?.enabled ? learnedPolicy.prediction : null;
 }
@@ -1420,7 +1472,26 @@ function hasSoftControlWarning({ workflowContract, workflowControl, costControl,
     || (learnedRecall && riskScore >= 0.34);
 }
 
-function chooseDecision({ riskScore, integrity, memoryGuard, learnedPolicy, blastRadius, command, costControl, financialControl, workflowControl, workflowContract, actionProfile }) {
+function chooseDecision({
+  riskScore,
+  integrity,
+  memoryGuard,
+  learnedPolicy,
+  blastRadius,
+  command,
+  toolName,
+  costControl,
+  financialControl,
+  workflowControl,
+  workflowContract,
+  actionProfile,
+}) {
+  // Version/probe allowlist is Bash-only — other tools may carry a "command"
+  // field without being a shell version probe.
+  if (shouldAllowVersionProbe(toolName, command)) {
+    return 'allow';
+  }
+
   if (financialControl?.mode === 'block' || costControl?.mode === 'block' || workflowControl?.mode === 'block' || workflowContract?.mode === 'block') {
     return 'deny';
   }
@@ -1485,10 +1556,35 @@ function evaluateWorkflowSentinel(toolName, toolInput = {}, options = {}) {
   const workflowControl = buildWorkflowControl(normalizedAction, options.workflowPolicy || toolInput.workflowPolicy || options.budget || toolInput.budget || {});
   const governanceState = options.governanceState || loadGovernanceState();
   const repoPath = options.repoPath || normalizedToolInput.repoPath || normalizedToolInput.cwd || process.cwd();
-  const repoRoot = resolveRepoRoot(repoPath) || null;
+  let repoRoot = null;
+  try {
+    const engine = require('./gates-engine');
+    if (typeof engine.resolveRepoRoot === 'function') {
+      repoRoot = engine.resolveRepoRoot({
+        ...normalizedToolInput,
+        cwd: normalizedToolInput.cwd || repoPath,
+        repoPath: normalizedToolInput.repoPath || repoPath,
+      });
+    }
+  } catch {
+    repoRoot = null;
+  }
+  if (!repoRoot) {
+    repoRoot = resolveRepoRoot(repoPath) || null;
+  }
+  const explicitChanged = Array.isArray(normalizedToolInput.changedFiles)
+    ? normalizedToolInput.changedFiles
+    : (Array.isArray(normalizedToolInput.changed_files) ? normalizedToolInput.changed_files : null);
+
   const affectedFiles = Array.isArray(options.affectedFiles)
-    ? options.affectedFiles.map((filePath) => normalizePosix(filePath)).filter(Boolean)
-    : collectAffectedFiles(normalizedToolName, normalizedToolInput, repoRoot);
+    ? options.affectedFiles
+      .map((filePath) => toRepoRelativePath(filePath, repoRoot))
+      .filter(Boolean)
+    : (explicitChanged
+      ? explicitChanged
+        .map((filePath) => toRepoRelativePath(filePath, repoRoot))
+        .filter(Boolean)
+      : collectAffectedFiles(normalizedToolName, normalizedToolInput, repoRoot));
   let actionProfile = classifyActionProfile(normalizedToolInput);
   const financialControl = evaluateFinancialControl({
     toolName: normalizedToolName,
@@ -1512,8 +1608,7 @@ function evaluateWorkflowSentinel(toolName, toolInput = {}, options = {}) {
   const highRiskAction = isHighRiskAction(normalizedToolName, normalizedToolInput, affectedFiles);
   const baseBranch = options.baseBranch
     || (governanceState.branchGovernance && governanceState.branchGovernance.baseBranch)
-    || normalizedToolInput.baseBranch
-    || DEFAULT_BASE_BRANCH;
+    || normalizedToolInput.baseBranch;
   const integrity = evaluateOperationalIntegrity({
     repoPath,
     baseBranch,
@@ -1627,6 +1722,7 @@ function evaluateWorkflowSentinel(toolName, toolInput = {}, options = {}) {
       unapprovedProtectedFiles: protectedSurfaceForRisk.unapprovedProtectedFiles.length,
     },
     command: normalizedToolInput.command || '',
+    toolName: normalizedToolName,
     costControl,
     financialControl,
     workflowControl,
@@ -1732,9 +1828,12 @@ module.exports = {
   collectAffectedFiles,
   evaluateWorkflowSentinel,
   isHighRiskAction,
+  isVersionOrProbeCommand,
   loadGovernanceState,
   normalizeLearnedPolicyForSentinel,
   scoreRisk,
+  shouldAllowVersionProbe,
+  toRepoRelativePath,
 };
 
 if (require.main === module) {