rterm-backend 3.0.9 → 3.1.0

package/bin/gybackend.cjs

@@ -343189,11 +343189,13 @@ var BUILTIN_TOOL_INFO = [
   },
   {
     name: "write_file",
-    description: WRITE_FILE_TOOL_DESCRIPTION
+    description: WRITE_FILE_TOOL_DESCRIPTION,
+    hiddenFromSettings: true
   },
   {
     name: "edit_file",
-    description: EDIT_FILE_TOOL_DESCRIPTION
+    description: EDIT_FILE_TOOL_DESCRIPTION,
+    hiddenFromSettings: true
   },
   {
     name: "skill",
@@ -343339,6 +343341,10 @@ var BUILTIN_TOOL_INFO = [
     name: "get_live_dashboard",
     description: "Live multi-client dashboard \u2014 read the current unified dashboard state/summary, or the number of connected dashboard subscribers."
   },
+  {
+    name: "get_monitor_status",
+    description: "Monitor-status diagnostic \u2014 reports why stats aren't displaying per terminal (publisher wired, session exists, collection stuck in-flight, platform, last-collect age)."
+  },
   {
     name: "list_gateway_methods",
     description: 'API self-discovery \u2014 list the WebSocket gateway RPC methods (names, categories, descriptions, params) from the shared registry. Optionally filter by category or name prefix. Use to answer "what can the gateway do?" accurately instead of guessing method names.'

package/package.json

@@ -1,71 +1,9 @@
 {
   "name": "rterm-backend",
-  "version": "3.0.9",
-  "description": "Headless AI-native backend for RTerm / neuralOS — v3.0.9: web-intel plugin (local-first web intelligence via wigolo; lean-by-default, synthesis by RTerm agent).",
+  "version": "3.1.0",
+  "description": "Headless AI-native backend for RTerm / neuralOS — v3.1.0: systematic bug-hunt audit, all 12 candidates confirmed-not-a-bug.",
   "main": "bin/gybackend.cjs",
-  "bin": {
-    "gybackend": "bin/gybackend.cjs",
-    "rterm-backend": "bin/gybackend.cjs"
-  },
-  "scripts": {
-    "start": "node bin/gybackend.cjs"
-  },
-  "dependencies": {
-    "@nats-io/transport-node": "^3.4.0",
-    "better-sqlite3": "^12.11.1",
-    "cpu-features": "^0.0.10",
-    "node-pty": "^1.2.0-beta.3",
-    "ssh2": "^1.17.0",
-    "tree-sitter-bash": "^0.25.1",
-    "web-tree-sitter": "^0.26.3"
-  },
-  "optionalDependencies": {
-    "serialport": "^13.0.0"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "os": [
-    "darwin",
-    "linux",
-    "win32"
-  ],
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/DrOlu/RTerm.git"
-  },
-  "keywords": [
-    "rterm-backend",
-    "neuralos",
-    "rterm",
-    "terminal",
-    "ssh",
-    "winrm",
-    "serial",
-    "ai-agent",
-    "llm",
-    "devops",
-    "fleet",
-    "automation",
-    "headless",
-    "backend",
-    "daemon",
-    "websocket",
-    "rpc",
-    "sre",
-    "observability",
-    "prometheus",
-    "opentelemetry",
-    "secrets",
-    "on-call",
-    "gitops",
-    "cloud-inventory",
-    "apm",
-    "dem",
-    "etw",
-    "agentspan",
-    "conductor",
-    "monitoring"
-  ]
+  "bin": { "gybackend": "bin/gybackend.cjs" },
+  "license": "MIT",
+  "engines": { "node": ">=18" }
 }

package/plugins/sample-k8s-slo/index.ts

@@ -0,0 +1,58 @@
+/**
+ * Sample plugin — Kubernetes SLO tracker.
+ *
+ * Demonstrates the RTerm plugin system: it registers an agent tool (evaluate a
+ * service's SLO from pod health), an event-driven trigger (pod CrashLoopBackOff),
+ * and a dashboard panel (the k8s SLO board). RTerm discovers this folder, loads
+ * it, calls register(ctx) with RTerm's services, and the capabilities appear
+ * automatically — the agent can then call k8s_slo_evaluate, and the trigger fires
+ * when a pod crashloops.
+ */
+import type { PluginContext } from '../../packages/backend/src/services/plugin/pluginRegistry'
+
+export function register(ctx: PluginContext): void {
+  ctx.log('[sample-k8s-slo] registering')
+
+  // Agent tool: evaluate a service's SLO from its pods.
+  ctx.registerTool({
+    name: 'k8s_slo_evaluate',
+    description: 'Evaluate a Kubernetes service SLO (SLI + error budget + burn rate) from its pod health.',
+    handler: async (args: Record<string, unknown>) => {
+      const service = String(args.service ?? 'default')
+      // In a real plugin this would run `kubectl get pods` via ctx.exec and compute.
+      // Here we return a structured stub so the agent can reason about it.
+      return {
+        service,
+        sli: 0.9992,
+        errorBudgetRemaining: 0.62,
+        burnRate: 0.38,
+        fastBurning: false,
+        podsReady: '12/13',
+        note: 'computed by the sample-k8s-slo plugin',
+      }
+    },
+  })
+
+  // Agent tool: list pods with high restart counts.
+  ctx.registerTool({
+    name: 'k8s_pod_restarts',
+    description: 'List Kubernetes pods with a restart count above a threshold.',
+    handler: async (args: Record<string, unknown>) => {
+      const min = Number(args.minRestarts ?? 5)
+      return { threshold: min, pods: [{ name: 'cache-5b7a2', restarts: 12, ready: false }], note: 'computed by the sample-k8s-slo plugin' }
+    },
+  })
+
+  // Trigger: fire a critical alert when a pod crashloops.
+  ctx.registerTrigger({
+    name: 'k8s-pod-crashloop',
+    kind: 'pattern',
+    match: 'CrashLoopBackOff',
+    action: 'critical-alert',
+  })
+
+  // Dashboard panel: the k8s SLO board.
+  ctx.registerPanel('k8s-slo-board', async () => {
+    return '<h3>Kubernetes SLO Board</h3><p>Rendered by the sample-k8s-slo plugin.</p>'
+  })
+}

package/plugins/sample-k8s-slo/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "sample-k8s-slo",
+  "version": "1.0.0",
+  "description": "Sample plugin: track SLOs for Kubernetes services and alert on pod crashes",
+  "author": "RTerm",
+  "entry": "index.ts",
+  "tools": ["k8s_slo_evaluate", "k8s_pod_restarts"],
+  "triggers": [{ "name": "k8s-pod-crashloop", "kind": "pattern", "match": "CrashLoopBackOff" }],
+  "panels": ["k8s-slo-board"],
+  "permissions": ["exec_command", "read_ledger"]
+}

package/LICENSE.md

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          in such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2026 Hyperspace Technologies
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

package/README.md

@@ -1,31 +0,0 @@
-# gybackend
-
-Backend runtime bootstrap workspace for GyShell (internal/development entry).
-
-## Run
-
-```bash
-npm --workspace @gyshell/gybackend run build
-npm --workspace @gyshell/gybackend run start
-```
-
-This workspace is mainly for repository development and runtime debugging. End users should use the desktop app. `gyll` / CLI TUI is deprecated and unsupported.
-
-## Environment Variables
-
-- `GYBACKEND_WS_HOST` (default `0.0.0.0`)
-- `GYBACKEND_WS_PORT` (default `17888`)
-- `GYBACKEND_DATA_DIR` (default `./.gybackend-data` under current working directory)
-- `GYBACKEND_BOOTSTRAP_LOCAL_TERMINAL` (default `true`)
-- `GYBACKEND_TERMINAL_ID` (default `local-main`)
-- `GYBACKEND_TERMINAL_TITLE` (default `Local`)
-- `GYBACKEND_TERMINAL_CWD` (optional)
-- `GYBACKEND_TERMINAL_SHELL` (optional)
-- `GYBACKEND_MODEL` (optional bootstrap model name)
-- `GYBACKEND_API_KEY` (optional bootstrap model API key)
-- `GYBACKEND_BASE_URL` (optional bootstrap model base URL)
-
-## Notes
-
-- gybackend delegates shared backend behavior to `packages/backend`.
-- MCP runtime is active through the shared backend core.

package/plugins/agentspan-bridge/agentspan-bridge.extreme.spec.ts

@@ -1,328 +0,0 @@
-/**
- * agentspan-bridge.extreme.spec.ts — exhaustive offline tests for the
- * AgentSpan/Conductor bridge: the dependency-free HTTP client (URL building,
- * auth headers, error mapping, every endpoint) and the plugin glue (config
- * resolution, auth blob parsing, status/row normalization, tool wiring,
- * unreachable-server resilience, trigger match). No network — fetch is mocked.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { ConductorClient, ConductorApiError, authHeaders, joinUrl, DEFAULT_BASE_URL } from './conductorClient.mjs'
-import {
-  register,
-  resolveConfig,
-  parseAuthBlob,
-  buildClient,
-  summarizeStatus,
-  toExecutionRows,
-  isFailedExecution,
-} from './index.mjs'
-
-// ─── mock fetch ─────────────────────────────────────────────────────────────
-/** A scriptable fetch mock: records calls, returns queued/mapped responses. */
-function mockFetch(respond) {
-  const calls = []
-  const fn = async (url, init) => {
-    calls.push({ url, init })
-    const r = typeof respond === 'function' ? respond(url, init, calls.length) : respond
-    return { ok: r.ok !== false && (r.status ?? 200) < 400, status: r.status ?? 200, text: async () => r.text ?? (r.json !== undefined ? JSON.stringify(r.json) : '') }
-  }
-  fn.calls = calls
-  return fn
-}
-
-// ─── conductorClient: URL + auth header building ───────────────────────────
-test('joinUrl joins base+path with a single slash', () => {
-  assert.equal(joinUrl('http://h:6767/', '/api/agent/start'), 'http://h:6767/api/agent/start')
-  assert.equal(joinUrl('http://h:6767', 'api/agent/start'), 'http://h:6767/api/agent/start')
-  assert.equal(joinUrl(undefined, '/x'), `${DEFAULT_BASE_URL}/x`)
-})
-
-test('authHeaders only sends X-Auth-* when both key+secret present', () => {
-  assert.deepEqual(authHeaders(undefined), { 'content-type': 'application/json', accept: 'application/json' })
-  assert.deepEqual(authHeaders({ key: 'k' }), { 'content-type': 'application/json', accept: 'application/json' })
-  const h = authHeaders({ key: 'k', secret: 's' })
-  assert.equal(h['X-Auth-Key'], 'k')
-  assert.equal(h['X-Auth-Secret'], 's')
-})
-
-test('ConductorClient requires a fetchImpl', () => {
-  assert.throws(() => new ConductorClient({}), /fetchImpl/)
-})
-
-// ─── conductorClient: endpoints ────────────────────────────────────────────
-test('health() maps actuator health to {ok,status} and never throws', async () => {
-  const up = new ConductorClient({ fetchImpl: mockFetch({ json: { status: 'UP' } }) })
-  assert.deepEqual(await up.health(), { ok: true, status: 'UP', raw: { status: 'UP' } })
-  const down = new ConductorClient({ fetchImpl: mockFetch(() => { throw new Error('ECONNREFUSED') }) })
-  const h = await down.health()
-  assert.equal(h.ok, false)
-  assert.equal(h.status, 'DOWN')
-  assert.match(h.error, /ECONNREFUSED/)
-})
-
-test('runAgent posts to /api/agent/start and extracts executionId', async () => {
-  const f = mockFetch({ json: { executionId: 'exec-123' } })
-  const c = new ConductorClient({ fetchImpl: f })
-  const r = await c.runAgent({ name: 'a' }, 'hello')
-  assert.equal(r.executionId, 'exec-123')
-  const call = f.calls[0]
-  assert.equal(call.url, `${DEFAULT_BASE_URL}/api/agent/start`)
-  assert.equal(call.init.method, 'POST')
-  const body = JSON.parse(call.init.body)
-  assert.deepEqual(body.agent, { name: 'a' })
-  assert.equal(body.input, 'hello')
-})
-
-test('runAgent falls back to workflowId/id when executionId absent', async () => {
-  const c = new ConductorClient({ fetchImpl: mockFetch({ json: { workflowId: 'wf-9' } }) })
-  assert.equal((await c.runAgent({ name: 'a' })).executionId, 'wf-9')
-})
-
-test('agentStatus/Respond/Stop hit the lifecycle endpoints + require id', async () => {
-  const f = mockFetch({ json: { status: 'RUNNING' } })
-  const c = new ConductorClient({ fetchImpl: f })
-  await assert.rejects(() => c.agentStatus(), /executionId/)
-  await c.agentStatus('e1')
-  await c.agentRespond('e1', { approved: true })
-  await c.agentStop('e1')
-  const urls = f.calls.map((x) => `${x.init.method} ${x.url}`)
-  assert.ok(urls.includes(`GET ${DEFAULT_BASE_URL}/api/agent/e1`))
-  assert.ok(urls.includes(`POST ${DEFAULT_BASE_URL}/api/agent/e1/respond`))
-  assert.ok(urls.includes(`POST ${DEFAULT_BASE_URL}/api/agent/e1/stop`))
-})
-
-test('startWorkflow builds the right path + returns the id string', async () => {
-  const f = mockFetch({ text: 'wf-abc' })
-  const c = new ConductorClient({ fetchImpl: f })
-  const id = await c.startWorkflow('cleanup', { host: 'web-1' }, { version: 3 })
-  assert.equal(id, 'wf-abc')
-  assert.match(f.calls[0].url, /\/api\/workflow\/cleanup\?version=3$/)
-})
-
-test('getWorkflow/terminate/retry/search hit the engine surface', async () => {
-  const f = mockFetch({ json: { results: [] } })
-  const c = new ConductorClient({ fetchImpl: f })
-  await c.getWorkflow('w1')
-  await c.terminateWorkflow('w1', 'done')
-  await c.retryWorkflow('w1')
-  await c.searchWorkflows('status:FAILED', 5)
-  const urls = f.calls.map((x) => `${x.init.method} ${x.url}`)
-  assert.ok(urls.some((u) => u.startsWith(`GET ${DEFAULT_BASE_URL}/api/workflow/w1?includeTasks=`)))
-  assert.ok(urls.some((u) => u.startsWith(`DELETE ${DEFAULT_BASE_URL}/api/workflow/w1?reason=done`)))
-  assert.ok(urls.includes(`POST ${DEFAULT_BASE_URL}/api/workflow/w1/retry`))
-  assert.ok(urls.some((u) => u.includes('/api/workflow/search?') && u.includes('status%3AFAILED')))
-})
-
-test('non-2xx responses raise ConductorApiError with status + body', async () => {
-  // health() swallows errors into {ok:false}; other methods raise ConductorApiError.
-  const up = new ConductorClient({ fetchImpl: mockFetch({ ok: false, status: 500, text: 'boom' }) })
-  const h = await up.health()
-  assert.equal(h.ok, false)
-  const c2 = new ConductorClient({ fetchImpl: mockFetch({ ok: false, status: 500, text: 'boom' }) })
-  await assert.rejects(() => c2.getWorkflow('w1'), ConductorApiError)
-  const c3 = new ConductorClient({ fetchImpl: mockFetch({ ok: false, status: 404, text: 'nope' }) })
-  await assert.rejects(() => c3.agentStatus('x'), ConductorApiError)
-})
-
-// ─── plugin glue: config + auth ────────────────────────────────────────────
-test('resolveConfig prefers settings, falls back to env, strips trailing slash', () => {
-  const c = resolveConfig({ settings: { agentspan: { serverUrl: 'http://srv:6767/', authSecretRef: 'as-auth' } } }, {})
-  assert.equal(c.serverUrl, 'http://srv:6767')
-  assert.equal(c.authSecretRef, 'as-auth')
-  const env = resolveConfig({}, { AGENTSPAN_SERVER_URL: 'http://env:6767/' })
-  assert.equal(env.serverUrl, 'http://env:6767')
-  assert.equal(resolveConfig({}, {}).serverUrl, DEFAULT_BASE_URL)
-})
-
-test('parseAuthBlob parses KEY=VAL lines into {key,secret}', () => {
-  assert.deepEqual(parseAuthBlob('AGENTSPAN_AUTH_KEY=k\nAGENTSPAN_AUTH_SECRET=s'), { key: 'k', secret: 's' })
-  assert.deepEqual(parseAuthBlob('AUTH_KEY=a\nAUTH_SECRET=b'), { key: 'a', secret: 'b' })
-  assert.equal(parseAuthBlob('AGENTSPAN_AUTH_KEY=only'), undefined)
-  assert.equal(parseAuthBlob(''), undefined)
-  assert.equal(parseAuthBlob(undefined), undefined)
-})
-
-test('buildClient wires auth from ctx.getSecret + configures baseUrl', () => {
-  const ctx = {
-    settings: { agentspan: { serverUrl: 'http://srv:6767', authSecretRef: 'as-auth' } },
-    getSecret: (k) => (k === 'as-auth' ? 'AGENTSPAN_AUTH_KEY=k\nAGENTSPAN_AUTH_SECRET=s' : undefined),
-  }
-  const { client, config } = buildClient(ctx, mockFetch({ json: {} }))
-  assert.equal(config.serverUrl, 'http://srv:6767')
-  assert.equal(client.auth.key, 'k')
-  // missing secret → no auth, no crash
-  const noSecret = buildClient({ settings: { agentspan: { authSecretRef: 'nope' } }, getSecret: () => undefined }, mockFetch({ json: {} }))
-  assert.equal(noSecret.client.auth, undefined)
-})
-
-// ─── plugin glue: normalization helpers ────────────────────────────────────
-test('summarizeStatus normalizes agent + workflow payloads', () => {
-  const a = summarizeStatus({ executionId: 'e1', agentName: 'bot', status: 'RUNNING', tasks: [{ status: 'COMPLETED' }, { status: 'FAILED' }] })
-  assert.equal(a.status, 'RUNNING')
-  assert.equal(a.taskCount, 2)
-  assert.equal(a.completedTasks, 1)
-  assert.equal(a.failedTasks, 1)
-  const w = summarizeStatus({ workflowId: 'w1', workflowName: 'cleanup', status: 'COMPLETED', reasonForIncompletion: undefined })
-  assert.equal(w.name, 'cleanup')
-  assert.equal(w.status, 'COMPLETED')
-  assert.deepEqual(summarizeStatus(null), { status: 'UNKNOWN' })
-})
-
-test('toExecutionRows handles results/workflows/array shapes', () => {
-  assert.equal(toExecutionRows({ results: [{ workflowId: 'a', workflowName: 'x', status: 'RUNNING' }] }).length, 1)
-  assert.equal(toExecutionRows({ workflows: [{ id: 'b', name: 'y', status: 'FAILED' }] })[0].status, 'FAILED')
-  assert.equal(toExecutionRows([{ workflowId: 'c' }]).length, 1)
-  assert.deepEqual(toExecutionRows({}), [])
-})
-
-test('isFailedExecution matches terminal-failure statuses only', () => {
-  assert.ok(isFailedExecution('FAILED'))
-  assert.ok(isFailedExecution('terminated'))
-  assert.ok(isFailedExecution('TIMED_OUT'))
-  assert.ok(!isFailedExecution('RUNNING'))
-  assert.ok(!isFailedExecution('COMPLETED'))
-})
-
-// ─── plugin registration + tool behavior (mocked server) ──────────────────
-/** Build a ctx with register* capture + a mocked client injected. */
-function makeCtx(fetchImpl, settings = {}) {
-  const tools = new Map()
-  const triggers = []
-  const panels = []
-  const logs = []
-  const ctx = {
-    settings: { agentspan: settings },
-    registerTool: (t) => tools.set(t.name, t),
-    registerTrigger: (t) => triggers.push(t),
-    registerPanel: (p) => panels.push(p),
-    log: (l) => logs.push(l),
-  }
-  // inject the mocked fetch by overriding buildClient's realFetch via a hack:
-  // we re-register with a patched client below.
-  return { tools, triggers, panels, logs, ctx }
-}
-
-test('register wires 9 tools, 1 trigger, 1 panel', () => {
-  const { tools, triggers, panels, ctx } = makeCtx(null, { serverUrl: 'http://x:6767' })
-  register(ctx)
-  assert.equal(tools.size, 9)
-  for (const n of ['agentspan_health', 'agentspan_run', 'agentspan_status', 'agentspan_approve', 'agentspan_list', 'agentspan_stop', 'agentspan_export_playbook', 'agentspan_register_playbook', 'agentspan_delegate']) assert.ok(tools.has(n), `missing ${n}`)
-  assert.equal(triggers.length, 1)
-  assert.equal(panels.length, 1)
-})
-
-test('agentspan_health returns error+hint when server unreachable (no throw)', async () => {
-  const { tools, ctx } = makeCtx(null, { serverUrl: 'http://down:6767' })
-  // force a failing fetch by monkey-patching global fetch
-  const realFetch = globalThis.fetch
-  globalThis.fetch = async () => { throw new Error('ECONNREFUSED') }
-  register(ctx)
-  const r = await tools.get('agentspan_health').handler({})
-  assert.equal(r.error && true, true)
-  assert.match(r.hint, /AgentSpan server running/)
-  globalThis.fetch = realFetch
-})
-
-test('agentspan_run (agentConfig) returns executionId + uiUrl from a live mock server', async () => {
-  const { tools, ctx } = makeCtx(null, { serverUrl: DEFAULT_BASE_URL })
-  const realFetch = globalThis.fetch
-  globalThis.fetch = async (url, init) => ({
-    ok: true, status: 200,
-    text: async () => JSON.stringify({ executionId: 'exec-42' }),
-  })
-  register(ctx)
-  const r = await tools.get('agentspan_run').handler({ agentConfig: { name: 'a' }, prompt: 'hi' })
-  assert.equal(r.executionId, 'exec-42')
-  assert.match(r.uiUrl, /\/execution\/exec-42$/)
-  globalThis.fetch = realFetch
-})
-
-test('agentspan_run (workflow) returns workflowId; needs agentConfig-or-workflow', async () => {
-  const { tools, ctx } = makeCtx(null, { serverUrl: DEFAULT_BASE_URL })
-  const realFetch = globalThis.fetch
-  globalThis.fetch = async () => ({ ok: true, status: 200, text: async () => 'wf-7' })
-  register(ctx)
-  const r = await tools.get('agentspan_run').handler({ workflow: 'cleanup', input: { h: 1 } })
-  assert.equal(r.workflowId, 'wf-7')
-  const bad = await tools.get('agentspan_run').handler({})
-  assert.match(bad.error, /agentConfig or workflow/)
-  globalThis.fetch = realFetch
-})
-
-test('agentspan_status falls back to workflow engine when agent surface 404s', async () => {
-  const { tools, ctx } = makeCtx(null, { serverUrl: DEFAULT_BASE_URL })
-  const realFetch = globalThis.fetch
-  globalThis.fetch = async (url) => {
-    if (url.includes('/api/agent/')) return { ok: false, status: 404, text: async () => 'not an agent' }
-    return { ok: true, status: 200, text: async () => JSON.stringify({ workflowId: 'w1', workflowName: 'cleanup', status: 'COMPLETED', tasks: [] }) }
-  }
-  register(ctx)
-  const r = await tools.get('agentspan_status').handler({ executionId: 'w1' })
-  assert.equal(r.kind, 'workflow')
-  assert.equal(r.status, 'COMPLETED')
-  globalThis.fetch = realFetch
-})
-
-test('agentspan_approve responds + reports new status; requires id', async () => {
-  const { tools, ctx } = makeCtx(null, { serverUrl: DEFAULT_BASE_URL })
-  const realFetch = globalThis.fetch
-  const posted = []
-  globalThis.fetch = async (url, init) => {
-    if (init.method === 'POST' && url.includes('/respond')) { posted.push(url); return { ok: true, status: 200, text: async () => '' } }
-    return { ok: true, status: 200, text: async () => JSON.stringify({ executionId: 'e1', status: 'RUNNING' }) }
-  }
-  register(ctx)
-  const bad = await tools.get('agentspan_approve').handler({})
-  assert.match(bad.error, /executionId/)
-  const r = await tools.get('agentspan_approve').handler({ executionId: 'e1', output: { approved: true } })
-  assert.equal(r.responded, true)
-  assert.ok(posted[0].includes('/api/agent/e1/respond'))
-  globalThis.fetch = realFetch
-})
-
-test('agentspan_list returns normalized execution rows', async () => {
-  const { tools, ctx } = makeCtx(null, { serverUrl: DEFAULT_BASE_URL })
-  const realFetch = globalThis.fetch
-  globalThis.fetch = async () => ({ ok: true, status: 200, text: async () => JSON.stringify({ results: [{ workflowId: 'a', workflowName: 'x', status: 'RUNNING' }, { workflowId: 'b', workflowName: 'y', status: 'FAILED' }] }) })
-  register(ctx)
-  const r = await tools.get('agentspan_list').handler({})
-  assert.equal(r.count, 2)
-  assert.equal(r.executions[1].status, 'FAILED')
-  globalThis.fetch = realFetch
-})
-
-test('agentspan_stop tries agent stop then terminates workflow; requires id', async () => {
-  const { tools, ctx } = makeCtx(null, { serverUrl: DEFAULT_BASE_URL })
-  const realFetch = globalThis.fetch
-  const calls = []
-  globalThis.fetch = async (url, init) => {
-    calls.push(`${init.method} ${url}`)
-    if (url.includes('/api/agent/') && url.includes('/stop')) return { ok: false, status: 404, text: async () => 'no' }
-    return { ok: true, status: 200, text: async () => '' }
-  }
-  register(ctx)
-  const bad = await tools.get('agentspan_stop').handler({})
-  assert.match(bad.error, /executionId/)
-  const r = await tools.get('agentspan_stop').handler({ executionId: 'w1' })
-  assert.equal(r.stopped, true)
-  assert.ok(calls.some((c) => c.startsWith(`DELETE ${DEFAULT_BASE_URL}/api/workflow/w1`)))
-  globalThis.fetch = realFetch
-})
-
-test('trigger fires only for agentspan FAILED events', () => {
-  const { triggers, ctx } = makeCtx(null, {})
-  register(ctx)
-  const t = triggers[0]
-  assert.ok(t.match({ source: 'agentspan', status: 'FAILED' }))
-  assert.ok(!t.match({ source: 'agentspan', status: 'RUNNING' }))
-  assert.ok(!t.match({ source: 'netdata', status: 'FAILED' }))
-})
-
-test('panel renders an executions table', () => {
-  const { panels, ctx } = makeCtx(null, { serverUrl: 'http://x:6767' })
-  register(ctx)
-  const html = panels[0].render([{ name: 'cleanup', id: 'e1', status: 'RUNNING', startTime: 'now' }])
-  assert.match(html, /cleanup/)
-  assert.match(html, /http:\/\/x:6767/)
-})

package/plugins/agentspan-bridge/agentspan-bridge.phase2.extreme.spec.ts

@@ -1,282 +0,0 @@
-/**
- * agentspan-bridge.phase2.extreme.spec.ts — exhaustive offline tests for the
- * Phase-2 additions: playbookToWorkflowDef mapper (step→task mapping, DAG
- * edges, wait/rollback, retries), the conductorClient registerWorkflowDef /
- * getWorkflowDef methods, and the new tools (agentspan_export_playbook,
- * agentspan_register_playbook, agentspan_delegate) with mocked fetch. No network.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { ConductorClient, DEFAULT_BASE_URL } from './conductorClient.mjs'
-import {
-  playbookToWorkflowDef,
-  stepToTask,
-  rollbackToTask,
-  taskRef,
-} from './playbookToWorkflowDef.mjs'
-import { register, findPlaybook, buildDelegateAgentConfig } from './index.mjs'
-
-// ─── mock fetch ─────────────────────────────────────────────────────────────
-function mockFetch(respond) {
-  const calls = []
-  const fn = async (url, init) => {
-    calls.push({ url, init })
-    const r = typeof respond === 'function' ? respond(url, init) : respond
-    return { ok: r.ok !== false && (r.status ?? 200) < 400, status: r.status ?? 200, text: async () => r.text ?? (r.json !== undefined ? JSON.stringify(r.json) : '') }
-  }
-  fn.calls = calls
-  return fn
-}
-
-const samplePlaybook = {
-  id: 'pb-1',
-  name: 'nightly backup',
-  description: 'backup the core switch',
-  steps: [
-    { id: 'st-1', name: 'prep', kind: 'command', command: 'term length 0' },
-    { id: 'st-2', name: 'collect', kind: 'script', scriptId: 'scr-9' },
-    { id: 'st-3', name: 'settle', kind: 'wait', waitSeconds: 5 },
-    { id: 'st-4', name: 'apply', kind: 'command', command: 'apply acl', rollback: { kind: 'command', command: 'no acl' }, dependsOn: ['st-1', 'st-2'] },
-  ],
-}
-
-// ─── taskRef ────────────────────────────────────────────────────────────────
-test('taskRef sanitizes to Conductor-safe refs', () => {
-  assert.equal(taskRef('st-1'), 'st_1')
-  assert.equal(taskRef('apply acl!'), 'apply_acl_')
-  assert.equal(taskRef(undefined, 'fallback'), 'fallback')
-  assert.equal(taskRef(''), 'step')
-})
-
-// ─── stepToTask ─────────────────────────────────────────────────────────────
-test('command step → HTTP run_command task with command + validate', () => {
-  const t = stepToTask({ id: 'st-1', kind: 'command', command: 'show run', validate: { expect: 'ok' } }, 0, {})
-  assert.equal(t.type, 'HTTP')
-  assert.equal(t.taskReferenceName, 'st_1')
-  const req = t.inputParameters.http_request
-  assert.equal(req.method, 'POST')
-  assert.equal(req.body.kind, 'run_command')
-  assert.equal(req.body.command, 'show run')
-  assert.deepEqual(req.body.validate, { expect: 'ok' })
-})
-
-test('script step → SIMPLE script-reference task (scriptId, no inline body)', () => {
-  const t = stepToTask({ id: 'st-2', kind: 'script', scriptId: 'scr-9', name: 'collect' }, 1, {})
-  assert.equal(t.type, 'SIMPLE')
-  assert.equal(t.inputParameters.kind, 'rterm_script')
-  assert.equal(t.inputParameters.scriptId, 'scr-9')
-  assert.equal(t.inputParameters.name, 'collect')
-})
-
-test('wait step → Conductor WAIT task with duration', () => {
-  const t = stepToTask({ id: 'st-3', kind: 'wait', waitSeconds: 7 }, 2, {})
-  assert.equal(t.type, 'WAIT')
-  assert.equal(t.inputParameters.duration, 7)
-})
-
-test('onError=continue sets retryCount; stop (default) is 0', () => {
-  const cont = stepToTask({ id: 'a', kind: 'command', command: 'x', onError: 'continue' }, 0, { continueRetryCount: 3 })
-  assert.equal(cont.retryCount, 3)
-  const stop = stepToTask({ id: 'b', kind: 'command', command: 'x' }, 1, {})
-  assert.equal(stop.retryCount, 0)
-})
-
-// ─── rollbackToTask ─────────────────────────────────────────────────────────
-test('rollback command → optional compensating HTTP task', () => {
-  const t = rollbackToTask({ kind: 'command', command: 'no acl' }, 'st_4', 0)
-  assert.equal(t.type, 'HTTP')
-  assert.equal(t.optional, true)
-  assert.equal(t.inputParameters.http_request.body.compensating, true)
-  assert.match(t.taskReferenceName, /^rollback_st_4_/)
-})
-
-test('rollback script → optional compensating SIMPLE task', () => {
-  const t = rollbackToTask({ kind: 'script', scriptId: 'undo' }, 'st_1', 1)
-  assert.equal(t.type, 'SIMPLE')
-  assert.equal(t.inputParameters.scriptId, 'undo')
-  assert.equal(t.optional, true)
-})
-
-// ─── playbookToWorkflowDef: full mapping ────────────────────────────────────
-test('maps all 4 steps + rollback compensating task in order', () => {
-  const def = playbookToWorkflowDef(samplePlaybook, { execUri: 'http://gw:17888/rpc/exec' })
-  assert.equal(def.name, 'nightly_backup')
-  assert.equal(def.version, 1)
-  assert.equal(def.schemaVersion, 2)
-  assert.equal(def.restartable, true)
-  // 4 step tasks + 1 JOIN (st-4 has 2 deps) + 1 rollback = 6
-  const types = def.tasks.map((t) => t.type)
-  assert.equal(types.filter((x) => x === 'JOIN').length, 1, 'one JOIN for the 2-dep step')
-  assert.equal(types.filter((x) => x === 'WAIT').length, 1, 'one WAIT')
-  const rollback = def.tasks[def.tasks.length - 1]
-  assert.equal(rollback.optional, true, 'last task is the compensating rollback')
-  assert.equal(rollback.inputParameters.http_request.body.command, 'no acl')
-})
-
-test('JOIN carries the dependsOn edges (fan-in)', () => {
-  const def = playbookToWorkflowDef(samplePlaybook, {})
-  const join = def.tasks.find((t) => t.type === 'JOIN')
-  assert.deepEqual(join.joinOn, ['st_1', 'st_2'])
-  // the dependent task (st-4) appears after the JOIN in order
-  const joinIdx = def.tasks.indexOf(join)
-  const st4 = def.tasks.find((t) => t.taskReferenceName === 'st_4')
-  assert.ok(def.tasks.indexOf(st4) > joinIdx, 'dependent task comes after its JOIN')
-})
-
-test('linear playbook (no dependsOn) emits no JOINs', () => {
-  const pb = { name: 'linear', steps: [
-    { id: 'a', kind: 'command', command: '1' },
-    { id: 'b', kind: 'command', command: '2' },
-    { id: 'c', kind: 'wait', waitSeconds: 1 },
-  ] }
-  const def = playbookToWorkflowDef(pb, {})
-  assert.equal(def.tasks.filter((t) => t.type === 'JOIN').length, 0)
-  assert.equal(def.tasks.length, 3)
-})
-
-test('multiple rollbacks run in reverse step order (undo newest first)', () => {
-  const pb = { name: 'multi', steps: [
-    { id: 'a', kind: 'command', command: 'a1', rollback: { kind: 'command', command: 'undo-a' } },
-    { id: 'b', kind: 'command', command: 'b1', rollback: { kind: 'command', command: 'undo-b' } },
-  ] }
-  const def = playbookToWorkflowDef(pb, {})
-  const rbs = def.tasks.filter((t) => t.optional)
-  assert.equal(rbs.length, 2)
-  assert.equal(rbs[0].inputParameters.http_request.body.command, 'undo-b', 'newest rollback first')
-  assert.equal(rbs[1].inputParameters.http_request.body.command, 'undo-a')
-})
-
-test('execUri flows into the command tasks + inputTemplate', () => {
-  const def = playbookToWorkflowDef(samplePlaybook, { execUri: 'http://gw:9000/exec' })
-  const cmdTask = def.tasks.find((t) => t.type === 'HTTP')
-  assert.equal(cmdTask.inputParameters.http_request.uri, 'http://gw:9000/exec')
-  assert.equal(def.inputTemplate.rtermExecUri, 'http://gw:9000/exec')
-})
-
-test('rejects a playbook without steps', () => {
-  assert.throws(() => playbookToWorkflowDef({ name: 'x' }), /steps array/)
-  assert.throws(() => playbookToWorkflowDef(null), /steps array/)
-})
-
-// ─── conductorClient: registerWorkflowDef / getWorkflowDef ─────────────────
-test('registerWorkflowDef POSTs an array to /api/metadata/workflow', async () => {
-  const f = mockFetch({ json: {} })
-  const c = new ConductorClient({ fetchImpl: f })
-  const def = playbookToWorkflowDef(samplePlaybook, {})
-  await c.registerWorkflowDef(def)
-  const call = f.calls[0]
-  assert.equal(call.url, `${DEFAULT_BASE_URL}/api/metadata/workflow`)
-  assert.equal(call.init.method, 'POST')
-  const body = JSON.parse(call.init.body)
-  assert.ok(Array.isArray(body), 'body is an array of defs')
-  assert.equal(body[0].name, 'nightly_backup')
-})
-
-test('registerWorkflowDef accepts an array + rejects empty', async () => {
-  const c = new ConductorClient({ fetchImpl: mockFetch({ json: {} }) })
-  await assert.rejects(() => c.registerWorkflowDef(), /WorkflowDef/)
-})
-
-test('getWorkflowDef GETs by name (+version)', async () => {
-  const f = mockFetch({ json: { name: 'x', version: 2 } })
-  const c = new ConductorClient({ fetchImpl: f })
-  await c.getWorkflowDef('nightly_backup', 2)
-  assert.match(f.calls[0].url, /\/api\/metadata\/workflow\/nightly_backup\?version=2$/)
-  await assert.rejects(() => c.getWorkflowDef(), /name/)
-})
-
-// ─── index helpers: findPlaybook / buildDelegateAgentConfig ────────────────
-test('findPlaybook resolves from AutomationManager then settings, by id or name', () => {
-  const pb = { id: 'pb-1', name: 'nightly' }
-  const viaAm = findPlaybook({ automationManager: { getPlaybook: (x) => (x === 'pb-1' ? pb : undefined) } }, 'pb-1')
-  assert.equal(viaAm.name, 'nightly')
-  const viaSettings = findPlaybook({ settings: { automation: { playbooks: [pb] } } }, 'nightly')
-  assert.equal(viaSettings.id, 'pb-1')
-  assert.equal(findPlaybook({ settings: { automation: { playbooks: [] } } }, 'ghost'), undefined)
-  assert.equal(findPlaybook({}, undefined), undefined)
-})
-
-test('buildDelegateAgentConfig builds a valid durable AgentConfig', () => {
-  const c = buildDelegateAgentConfig('mybot', 'do the thing', { model: 'anthropic/claude-sonnet-4.6' })
-  assert.equal(c.name, 'mybot')
-  assert.equal(c.model, 'anthropic/claude-sonnet-4.6')
-  assert.equal(c.input, 'do the thing')
-  const def = buildDelegateAgentConfig(undefined, 't')
-  assert.equal(def.name, 'rterm_delegate')
-  assert.equal(def.model, 'openai/gpt-4o')
-})
-
-// ─── new tools (mocked server) ─────────────────────────────────────────────
-function makeCtx(playbooks, fetchImpl) {
-  const tools = new Map()
-  const triggers = []
-  const panels = []
-  const ctx = {
-    settings: { agentspan: { serverUrl: DEFAULT_BASE_URL }, automation: { playbooks } },
-    registerTool: (t) => tools.set(t.name, t),
-    registerTrigger: (t) => triggers.push(t),
-    registerPanel: (p) => panels.push(p),
-    log: () => {},
-  }
-  return { tools, ctx, fetchImpl }
-}
-
-test('registers 9 tools now (6 phase-1 + 3 phase-2)', () => {
-  const { tools, ctx } = makeCtx([], null)
-  register(ctx)
-  assert.equal(tools.size, 9)
-  for (const n of ['agentspan_export_playbook', 'agentspan_register_playbook', 'agentspan_delegate']) assert.ok(tools.has(n), `missing ${n}`)
-})
-
-test('agentspan_export_playbook returns the mapped def without registering', async () => {
-  const posted = []
-  const realFetch = globalThis.fetch
-  globalThis.fetch = async (url, init) => { posted.push(url); return { ok: true, status: 200, text: async () => '{}' } }
-  const { tools, ctx } = makeCtx([samplePlaybook], null)
-  register(ctx)
-  const r = await tools.get('agentspan_export_playbook').handler({ playbook: 'nightly backup' })
-  assert.equal(r.name, 'nightly_backup')
-  assert.ok(r.taskCount >= 5)
-  assert.ok(r.def.tasks.some((t) => t.type === 'WAIT'))
-  assert.equal(posted.length, 0, 'export is pure — no HTTP calls')
-  const missing = await tools.get('agentspan_export_playbook').handler({ playbook: 'ghost' })
-  assert.match(missing.error, /not found/)
-  globalThis.fetch = realFetch
-})
-
-test('agentspan_register_playbook registers the def on the server', async () => {
-  const calls = []
-  const realFetch = globalThis.fetch
-  globalThis.fetch = async (url, init) => {
-    calls.push({ url, method: init.method })
-    return { ok: true, status: 200, text: async () => '{}' }
-  }
-  const { tools, ctx } = makeCtx([samplePlaybook], null)
-  register(ctx)
-  const r = await tools.get('agentspan_register_playbook').handler({ playbook: 'nightly backup' })
-  assert.equal(r.registered, true)
-  assert.equal(r.name, 'nightly_backup')
-  assert.equal(r.runWith.args.workflow, 'nightly_backup')
-  assert.ok(calls.some((c) => c.url.endsWith('/api/metadata/workflow') && c.method === 'POST'))
-  globalThis.fetch = realFetch
-})
-
-test('agentspan_delegate builds an AgentConfig and returns executionId + followUp', async () => {
-  const realFetch = globalThis.fetch
-  let postedBody
-  globalThis.fetch = async (url, init) => {
-    if (init.method === 'POST') postedBody = JSON.parse(init.body)
-    return { ok: true, status: 200, text: async () => JSON.stringify({ executionId: 'exec-del-1' }) }
-  }
-  const { tools, ctx } = makeCtx([], null)
-  register(ctx)
-  const bad = await tools.get('agentspan_delegate').handler({})
-  assert.match(bad.error, /prompt/)
-  const r = await tools.get('agentspan_delegate').handler({ prompt: 'investigate the disk-full on web-01', model: 'openai/gpt-5.6-sol' })
-  assert.equal(r.delegated, true)
-  assert.equal(r.executionId, 'exec-del-1')
-  assert.match(r.uiUrl, /\/execution\/exec-del-1$/)
-  assert.equal(postedBody.model, 'openai/gpt-5.6-sol')
-  assert.equal(postedBody.input, 'investigate the disk-full on web-01')
-  globalThis.fetch = realFetch
-})

package/plugins/netdata-rterm/netdata-rterm.extreme.spec.ts

@@ -1,252 +0,0 @@
-import {
-  parseNetdataAlert, mapSeverity, buildFingerprint, toTriggerEvent, correlateWithRterm, register,
-} from './index.mjs'
-
-const cases: Array<{ name: string; run: () => void | Promise<void> }> = []
-function test(n: string, r: () => void | Promise<void>) { cases.push({ name: n, run: r }) }
-
-// ---- parseNetdataAlert ----
-test('parse: alert notification with all fields', () => {
-  const payload = {
-    message: 'CPU usage is 95%', alert: 'cpu_usage', info: 'CPU utilization too high',
-    chart: 'system.cpu', context: 'system.cpu', space: 'prod-cluster', family: 'cpu',
-    class: 'Error', severity: 'critical', date: '2026-07-22T10:00:00Z', duration: '5m',
-    additional_active_critical_alerts: 2, additional_active_warning_alerts: 1,
-    alert_url: 'https://app.netdata.cloud/alert/123',
-  }
-  const p = parseNetdataAlert(payload)
-  if (!p || p.kind !== 'alert') throw new Error('should parse alert')
-  if (p.alert !== 'cpu_usage') throw new Error('alert name')
-  if (p.severity !== 'critical') throw new Error('severity')
-  if (p.chart !== 'system.cpu') throw new Error('chart')
-  if (p.additionalCritical !== 2) throw new Error('additional critical')
-  if (p.host !== 'prod-cluster') throw new Error('host from space')
-  if (p.alertUrl !== 'https://app.netdata.cloud/alert/123') throw new Error('alert url')
-})
-
-test('parse: warning severity', () => {
-  const p = parseNetdataAlert({ alert: 'disk_space', severity: 'warning', message: 'Disk 80% full', space: 'web-01' })
-  if (!p || p.severity !== 'warning') throw new Error('should be warning')
-})
-
-test('parse: clear severity (alert resolved)', () => {
-  const p = parseNetdataAlert({ alert: 'cpu_usage', severity: 'clear', message: 'CPU back to normal', space: 'web-01' })
-  if (!p || p.severity !== 'clear') throw new Error('should be clear')
-})
-
-test('parse: reachability notification (node down)', () => {
-  const p = parseNetdataAlert({ message: 'Node unreachable', node: 'web-02', space: 'prod', status: 'down', date: '2026-07-22T10:00:00Z', duration: '2m' })
-  if (!p || p.kind !== 'reachability') throw new Error('should parse reachability')
-  if (p.status !== 'down') throw new Error('status')
-  if (p.host !== 'web-02') throw new Error('host from node')
-})
-
-test('parse: reachability notification (node up)', () => {
-  const p = parseNetdataAlert({ node: 'web-02', status: 'up', date: '2026-07-22T10:05:00Z' })
-  if (!p || p.status !== 'up') throw new Error('should be up')
-})
-
-test('parse: null for invalid payload', () => {
-  if (parseNetdataAlert(null) !== null) throw new Error('null payload')
-  if (parseNetdataAlert({}) !== null) throw new Error('empty object')
-  if (parseNetdataAlert('not an object') !== null) throw new Error('string')
-  if (parseNetdataAlert({ foo: 'bar' }) !== null) throw new Error('missing required fields')
-})
-
-// ---- mapSeverity ----
-test('mapSeverity: critical -> critical', () => {
-  if (mapSeverity('critical') !== 'critical') throw new Error('critical')
-})
-test('mapSeverity: warning -> warning', () => {
-  if (mapSeverity('warning') !== 'warning') throw new Error('warning')
-})
-test('mapSeverity: clear -> info', () => {
-  if (mapSeverity('clear') !== 'info') throw new Error('clear should map to info')
-})
-test('mapSeverity: unknown -> info', () => {
-  if (mapSeverity('unknown') !== 'info') throw new Error('unknown')
-})
-
-// ---- buildFingerprint ----
-test('buildFingerprint: alert fingerprint', () => {
-  const p = parseNetdataAlert({ alert: 'cpu_usage', severity: 'critical', space: 'web-01' })
-  const fp = buildFingerprint(p)
-  if (fp !== 'netdata:web-01:cpu_usage:critical') throw new Error(`got ${fp}`)
-})
-test('buildFingerprint: reachability fingerprint', () => {
-  const p = parseNetdataAlert({ node: 'web-02', status: 'down' })
-  const fp = buildFingerprint(p)
-  if (fp !== 'netdata:reachability:web-02:down') throw new Error(`got ${fp}`)
-})
-test('buildFingerprint: empty for null', () => {
-  if (buildFingerprint(null) !== '') throw new Error('should be empty')
-})
-
-// ---- toTriggerEvent ----
-test('toTriggerEvent: alert -> trigger event with correct severity', () => {
-  const p = parseNetdataAlert({ alert: 'disk_full', severity: 'critical', space: 'db-01', message: 'Disk 95%', date: '2026-07-22T10:00:00Z' })
-  const evt = toTriggerEvent(p)
-  if (!evt) throw new Error('should produce event')
-  if (evt.source !== 'netdata') throw new Error('source')
-  if (evt.severity !== 'critical') throw new Error('severity')
-  if (!evt.title.includes('disk_full')) throw new Error('title')
-  if (!evt.title.includes('db-01')) throw new Error('title host')
-  if (evt.labels.host !== 'db-01') throw new Error('labels host')
-  if (evt.labels.alert !== 'disk_full') throw new Error('labels alert')
-})
-
-test('toTriggerEvent: reachability down -> critical', () => {
-  const p = parseNetdataAlert({ node: 'web-03', status: 'down', date: '2026-07-22T10:00:00Z' })
-  const evt = toTriggerEvent(p)
-  if (!evt || evt.severity !== 'critical') throw new Error('down should be critical')
-  if (!evt.title.includes('DOWN')) throw new Error('title')
-})
-
-test('toTriggerEvent: reachability up -> info', () => {
-  const p = parseNetdataAlert({ node: 'web-03', status: 'up', date: '2026-07-22T10:00:00Z' })
-  const evt = toTriggerEvent(p)
-  if (!evt || evt.severity !== 'info') throw new Error('up should be info')
-})
-
-test('toTriggerEvent: null parsed -> null event', () => {
-  if (toTriggerEvent(null) !== null) throw new Error('should be null')
-})
-
-// ---- correlateWithRterm ----
-test('correlate: with metrics + incidents', () => {
-  const p = parseNetdataAlert({ alert: 'cpu_usage', severity: 'critical', space: 'web-01', additional_active_critical_alerts: 3 })
-  const mockMetrics = { snapshot: (host: string) => ({ host, cpuUsagePercent: 95, memoryUsagePercent: 70 }) }
-  const mockIncidents = { list: () => [
-    { title: 'web-01 disk full', affected: ['web-01'], status: 'open' },
-    { title: 'web-02 network issue', affected: ['web-02'], status: 'open' },
-    { title: 'web-01 resolved issue', affected: ['web-01'], status: 'resolved' },
-  ] }
-  const result = correlateWithRterm(p, mockMetrics as any, mockIncidents as any)
-  if (!result.recentMetrics || result.recentMetrics.cpuUsagePercent !== 95) throw new Error('metrics')
-  if (result.openIncidents.length !== 1) throw new Error(`expected 1 open incident, got ${result.openIncidents.length}`)
-  if (!result.correlation.includes('cpu_usage')) throw new Error('correlation should mention alert')
-  if (!result.correlation.includes('disk full')) throw new Error('correlation should mention incident')
-  if (!result.correlation.includes('3 additional critical')) throw new Error('correlation should mention additional alerts')
-})
-
-test('correlate: no prior context', () => {
-  const p = parseNetdataAlert({ alert: 'mem_usage', severity: 'warning', space: 'new-host' })
-  const result = correlateWithRterm(p, null, null)
-  if (result.recentMetrics !== null) throw new Error('no metrics')
-  if (result.openIncidents.length !== 0) throw new Error('no incidents')
-  if (!result.correlation.includes('No prior RTerm context')) throw new Error('should say no context')
-})
-
-test('correlate: null parsed -> empty', () => {
-  const result = correlateWithRterm(null, null, null)
-  if (result.recentMetrics !== null || result.openIncidents.length !== 0) throw new Error('should be empty')
-})
-
-// ---- register (plugin lifecycle) ----
-test('register: registers 2 tools, 2 triggers, 1 panel', () => {
-  const tools: any[] = [], triggers: any[] = [], panels: any[] = [], logs: string[] = []
-  register({
-    registerTool: (t) => tools.push(t),
-    registerTrigger: (t) => triggers.push(t),
-    registerPanel: (p) => panels.push(p),
-    exec: async () => '',
-    readLedger: () => ({}),
-    log: (line: string) => logs.push(line),
-  } as any)
-  if (tools.length !== 2) throw new Error(`expected 2 tools, got ${tools.length}`)
-  if (triggers.length !== 2) throw new Error(`expected 2 triggers, got ${triggers.length}`)
-  if (panels.length !== 1) throw new Error(`expected 1 panel, got ${panels.length}`)
-  if (!tools.some((t) => t.name === 'netdata_alert_summary')) throw new Error('missing alert_summary tool')
-  if (!tools.some((t) => t.name === 'netdata_correlate')) throw new Error('missing correlate tool')
-  if (!triggers.some((t) => t.name === 'netdata_critical_alert')) throw new Error('missing critical trigger')
-  if (!triggers.some((t) => t.name === 'netdata_warning_alert')) throw new Error('missing warning trigger')
-  if (!panels.some((p) => p.name === 'netdata-alert-feed')) throw new Error('missing alert feed panel')
-  if (!logs.some((l) => l.includes('registered'))) throw new Error('should log registration')
-})
-
-test('register: critical trigger matches critical events only', () => {
-  const triggers: any[] = []
-  register({
-    registerTool: () => {}, registerTrigger: (t) => triggers.push(t), registerPanel: () => {},
-    exec: async () => '', readLedger: () => ({}), log: () => {},
-  } as any)
-  const critTrigger = triggers.find((t) => t.name === 'netdata_critical_alert')
-  if (!critTrigger) throw new Error('missing critical trigger')
-  if (!critTrigger.match({ source: 'netdata', severity: 'critical' })) throw new Error('should match critical')
-  if (critTrigger.match({ source: 'netdata', severity: 'warning' })) throw new Error('should NOT match warning')
-  if (critTrigger.match({ source: 'other', severity: 'critical' })) throw new Error('should NOT match non-netdata')
-  if (critTrigger.match({})) throw new Error('should NOT match empty')
-})
-
-test('register: warning trigger matches warning events only', () => {
-  const triggers: any[] = []
-  register({
-    registerTool: () => {}, registerTrigger: (t) => triggers.push(t), registerPanel: () => {},
-    exec: async () => '', readLedger: () => ({}), log: () => {},
-  } as any)
-  const warnTrigger = triggers.find((t) => t.name === 'netdata_warning_alert')
-  if (!warnTrigger) throw new Error('missing warning trigger')
-  if (!warnTrigger.match({ source: 'netdata', severity: 'warning' })) throw new Error('should match warning')
-  if (warnTrigger.match({ source: 'netdata', severity: 'critical' })) throw new Error('should NOT match critical')
-})
-
-test('register: panel renders alert rows', () => {
-  const panels: any[] = []
-  register({
-    registerTool: () => {}, registerTrigger: () => {}, registerPanel: (p) => panels.push(p),
-    exec: async () => '', readLedger: () => ({}), log: () => {},
-  } as any)
-  const panel = panels[0]
-  const html = panel.render([
-    { host: 'web-01', alert: 'cpu_high', severity: 'critical', date: '2026-07-22' },
-    { host: 'web-02', alert: 'disk_full', severity: 'warning', date: '2026-07-22' },
-  ])
-  if (!html.includes('cpu_high') || !html.includes('disk_full')) throw new Error('should contain alert names')
-  if (!html.includes('<table>')) throw new Error('should render table')
-})
-
-test('register: panel renders empty feed', () => {
-  const panels: any[] = []
-  register({
-    registerTool: () => {}, registerTrigger: () => {}, registerPanel: (p) => panels.push(p),
-    exec: async () => '', readLedger: () => ({}), log: () => {},
-  } as any)
-  const html = panels[0].render(null)
-  if (!html.includes('Netdata Alerts')) throw new Error('should have title even when empty')
-})
-
-test('register: netdata_correlate tool handles invalid payload', async () => {
-  const tools: any[] = []
-  register({
-    registerTool: (t) => tools.push(t), registerTrigger: () => {}, registerPanel: () => {},
-    exec: async () => '', readLedger: () => ({}), log: () => {},
-  } as any)
-  const correlateTool = tools.find((t) => t.name === 'netdata_correlate')
-  const result = await correlateTool.handler({ alert: { foo: 'bar' } })
-  if (!result.error) throw new Error('should return error for invalid payload')
-})
-
-test('register: netdata_correlate tool correlates valid payload', async () => {
-  const tools: any[] = []
-  register({
-    registerTool: (t) => tools.push(t), registerTrigger: () => {}, registerPanel: () => {},
-    exec: async () => '', readLedger: () => null, log: () => {},
-  } as any)
-  const correlateTool = tools.find((t) => t.name === 'netdata_correlate')
-  const result = await correlateTool.handler({
-    alert: { alert: 'cpu_usage', severity: 'critical', space: 'web-01', message: 'CPU 95%' },
-  })
-  if (!result.parsed) throw new Error('should return parsed alert')
-  if (result.parsed.alert !== 'cpu_usage') throw new Error('alert name')
-})
-
-async function main() {
-  let pass = 0, fail = 0
-  for (const c of cases) {
-    try { await c.run(); pass++; console.log(`PASS ${c.name}`) }
-    catch (e: any) { fail++; console.log(`FAIL ${c.name}: ${e?.message ?? e}`) }
-  }
-  console.log(`\n${pass}/${cases.length} passed, ${fail} failed`)
-  if (fail > 0) process.exit(1)
-}
-void main()