@cspeach/cli 0.6.3 → 0.6.4

package/dist/tools/__tests__/sap-write-extras.test.js

@@ -0,0 +1,573 @@
+/**
+ * Tests for the 8 new tools added in Phase 3-Lite A.5 + A.6:
+ *
+ * A.5 (sap-write.ts): sap_lock, sap_unlock, sap_service_binding_publish,
+ *                     sap_message_maintain (STUB), sap_number_range_intervals (STUB)
+ * A.6 (snapshot.ts):  sap_snapshot_list, sap_snapshot_read, sap_snapshot_cleanup
+ *
+ * B.1 (sap-write.ts): sap_update_method — diff-preview gate (4 tests)
+ *
+ * B.2 (sap-write.ts): sap_set_source safety confirmation — 2 tests
+ *                     sap_delete_object safety confirmation — 2 tests
+ *
+ * Pattern: partial mock as `{ method: vi.fn() } as unknown as AdtClient`.
+ * STUB tools: assert is_error + not_implemented envelope; assert no AdtClient
+ *             method was called.
+ * Each tool gets 2 tests = 16 tests total (A.5 + A.6) + 4 new (B.1) = 20 + 4 (B.2) = 24.
+ */
+import '../sap-write.js'; // triggers registration side-effect
+import '../snapshot.js'; // triggers registration side-effect
+import { getTool } from '../index.js';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { CancelledByUserError } from '../update-method-intercept.js';
+// ---------------------------------------------------------------------------
+// Mock @cspeach/sap-client snapshots namespace
+// ---------------------------------------------------------------------------
+const mockSnapshotsList = vi.hoisted(() => vi.fn());
+const mockSnapshotsRead = vi.hoisted(() => vi.fn());
+const mockSnapshotsCleanup = vi.hoisted(() => vi.fn());
+// preserve `take` stub so autoSnapshot in sap-write.ts doesn't fail
+const mockSnapshotsTake = vi.hoisted(() => vi.fn());
+vi.mock('@cspeach/sap-client', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        snapshots: {
+            take: mockSnapshotsTake,
+            list: mockSnapshotsList,
+            read: mockSnapshotsRead,
+            cleanup: mockSnapshotsCleanup,
+        },
+    };
+});
+// ---------------------------------------------------------------------------
+// B.1: Mock verifyAndSpendApprovalId to bypass JWT check
+// ---------------------------------------------------------------------------
+const mockVerifyAndSpend = vi.hoisted(() => vi.fn());
+vi.mock('../../approvals/jwt.js', () => ({
+    verifyAndSpendApprovalId: mockVerifyAndSpend,
+    mintApprovalId: vi.fn(),
+}));
+// ---------------------------------------------------------------------------
+// B.1: Mock interceptUpdateMethod so we can control its behaviour
+// ---------------------------------------------------------------------------
+const mockInterceptUpdateMethod = vi.hoisted(() => vi.fn());
+vi.mock('../update-method-intercept.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        interceptUpdateMethod: mockInterceptUpdateMethod,
+    };
+});
+// ---------------------------------------------------------------------------
+// B.1: Mock session pending helpers so WAL doesn't hit the filesystem
+// ---------------------------------------------------------------------------
+vi.mock('../../session/pending.js', () => ({
+    appendPending: vi.fn().mockResolvedValue(undefined),
+    finalizeToolCall: vi.fn().mockResolvedValue(undefined),
+    hasUnfinishedMutations: vi.fn().mockReturnValue(false),
+}));
+// ---------------------------------------------------------------------------
+// B.1: Mock verify helper — syntax-check gate used after write
+// ---------------------------------------------------------------------------
+vi.mock('../verify.js', () => ({
+    verifySyntax: vi.fn().mockResolvedValue({ ok: true, errors: [], warnings: [] }),
+    verifyActive: vi.fn().mockResolvedValue({ active: true }),
+}));
+// ---------------------------------------------------------------------------
+// B.2: Mock safety-confirm and safety-mode-state
+// ---------------------------------------------------------------------------
+const mockIsSafetyConfirmEnabled = vi.hoisted(() => vi.fn());
+vi.mock('../../repl/safety-mode-state.js', () => ({
+    isSafetyConfirmEnabled: mockIsSafetyConfirmEnabled,
+}));
+const mockPresentSafetyConfirmation = vi.hoisted(() => vi.fn());
+vi.mock('../../repl/safety-confirm.js', () => ({
+    presentSafetyConfirmation: mockPresentSafetyConfirmation,
+}));
+// ---------------------------------------------------------------------------
+// Helper: build a minimal ToolContext stub
+// ---------------------------------------------------------------------------
+function makeCtx(adt, extras) {
+    return {
+        adt: adt,
+        sapAlias: 'dev',
+        session: { toolCalls: [] },
+        cwd: '.',
+        ...extras,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    // Default: approval always succeeds
+    mockVerifyAndSpend.mockResolvedValue({ ok: true, payload: {} });
+    // Default: snapshot take is a no-op
+    mockSnapshotsTake.mockResolvedValue({ id: 'snap1' });
+    // Default: safety mode OFF so existing tests are unaffected
+    mockIsSafetyConfirmEnabled.mockReturnValue(false);
+});
+// ---------------------------------------------------------------------------
+// A.5.1 sap_lock
+// ---------------------------------------------------------------------------
+describe('sap_lock', () => {
+    it('calls lock(type, name) and returns JSON result', async () => {
+        const fakeResult = { lockHandle: 'abc123', status: 'locked' };
+        const adt = { lock: vi.fn().mockResolvedValue(fakeResult) };
+        const tool = getTool('sap_lock');
+        const result = await tool.handler({ type: 'CLAS', name: 'ZCL_FOO' }, makeCtx(adt));
+        expect(adt.lock).toHaveBeenCalledWith('CLAS', 'ZCL_FOO');
+        expect(JSON.parse(result.content)).toEqual(fakeResult);
+    });
+    it('propagates error when lock throws', async () => {
+        const adt = { lock: vi.fn().mockRejectedValue(new Error('already locked')) };
+        const tool = getTool('sap_lock');
+        await expect(tool.handler({ type: 'CLAS', name: 'ZCL_FOO' }, makeCtx(adt))).rejects.toThrow('already locked');
+    });
+});
+// ---------------------------------------------------------------------------
+// A.5.2 sap_unlock
+// ---------------------------------------------------------------------------
+describe('sap_unlock', () => {
+    it('calls unlock(type, name, lockHandle) and returns ok status', async () => {
+        const adt = { unlock: vi.fn().mockResolvedValue(undefined) };
+        const tool = getTool('sap_unlock');
+        const result = await tool.handler({ type: 'CLAS', name: 'ZCL_FOO', lockHandle: 'abc123' }, makeCtx(adt));
+        expect(adt.unlock).toHaveBeenCalledWith('CLAS', 'ZCL_FOO', 'abc123');
+        expect(JSON.parse(result.content)).toEqual({ status: 'ok' });
+    });
+    it('propagates error when unlock throws', async () => {
+        const adt = { unlock: vi.fn().mockRejectedValue(new Error('invalid lock handle')) };
+        const tool = getTool('sap_unlock');
+        await expect(tool.handler({ type: 'CLAS', name: 'ZCL_FOO', lockHandle: 'bad' }, makeCtx(adt))).rejects.toThrow('invalid lock handle');
+    });
+});
+// ---------------------------------------------------------------------------
+// A.5.3 sap_service_binding_publish
+// ---------------------------------------------------------------------------
+describe('sap_service_binding_publish', () => {
+    it('calls serviceBindingPublish(name) and returns JSON result', async () => {
+        const fakeResult = { status: 200 };
+        const adt = { serviceBindingPublish: vi.fn().mockResolvedValue(fakeResult) };
+        const tool = getTool('sap_service_binding_publish');
+        const result = await tool.handler({ name: 'ZSALES_UI_V4' }, makeCtx(adt));
+        expect(adt.serviceBindingPublish).toHaveBeenCalledWith('ZSALES_UI_V4');
+        expect(JSON.parse(result.content)).toEqual(fakeResult);
+    });
+    it('propagates error when serviceBindingPublish throws', async () => {
+        const adt = {
+            serviceBindingPublish: vi.fn().mockRejectedValue(new Error('ADT 404')),
+        };
+        const tool = getTool('sap_service_binding_publish');
+        await expect(tool.handler({ name: 'ZMISSING_UI_V4' }, makeCtx(adt))).rejects.toThrow('ADT 404');
+    });
+});
+// ---------------------------------------------------------------------------
+// A.5.4 sap_message_maintain (STUB)
+// ---------------------------------------------------------------------------
+describe('sap_message_maintain', () => {
+    it('returns not_implemented envelope for fully-populated args and is_error: true', async () => {
+        // STUB: no ADT method is called — do NOT set up any adt mock method
+        const adt = { messageMaintain: vi.fn() };
+        const tool = getTool('sap_message_maintain');
+        const result = await tool.handler({
+            messageClass: 'ZMSG_SALES',
+            messageNumber: '001',
+            messageText: 'Order &1 created',
+            messageType: 'S',
+        }, makeCtx(adt));
+        expect(result.is_error).toBe(true);
+        const parsed = JSON.parse(result.content);
+        expect(parsed.error).toBe('not_implemented');
+        expect(parsed.detail).toBeTruthy();
+        // Critical: STUB must not call any AdtClient method
+        expect(adt.messageMaintain).not.toHaveBeenCalled();
+    });
+    it('returns same not_implemented envelope for minimally-populated args', async () => {
+        const adt = { messageMaintain: vi.fn() };
+        const tool = getTool('sap_message_maintain');
+        const result = await tool.handler({ messageClass: 'ZMSG', messageNumber: '001', messageText: 'x' }, makeCtx(adt));
+        expect(result.is_error).toBe(true);
+        expect(JSON.parse(result.content).error).toBe('not_implemented');
+        expect(adt.messageMaintain).not.toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// A.5.5 sap_number_range_intervals (STUB)
+// ---------------------------------------------------------------------------
+describe('sap_number_range_intervals', () => {
+    it('returns not_implemented envelope for fully-populated args and is_error: true', async () => {
+        const adt = { numberRangeIntervals: vi.fn() };
+        const tool = getTool('sap_number_range_intervals');
+        const result = await tool.handler({
+            nrObject: 'ZNROB_SALES',
+            subobject: '',
+            intervals: [{ from: '0000000001', to: '0000009999', ext: false }],
+        }, makeCtx(adt));
+        expect(result.is_error).toBe(true);
+        const parsed = JSON.parse(result.content);
+        expect(parsed.error).toBe('not_implemented');
+        expect(parsed.detail).toBeTruthy();
+        expect(adt.numberRangeIntervals).not.toHaveBeenCalled();
+    });
+    it('returns same not_implemented envelope for minimally-populated args', async () => {
+        const adt = { numberRangeIntervals: vi.fn() };
+        const tool = getTool('sap_number_range_intervals');
+        const result = await tool.handler({ nrObject: 'ZNROB_SALES' }, makeCtx(adt));
+        expect(result.is_error).toBe(true);
+        expect(JSON.parse(result.content).error).toBe('not_implemented');
+        expect(adt.numberRangeIntervals).not.toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// A.6.1 sap_snapshot_list
+// ---------------------------------------------------------------------------
+describe('sap_snapshot_list', () => {
+    it('calls snapshots.list with type and name when provided', async () => {
+        const fakeEntries = [{ id: 'snap1', type: 'CLAS', name: 'ZCL_FOO' }];
+        mockSnapshotsList.mockResolvedValue(fakeEntries);
+        const tool = getTool('sap_snapshot_list');
+        const result = await tool.handler({ type: 'CLAS', name: 'ZCL_FOO' }, makeCtx({}));
+        expect(mockSnapshotsList).toHaveBeenCalledWith('CLAS', 'ZCL_FOO');
+        expect(JSON.parse(result.content)).toEqual(fakeEntries);
+    });
+    it('propagates error when snapshots.list throws', async () => {
+        mockSnapshotsList.mockRejectedValue(new Error('snapshot dir not found'));
+        const tool = getTool('sap_snapshot_list');
+        await expect(tool.handler({}, makeCtx({}))).rejects.toThrow('snapshot dir not found');
+    });
+});
+// ---------------------------------------------------------------------------
+// A.6.2 sap_snapshot_read
+// ---------------------------------------------------------------------------
+describe('sap_snapshot_read', () => {
+    it('calls snapshots.read and returns raw source as content', async () => {
+        const fakeSource = 'CLASS ZCL_FOO DEFINITION.\nENDCLASS.';
+        mockSnapshotsRead.mockResolvedValue(fakeSource);
+        const tool = getTool('sap_snapshot_read');
+        const result = await tool.handler({ type: 'CLAS', name: 'ZCL_FOO', snapshotId: 'snap1.abap' }, makeCtx({}));
+        expect(mockSnapshotsRead).toHaveBeenCalledWith('CLAS', 'ZCL_FOO', 'snap1.abap');
+        // sap_snapshot_read returns raw text (not stringified)
+        expect(result.content).toBe(fakeSource);
+    });
+    it('propagates error when snapshots.read throws', async () => {
+        mockSnapshotsRead.mockRejectedValue(new Error('snapshot not found'));
+        const tool = getTool('sap_snapshot_read');
+        await expect(tool.handler({ type: 'CLAS', name: 'ZCL_FOO', snapshotId: 'missing.abap' }, makeCtx({}))).rejects.toThrow('snapshot not found');
+    });
+});
+// ---------------------------------------------------------------------------
+// A.6.3 sap_snapshot_cleanup
+// ---------------------------------------------------------------------------
+describe('sap_snapshot_cleanup', () => {
+    it('calls snapshots.cleanup with retentionHours and returns deleted count', async () => {
+        mockSnapshotsCleanup.mockResolvedValue(7);
+        const tool = getTool('sap_snapshot_cleanup');
+        const result = await tool.handler({ retentionHours: 48 }, makeCtx({}));
+        expect(mockSnapshotsCleanup).toHaveBeenCalledWith(48);
+        expect(JSON.parse(result.content)).toEqual({ deleted: 7 });
+    });
+    it('propagates error when snapshots.cleanup throws', async () => {
+        mockSnapshotsCleanup.mockRejectedValue(new Error('permission denied'));
+        const tool = getTool('sap_snapshot_cleanup');
+        await expect(tool.handler({}, makeCtx({}))).rejects.toThrow('permission denied');
+    });
+});
+// ---------------------------------------------------------------------------
+// B.1 sap_update_method — diff-preview gate (Rule 7a)
+//
+// Mocking strategy:
+//   - verifyAndSpendApprovalId: mocked globally above (returns ok:true by default)
+//   - interceptUpdateMethod: mocked globally above (we control resolve/throw per test)
+//   - autoSnapshot: relies on ctx.adt.getSource + snapshots.take (both mocked)
+//   - appendPending / finalizeToolCall: mocked globally above
+//   - verifySyntax: mocked globally above (returns ok:true by default)
+// ---------------------------------------------------------------------------
+// Minimal class source used by autoSnapshot's ctx.adt.getSource call.
+const SAMPLE_CLASS_SOURCE = `CLASS zcl_demo DEFINITION PUBLIC FINAL CREATE PUBLIC.
+  PUBLIC SECTION.
+    METHODS do_work.
+ENDCLASS.
+
+CLASS zcl_demo IMPLEMENTATION.
+  METHOD do_work.
+    RETURN.
+  ENDMETHOD.
+ENDCLASS.`;
+describe('sap_update_method', () => {
+    // B.1 test 1 — Happy path: confirmed preview → updateMethod called once
+    it('calls updateMethod when interceptUpdateMethod confirms (previewHook resolves confirmed)', async () => {
+        const mockUpdateMethod = vi.fn().mockResolvedValue({ status: 'ok' });
+        const mockGetSource = vi.fn().mockResolvedValue(SAMPLE_CLASS_SOURCE);
+        // interceptUpdateMethod resolves (confirmed) → flow continues to write
+        mockInterceptUpdateMethod.mockResolvedValue(undefined);
+        const previewHook = vi.fn().mockResolvedValue({ confirmed: true });
+        const adt = { updateMethod: mockUpdateMethod, getSource: mockGetSource };
+        const tool = getTool('sap_update_method');
+        const result = await tool.handler({
+            class_name: 'ZCL_DEMO',
+            method_name: 'do_work',
+            method_source: '  DATA lv_x TYPE i.\n  lv_x = 42.',
+            transport: 'SXXK999999',
+            approval_id: 'dummy-jwt',
+        }, makeCtx(adt, { previewHook }));
+        expect(mockInterceptUpdateMethod).toHaveBeenCalledOnce();
+        const [minimalArg, callArg, hookArg] = mockInterceptUpdateMethod.mock.calls[0];
+        expect(typeof minimalArg.getSource).toBe('function');
+        expect(callArg.className).toBe('ZCL_DEMO');
+        expect(callArg.methodName).toBe('do_work');
+        expect(hookArg).toBe(previewHook);
+        expect(mockUpdateMethod).toHaveBeenCalledOnce();
+        expect(mockUpdateMethod).toHaveBeenCalledWith('ZCL_DEMO', 'do_work', '  DATA lv_x TYPE i.\n  lv_x = 42.', 'SXXK999999');
+        const parsed = JSON.parse(result.content);
+        expect(parsed.updated).toBe(true);
+        expect(result.is_error).toBeFalsy();
+    });
+    // B.1 test 2 — previewHook missing: handler returns preview_hook_unavailable; updateMethod NOT called
+    it('returns preview_hook_unavailable envelope when ctx.previewHook is undefined', async () => {
+        const mockUpdateMethod = vi.fn();
+        const mockGetSource = vi.fn().mockResolvedValue(SAMPLE_CLASS_SOURCE);
+        const adt = { updateMethod: mockUpdateMethod, getSource: mockGetSource };
+        const tool = getTool('sap_update_method');
+        const result = await tool.handler({
+            class_name: 'ZCL_DEMO',
+            method_name: 'do_work',
+            method_source: '  RETURN.',
+            approval_id: 'dummy-jwt',
+        }, makeCtx(adt));
+        expect(result.is_error).toBe(true);
+        const parsed = JSON.parse(result.content);
+        expect(parsed.error).toBe('preview_hook_unavailable');
+        expect(parsed.detail).toBeTruthy();
+        // Critical: updateMethod must NOT be called
+        expect(mockUpdateMethod).not.toHaveBeenCalled();
+        expect(mockInterceptUpdateMethod).not.toHaveBeenCalled();
+    });
+    // B.1 test 3 — User declines: CancelledByUserError thrown → cancelled_by_user envelope; updateMethod NOT called
+    it('returns cancelled_by_user envelope when interceptUpdateMethod throws CancelledByUserError', async () => {
+        const mockUpdateMethod = vi.fn();
+        const mockGetSource = vi.fn().mockResolvedValue(SAMPLE_CLASS_SOURCE);
+        const cancelledCall = {
+            className: 'ZCL_DEMO', methodName: 'do_work',
+            methodSource: '  RETURN.', transport: '',
+        };
+        mockInterceptUpdateMethod.mockRejectedValue(new CancelledByUserError(cancelledCall));
+        const previewHook = vi.fn().mockResolvedValue({ confirmed: false });
+        const adt = { updateMethod: mockUpdateMethod, getSource: mockGetSource };
+        const tool = getTool('sap_update_method');
+        const result = await tool.handler({
+            class_name: 'ZCL_DEMO',
+            method_name: 'do_work',
+            method_source: '  RETURN.',
+            approval_id: 'dummy-jwt',
+        }, makeCtx(adt, { previewHook }));
+        expect(result.is_error).toBe(true);
+        const parsed = JSON.parse(result.content);
+        expect(parsed.error).toBe('cancelled_by_user');
+        expect(parsed.detail).toBeTruthy();
+        // Critical: updateMethod must NOT be called
+        expect(mockUpdateMethod).not.toHaveBeenCalled();
+    });
+    // B.1 test 4 — getSource rejects (preview_failed path): handler returns preview_failed; updateMethod NOT called
+    it('returns preview_failed envelope when ctx.adt.getSource rejects inside interceptUpdateMethod', async () => {
+        const mockUpdateMethod = vi.fn();
+        // getSource rejects — interceptUpdateMethod will throw a plain Error (not CancelledByUserError)
+        mockInterceptUpdateMethod.mockRejectedValue(new Error('ADT 404 class not found'));
+        const previewHook = vi.fn();
+        const adt = { updateMethod: mockUpdateMethod, getSource: vi.fn().mockRejectedValue(new Error('ADT 404')) };
+        const tool = getTool('sap_update_method');
+        const result = await tool.handler({
+            class_name: 'ZCL_MISSING',
+            method_name: 'do_work',
+            method_source: '  RETURN.',
+            approval_id: 'dummy-jwt',
+        }, makeCtx(adt, { previewHook }));
+        expect(result.is_error).toBe(true);
+        const parsed = JSON.parse(result.content);
+        expect(parsed.error).toBe('preview_failed');
+        expect(parsed.detail).toContain('ADT 404');
+        // Critical: updateMethod must NOT be called
+        expect(mockUpdateMethod).not.toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// B.2 sap_set_source — safety confirmation gate (Rule 7)
+// ---------------------------------------------------------------------------
+describe('sap_set_source safety confirmation', () => {
+    it('calls presentSafetyConfirmation with correct SafetyAction and proceeds when confirmed', async () => {
+        mockIsSafetyConfirmEnabled.mockReturnValue(true);
+        mockPresentSafetyConfirmation.mockResolvedValue({ confirmed: true });
+        // setSource returns a WriteResult — handler now checks writeStatus / error
+        // (regression fix: HTTP 4xx returns rather than throws). Success path = no
+        // error and writeStatus < 400. See memory/project_phase3_lite_regression.md.
+        const mockSetSource = vi.fn().mockResolvedValue({ writeStatus: 200 });
+        // autoSnapshot calls ctx.adt.getSource — provide a stub so the snapshot gate passes
+        const mockGetSource = vi.fn().mockResolvedValue('CLASS ZCL_MYCLASS DEFINITION.\nENDCLASS.\n');
+        const adt = { setSource: mockSetSource, getSource: mockGetSource };
+        const tool = getTool('sap_set_source');
+        const result = await tool.handler({
+            name: 'ZCL_MYCLASS',
+            type: 'CLAS',
+            source: 'CLASS ZCL_MYCLASS DEFINITION.\nENDCLASS.\n',
+            transport: 'DEVK900001',
+            approval_id: 'dummy-jwt',
+        }, makeCtx(adt));
+        // Safety confirmation must have been called with correct shape
+        expect(mockPresentSafetyConfirmation).toHaveBeenCalledOnce();
+        const action = mockPresentSafetyConfirmation.mock.calls[0][0];
+        expect(action.rule).toBe('RULE_7_SNAPSHOT_BEFORE_WRITE');
+        expect(action.op).toBe('set_source');
+        expect(action.object).toEqual({ type: 'CLAS', name: 'ZCL_MYCLASS' });
+        expect(action.what_will_happen).toBeTruthy();
+        expect(action.rollback_available).toBe(true);
+        expect(action.transport).toBe('DEVK900001');
+        // setSource must have been called (confirmed)
+        expect(mockSetSource).toHaveBeenCalledOnce();
+        const parsed = JSON.parse(result.content);
+        expect(parsed.written).toBe(true);
+        expect(result.is_error).toBeFalsy();
+    });
+    it('returns cancelled_by_user and does NOT call setSource when user declines', async () => {
+        mockIsSafetyConfirmEnabled.mockReturnValue(true);
+        mockPresentSafetyConfirmation.mockResolvedValue({ confirmed: false, reason: 'test decline' });
+        const mockSetSource = vi.fn();
+        // autoSnapshot calls ctx.adt.getSource — provide a stub so snapshot gate passes before Gate 3
+        const mockGetSource = vi.fn().mockResolvedValue('CLASS ZCL_MYCLASS DEFINITION.\nENDCLASS.\n');
+        const adt = { setSource: mockSetSource, getSource: mockGetSource };
+        const tool = getTool('sap_set_source');
+        const result = await tool.handler({
+            name: 'ZCL_MYCLASS',
+            type: 'CLAS',
+            source: 'CLASS ZCL_MYCLASS DEFINITION.\nENDCLASS.\n',
+            approval_id: 'dummy-jwt',
+        }, makeCtx(adt));
+        expect(result.is_error).toBe(true);
+        const parsed = JSON.parse(result.content);
+        expect(parsed.error).toBe('cancelled_by_user');
+        expect(parsed.reason).toBe('test decline');
+        // Critical: setSource must NOT be called
+        expect(mockSetSource).not.toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// B.2 sap_delete_object — safety confirmation gate (Rule 7)
+// ---------------------------------------------------------------------------
+describe('sap_delete_object safety confirmation', () => {
+    it('calls presentSafetyConfirmation with correct SafetyAction and proceeds when confirmed', async () => {
+        mockIsSafetyConfirmEnabled.mockReturnValue(true);
+        mockPresentSafetyConfirmation.mockResolvedValue({ confirmed: true });
+        const mockDeleteObject = vi.fn().mockResolvedValue({ status: 200 });
+        // objectStructure called in post-check — return rejection (object gone)
+        const mockObjectStructure = vi.fn().mockRejectedValue(new Error('not found'));
+        const adt = { deleteObject: mockDeleteObject, objectStructure: mockObjectStructure };
+        const tool = getTool('sap_delete_object');
+        const result = await tool.handler({
+            name: 'ZCL_OLD',
+            type: 'CLAS',
+            transport: 'DEVK900002',
+            approval_id: 'dummy-jwt',
+        }, makeCtx(adt));
+        // Safety confirmation must have been called with correct shape
+        expect(mockPresentSafetyConfirmation).toHaveBeenCalledOnce();
+        const action = mockPresentSafetyConfirmation.mock.calls[0][0];
+        expect(action.rule).toBe('RULE_7_SNAPSHOT_BEFORE_WRITE');
+        expect(action.op).toBe('delete_object');
+        expect(action.object).toEqual({ type: 'CLAS', name: 'ZCL_OLD' });
+        expect(action.what_will_happen).toBeTruthy();
+        expect(action.rollback_available).toBe(true);
+        expect(action.transport).toBe('DEVK900002');
+        // deleteObject must have been called (confirmed)
+        expect(mockDeleteObject).toHaveBeenCalledOnce();
+        const parsed = JSON.parse(result.content);
+        expect(parsed.deleted).toBe(true);
+        expect(result.is_error).toBeFalsy();
+    });
+    it('returns cancelled_by_user and does NOT call deleteObject when user declines', async () => {
+        mockIsSafetyConfirmEnabled.mockReturnValue(true);
+        mockPresentSafetyConfirmation.mockResolvedValue({ confirmed: false, reason: 'no delete' });
+        const mockDeleteObject = vi.fn();
+        const adt = { deleteObject: mockDeleteObject };
+        const tool = getTool('sap_delete_object');
+        const result = await tool.handler({
+            name: 'ZCL_OLD',
+            type: 'CLAS',
+            approval_id: 'dummy-jwt',
+        }, makeCtx(adt));
+        expect(result.is_error).toBe(true);
+        const parsed = JSON.parse(result.content);
+        expect(parsed.error).toBe('cancelled_by_user');
+        expect(parsed.reason).toBe('no delete');
+        // Critical: deleteObject must NOT be called
+        expect(mockDeleteObject).not.toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// Regression guard 2026-05-01 — handlers MUST check the AdtClient return value.
+// Phase 3-Lite shipped with sap_set_source / sap_update_method / sap_delete_object
+// silently reporting success when the underlying ADT REST call returned a 4xx
+// without throwing (the SDK only throws on catastrophic failure). The LLM
+// believed writes succeeded; SAP source was unchanged. Full diagnosis at
+// memory/project_phase3_lite_regression.md.
+// ---------------------------------------------------------------------------
+describe('regression: handlers surface AdtClient HTTP-level failures', () => {
+    it('sap_set_source returns is_error when AdtClient.setSource resolves with writeStatus >= 400', async () => {
+        mockIsSafetyConfirmEnabled.mockReturnValue(false);
+        const mockSetSource = vi.fn().mockResolvedValue({
+            writeStatus: 423,
+            error: 'Write failed with HTTP 423: locked',
+        });
+        const mockGetSource = vi.fn().mockResolvedValue('REPORT z. WRITE / 1.');
+        const adt = { setSource: mockSetSource, getSource: mockGetSource };
+        const tool = getTool('sap_set_source');
+        const result = await tool.handler({ name: 'Z_PROBE', type: 'PROG', source: 'REPORT z. WRITE / 2.', approval_id: 'dummy-jwt' }, makeCtx(adt));
+        expect(result.is_error).toBe(true);
+        const parsed = JSON.parse(result.content);
+        expect(parsed.error).toBe('write_failed');
+        expect(parsed.write_status).toBe(423);
+        expect(parsed.detail).toContain('423');
+        // setSource WAS called — the failure happened on the server side.
+        expect(mockSetSource).toHaveBeenCalledOnce();
+    });
+    it('sap_update_method returns is_error when AdtClient.updateMethod resolves with writeStatus >= 400', async () => {
+        // Need to mock interceptUpdateMethod (B.1 wiring) so the diff-preview gate proceeds.
+        mockInterceptUpdateMethod.mockResolvedValue(undefined);
+        const previewHook = vi.fn().mockResolvedValue({ confirmed: true });
+        const mockUpdateMethod = vi.fn().mockResolvedValue({
+            writeStatus: 412,
+            error: 'Write failed with HTTP 412: precondition failed',
+        });
+        const mockGetSource = vi.fn().mockResolvedValue('CLASS zcl. METHOD do. ENDMETHOD. ENDCLASS.');
+        const adt = {
+            updateMethod: mockUpdateMethod,
+            getSource: mockGetSource,
+        };
+        const tool = getTool('sap_update_method');
+        const result = await tool.handler({
+            class_name: 'ZCL_X',
+            method_name: 'do',
+            method_source: '  WRITE 1.',
+            transport: 'DEVK900003',
+            approval_id: 'dummy-jwt',
+        }, makeCtx(adt, { previewHook }));
+        expect(result.is_error).toBe(true);
+        const parsed = JSON.parse(result.content);
+        expect(parsed.error).toBe('update_failed');
+        expect(parsed.write_status).toBe(412);
+        expect(mockUpdateMethod).toHaveBeenCalledOnce();
+    });
+    it('sap_delete_object returns is_error when AdtClient.deleteObject resolves with status >= 400', async () => {
+        mockIsSafetyConfirmEnabled.mockReturnValue(false);
+        const mockDeleteObject = vi.fn().mockResolvedValue({
+            status: 403,
+            error: 'Delete forbidden — package locked',
+        });
+        const mockGetSource = vi.fn().mockResolvedValue('REPORT z.');
+        const adt = { deleteObject: mockDeleteObject, getSource: mockGetSource };
+        const tool = getTool('sap_delete_object');
+        const result = await tool.handler({ name: 'Z_PROBE', type: 'PROG', approval_id: 'dummy-jwt' }, makeCtx(adt));
+        expect(result.is_error).toBe(true);
+        const parsed = JSON.parse(result.content);
+        expect(parsed.error).toBe('delete_failed');
+        expect(parsed.status).toBe(403);
+        expect(mockDeleteObject).toHaveBeenCalledOnce();
+    });
+});

package/dist/tools/__tests__/schedule_create.test.js

@@ -0,0 +1,85 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { scheduleCreateHandler, __setSchedulesDirForTests } from '../subagent/schedule_create.js';
+import { makeCtx } from './_helpers.js';
+let dir;
+const ctx = () => makeCtx(process.cwd());
+beforeEach(async () => {
+    dir = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-schedules-'));
+    __setSchedulesDirForTests(dir);
+});
+afterEach(async () => {
+    __setSchedulesDirForTests(null); // restore default
+    await fs.rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
+});
+async function listJsonFiles() {
+    const entries = await fs.readdir(dir);
+    return entries.filter((e) => e.endsWith('.json'));
+}
+describe('schedule_create handler', () => {
+    it('persists a oneoff schedule with crypto.randomUUID filename', async () => {
+        const r = await scheduleCreateHandler({ kind: 'oneoff', when: '2099-06-01T10:00:00Z', command: 'echo hello' }, ctx());
+        expect(r.is_error).toBeFalsy();
+        const files = await listJsonFiles();
+        expect(files).toHaveLength(1);
+        expect(files[0]).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.json$/i);
+        const body = JSON.parse(await fs.readFile(path.join(dir, files[0]), 'utf-8'));
+        expect(body.kind).toBe('oneoff');
+        expect(body.when).toBe('2099-06-01T10:00:00Z');
+        expect(body.command).toBe('echo hello');
+        expect(typeof body.id).toBe('string');
+        expect(typeof body.createdAt).toBe('string');
+    });
+    it('persists a cron schedule', async () => {
+        const r = await scheduleCreateHandler({ kind: 'cron', when: '0 9 * * 1-5', command: 'pnpm test' }, ctx());
+        expect(r.is_error).toBeFalsy();
+        const files = await listJsonFiles();
+        const body = JSON.parse(await fs.readFile(path.join(dir, files[0]), 'utf-8'));
+        expect(body.kind).toBe('cron');
+        expect(body.when).toBe('0 9 * * 1-5');
+    });
+    it('rejects missing kind', async () => {
+        const r = await scheduleCreateHandler({ when: '2099-06-01T10:00:00Z', command: 'echo' }, ctx());
+        expect(r.is_error).toBe(true);
+        expect(r.content).toMatch(/kind/i);
+    });
+    it('rejects unknown kind', async () => {
+        const r = await scheduleCreateHandler({ kind: 'twice-monthly', when: '?', command: 'echo' }, ctx());
+        expect(r.is_error).toBe(true);
+        expect(r.content).toMatch(/kind/i);
+    });
+    it('rejects oneoff with a non-ISO `when`', async () => {
+        const r = await scheduleCreateHandler({ kind: 'oneoff', when: 'tomorrow at 10', command: 'echo' }, ctx());
+        expect(r.is_error).toBe(true);
+        expect(r.content).toMatch(/ISO/i);
+    });
+    it('rejects oneoff with a `when` in the past', async () => {
+        const r = await scheduleCreateHandler({ kind: 'oneoff', when: '2000-01-01T00:00:00Z', command: 'echo' }, ctx());
+        expect(r.is_error).toBe(true);
+        expect(r.content).toMatch(/past|future/i);
+    });
+    it('rejects calendar-invalid dates that Date.parse would silently roll forward (e.g. Feb 30)', async () => {
+        const r = await scheduleCreateHandler({ kind: 'oneoff', when: '2099-02-30T00:00:00Z', command: 'echo' }, ctx());
+        expect(r.is_error).toBe(true);
+        expect(r.content).toMatch(/calendar|valid|rolls/i);
+    });
+    it('rejects empty command', async () => {
+        const r = await scheduleCreateHandler({ kind: 'oneoff', when: '2099-06-01T10:00:00Z', command: '' }, ctx());
+        expect(r.is_error).toBe(true);
+        expect(r.content).toMatch(/command/i);
+    });
+    it('creates the schedules dir if missing', async () => {
+        const nested = path.join(dir, 'nested', 'dir');
+        __setSchedulesDirForTests(nested);
+        const r = await scheduleCreateHandler({ kind: 'oneoff', when: '2099-06-01T10:00:00Z', command: 'echo' }, ctx());
+        expect(r.is_error).toBeFalsy();
+        const stat = await fs.stat(nested);
+        expect(stat.isDirectory()).toBe(true);
+    });
+    it('mentions in the response that scheduled jobs are persisted but NOT yet executed', async () => {
+        const r = await scheduleCreateHandler({ kind: 'oneoff', when: '2099-06-01T10:00:00Z', command: 'echo' }, ctx());
+        expect(r.content).toMatch(/persisted|not yet executed|runner/i);
+    });
+});