onbuzz 4.6.0 → 4.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "4.6.0",
+  "version": "4.6.2",
   "description": "Loxia OnBuzz - Your AI Fleet",
   "type": "module",
   "main": "src/index.js",

package/src/core/__tests__/flowTemplates.test.js

@@ -181,3 +181,131 @@ describe('STARTER_TEMPLATES — every template validates clean', () => {
     });
   }
 });
+
+// ---- Per-template behavioural locks ----
+//
+// The generic checks above guarantee schema/lint/Phase-7 hygiene across
+// every template. The blocks below lock the specific behaviour each new
+// template exists to demonstrate — so a refactor can't silently drop the
+// feature that justifies the template's existence.
+
+describe('Template "support-triage" — feature locks', () => {
+  const triage = getTemplateByKey('support-triage');
+
+  test('exists', () => {
+    expect(triage).not.toBeNull();
+  });
+
+  test('has the four specialist-pipeline nodes (classifier, specialist, formatter, plus io)', () => {
+    const ids = triage.flow.nodes.map(n => n.id);
+    expect(ids).toEqual(expect.arrayContaining(['classifier', 'specialist', 'formatter', 'in', 'out']));
+  });
+
+  test('classifier emits the three routing fields (category enum, urgency number, sentiment enum)', () => {
+    const classifier = triage.flow.nodes.find(n => n.id === 'classifier');
+    const outputNames = (classifier.outputs || []).map(o => o.name);
+    expect(outputNames).toEqual(expect.arrayContaining(['category', 'urgency', 'sentiment']));
+    const urgency = classifier.outputs.find(o => o.name === 'urgency');
+    expect(urgency.type).toBe('number');
+  });
+
+  test('classifier has a tight timeout (≤30s) — fast classification is the whole point', () => {
+    const classifier = triage.flow.nodes.find(n => n.id === 'classifier');
+    expect(classifier.execution?.timeoutMs).toBeDefined();
+    expect(classifier.execution.timeoutMs).toBeLessThanOrEqual(30000);
+  });
+
+  test('specialist has a longer timeout (≥60s) — resolution work needs more headroom than classification', () => {
+    const specialist = triage.flow.nodes.find(n => n.id === 'specialist');
+    expect(specialist.execution?.timeoutMs).toBeDefined();
+    expect(specialist.execution.timeoutMs).toBeGreaterThanOrEqual(60000);
+  });
+
+  test('flow has retry policy (queue robustness across transient failures)', () => {
+    expect(triage.flow.execution?.maxRetries).toBeDefined();
+    expect(triage.flow.execution.maxRetries).toBeGreaterThan(0);
+  });
+
+  test('all three classifier outputs reach the specialist (typed routing)', () => {
+    const edges = triage.flow.edges.filter(e => e.source === 'classifier' && e.target === 'specialist');
+    const fields = edges.map(e => e.sourceField).sort();
+    expect(fields).toEqual(['category', 'sentiment', 'urgency']);
+  });
+
+  test('formatter receives both the resolution AND the sentiment (tone-matching contract)', () => {
+    const inbound = triage.flow.edges.filter(e => e.target === 'formatter');
+    const targetFields = inbound.map(e => e.targetField).sort();
+    expect(targetFields).toEqual(['resolution', 'sentiment']);
+  });
+
+  test('output node receives the polished reply (formatter.reply), not raw resolution', () => {
+    const out = triage.flow.nodes.find(n => n.id === 'out');
+    const inbound = triage.flow.edges.find(e => e.target === out.id);
+    expect(inbound.source).toBe('formatter');
+    expect(inbound.sourceField).toBe('reply');
+  });
+});
+
+describe('Template "spec-plan-implement-verify" — feature locks', () => {
+  const sp = getTemplateByKey('spec-plan-implement-verify');
+
+  test('exists', () => {
+    expect(sp).not.toBeNull();
+  });
+
+  test('has the four-stage autonomous-coding pipeline (pm → architect → implementer → verifier)', () => {
+    const ids = sp.flow.nodes.map(n => n.id);
+    expect(ids).toEqual(expect.arrayContaining(['pm', 'architect', 'implementer', 'verifier', 'in', 'out']));
+  });
+
+  test('PM produces structured requirements (json), not free prose', () => {
+    const pm = sp.flow.nodes.find(n => n.id === 'pm');
+    const requirements = (pm.outputs || []).find(o => o.name === 'requirements');
+    expect(requirements).toBeDefined();
+    expect(requirements.type).toBe('json');
+  });
+
+  test('architect produces a typed file list (the implementer\'s contract — most important guarantee in this flow)', () => {
+    const architect = sp.flow.nodes.find(n => n.id === 'architect');
+    const files = (architect.outputs || []).find(o => o.name === 'files');
+    expect(files).toBeDefined();
+    // Either json (a structured list) or list-of-something is acceptable;
+    // the value comes from being structured — not a prose blob.
+    expect(['json', 'list<text>']).toContain(files.type);
+  });
+
+  test('implementer receives the architect\'s files list AND the prose plan (typed handoff prevents drift)', () => {
+    const inbound = sp.flow.edges.filter(e => e.target === 'implementer');
+    const targets = inbound.map(e => e.targetField).sort();
+    expect(targets).toEqual(['files', 'plan']);
+    // Both must come from the architect — the implementer can't take a
+    // file list from anywhere else.
+    expect(inbound.every(e => e.source === 'architect')).toBe(true);
+  });
+
+  test('implementer has the longest timeout (≥5min) and ≥2 retries — code generation is the slow + flaky step', () => {
+    const implementer = sp.flow.nodes.find(n => n.id === 'implementer');
+    expect(implementer.execution?.timeoutMs).toBeGreaterThanOrEqual(300000);
+    expect(implementer.execution?.maxRetries).toBeGreaterThanOrEqual(2);
+  });
+
+  test('verifier has zero retries (deterministic step — re-running tests on the same code is wasted work)', () => {
+    const verifier = sp.flow.nodes.find(n => n.id === 'verifier');
+    expect(verifier.execution?.maxRetries).toBe(0);
+  });
+
+  test('verifier emits all three required signals: passed (boolean), failures (list<text>), report (text)', () => {
+    const verifier = sp.flow.nodes.find(n => n.id === 'verifier');
+    const byName = Object.fromEntries((verifier.outputs || []).map(o => [o.name, o]));
+    expect(byName.passed?.type).toBe('boolean');
+    expect(byName.failures?.type).toBe('list<text>');
+    expect(byName.report?.type).toBe('text');
+  });
+
+  test('output node receives the human-readable report (text) — type-compatible with the output node', () => {
+    const out = sp.flow.nodes.find(n => n.id === 'out');
+    const inbound = sp.flow.edges.find(e => e.target === out.id);
+    expect(inbound.source).toBe('verifier');
+    expect(inbound.sourceField).toBe('report');
+  });
+});

package/src/core/__tests__/stateManager.test.js

@@ -373,6 +373,73 @@ describe('StateManager', () => {
     });
   });
 
+  // ─── createFlow edge-id stamping (renders arrows for templates) ────────
+  describe('createFlow edge-id stamping', () => {
+    test('stamps a stable id on every edge that arrives without one', async () => {
+      // Templates + marketplace-installed flows arrive WITHOUT edge ids.
+      // ReactFlow silently drops edges missing `id`, so the canvas
+      // showed nodes-without-arrows for every freshly-loaded template
+      // until this stamp ran.
+      mockReadFile.mockResolvedValueOnce('{}');     // empty flow index
+      const flowData = {
+        name: 'arrow-test',
+        nodes: [
+          { id: 'a', type: 'agent', position: { x: 0, y: 0 } },
+          { id: 'b', type: 'agent', position: { x: 200, y: 0 } },
+        ],
+        edges: [
+          { source: 'a', sourceField: 'topic', target: 'b', targetField: 'topic' },
+          { source: 'a', sourceField: 'extra', target: 'b', targetField: 'extra' },
+        ],
+      };
+      const created = await sm.createFlow(flowData, '/proj');
+      // Every edge now has an id.
+      expect(created.edges).toHaveLength(2);
+      expect(created.edges.every(e => typeof e.id === 'string' && e.id.length > 0)).toBe(true);
+      // Ids reflect source/target/fields so they're stable across saves.
+      expect(created.edges[0].id).toMatch(/^e-a:topic-b:topic-/);
+      expect(created.edges[1].id).toMatch(/^e-a:extra-b:extra-/);
+    });
+
+    test('preserves existing edge ids — does NOT clobber them', async () => {
+      mockReadFile.mockResolvedValueOnce('{}');
+      const flowData = {
+        name: 'preserve-test',
+        nodes: [],
+        edges: [
+          { id: 'user-supplied-id', source: 'a', target: 'b' },
+        ],
+      };
+      const created = await sm.createFlow(flowData, '/proj');
+      expect(created.edges[0].id).toBe('user-supplied-id');
+    });
+
+    test('handles edges without sourceField/targetField (untyped flows)', async () => {
+      mockReadFile.mockResolvedValueOnce('{}');
+      const flowData = {
+        name: 'untyped',
+        nodes: [],
+        edges: [{ source: 'a', target: 'b' }],
+      };
+      const created = await sm.createFlow(flowData, '/proj');
+      expect(created.edges[0].id).toMatch(/^e-a-b-/);
+    });
+
+    test('persists createdBy when provided (used by platformcontrol create-flow)', async () => {
+      mockReadFile.mockResolvedValueOnce('{}');
+      const flow = await sm.createFlow({
+        name: 'authored', nodes: [], edges: [], createdBy: 'agent-x'
+      }, '/proj');
+      expect(flow.createdBy).toBe('agent-x');
+    });
+
+    test('omits createdBy when not provided (UI-created flows stay minimal)', async () => {
+      mockReadFile.mockResolvedValueOnce('{}');
+      const flow = await sm.createFlow({ name: 'plain', nodes: [], edges: [] }, '/proj');
+      expect(flow).not.toHaveProperty('createdBy');
+    });
+  });
+
   // ─── loadJSONResilient — corrupt file recovery ─────────────────────────
   describe('loadJSONResilient', () => {
     test('happy path: parses clean JSON without recovery', async () => {

package/src/core/stateManager.js

@@ -589,14 +589,28 @@ class StateManager {
     const safeName = (flowData.name || 'flow').toLowerCase().replace(/[^a-z0-9]/g, '-').slice(0, 20);
     const flowId = `flow-${safeName}-${Date.now()}`;
 
+    // Stamp edge ids on save. Templates and marketplace-installed flows
+    // ship without edge ids; ReactFlow refuses to render edges that
+    // don't have a unique `id`, so unstamped edges show up as
+    // disconnected dots on the canvas. Doing this here rather than in
+    // the editor means the durable shape on disk is always renderable.
+    // Helper is shared with FlowEditor's defense-in-depth layer so the
+    // id format stays consistent across save + reload.
+    const { ensureEdgeIds } = await import('../utilities/flowEdgeIds.js');
+    const stampedEdges = ensureEdgeIds(flowData.edges);
+
     const flow = {
       name: flowData.name,
       description: flowData.description || '',
       nodes: flowData.nodes || [],
-      edges: flowData.edges || [],
+      edges: stampedEdges,
       variables: flowData.variables || {},
       createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString()
+      updatedAt: new Date().toISOString(),
+      // createdBy: only present when the caller stamps it (e.g.
+      // platformControlTool's create-flow path). Not required for the
+      // happy-path UI flow but durable when set.
+      ...(flowData.createdBy ? { createdBy: flowData.createdBy } : {})
     };
 
     flowIndex[flowId] = flow;

package/src/index.js

@@ -538,6 +538,15 @@ class LoxiaApplication {
         const { getMemoryService } = await import('./services/memoryService.js');
         platformControlTool.setMemoryService(getMemoryService(this.logger));
       }
+      // Flow CRUD + execution requires the FlowExecutor (created later in
+      // the boot sequence by the webServer). The webServer init also
+      // calls setFlowExecutor on this tool when it spins up — so this
+      // call is the one that fires when the executor is already alive
+      // (rare during startup), and the webServer call covers the normal
+      // path. Both are idempotent.
+      if (typeof platformControlTool.setFlowExecutor === 'function' && this.flowExecutor) {
+        platformControlTool.setFlowExecutor(this.flowExecutor);
+      }
     }
     
     // Set AgentPool dependency for JobDoneTool

package/src/interfaces/webServer.js

@@ -31,6 +31,7 @@ import { getVisualEditorServer, getVisualEditorPort, getVisualEditorBaseUrl, set
 import { getCredentialVault } from '../services/credentialVault.js';
 import { getGalleryService } from '../services/galleryService.js';
 import { getUserDataPaths } from '../utilities/userDataDir.js';
+import { projectActiveRuns } from '../utilities/flowRunFilters.js';
 
 // Connect visual editor server to bridge (enables element selection forwarding)
 setBridgeGetter(getVisualEditorBridge);
@@ -584,6 +585,14 @@ class WebServer {
         if (jobDoneTool && typeof jobDoneTool.setFlowExecutor === 'function') {
           jobDoneTool.setFlowExecutor(this.flowExecutor);
         }
+        // Wire FlowExecutor into platformControlTool so its execute-flow
+        // and dry-run-flow actions can reach the executor. Without this,
+        // an agent with `flows: 'all'` permission would still get
+        // "FlowExecutor not available" when calling execute-flow.
+        const platformControlTool = toolsRegistry.getTool('platformcontrol');
+        if (platformControlTool && typeof platformControlTool.setFlowExecutor === 'function') {
+          platformControlTool.setFlowExecutor(this.flowExecutor);
+        }
       }
 
       this.logger.info('FlowExecutor initialized successfully');
@@ -5277,6 +5286,30 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       }
     });
 
+    // List all currently-active runs across every flow. Used by the
+    // FlowsPage to mark which cards are "running" without polling each
+    // flow individually. Active = status in {queued, pending, running,
+    // paused} — anything not yet terminal.
+    //
+    // Mounted ABOVE `/api/flows/:flowId/runs` so the literal `active`
+    // segment isn't captured as a flowId by Express's pattern matcher.
+    this.app.get('/api/flows/runs/active', async (req, res) => {
+      try {
+        const projectDir = this.orchestrator.config.project?.directory || process.cwd();
+        const runIndex = await this.orchestrator.stateManager.loadFlowRunIndex(projectDir);
+        // Pre-load the flow index ONCE so the progress summary can
+        // resolve total node count + current step labels per run
+        // without N+1 lookups. The lookup callback is a closure over
+        // the flow map; the helper queries by id at call time only.
+        const flowIndex = await this.orchestrator.stateManager.loadFlowIndex(projectDir);
+        const flowLookup = (flowId) => (flowIndex && flowId) ? flowIndex[flowId] || null : null;
+        res.json({ success: true, data: projectActiveRuns(runIndex, flowLookup) });
+      } catch (error) {
+        this.logger.error('Failed to list active flow runs', { error: error.message });
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
     // List runs for a flow
     this.app.get('/api/flows/:flowId/runs', async (req, res) => {
       try {

package/src/tools/__tests__/platformControlAgentTeamPermissions.test.js

@@ -251,3 +251,203 @@ describe('Team scope (multi-select)', () => {
     expect(out.map(t => t.id).sort()).toEqual(['a', 'b']);
   });
 });
+
+// ─── FLOW permissions (parallel to AGENT permissions above) ────────────
+import {
+  FLOW_ACCESS_LEVELS,
+  getFlowAccessLevel,
+  getMaxFlowsCreated,
+  checkFlowMutationAccess,
+  filterMutableFlows,
+} from '../platformControl/permissions.js';
+
+const FL = FLOW_ACCESS_LEVELS;
+
+describe('getFlowAccessLevel', () => {
+  test('default + unknown values collapse to "disabled" (no silent grant)', () => {
+    expect(getFlowAccessLevel(undefined)).toBe('disabled');
+    expect(getFlowAccessLevel(null)).toBe('disabled');
+    expect(getFlowAccessLevel({})).toBe('disabled');
+    expect(getFlowAccessLevel({ flows: 'gibberish' })).toBe('disabled');
+    expect(getFlowAccessLevel({ flows: 'admin' })).toBe('disabled');     // close-but-wrong
+    expect(getFlowAccessLevel({ flows: 'own' })).toBe('disabled');        // schedules-key, not flows
+  });
+
+  test('valid values pass through', () => {
+    expect(getFlowAccessLevel({ flows: 'disabled' })).toBe('disabled');
+    expect(getFlowAccessLevel({ flows: 'self-created' })).toBe('self-created');
+    expect(getFlowAccessLevel({ flows: 'all' })).toBe('all');
+  });
+
+  test('exposed constants match expected level strings', () => {
+    expect(FL.DISABLED).toBe('disabled');
+    expect(FL.SELF_CREATED).toBe('self-created');
+    expect(FL.ALL).toBe('all');
+  });
+});
+
+describe('getMaxFlowsCreated', () => {
+  test('null/undefined/missing → null (unlimited)', () => {
+    expect(getMaxFlowsCreated(undefined)).toBe(null);
+    expect(getMaxFlowsCreated({})).toBe(null);
+    expect(getMaxFlowsCreated({ maxFlowsCreated: null })).toBe(null);
+    expect(getMaxFlowsCreated({ maxFlowsCreated: undefined })).toBe(null);
+  });
+
+  test('positive integers pass through', () => {
+    expect(getMaxFlowsCreated({ maxFlowsCreated: 0 })).toBe(0);
+    expect(getMaxFlowsCreated({ maxFlowsCreated: 1 })).toBe(1);
+    expect(getMaxFlowsCreated({ maxFlowsCreated: 100 })).toBe(100);
+  });
+
+  test('negative / NaN / non-numeric collapse to null (unlimited, lenient)', () => {
+    expect(getMaxFlowsCreated({ maxFlowsCreated: -5 })).toBe(null);
+    expect(getMaxFlowsCreated({ maxFlowsCreated: NaN })).toBe(null);
+    expect(getMaxFlowsCreated({ maxFlowsCreated: Infinity })).toBe(null);
+    expect(getMaxFlowsCreated({ maxFlowsCreated: 'two' })).toBe(null);
+    expect(getMaxFlowsCreated({ maxFlowsCreated: {} })).toBe(null);
+  });
+
+  test('floats are floored', () => {
+    expect(getMaxFlowsCreated({ maxFlowsCreated: 3.7 })).toBe(3);
+    expect(getMaxFlowsCreated({ maxFlowsCreated: 0.5 })).toBe(0);
+  });
+});
+
+describe('checkFlowMutationAccess', () => {
+  const myFlow    = { id: 'f-mine',  createdBy: 'me' };
+  const otherFlow = { id: 'f-other', createdBy: 'someone' };
+
+  test('disabled level → never allow', () => {
+    expect(checkFlowMutationAccess(FL.DISABLED, 'me', myFlow).allow).toBe(false);
+    expect(checkFlowMutationAccess(FL.DISABLED, 'me', otherFlow).allow).toBe(false);
+  });
+
+  test('all level → always allow (any flow)', () => {
+    expect(checkFlowMutationAccess(FL.ALL, 'me', myFlow).allow).toBe(true);
+    expect(checkFlowMutationAccess(FL.ALL, 'me', otherFlow).allow).toBe(true);
+  });
+
+  test('self-created → only flows authored by caller', () => {
+    expect(checkFlowMutationAccess(FL.SELF_CREATED, 'me', myFlow).allow).toBe(true);
+    const denied = checkFlowMutationAccess(FL.SELF_CREATED, 'me', otherFlow);
+    expect(denied.allow).toBe(false);
+    expect(denied.reason).toMatch(/self-created/i);
+  });
+
+  test('returns reason on denial (so the tool can echo a useful error)', () => {
+    const r = checkFlowMutationAccess(FL.DISABLED, 'me', myFlow);
+    expect(r.allow).toBe(false);
+    expect(typeof r.reason).toBe('string');
+    expect(r.reason.length).toBeGreaterThan(0);
+  });
+
+  test('rejects missing target flow defensively', () => {
+    expect(checkFlowMutationAccess(FL.ALL, 'me', null).allow).toBe(false);
+    expect(checkFlowMutationAccess(FL.ALL, 'me', {}).allow).toBe(false);
+    expect(checkFlowMutationAccess(FL.ALL, 'me', { id: '' }).allow).toBe(false);
+  });
+
+  test('rejects unknown level (no silent grant)', () => {
+    const r = checkFlowMutationAccess('admin-everywhere', 'me', myFlow);
+    expect(r.allow).toBe(false);
+    expect(r.reason).toMatch(/unknown.*level/i);
+  });
+});
+
+describe('filterMutableFlows', () => {
+  const flows = [
+    { id: 'a', createdBy: 'me' },
+    { id: 'b', createdBy: 'someone' },
+    { id: 'c', createdBy: 'me' },
+  ];
+
+  test('disabled → empty list', () => {
+    expect(filterMutableFlows(FL.DISABLED, 'me', flows)).toEqual([]);
+  });
+
+  test('all → keeps every flow', () => {
+    expect(filterMutableFlows(FL.ALL, 'me', flows)).toHaveLength(3);
+  });
+
+  test('self-created → only flows authored by caller', () => {
+    const r = filterMutableFlows(FL.SELF_CREATED, 'me', flows);
+    expect(r.map(f => f.id).sort()).toEqual(['a', 'c']);
+  });
+
+  test('non-array input returns empty list', () => {
+    expect(filterMutableFlows(FL.ALL, 'me', null)).toEqual([]);
+    expect(filterMutableFlows(FL.ALL, 'me', undefined)).toEqual([]);
+    expect(filterMutableFlows(FL.ALL, 'me', 'not-an-array')).toEqual([]);
+  });
+});
+
+describe('clampToolConfigForChild — flows + maxFlowsCreated (privilege escalation guard)', () => {
+  test('clamps flow level: child cannot exceed parent (self-created → all attempt)', () => {
+    const result = clampToolConfigForChild(
+      { flows: 'self-created' },           // caller has only self-created
+      { flows: 'all' }                      // tries to spawn child with 'all'
+    );
+    expect(result.config.flows).toBe('self-created');
+    expect(result.clamps).toEqual(expect.arrayContaining([
+      { key: 'flows', requested: 'all', clampedTo: 'self-created' },
+    ]));
+  });
+
+  test('clamps flow level: disabled caller cannot grant any', () => {
+    const result = clampToolConfigForChild(
+      {},                                   // caller defaults to disabled
+      { flows: 'self-created' }
+    );
+    expect(result.config.flows).toBe('disabled');
+  });
+
+  test('does NOT clamp when child requests less than parent has', () => {
+    const result = clampToolConfigForChild(
+      { flows: 'all' },
+      { flows: 'self-created' }
+    );
+    expect(result.config.flows).toBe('self-created');
+    // no clamp record — request was already at-or-below parent.
+    expect(result.clamps.find(c => c.key === 'flows')).toBeUndefined();
+  });
+
+  test('clamps maxFlowsCreated: child cannot exceed parent quota', () => {
+    const result = clampToolConfigForChild(
+      { flows: 'all', maxFlowsCreated: 5 },
+      { flows: 'all', maxFlowsCreated: 100 }
+    );
+    expect(result.config.maxFlowsCreated).toBe(5);
+    expect(result.clamps).toEqual(expect.arrayContaining([
+      { key: 'maxFlowsCreated', requested: 100, clampedTo: 5 },
+    ]));
+  });
+
+  test('clamps maxFlowsCreated: child requests "unlimited" but parent has limit', () => {
+    const result = clampToolConfigForChild(
+      { flows: 'all', maxFlowsCreated: 3 },
+      { flows: 'all', maxFlowsCreated: null }   // null = unlimited
+    );
+    expect(result.config.maxFlowsCreated).toBe(3);
+  });
+
+  test('caller-unlimited (null max) lets any child max through', () => {
+    const result = clampToolConfigForChild(
+      { flows: 'all' },                      // no max → unlimited
+      { flows: 'all', maxFlowsCreated: 1000 }
+    );
+    expect(result.config.maxFlowsCreated).toBe(1000);
+    expect(result.clamps.find(c => c.key === 'maxFlowsCreated')).toBeUndefined();
+  });
+
+  test('flow clamps surface alongside agent clamps (multi-key escalation attempt)', () => {
+    const result = clampToolConfigForChild(
+      { agents: 'self-created', flows: 'self-created' },
+      { agents: 'all', flows: 'all' }
+    );
+    const keys = result.clamps.map(c => c.key).sort();
+    expect(keys).toEqual(['agents', 'flows']);
+    expect(result.config.agents).toBe('self-created');
+    expect(result.config.flows).toBe('self-created');
+  });
+});