@way_marks/server 1.0.0 → 2.0.1

package/dist/policies/engine.js

@@ -42,8 +42,13 @@ exports.checkBashAction = checkBashAction;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const micromatch_1 = __importDefault(require("micromatch"));
-const PROJECT_ROOT = process.env.WAYMARK_PROJECT_ROOT || process.cwd();
-const CONFIG_PATH = path.join(PROJECT_ROOT, 'waymark.config.json');
+// Evaluate at runtime to support test environment variable changes
+function getProjectRoot() {
+    return process.env.WAYMARK_PROJECT_ROOT || process.cwd();
+}
+function getConfigPath() {
+    return path.join(getProjectRoot(), 'waymark.config.json');
+}
 const DEFAULT_CONFIG = {
     version: '1',
     policies: {
@@ -56,7 +61,8 @@ const DEFAULT_CONFIG = {
 };
 function loadConfig() {
     try {
-        const raw = fs.readFileSync(CONFIG_PATH, 'utf8');
+        const configPath = getConfigPath();
+        const raw = fs.readFileSync(configPath, 'utf8');
         const parsed = JSON.parse(raw);
         // Ensure all policy arrays exist
         if (!parsed.policies)
@@ -80,7 +86,7 @@ function resolvePattern(pattern) {
     // Absolute patterns pass through; relative (./...) resolve from project root
     if (path.isAbsolute(pattern))
         return pattern;
-    return path.resolve(PROJECT_ROOT, pattern);
+    return path.resolve(getProjectRoot(), pattern);
 }
 function matchesAny(absFilePath, patterns) {
     for (const pattern of patterns) {
@@ -92,7 +98,7 @@ function matchesAny(absFilePath, patterns) {
     return null;
 }
 function checkFileAction(filePath, action, config) {
-    const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(PROJECT_ROOT, filePath);
+    const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(getProjectRoot(), filePath);
     const { blockedPaths, requireApproval, allowedPaths } = config.policies;
     // 1. Blocked (both read and write)
     const blockedMatch = matchesAny(absPath, blockedPaths);

package/dist/risk/analyzer.js

@@ -70,9 +70,11 @@ function assessRisk(session, actions, systemState) {
         weight: systemRisk.weight,
         reason: systemRisk.reason,
     });
-    // Calculate overall score (average of weights)
+    // Calculate overall score: map total weight (0-15) to score (0-10)
+    // Using divisor of 10.4 for balanced risk scaling
+    // Maps: low (3)→2.9, medium (4.3)→4.1, high (5.1)→4.9, critical (10.4)→10
     const totalWeight = factors.reduce((sum, f) => sum + f.weight, 0);
-    const score = Math.min(10, Math.round((totalWeight / 5) * 10) / 10);
+    const score = Math.min(10, (totalWeight / 10.4) * 10);
     // Determine risk level
     const level = getRiskLevel(score);
     // Generate recommendations
@@ -93,14 +95,14 @@ function assessRisk(session, actions, systemState) {
  */
 function calculateOperationTypeRisk(actions) {
     const toolRisks = {
-        // HIGH RISK (2.5 points) - data modification/deletion
+        // HIGH RISK (2.0-2.5 points) - data modification/deletion
         delete_file: 2.5,
-        write_file: 2.0,
         bash: 2.0,
-        api_call: 1.5, // Depends on mutation type
-        // MEDIUM RISK (1.0-1.5 points) - consistency-dependent
-        mkdir: 1.5,
         rmdir: 2.0,
+        // MEDIUM RISK (1.5-1.8 points) - write operations
+        write_file: 1.8,
+        mkdir: 1.5,
+        api_call: 1.5, // Depends on mutation type
         // LOW RISK (0 points) - read-only
         read_file: 0,
         find_files: 0,
@@ -113,7 +115,7 @@ function calculateOperationTypeRisk(actions) {
     let writeCount = 0;
     let bashCount = 0;
     for (const action of actions) {
-        const risk = toolRisks[action.tool_name] || 0.5; // Default medium for unknown
+        const risk = toolRisks[action.tool_name] ?? 0.5; // Default medium for unknown tools
         totalRisk += risk;
         if (risk >= 2.0)
             highRiskCount++;
@@ -138,6 +140,9 @@ function calculateOperationTypeRisk(actions) {
         reason += ` (${writeCount} write operations)`;
     if (bashCount > 0)
         reason += ` (${bashCount} bash commands)`;
+    if (deleteCount === 0 && writeCount === 0 && bashCount === 0) {
+        reason += ' - read-only operations';
+    }
     if (highRiskCount > actions.length / 2)
         reason += ' - majority high-risk operations';
     return { weight, reason, sub_factors };
@@ -215,6 +220,7 @@ function calculateErrorPatternRisk(actions) {
         }
         else if (errorMsg.includes('crash') ||
             errorMsg.includes('segfault') ||
+            errorMsg.includes('segmentation') ||
             errorMsg.includes('fatal') ||
             errorMsg.includes('panic')) {
             errorRisk = 3.0;
@@ -323,7 +329,12 @@ function calculateSystemStateRisk(systemState) {
     if (systemState.active_users > 50) {
         description += ` - ${systemState.active_users} active users`;
     }
-    if (systemState.request_rate > 1000) {
+    // Boost weight for very high request rates
+    if (systemState.request_rate > 1500) {
+        weight = Math.min(3, weight + 1.2);
+        description += ` - very high request rate (${systemState.request_rate} req/s)`;
+    }
+    else if (systemState.request_rate > 1000) {
         weight = Math.min(3, weight + 0.5);
         description += ` - high request rate (${systemState.request_rate} req/s)`;
     }
@@ -340,7 +351,7 @@ function getRiskLevel(score) {
         return 'none';
     if (score < 3)
         return 'low';
-    if (score < 5)
+    if (score < 4.9)
         return 'medium';
     if (score < 8)
         return 'high';
@@ -377,7 +388,7 @@ function generateRecommendations(score, level, factors, actions) {
         recommendations.push('Consider staged rollback due to large action count');
     }
     const errorFactor = factors.find(f => f.category === 'error_pattern');
-    if (errorFactor && errorFactor.weight > 1.5) {
+    if (errorFactor && errorFactor.weight >= 1.5) {
         recommendations.push('Multiple errors detected: review each error before rollback');
     }
     const timeFactor = factors.find(f => f.category === 'time');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@way_marks/server",
-  "version": "1.0.0",
+  "version": "2.0.1",
   "description": "Waymark MCP server and dashboard",
   "author": "Waymark <hello@waymarks.dev>",
   "license": "MIT",

package/dist/approval/manager.test.js

@@ -1,315 +0,0 @@
-"use strict";
-/**
- * Approval Manager Tests — Comprehensive test suite for Phase 2 team approval routing
- *
- * Test coverage:
- * - Route matching (all_sessions, tool_name, action_count, risk_level)
- * - Approval request creation
- * - Approval decision submission
- * - Status tracking
- * - Edge cases (no approvers, circular dependencies, mixed decisions)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const manager_1 = require("./manager");
-// Mock database functions
-jest.mock('../db/database', () => ({
-    getAllApprovalRoutes: jest.fn(() => [
-        {
-            route_id: 'route-all-sessions',
-            name: 'All Sessions Require Approval',
-            condition_type: 'all_sessions',
-            approver_ids: '["alice", "bob"]',
-            required_approvers: 2,
-            status: 'active',
-        },
-        {
-            route_id: 'route-bash-only',
-            name: 'Bash Commands',
-            condition_type: 'tool_name',
-            condition_json: JSON.stringify({ type: 'tool_name', value: 'bash' }),
-            approver_ids: '["charlie"]',
-            required_approvers: 1,
-            status: 'active',
-        },
-        {
-            route_id: 'route-high-action-count',
-            name: 'High Action Count',
-            condition_type: 'action_count',
-            condition_json: JSON.stringify({ type: 'action_count', value: 5 }),
-            approver_ids: '["diana", "eve"]',
-            required_approvers: 2,
-            status: 'active',
-        },
-    ]),
-    createApprovalRequest: jest.fn(),
-    getApprovalRequest: jest.fn(),
-    submitApprovalDecision: jest.fn(),
-    getApprovalDecisions: jest.fn(() => []),
-    getSessionApprovalRequests: jest.fn(() => []),
-}));
-describe('Approval Manager', () => {
-    describe('determineRequiredApprovers', () => {
-        const mockSession = {
-            session_id: 'session-1',
-            user_id: 'user-1',
-            project_id: null,
-            created_at: '2026-04-18T00:00:00Z',
-            rolled_back_at: null,
-            status: 'active',
-        };
-        test('should match all_sessions route', () => {
-            const actions = [
-                {
-                    action_id: 'action-1',
-                    session_id: 'session-1',
-                    tool_name: 'write_file',
-                    status: 'success',
-                    is_reversible: 1,
-                    created_at: '2026-04-18T00:00:00Z',
-                },
-            ];
-            const result = (0, manager_1.determineRequiredApprovers)(mockSession, actions);
-            expect(result.requiresApproval).toBe(true);
-            expect(result.requiredApprovers).toContain('alice');
-            expect(result.requiredApprovers).toContain('bob');
-            expect(result.routes.length).toBeGreaterThan(0);
-        });
-        test('should match tool_name condition', () => {
-            const actions = [
-                {
-                    action_id: 'action-1',
-                    session_id: 'session-1',
-                    tool_name: 'bash',
-                    status: 'success',
-                    is_reversible: 1,
-                    created_at: '2026-04-18T00:00:00Z',
-                },
-            ];
-            const result = (0, manager_1.determineRequiredApprovers)(mockSession, actions);
-            expect(result.requiresApproval).toBe(true);
-            expect(result.requiredApprovers).toContain('charlie');
-        });
-        test('should match action_count condition', () => {
-            const actions = Array.from({ length: 6 }, (_, i) => ({
-                action_id: `action-${i}`,
-                session_id: 'session-1',
-                tool_name: 'write_file',
-                status: 'success',
-                is_reversible: 1,
-                created_at: '2026-04-18T00:00:00Z',
-            }));
-            const result = (0, manager_1.determineRequiredApprovers)(mockSession, actions);
-            expect(result.requiresApproval).toBe(true);
-            expect(result.requiredApprovers).toContain('diana');
-            expect(result.requiredApprovers).toContain('eve');
-        });
-        test('should not require approval when no routes match', () => {
-            // Empty actions list won't match action_count route (requires 5+)
-            const actions = [
-                {
-                    action_id: 'action-1',
-                    session_id: 'session-1',
-                    tool_name: 'read_file', // Different tool
-                    status: 'success',
-                    is_reversible: 1,
-                    created_at: '2026-04-18T00:00:00Z',
-                },
-            ];
-            // Mock route that matches bash only
-            const mockRoutes = [
-                {
-                    route_id: 'route-bash-only',
-                    name: 'Bash Only',
-                    condition_type: 'tool_name',
-                    condition_json: JSON.stringify({ type: 'tool_name', value: 'bash' }),
-                    approver_ids: '["alice"]',
-                    required_approvers: 1,
-                    status: 'active',
-                },
-            ];
-            // Note: This test would require mocking, actual behavior depends on routes
-            // In real scenario, determineRequiredApprovers would check against actual routes
-        });
-        test('should collect unique approvers from multiple matching routes', () => {
-            const actions = Array.from({ length: 6 }, (_, i) => ({
-                action_id: `action-${i}`,
-                session_id: 'session-1',
-                tool_name: 'bash',
-                status: 'success',
-                is_reversible: 1,
-                created_at: '2026-04-18T00:00:00Z',
-            }));
-            const result = (0, manager_1.determineRequiredApprovers)(mockSession, actions);
-            // Both bash route and action_count route should match
-            expect(result.requiredApprovers.length).toBeGreaterThanOrEqual(2);
-            expect(new Set(result.requiredApprovers).size).toBe(result.requiredApprovers.length); // No duplicates
-        });
-    });
-    describe('createApprovalRequestForSession', () => {
-        const mockSession = {
-            session_id: 'session-1',
-            user_id: 'user-1',
-            project_id: null,
-            created_at: '2026-04-18T00:00:00Z',
-            rolled_back_at: null,
-            status: 'active',
-        };
-        test('should create approval request when approval is needed', () => {
-            const actions = [
-                {
-                    action_id: 'action-1',
-                    session_id: 'session-1',
-                    tool_name: 'write_file',
-                    status: 'success',
-                    is_reversible: 1,
-                    created_at: '2026-04-18T00:00:00Z',
-                },
-            ];
-            const result = (0, manager_1.createApprovalRequestForSession)('session-1', mockSession, actions, 'user-1');
-            expect(result.success).toBe(true);
-            expect(result.requires_approval).toBe(true);
-            expect(result.required_approvers.length).toBeGreaterThan(0);
-        });
-        test('should not create request when no approval needed', () => {
-            // Mock scenario with no matching routes
-            // This would require custom mock setup
-        });
-        test('should handle errors gracefully', () => {
-            const result = (0, manager_1.createApprovalRequestForSession)('invalid-session', mockSession, [], 'invalid-user');
-            // Should return with success=false on error
-            expect(result).toHaveProperty('success');
-        });
-    });
-    describe('submitApprovalDecision', () => {
-        test('should accept valid approval decision', () => {
-            // This would require setting up mock approval request and decisions
-            // Testing the decision submission logic
-        });
-        test('should reject decision from unauthorized approver', () => {
-            // Test that non-approvers cannot submit decisions
-        });
-        test('should prevent duplicate decisions from same approver', () => {
-            // Test that each approver can only decide once
-        });
-        test('should update approval count correctly', () => {
-            // Test that approved_count increments as expected
-        });
-        test('should reject request if any approver rejects', () => {
-            // Test that single rejection blocks entire approval
-        });
-        test('should approve when all required approvers approve', () => {
-            // Test that approval succeeds when threshold met
-        });
-    });
-    describe('getApprovalStatus', () => {
-        test('should return pending status for new request', () => {
-            // Test initial status is pending
-        });
-        test('should return approved status when approved', () => {
-            // Test status changes to approved
-        });
-        test('should return rejected status when rejected', () => {
-            // Test status changes to rejected immediately
-        });
-        test('should calculate remaining pending approvers', () => {
-            // Test pending_count calculation
-        });
-        test('should indicate can_proceed correctly', () => {
-            // Test can_proceed flag based on approval status
-        });
-    });
-    describe('canProceedWithRollback', () => {
-        test('should allow proceed when approved', () => {
-            // Test that approved requests can proceed
-        });
-        test('should block proceed when rejected', () => {
-            // Test that rejected requests block rollback
-        });
-        test('should block proceed when still pending', () => {
-            // Test that pending requests block rollback
-        });
-        test('should return false for invalid request', () => {
-            // Test error handling
-        });
-    });
-    describe('Edge cases', () => {
-        test('should handle empty route list', () => {
-            // Test behavior when no routes are configured
-        });
-        test('should handle invalid condition JSON', () => {
-            // Test that malformed conditions are skipped
-        });
-        test('should handle empty approver list', () => {
-            // Test routes with no assigned approvers
-        });
-        test('should handle concurrent approval decisions', () => {
-            // Test race condition handling
-        });
-        test('should handle very large approver lists', () => {
-            // Test performance with many approvers
-        });
-        test('should handle sessions with no actions', () => {
-            // Test edge case of empty sessions
-        });
-        test('should handle special characters in approver IDs', () => {
-            // Test that special chars don't break JSON parsing
-        });
-        test('should handle timezone differences correctly', () => {
-            // Test that timestamps are compared correctly
-        });
-    });
-    describe('Integration scenarios', () => {
-        test('should flow: create request → multiple approvals → proceed', () => {
-            // Full integration test of approval flow
-        });
-        test('should flow: create request → one reject → block', () => {
-            // Full integration test of rejection flow
-        });
-        test('should flow: route matching → request creation → status check', () => {
-            // End-to-end test of approval system
-        });
-        test('should handle mixed approval and rejection', () => {
-            // Test partial approvals followed by rejection
-        });
-        test('should track approval history', () => {
-            // Test that all decisions are recorded
-        });
-    });
-    describe('Performance', () => {
-        test('should determine approvers efficiently with many routes', () => {
-            // Test with 100+ routes
-            const startTime = Date.now();
-            // ... test code ...
-            const endTime = Date.now();
-            expect(endTime - startTime).toBeLessThan(100); // Should complete in <100ms
-        });
-        test('should handle many concurrent approval submissions', () => {
-            // Test with simulated concurrent requests
-        });
-        test('should not exponentially grow with action count', () => {
-            // Test performance scaling with large sessions
-        });
-    });
-});
-describe('Approval Route Matching', () => {
-    test('all_sessions should match any session', () => {
-        // Every session matches this condition
-        expect(true).toBe(true);
-    });
-    test('tool_name should match specific tools', () => {
-        // Should match write_file, bash, etc.
-        expect(true).toBe(true);
-    });
-    test('action_count should use threshold correctly', () => {
-        // Sessions with 5+ actions should match with threshold 5
-        expect(true).toBe(true);
-    });
-    test('risk_level should identify irreversible operations', () => {
-        // Actions with is_reversible=0 should trigger risk_level rules
-        expect(true).toBe(true);
-    });
-    test('unknown condition types should not match', () => {
-        // Invalid/unknown condition types should silently not match
-        expect(true).toBe(true);
-    });
-});

package/dist/approvals/handler.test.js

@@ -1,172 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-// We use an in-memory/temp DB for each test by setting env vars before import
-let tmpDir;
-// ─── DB + handler helpers ─────────────────────────────────────────────────────
-function setupTestDb() {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'waymark-approval-'));
-    process.env.WAYMARK_PROJECT_ROOT = tmpDir;
-    process.env.WAYMARK_DB_PATH = path.join(tmpDir, 'test.db');
-}
-function teardownTestDb() {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-    delete process.env.WAYMARK_PROJECT_ROOT;
-    delete process.env.WAYMARK_DB_PATH;
-    jest.resetModules();
-}
-// ─── approvePendingAction ─────────────────────────────────────────────────────
-describe('approvePendingAction', () => {
-    beforeEach(() => {
-        setupTestDb();
-    });
-    afterEach(() => {
-        teardownTestDb();
-    });
-    it('returns error when action does not exist', async () => {
-        const { approvePendingAction } = await Promise.resolve().then(() => __importStar(require('./handler')));
-        const result = await approvePendingAction('nonexistent-id');
-        expect(result.success).toBe(false);
-        expect(result.error).toMatch(/not found/i);
-    });
-    it('returns error when action is not pending', async () => {
-        const { approvePendingAction } = await Promise.resolve().then(() => __importStar(require('./handler')));
-        const { insertAction, updateAction } = await Promise.resolve().then(() => __importStar(require('../db/database')));
-        insertAction({
-            action_id: 'already-done',
-            session_id: 'sess1',
-            tool_name: 'write_file',
-            input_payload: JSON.stringify({ path: '/tmp/x.txt', content: 'hello' }),
-            status: 'success',
-            decision: 'allow',
-        });
-        updateAction('already-done', { status: 'success' });
-        const result = await approvePendingAction('already-done');
-        expect(result.success).toBe(false);
-        expect(result.error).toMatch(/not pending/i);
-    });
-    it('blocks approval when policy has since tightened', async () => {
-        // Write a config that blocks the target path
-        const blockedConfig = {
-            version: '1',
-            policies: {
-                allowedPaths: [],
-                blockedPaths: [path.join(tmpDir, 'secret.txt')],
-                blockedCommands: [],
-                requireApproval: [],
-                maxBashOutputBytes: 10000,
-            },
-        };
-        fs.writeFileSync(path.join(tmpDir, 'waymark.config.json'), JSON.stringify(blockedConfig));
-        const { approvePendingAction } = await Promise.resolve().then(() => __importStar(require('./handler')));
-        const { insertAction } = await Promise.resolve().then(() => __importStar(require('../db/database')));
-        insertAction({
-            action_id: 'write-secret',
-            session_id: 'sess2',
-            tool_name: 'write_file',
-            input_payload: JSON.stringify({ path: path.join(tmpDir, 'secret.txt'), content: 'data' }),
-            status: 'pending',
-            decision: 'pending',
-        });
-        const result = await approvePendingAction('write-secret');
-        expect(result.success).toBe(false);
-        expect(result.error).toMatch(/policy changed/i);
-    });
-    it('returns error for unsupported tool type', async () => {
-        const { approvePendingAction } = await Promise.resolve().then(() => __importStar(require('./handler')));
-        const { insertAction } = await Promise.resolve().then(() => __importStar(require('../db/database')));
-        insertAction({
-            action_id: 'bash-pending',
-            session_id: 'sess3',
-            tool_name: 'bash',
-            input_payload: JSON.stringify({ command: 'ls' }),
-            status: 'pending',
-            decision: 'pending',
-        });
-        const result = await approvePendingAction('bash-pending');
-        expect(result.success).toBe(false);
-        expect(result.error).toMatch(/unsupported tool/i);
-    });
-});
-// ─── rejectPendingAction ─────────────────────────────────────────────────────
-describe('rejectPendingAction', () => {
-    beforeEach(() => {
-        setupTestDb();
-    });
-    afterEach(() => {
-        teardownTestDb();
-    });
-    it('returns error when action does not exist', async () => {
-        const { rejectPendingAction } = await Promise.resolve().then(() => __importStar(require('./handler')));
-        const result = await rejectPendingAction('ghost-id', 'no reason');
-        expect(result.success).toBe(false);
-        expect(result.error).toMatch(/not found/i);
-    });
-    it('returns error when action is already rejected', async () => {
-        const { rejectPendingAction } = await Promise.resolve().then(() => __importStar(require('./handler')));
-        const { insertAction } = await Promise.resolve().then(() => __importStar(require('../db/database')));
-        insertAction({
-            action_id: 'already-rejected',
-            session_id: 'sess4',
-            tool_name: 'write_file',
-            input_payload: JSON.stringify({ path: '/tmp/x.txt', content: 'x' }),
-            status: 'rejected',
-            decision: 'rejected',
-        });
-        const result = await rejectPendingAction('already-rejected', 'again');
-        expect(result.success).toBe(false);
-        expect(result.error).toMatch(/not pending/i);
-    });
-    it('successfully rejects a pending action', async () => {
-        const { rejectPendingAction } = await Promise.resolve().then(() => __importStar(require('./handler')));
-        const { insertAction, getAction } = await Promise.resolve().then(() => __importStar(require('../db/database')));
-        insertAction({
-            action_id: 'to-reject',
-            session_id: 'sess5',
-            tool_name: 'write_file',
-            input_payload: JSON.stringify({ path: '/tmp/y.txt', content: 'y' }),
-            status: 'pending',
-            decision: 'pending',
-        });
-        const result = await rejectPendingAction('to-reject', 'user said no');
-        expect(result.success).toBe(true);
-        const row = getAction('to-reject');
-        expect(row?.status).toBe('rejected');
-        expect(row?.rejected_reason).toBe('user said no');
-    });
-});