feat(reporting-governance): add minimal runtime integrated slice

plugins/reporting-governance/test/runtime-integrated.integration.test.mjs

@@ -0,0 +1,207 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+import { executeRuntimeIntegratedGovernance } from '../src/index.mjs';
+import capabilityDescriptor from '../capabilities/openclaw-watchdog-reference.json' with { type: 'json' };
+
+const packageRoot = path.resolve(import.meta.dirname, '..');
+const repoRoot = path.resolve(packageRoot, '..', '..');
+
+const noSilencePack = {
+  metadata: { id: 'no-silence', severity_default: 'high' },
+  spec: {
+    evaluation_mode: 'any_rule_match',
+    rules: [
+      {
+        id: 'no-silence.missed-checkpoint',
+        title: 'Missed checkpoint requires visible recovery',
+        triggers: { event_types: ['silence_timeout'] },
+        conditions: {
+          all: [
+            { fact: 'checkpoint.is_overdue', equals: true }
+          ]
+        },
+        decision_output: {
+          decision: 'force_checkpoint',
+          severity: 'high',
+          reason: 'checkpoint overdue triggered forced operator-visible recovery',
+          required_actions: [
+            { action: 'notify_operator', target: 'operator_channel', mandatory: true },
+            { action: 'emit_event', target: 'event_stream', mandatory: true }
+          ],
+          operator_notice: {
+            required: true,
+            channel: 'telegram',
+            urgency: 'high',
+            message: 'Required update: checkpoint overdue.',
+            deadline: '2026-01-01T00:00:00.000Z'
+          }
+        }
+      }
+    ]
+  }
+};
+
+const strictProfileArtifact = {
+  kind: 'DeploymentProfileArtifact',
+  apiVersion: 'reporting-governance/v1alpha1',
+  metadata: {
+    id: 'strict-manager-mode',
+    runtime: 'openclaw',
+    compatibility_mode: 'strict_envelope',
+  },
+  spec: {
+    package: { pluginVersion: '0.1.0-mainline' },
+    policies: {
+      overrides: {
+        checkpoints: { overdueAction: 'force_checkpoint' }
+      }
+    },
+    notifications: {
+      operatorVisibleRecoveryRequired: true
+    },
+    bindings: {
+      runtime: 'openclaw',
+      entrypoint: 'scripts/watchdog_auto_notify_orchestrator.mjs',
+      scripts: {
+        watchdog: 'scripts/long_task_watchdog.mjs',
+        dispatcher: 'scripts/operator_notify_dispatcher.mjs',
+        bridgeSupervisor: 'scripts/operator_notify_bridge_supervisor.mjs',
+        senderBinding: 'scripts/operator_notify_sender_binding.mjs',
+        orchestrator: 'scripts/watchdog_auto_notify_orchestrator.mjs'
+      },
+      artifact_roots: {
+        queueItems: 'state/operator-notify-queue'
+      }
+    }
+  },
+  capability_expectations: {
+    required: [
+      'emit_canonical_events',
+      'evaluate_watchdog_overdue',
+      'create_queue_items',
+      'create_spool_handoff',
+      'write_bridge_receipts'
+    ],
+    preferred: ['direct_sender_binding', 'final_delivery_ack']
+  }
+};
+
+function createFixtureRoot() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'reporting-governance-runtime-integrated-'));
+}
+
+function mkdirs(root, names) {
+  for (const name of names) {
+    fs.mkdirSync(path.join(root, name), { recursive: true });
+  }
+}
+
+function writeState(root) {
+  const statePath = path.join(root, 'watchdog-state.json');
+  fs.writeFileSync(statePath, `${JSON.stringify({
+    version: 1,
+    watchdogs: [
+      {
+        id: 'reporting-governance-plugin-watchdog',
+        task: 'reporting-governance plugin spec development',
+        status: 'active',
+        ownerSessionKey: 'agent:coder:main',
+        reportChannel: 'telegram',
+        reportTarget: '864811879',
+        intervalMinutes: 10,
+        lastMilestoneAt: '2026-05-07T08:00:00.000Z',
+        lastAlertAt: null,
+      },
+    ],
+  }, null, 2)}\n`, 'utf8');
+  return statePath;
+}
+
+function readSingleJson(dirPath) {
+  const files = fs.readdirSync(dirPath).filter((name) => name.endsWith('.json')).sort();
+  assert.equal(files.length, 1, `expected exactly one json file in ${dirPath}`);
+  return JSON.parse(fs.readFileSync(path.join(dirPath, files[0]), 'utf8'));
+}
+
+test('runtime-integrated path wires executeGovernanceContract deployment binding into orchestrator execution', () => {
+  const root = createFixtureRoot();
+  try {
+    mkdirs(root, ['evidence', 'events', 'queue', 'spool', 'receipts']);
+    const statePath = writeState(root);
+
+    const result = executeRuntimeIntegratedGovernance({
+      event: {
+        type: 'silence_timeout',
+        payload: {
+          checkpoint_overdue: true,
+        }
+      },
+      evidence: [
+        { id: 'ev-watchdog', quality: 'moderate', is_new: true }
+      ],
+      capabilityDescriptor,
+      policyPacks: [noSilencePack],
+      context: {
+        signals: ['checkpoint_overdue'],
+      },
+      profile: strictProfileArtifact,
+      packageVersion: '0.1.0-mainline',
+      repoRootOverride: repoRoot,
+      runtime: {
+        state: statePath,
+        evidenceDir: path.join(root, 'evidence'),
+        eventDir: path.join(root, 'events'),
+        queueDir: path.join(root, 'queue'),
+        spoolDir: path.join(root, 'spool'),
+        receiptDir: path.join(root, 'receipts'),
+        writeState: true,
+        dryRun: true,
+        now: '2026-05-07T08:20:00.000Z',
+      },
+    });
+
+    assert.equal(result.preflight.status, 'pass');
+    assert.equal(result.contract.decision, 'force_checkpoint');
+    assert.equal(result.runtimeIntegration.attempted, true);
+    assert.equal(result.runtimeIntegration.adapter, 'orchestrator');
+    assert.equal(result.runtimeExecution.ok, true);
+    assert.equal(result.runtimeExecution.result.dispatcher.dispatchedCount, 1);
+    assert.equal(result.runtimeExecution.result.supervisor.pendingCount, 1);
+
+    const queueItem = readSingleJson(path.join(root, 'queue'));
+    assert.equal(queueItem.status, 'dispatched');
+
+    const receipt = readSingleJson(path.join(root, 'receipts'));
+    assert.equal(receipt.state, 'pending_external_send');
+    assert.equal(receipt.supervisor_mode, 'dry_run');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('runtime-integrated path stays planning-only when no runtime payload is supplied', () => {
+  const result = executeRuntimeIntegratedGovernance({
+    event: {
+      type: 'silence_timeout',
+      payload: {
+        checkpoint_overdue: true,
+      }
+    },
+    capabilityDescriptor,
+    policyPacks: [noSilencePack],
+    context: {
+      signals: ['checkpoint_overdue'],
+    },
+    profile: strictProfileArtifact,
+    packageVersion: '0.1.0-mainline',
+    repoRootOverride: repoRoot,
+  });
+
+  assert.equal(result.preflight.status, 'pass');
+  assert.equal(result.runtimeIntegration.attempted, false);
+  assert.equal(result.runtimeExecution, null);
+});