@sienklogic/plan-build-run 2.29.0 → 2.31.0

package/dashboard/src/services/timeline.service.js

@@ -0,0 +1,174 @@
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { TTLCache } from '../utils/cache.js';
+
+const execFile = promisify(execFileCb);
+
+export const cache = new TTLCache(30_000); // 30s TTL
+
+/**
+ * Run a git command in the given directory, returning stdout.
+ * Returns empty string on failure.
+ */
+async function git(projectDir, args) {
+  try {
+    const { stdout } = await execFile('git', args, {
+      cwd: projectDir,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return stdout;
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Aggregate timeline events from git commits, todo completions, and STATE.md
+ * phase transitions into a unified chronological array.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @param {{ types?: string[], phase?: string, dateFrom?: string, dateTo?: string }} filters
+ * @returns {Promise<Array>}
+ */
+export async function getTimelineEvents(projectDir, filters = {}) {
+  const cacheKey = `timeline:${projectDir}:${JSON.stringify(filters)}`;
+  const cached = cache.get(cacheKey);
+  if (cached) return cached;
+
+  const dateFrom = filters.dateFrom ? new Date(filters.dateFrom) : null;
+  const dateTo = filters.dateTo ? new Date(filters.dateTo + 'T23:59:59Z') : null;
+
+  // --- Git commits ---
+  let commitEvents = [];
+  const logOutput = await git(projectDir, [
+    'log', '--all', '--format=%H|%aI|%s|%an'
+  ]);
+  if (logOutput.trim()) {
+    for (const line of logOutput.trim().split('\n')) {
+      const parts = line.split('|');
+      if (parts.length < 4) continue;
+      const [id, isoDate, subject, ...authorParts] = parts;
+      const author = authorParts.join('|');
+      const date = new Date(isoDate);
+      if (isNaN(date.getTime())) continue;
+
+      // Phase filter: keep only commits whose subject matches scope pattern for that phase
+      if (filters.phase) {
+        const phaseNum = String(filters.phase).padStart(2, '0');
+        const scopeRe = new RegExp(`\\(${phaseNum}-`);
+        if (!scopeRe.test(subject)) continue;
+      }
+
+      if (dateFrom && date < dateFrom) continue;
+      if (dateTo && date > dateTo) continue;
+
+      commitEvents.push({ type: 'commit', id, date, title: subject, author });
+    }
+  }
+
+  // --- Todo completions ---
+  let todoEvents = [];
+  try {
+    const doneDir = join(projectDir, '.planning', 'todos', 'done');
+    const entries = await readdir(doneDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+      try {
+        const raw = await readFile(join(doneDir, entry.name), 'utf-8');
+        // Parse frontmatter manually
+        const lines = raw.split(/\r?\n/);
+        if (lines[0] !== '---') continue;
+        const endIdx = lines.indexOf('---', 1);
+        if (endIdx === -1) continue;
+        const fmLines = lines.slice(1, endIdx);
+        let title = '';
+        let completedAt = '';
+        for (const fmLine of fmLines) {
+          const titleMatch = fmLine.match(/^title:\s*['"]?(.+?)['"]?\s*$/);
+          if (titleMatch) title = titleMatch[1];
+          const completedMatch = fmLine.match(/^completed_at:\s*['"]?(.+?)['"]?\s*$/);
+          if (completedMatch) completedAt = completedMatch[1];
+        }
+        if (!completedAt) continue;
+        const date = new Date(completedAt);
+        if (isNaN(date.getTime())) continue;
+
+        if (dateFrom && date < dateFrom) continue;
+        if (dateTo && date > dateTo) continue;
+
+        todoEvents.push({
+          type: 'todo-completion',
+          id: entry.name,
+          date,
+          title: title || entry.name.replace(/^\d{3}-/, '').replace(/\.md$/, '').replace(/-/g, ' ')
+        });
+      } catch {
+        // skip unreadable files
+      }
+    }
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      // Non-ENOENT errors: skip silently for robustness
+    }
+  }
+
+  // --- Phase transitions from STATE.md ---
+  let phaseEvents = [];
+  try {
+    const statePath = join(projectDir, '.planning', 'STATE.md');
+    const raw = await readFile(statePath, 'utf-8');
+    const lines = raw.split(/\r?\n/);
+
+    // Best-effort: extract current phase and last updated
+    let currentPhase = '';
+    let currentStatus = '';
+    let lastUpdated = '';
+
+    for (const line of lines) {
+      const phaseMatch = line.match(/\*\*Current phase:\*\*\s*(.+)/);
+      if (phaseMatch) currentPhase = phaseMatch[1].trim();
+
+      const statusMatch = line.match(/\*\*Status:\*\*\s*(.+)/);
+      if (statusMatch) currentStatus = statusMatch[1].trim();
+
+      const updatedMatch = line.match(/\*\*Last updated:\*\*\s*(.+)/);
+      if (updatedMatch) lastUpdated = updatedMatch[1].trim();
+    }
+
+    if (lastUpdated) {
+      const date = new Date(lastUpdated);
+      if (!isNaN(date.getTime())) {
+        const title = currentPhase
+          ? `Phase ${currentPhase} — ${currentStatus || 'active'}`
+          : `Status: ${currentStatus || 'active'}`;
+
+        if ((!dateFrom || date >= dateFrom) && (!dateTo || date <= dateTo)) {
+          phaseEvents.push({
+            type: 'phase-transition',
+            id: 'state-current',
+            date,
+            title
+          });
+        }
+      }
+    }
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      // Non-ENOENT: skip silently
+    }
+  }
+
+  // Merge and sort descending (newest first)
+  let events = [...commitEvents, ...todoEvents, ...phaseEvents];
+  events.sort((a, b) => b.date - a.date);
+
+  // Apply types filter
+  if (filters.types && filters.types.length > 0) {
+    events = events.filter(e => filters.types.includes(e.type));
+  }
+
+  cache.set(cacheKey, events);
+  return events;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sienklogic/plan-build-run",
-  "version": "2.29.0",
+  "version": "2.31.0",
   "description": "Plan it, Build it, Run it — structured development workflow for Claude Code",
   "keywords": [
     "claude-code",

package/plugins/copilot-pbr/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pbr",
   "displayName": "Plan-Build-Run",
-  "version": "2.29.0",
+  "version": "2.31.0",
   "description": "Plan-Build-Run — Structured development workflow for GitHub Copilot CLI. Solves context rot through disciplined agent delegation, structured planning, atomic execution, and goal-backward verification.",
   "author": {
     "name": "SienkLogic",

package/plugins/cursor-pbr/.cursor-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pbr",
   "displayName": "Plan-Build-Run",
-  "version": "2.29.0",
+  "version": "2.31.0",
   "description": "Plan-Build-Run — Structured development workflow for Cursor. Solves context rot through disciplined subagent delegation, structured planning, atomic execution, and goal-backward verification.",
   "author": {
     "name": "SienkLogic",

package/plugins/pbr/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pbr",
-  "version": "2.29.0",
+  "version": "2.31.0",
   "description": "Plan-Build-Run — Structured development workflow for Claude Code. Solves context rot through disciplined subagent delegation, structured planning, atomic execution, and goal-backward verification.",
   "author": {
     "name": "SienkLogic",

package/plugins/pbr/scripts/config-schema.json

@@ -254,6 +254,18 @@
       },
       "additionalProperties": false
     },
+    "workflow": {
+      "type": "object",
+      "properties": {
+        "enforce_pbr_skills": {
+          "type": "string",
+          "enum": ["advisory", "block", "off"],
+          "default": "advisory",
+          "description": "Enforcement level for PBR workflow compliance"
+        }
+      },
+      "additionalProperties": false
+    },
     "local_llm": {
       "type": "object",
       "properties": {

package/plugins/pbr/scripts/context-budget-check.js

@@ -268,7 +268,10 @@ function readConfigHighlights(planningDir) {
 }
 
 function buildRecoveryContext(activeOp, roadmapSummary, currentPlan, configHighlights, recentErrors, recentAgents) {
-  const parts = ['[Post-Compaction Recovery] Context was auto-compacted. Key state preserved:'];
+  const parts = [
+    '[Post-Compaction Recovery] Context was auto-compacted. Key state preserved:',
+    '[PBR WORKFLOW REQUIRED — Route all work through PBR commands]\n- Fix a bug or small task → /pbr:quick\n- Plan a feature → /pbr:plan N\n- Build from a plan → /pbr:build N\n- Explore or research → /pbr:explore\n- Freeform request → /pbr:do\n- Do NOT write source code or spawn generic agents without an active PBR skill.\n- Use PBR agents (pbr:researcher, pbr:executor, etc.) not Explore/general-purpose.'
+  ];
 
   if (activeOp) parts.push(`Active operation: ${activeOp}`);
   if (currentPlan) parts.push(`Current plan: ${currentPlan}`);

package/plugins/pbr/scripts/enforce-pbr-workflow.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+
+/**
+ * PBR workflow enforcement checks.
+ *
+ * Provides advisory and blocking checks that ensure PBR workflow is
+ * followed even when the user doesn't explicitly invoke /pbr:* commands.
+ *
+ * Functions:
+ *   loadEnforcementConfig(planningDir) — reads config.json for enforcement level
+ *   checkUnmanagedSourceWrite(data)    — PreToolUse Write|Edit: warns/blocks unmanaged source writes
+ *   checkNonPbrAgent(data)             — PreToolUse Task: advises using pbr:* agents
+ *   checkUnmanagedCommit(data)         — PreToolUse Bash: advises git commits to use /pbr:quick
+ *
+ * All functions return null for pass, or { exitCode, output } for action.
+ * checkNonPbrAgent always returns advisory (exitCode 0) — never blocks Task().
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+
+/**
+ * Load the enforcement configuration from .planning/config.json.
+ * Also checks for .planning/.native-mode which bypasses all enforcement.
+ *
+ * @param {string} planningDir - absolute path to the .planning directory
+ * @returns {{ level: "advisory"|"block"|"off" }}
+ */
+function loadEnforcementConfig(planningDir) {
+  // .native-mode bypass takes precedence over all config settings
+  const nativeModeFile = path.join(planningDir, '.native-mode');
+  if (fs.existsSync(nativeModeFile)) {
+    return { level: 'off' };
+  }
+
+  try {
+    const configPath = path.join(planningDir, 'config.json');
+    const parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const level = parsed.workflow && parsed.workflow.enforce_pbr_skills;
+    if (level === 'advisory' || level === 'block' || level === 'off') {
+      return { level };
+    }
+  } catch (_e) {
+    // No config or parse error — use default
+  }
+
+  return { level: 'advisory' };
+}
+
+/**
+ * PreToolUse Write|Edit: warns or blocks source file writes that happen
+ * without an active PBR skill.
+ *
+ * Skip conditions:
+ *   - No .planning/ directory (not a PBR project)
+ *   - .planning/.active-skill exists (PBR skill is managing the session)
+ *   - Target file is inside .planning/ (planning files are always OK)
+ *   - Enforcement level is "off"
+ *
+ * @param {Object} data - parsed hook input from Claude Code
+ * @returns {null|{ exitCode: number, output: Object }}
+ */
+function checkUnmanagedSourceWrite(data) {
+  const filePath = data.tool_input && (data.tool_input.file_path || data.tool_input.path);
+  if (!filePath) return null;
+
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+
+  // Skip if not a PBR project
+  if (!fs.existsSync(planningDir)) return null;
+
+  // Skip if a PBR skill is active
+  const activeSkillFile = path.join(planningDir, '.active-skill');
+  if (fs.existsSync(activeSkillFile)) return null;
+
+  // Skip if writing inside .planning/
+  const normalizedFile = filePath.replace(/\\/g, '/');
+  const normalizedPlanning = planningDir.replace(/\\/g, '/');
+  if (normalizedFile.startsWith(normalizedPlanning)) return null;
+
+  // Also check with resolved symlinks (macOS /var → /private/var)
+  try {
+    const resolvedPlanning = fs.realpathSync(planningDir).replace(/\\/g, '/');
+    if (normalizedFile.startsWith(resolvedPlanning)) return null;
+  } catch (_e) { /* not resolvable */ }
+
+  const config = loadEnforcementConfig(planningDir);
+  if (config.level === 'off') return null;
+
+  const message =
+    'PBR workflow required: You are editing source code without an active PBR skill. ' +
+    'Route this work through a PBR command: /pbr:quick (small fix), /pbr:build (planned work), ' +
+    'or /pbr:do (auto-route). Set workflow.enforce_pbr_skills: off in config to disable.';
+
+  if (config.level === 'block') {
+    logHook('enforce-pbr-workflow', 'PreToolUse', 'block', { file: path.basename(filePath), level: 'block' });
+    return {
+      exitCode: 2,
+      output: { decision: 'block', reason: message }
+    };
+  }
+
+  // advisory (default)
+  logHook('enforce-pbr-workflow', 'PreToolUse', 'advisory', { file: path.basename(filePath), level: 'advisory' });
+  return {
+    exitCode: 0,
+    output: { additionalContext: '[pbr] ' + message }
+  };
+}
+
+/**
+ * Agent type → PBR agent mapping for advisory messages.
+ */
+const AGENT_MAPPING = {
+  'Explore': 'pbr:researcher or pbr:codebase-mapper',
+  'general-purpose': 'pbr:general',
+  'Plan': 'pbr:planner',
+  'Bash': 'pbr:executor'
+};
+
+/**
+ * PreToolUse Task: advises using pbr:* agents instead of generic agents.
+ *
+ * Skip conditions:
+ *   - No .planning/ directory (not a PBR project)
+ *   - subagent_type starts with "pbr:" (already using PBR agent)
+ *   - subagent_type is missing/empty (can't determine type)
+ *   - Enforcement level is "off"
+ *
+ * NOTE: This function NEVER blocks Task() — blocking is too disruptive.
+ *       It always returns an advisory (exitCode 0) or null.
+ *
+ * @param {Object} data - parsed hook input from Claude Code
+ * @returns {null|{ exitCode: 0, output: Object }}
+ */
+function checkNonPbrAgent(data) {
+  const subagentType = data.tool_input && data.tool_input.subagent_type;
+  if (!subagentType || typeof subagentType !== 'string') return null;
+
+  // Already using a PBR agent
+  if (subagentType.startsWith('pbr:')) return null;
+
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+
+  // Skip if not a PBR project
+  if (!fs.existsSync(planningDir)) return null;
+
+  const config = loadEnforcementConfig(planningDir);
+  if (config.level === 'off') return null;
+
+  const suggestion = AGENT_MAPPING[subagentType] || 'a pbr:* agent (e.g., pbr:researcher, pbr:general, pbr:executor)';
+  const message =
+    `PBR workflow advisory: spawning generic agent "${subagentType}" without PBR routing. ` +
+    `Use ${suggestion} instead to maintain audit logging and workflow context. ` +
+    'PBR agents are auto-loaded via subagent_type — no extra setup needed.';
+
+  logHook('enforce-pbr-workflow', 'PreToolUse', 'advisory', { agentType: subagentType, suggestion });
+  return {
+    exitCode: 0,
+    output: { additionalContext: '[pbr] ' + message }
+  };
+}
+
+/**
+ * PreToolUse Bash: advises using /pbr:quick when git commit is run without
+ * an active PBR skill.
+ *
+ * Skip conditions:
+ *   - No .planning/ directory (not a PBR project)
+ *   - .planning/.active-skill exists (PBR skill is managing the session)
+ *   - Command is not a git commit
+ *   - Enforcement level is "off"
+ *
+ * @param {Object} data - parsed hook input from Claude Code
+ * @returns {null|{ exitCode: 0, output: Object }}
+ */
+function checkUnmanagedCommit(data) {
+  const command = data.tool_input && data.tool_input.command;
+  if (!command || typeof command !== 'string') return null;
+
+  // Only check git commit commands
+  if (!/\bgit\s+commit\b/.test(command)) return null;
+
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+
+  // Skip if not a PBR project
+  if (!fs.existsSync(planningDir)) return null;
+
+  // Skip if a PBR skill is active
+  const activeSkillFile = path.join(planningDir, '.active-skill');
+  if (fs.existsSync(activeSkillFile)) return null;
+
+  const config = loadEnforcementConfig(planningDir);
+  if (config.level === 'off') return null;
+
+  const message =
+    'Committing without PBR tracking. Use /pbr:quick to track this work. ' +
+    'PBR quick tasks create atomic commits with proper scope and audit trail.';
+
+  logHook('enforce-pbr-workflow', 'PreToolUse', 'advisory', { check: 'unmanaged-commit' });
+  return {
+    exitCode: 0,
+    output: { additionalContext: '[pbr] ' + message }
+  };
+}
+
+module.exports = {
+  loadEnforcementConfig,
+  checkUnmanagedSourceWrite,
+  checkNonPbrAgent,
+  checkUnmanagedCommit
+};

package/plugins/pbr/scripts/pre-bash-dispatch.js

@@ -49,6 +49,7 @@
 const { logHook } = require('./hook-logger');
 const { checkDangerous } = require('./check-dangerous-commands');
 const { checkCommit, enrichCommitLlm } = require('./validate-commit');
+const { checkUnmanagedCommit } = require('./enforce-pbr-workflow');
 
 function main() {
   let input = '';
@@ -97,6 +98,12 @@ function main() {
         }
       }
 
+      // Unmanaged commit advisory — warn when git commit runs without PBR skill
+      const unmanagedCommitResult = checkUnmanagedCommit(data);
+      if (unmanagedCommitResult) {
+        warnings.push(unmanagedCommitResult.output.additionalContext);
+      }
+
       // LLM commit semantic classification — advisory only
       const llmAdvisory = await enrichCommitLlm(data);
       if (llmAdvisory) {

package/plugins/pbr/scripts/pre-write-dispatch.js

@@ -3,33 +3,35 @@
 /**
  * PreToolUse dispatcher for Write|Edit hooks.
  *
- * Consolidates check-skill-workflow.js, check-phase-boundary.js,
- * and check-doc-sprawl.js into a single process, reading stdin once
- * and running all checks sequentially.
+ * Consolidates all PreToolUse Write|Edit checks into a single process,
+ * reading stdin once and running all checks sequentially.
  *
  * ── Dispatch Order & Rationale ──────────────────────────────────
  *
- *   1. check-skill-workflow  — Enforces planning-phase rules (e.g. no
- *      code writes during the plan phase). Runs first because workflow
- *      violations are the most fundamental: if the write shouldn't
- *      happen at all in the current workflow state, there's no point
- *      evaluating boundary or sprawl rules. Can block (exit 2).
+ *   1. enforce-pbr-workflow  — Warns or blocks source code writes that
+ *      happen without an active PBR skill. Runs first because this is
+ *      the most fundamental enforcement: if no PBR skill is managing
+ *      the session, all other skill-specific checks are moot.
+ *      Can block (exit 2) or advise (exit 0). Config-driven.
  *
- *   2. check-summary-gate    — Blocks STATE.md status advancement
+ *   2. check-agent-state-write — Blocks subagents from writing STATE.md
+ *      directly (except pbr:general). Runs before skill-specific checks
+ *      because agent isolation is a hard invariant. Can block (exit 2).
+ *
+ *   3. check-skill-workflow  — Enforces planning-phase rules (e.g. no
+ *      code writes during the plan phase). Can block (exit 2).
+ *
+ *   4. check-summary-gate    — Blocks STATE.md status advancement
  *      (to built/verified/complete) unless a SUMMARY file exists for
- *      the current phase. Prevents inconsistent state where a phase
- *      appears complete but has no build receipt. Can block (exit 2).
+ *      the current phase. Can block (exit 2).
  *
- *   3. check-phase-boundary  — Guards against writes that target files
- *      outside the current phase directory. Runs second because once
- *      we know the write is allowed by workflow rules, we need to
- *      verify it's scoped to the correct phase. Can block (exit 2)
+ *   5. check-phase-boundary  — Guards against writes that target files
+ *      outside the current phase directory. Can block (exit 2)
  *      or warn (exit 0 with message).
  *
- *   4. check-doc-sprawl      — Prevents creation of new .md/.txt files
+ *   6. check-doc-sprawl      — Prevents creation of new .md/.txt files
  *      outside a known allowlist (when enabled in config). Runs last
- *      because it's the most granular check — only relevant for new
- *      documentation files, not all writes. Can block (exit 2).
+ *      because it's the most granular check. Can block (exit 2).
  *
  * ── Short-Circuit Behavior ──────────────────────────────────────
  *
@@ -62,6 +64,7 @@ const { checkWorkflow } = require('./check-skill-workflow');
 const { checkSummaryGate } = require('./check-summary-gate');
 const { checkBoundary } = require('./check-phase-boundary');
 const { checkDocSprawl } = require('./check-doc-sprawl');
+const { checkUnmanagedSourceWrite } = require('./enforce-pbr-workflow');
 
 function main() {
   let input = '';
@@ -72,6 +75,15 @@ function main() {
     try {
       const data = JSON.parse(input);
 
+      // Unmanaged source write check — runs first as the most fundamental
+      // workflow enforcement: warn/block when source code is edited without
+      // an active PBR skill managing the session.
+      const unmanagedResult = checkUnmanagedSourceWrite(data);
+      if (unmanagedResult) {
+        process.stdout.write(JSON.stringify(unmanagedResult.output));
+        process.exit(unmanagedResult.exitCode || 0);
+      }
+
       // Agent STATE.md write blocker — most fundamental check
       const agentResult = checkAgentStateWrite(data);
       if (agentResult) {

package/plugins/pbr/scripts/progress-tracker.js

@@ -262,7 +262,7 @@ function buildContext(planningDir, stateFile) {
     parts.push(`\n${hookHealth}`);
   }
 
-  parts.push('\nAvailable commands: /pbr:status, /pbr:plan, /pbr:build, /pbr:review, /pbr:help');
+  parts.push('\n[PBR WORKFLOW REQUIRED — Route all work through PBR commands]\n- Fix a bug or small task → /pbr:quick\n- Plan a feature → /pbr:plan N\n- Build from a plan → /pbr:build N\n- Explore or research → /pbr:explore\n- Freeform request → /pbr:do\n- Do NOT write source code or spawn generic agents without an active PBR skill.\n- Use PBR agents (pbr:researcher, pbr:executor, etc.) not Explore/general-purpose.');
 
   return parts.join('\n');
 }

package/plugins/pbr/scripts/validate-task.js

@@ -22,6 +22,7 @@ const path = require('path');
 const { logHook } = require('./hook-logger');
 const { resolveConfig } = require('./local-llm/health');
 const { validateTask: llmValidateTask } = require('./local-llm/operations/validate-task');
+const { checkNonPbrAgent } = require('./enforce-pbr-workflow');
 
 /**
  * Load and resolve the local_llm config block from .planning/config.json.
@@ -48,7 +49,9 @@ const KNOWN_AGENTS = [
   'debugger',
   'codebase-mapper',
   'synthesizer',
-  'general'
+  'general',
+  'audit',
+  'dev-sync'
 ];
 
 const MAX_DESCRIPTION_LENGTH = 100;
@@ -800,6 +803,8 @@ function main() {
       if (debuggerWarning) warnings.push(debuggerWarning);
       const activeSkillWarning = checkActiveSkillIntegrity(data);
       if (activeSkillWarning) warnings.push(activeSkillWarning);
+      const nonPbrAgentResult = checkNonPbrAgent(data);
+      if (nonPbrAgentResult) warnings.push(nonPbrAgentResult.output.additionalContext);
 
       // LLM task coherence check — advisory only
       try {