@pixlcore/xycli 1.0.0 → 1.0.1

package/docs/help.md

@@ -231,7 +231,7 @@ xy sync ./ --up events,plugins --delete events
 
 **Objects with a `stock` or `marketplace` property are always ignored by deletion**, including during dry runs. They do not need local source files, and setup inclusion flags cannot override this protection.
 
-**The scanned directories must contain a complete inventory of the other objects you intend to keep for every type selected for deletion.** Delete mode is not limited to previously synced objects. A missing file, incomplete export, or unavailable mount can cause unintended deletions of your own definitions. Verify that all source directories are available and inspect a dry run before removing `--dry`. Source warnings or scan errors stop the run before any updates or deletions begin.
+**The scanned directories must contain a complete inventory of the other objects you intend to keep for every type selected for deletion.** Delete mode is not limited to previously synced objects. A missing file, incomplete export, or unavailable mount can cause unintended deletions of your own definitions. Verify that all source directories are available and inspect a dry run before removing `--dry`. Source warnings or scan errors stop the run before any updates begin. If an update or sync-tracking API operation fails, earlier successful updates remain in place, but the entire delete pass is skipped for that run.
 
 **Completion commands and notifications**
 
@@ -250,7 +250,7 @@ xy sync ./ --up events,plugins \
 
 Completion commands run in a local shell in the first base directory. Deletions alone do not trigger them. Event notifications receive `input.data.errors` and `input.data.warnings`.
 
-The configured API Key needs the appropriate resource permissions and `update_state` for sync tracking updates. Notification actions also need their usual permissions. Earlier successful changes are not rolled back if a later operation fails.
+The configured API Key needs the appropriate resource permissions and `update_state` for sync tracking updates. Notification actions also need their usual permissions. Earlier successful changes are not rolled back if a later operation fails. Retry the sync after correcting an error; previously applied updates compare equal, and deletion remains disabled until the pre-delete phase completes without warnings or errors.
 
 Sync warnings and errors exit with status `1`, including warnings or errors during dry runs and completion-command errors. Completion commands and notifications can finish before the process exits. Runs with no warnings or errors exit with status `0`. Scan warnings stop the run before updates and can trigger notifications.
 

package/docs/sync.md

@@ -472,7 +472,9 @@ Inspect the entire deletion list and confirm that the directory and remote inven
 xy sync ./ --up events,plugins,categories --down false --delete events
 ```
 
-Deleting an Event does not automatically remove its dependencies. Remote API rules still apply, including restrictions on active jobs and references. Successful earlier updates or deletions are not rolled back if a later deletion fails.
+Deleting an Event does not automatically remove its dependencies. Remote API rules still apply, including restrictions on active jobs and references.
+
+Deletion only begins after every update has completed and the sync-tracking state has been written without warnings or errors. If either phase fails, the entire delete pass is skipped for that run. Earlier successful updates remain in place, so correct the error and retry; definitions already updated will compare equal. Once deletion begins, successful earlier deletions are not rolled back if a later deletion fails.
 
 An unavailable base directory stops the scan, but an existing empty directory can look like an empty inventory. Do not treat that guard as protection against an empty mount, accidental file removal, or missing exports of your own definitions.
 

package/lib/sync.js

@@ -353,6 +353,14 @@ module.exports = {
 		// update state db
 		await this.syncState(state);
 		
+		// Deletion is the destructive final phase, so only begin it after every
+		// update and the sync-state write completed cleanly.  Earlier successful
+		// updates are intentionally left in place and will compare equal on retry.
+		if (sconfig.delete && (this.errors.length || this.warnings.length)) {
+			this.logSyncWarning("Delete pass skipped because the sync encountered earlier warnings or errors.");
+			return await this.completeSync();
+		}
+		
 		// now handle deletes
 		if (!sconfig.delete) return await this.completeSync();
 		

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pixlcore/xycli",
-	"version": "1.0.0",
+	"version": "1.0.1",
 	"description": "A complete command-line interface for the xyOps workflow automation system.",
 	"author": "Joseph Huckaby <jhuckaby@pixlcore.com>",
 	"homepage": "https://github.com/pixlcore/xycli",

package/test/README.md

@@ -8,7 +8,7 @@ Use Node.js 22 or newer and install the CLI dependencies with `npm install`.
 
 Start xyOps at `http://localhost:5522` and configure an administrator API key using your normal CLI config file or the `XYOPS_API_KEY` environment variable. The tests read the same configuration as `xy`, including `XYOPS_BASE_URL` overrides. They refuse to run against a different server address.
 
-Use an xyOps version that supports restoring API key IDs, hashes, and masks through `create_api_key`. The Server tests need a connected server, and the Monitor tests also need a server group. The log tests expect the standard log columns and debug entries in the current xyOps log.
+Use an xyOps version that supports restoring API key IDs, hashes, and masks through `create_api_key`. The Server and Job tests need a connected server, the Job tests need the enabled stock Shell Plugin, and the Monitor tests also need a server group. The log tests expect the standard log columns and debug entries in the current xyOps log.
 
 ## Running Tests
 
@@ -55,6 +55,8 @@ node --test test/config.test.js test/sync-unit.test.js
 | `categories` | CRUD, actions and limits, JSON input, validation, pagination, help |
 | `channels` | CRUD, recipients, indexed edits, filters, validation, help |
 | `config` | Offline user-file updates, inherited-setting isolation, missing-file creation, dotted edits, permissions, and read-only display |
+| `events` | CRUD, dependency filters, nested edits, triggers, actions, limits, fields, validation, and help |
+| `jobs` | Event launch, parameter and input overrides, completed reports, output logs, search, rerun, deletion, validation, and help |
 | `log` | Log searches, latest rows, matching, column selection, native output |
 | `markdown` | Terminal rendering, inline formatting inside list items, typographic bullets, and output margins |
 | `monitors` | CRUD, groups, evaluator requests, type conversions, validation, help |
@@ -65,7 +67,7 @@ node --test test/config.test.js test/sync-unit.test.js
 | `servers` | Active and recently offline lists, local filters, installer generation, historical search, live and historical Server details, charts, processes, connections, pagination, validation, help |
 | `system` | Admin dashboard, conductors, connected users, export, maintenance, optimization, rate resets, diagnostics, broadcasts, help |
 | `sync` | Setup export, isolated filesystem discovery, external property files, dry-run, upsync, downsync, composite global-state governance, no-op detection, and guarded delete mode |
-| `sync-unit` | Offline PID locking and stale recovery, up-only deletion guards, stock/Marketplace deletion protection, inherited settings and CLI overrides, warning/error exit status, duplicates, quiet/dry runs, completion failures, and notification delivery after warnings or errors |
+| `sync-unit` | Offline PID locking and stale recovery, up-only deletion guards, pre-delete failure blocking, stock/Marketplace deletion protection, inherited settings and CLI overrides, warning/error exit status, duplicates, quiet/dry runs, completion failures, and notification delivery after warnings or errors |
 | `tags` | CRUD, metadata search, sparse future-proof updates, JSON input, validation, pagination, help |
 | `tickets` | Search, CRUD, number resolution, comments, attachment uploads/downloads, Events, related Job lookup, sparse updates, validation, help |
 | `toast` | Warning-box word wrapping and terminal-width limits |
@@ -80,7 +82,7 @@ Pagination checks that require saved events, completed jobs, or alert history re
 
 The mutating suites create uniquely named disposable objects and remove them in cleanup blocks, including after assertion failures. Test events have no active triggers, channels are never invoked, monitor sources use constants, and Plugin definitions are never executed or attached to other objects. Temporary files live in private operating-system temp directories and are removed by native test hooks.
 
-The Marketplace suite installs and upgrades `pixlcore/xyplug-ai`, then deletes it without executing or attaching it to an Event. The suite requires this product to be uninstalled when the test begins and removes its own installation during cleanup. Ticket fixtures remain in `draft` for their entire lifecycle so assigned test users never receive email notifications.
+The Job suite creates one enabled Event with no triggers, launches short-lived Shell Plugin Jobs only through explicit test commands, and deletes the completed Jobs and Event. The Marketplace suite installs and upgrades `pixlcore/xyplug-ai`, then deletes it without executing or attaching it to an Event. The suite requires this product to be uninstalled when the test begins and removes its own installation during cleanup. Ticket fixtures remain in `draft` for their entire lifecycle so assigned test users never receive email notifications.
 
 API key tests keep plaintext secrets in memory. Export files contain the stored hash and mask, and are deleted after the test. Captured CLI output is omitted from process failure messages because it can contain credentials.
 

package/test/events.test.js

@@ -0,0 +1,187 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { loadTestConfig, createCheck, xy, json, call: apiCall, cleanupFixtures } = require('./helpers/common.js');
+
+test('events', async t => {
+	loadTestConfig();
+	const check = createCheck(t);
+	
+	// Keep the Event disabled for its entire lifecycle.  Its schedule, actions,
+	// limits, and source are saved definitions only and can never launch a Job.
+	const stamp = Date.now();
+	const id = 'cli_event_test_' + stamp;
+	const title = 'CLI Event Test ' + stamp;
+	const action = { type: 'email', enabled: true, condition: 'success', users: ['admin'] };
+	const limit = { type: 'time', enabled: true, duration: 300, abort: true };
+	const field = { id: 'message', title: 'Message', type: 'text', value: 'Hello' };
+	const script = 'echo "Event fixture ' + stamp + '"';
+	let category;
+	let plugin;
+	let group;
+	
+	try {
+		await check('local server has Event dependencies', async () => {
+			const data = await apiCall('getMultiple', { lists: 'categories,plugins,groups' });
+			category = data.categories.find(item => item.enabled) || data.categories[0];
+			plugin = data.plugins.find(item => item.id == 'shellplug') || data.plugins.find(item => item.type == 'event');
+			group = data.groups[0];
+			assert.ok(category, 'At least one Category is required');
+			assert.ok(plugin, 'At least one Event Plugin is required');
+			assert.ok(group, 'At least one Server Group is required');
+		});
+		
+		await check('dry creation builds a complete Event request', () => {
+			const req = json([
+				'event', 'create', '--id', id, '--title', title,
+				'--enabled', 'false', '--category', category.id, '--plugin', plugin.id,
+				'--targets', JSON.stringify([group.id]), '--algo', 'random',
+				'--notes', 'Original notes', '--params.script', script,
+				'--cron', '15 4 * * *', '--action', JSON.stringify(action),
+				'--limit', JSON.stringify(limit), '--field', JSON.stringify(field), '--dry'
+			]);
+			assert.equal(req.id, id);
+			assert.equal(req.enabled, false);
+			assert.equal(req.category, category.id);
+			assert.equal(req.plugin, plugin.id);
+			assert.deepEqual(req.targets, [group.id]);
+			assert.equal(req.params.script, script);
+			assert.ok(req.triggers.some(trigger => trigger.type == 'manual' && trigger.enabled));
+			assert.ok(req.triggers.some(trigger => trigger.type == 'schedule' && trigger.enabled));
+			assert.deepEqual(req.actions.at(-1), action);
+			assert.deepEqual(req.limits.at(-1), limit);
+			assert.deepEqual(req.fields.at(-1), field);
+		});
+		
+		await check('dry creation does not persist', () => assert.deepEqual(json(['events', '--id', id]), []));
+		
+		xy([
+			'event', 'create', '--id', id, '--title', title,
+			'--enabled', 'false', '--category', category.id, '--plugin', plugin.id,
+			'--targets', JSON.stringify([group.id]), '--algo', 'random',
+			'--notes', 'Original notes', '--params.script', script,
+			'--cron', '15 4 * * *', '--action', JSON.stringify(action),
+			'--limit', JSON.stringify(limit), '--field', JSON.stringify(field)
+		]);
+		const created = json(['event', id]);
+		
+		await check('create persists the complete Event definition', () => {
+			assert.equal(created.id, id);
+			assert.equal(created.title, title);
+			assert.equal(created.enabled, false);
+			assert.equal(created.category, category.id);
+			assert.equal(created.plugin, plugin.id);
+			assert.deepEqual(created.targets, [group.id]);
+			assert.equal(created.params.script, script);
+			assert.equal(created.notes, 'Original notes');
+			assert.equal(created.revision, 1);
+			assert.deepEqual(created.actions.at(-1), action);
+			assert.deepEqual(created.limits.at(-1), limit);
+			assert.deepEqual(created.fields.at(-1), field);
+		});
+		
+		await check('exact ID, named ID, and fuzzy title get the Event', () => {
+			assert.deepEqual(json(['event', id]), created);
+			assert.equal(json(['event', 'get', '--id', id]).id, id);
+			assert.equal(json(['event', 'get', '--title', title.toLowerCase()]).id, id);
+		});
+		
+		await check('search and dependency filters find only the fixture', () => {
+			assert.deepEqual(json(['events', title, '--category', category.id, '--plugin', plugin.id, '--target', group.id]), [created]);
+			assert.deepEqual(json(['event', 'list', id, '--enabled', 'true']), []);
+		});
+		
+		await check('human list and detail render Event configuration', () => {
+			const list = xy(['events', title]);
+			const detail = xy(['event', id]);
+			assert.match(list, /FILTERED EVENTS/);
+			assert.match(list, /Other Commands:/);
+			for (const label of ['Event Summary', 'Event ID', 'Event Notes', 'Original notes', 'Triggers', 'Actions', 'Limits', 'User Parameters']) {
+				assert.ok(detail.toLowerCase().includes(label.toLowerCase()), label);
+			}
+		});
+		
+		await check('dry update is sparse and preserves the saved revision', () => {
+			assert.deepEqual(json(['event', 'update', id, '--notes', 'Preview', '--dry']), { notes: 'Preview', id: id });
+			assert.equal(json(['event', id]).revision, 1);
+		});
+		
+		const actionIndex = created.actions.length - 1;
+		const limitIndex = created.limits.length - 1;
+		const fieldIndex = created.fields.length - 1;
+		const updatedScript = 'echo "Updated Event fixture ' + stamp + '"';
+		xy([
+			'event', 'update', id, '--title', title + ' Updated',
+			'--notes', 'Updated notes', '--params.script', updatedScript,
+			'--actions.' + actionIndex + '.condition', 'complete',
+			'--limits.' + limitIndex + '.duration', '600',
+			'--fields.' + fieldIndex + '.value', 'Updated'
+		]);
+		let updated = json(['event', id]);
+		
+		await check('dotted update preserves untouched Event settings', () => {
+			assert.equal(updated.title, title + ' Updated');
+			assert.equal(updated.notes, 'Updated notes');
+			assert.equal(updated.params.script, updatedScript);
+			assert.equal(updated.actions[actionIndex].condition, 'complete');
+			assert.equal(updated.actions[actionIndex].users[0], 'admin');
+			assert.equal(updated.limits[limitIndex].duration, 600);
+			assert.equal(updated.fields[fieldIndex].value, 'Updated');
+			assert.equal(updated.enabled, false);
+			assert.equal(updated.revision, 2);
+		});
+		
+		const originalTriggerCount = updated.triggers.length;
+		const delay = { type: 'delay', enabled: true, duration: 60 };
+		xy(['event', 'update', id, '--trigger', JSON.stringify(delay)]);
+		updated = json(['event', id]);
+		
+		await check('singular trigger appends to the saved trigger list', () => {
+			assert.equal(updated.triggers.length, originalTriggerCount + 1);
+			assert.deepEqual(updated.triggers.at(-1), delay);
+		});
+		
+		const revision = updated.revision;
+		for (const args of [
+			['update', id],
+			['update', id, '--actions.99.enabled', 'true'],
+			['update', id, '--actions.0.__proto__.polluted', 'true'],
+			['update', id, '--unknown', 'value'],
+			['delete', title + ' Updated', '--confirm']
+		]) {
+			await check('reject Event ' + args.slice(0, 4).join(' '), () => xy(['event', ...args], { fail: true }));
+		}
+		
+		await check('rejected requests leave the Event unchanged', () => assert.equal(json(['event', id]).revision, revision));
+		
+		await check('duplicate Event ID error is surfaced', () => {
+			assert.match(xy(['event', 'create', '--id', id, '--title', title, '--enabled', 'false', '--params.script', script], { fail: true }), /already exists/i);
+		});
+		
+		await check('unconfirmed delete shows the Event and warning toast', () => {
+			for (const args of [['delete', id], ['delete', id, '--confirm', 'maybe']]) {
+				const out = xy(['event', ...args]);
+				assert.match(out, /DELETE EVENT/);
+				assert.match(out, new RegExp(id));
+				assert.match(out, /Please confirm the delete/);
+			}
+		});
+		
+		await check('dry delete sends only the Event ID', () => {
+			assert.deepEqual(json(['event', 'delete', id, '--confirm', '--dry']), { id: id });
+			assert.equal(json(['event', id]).id, id);
+		});
+		
+		xy(['event', 'delete', id, '--confirm']);
+		await check('confirmed delete removes the Event', () => assert.deepEqual(json(['events', '--id', id]), []));
+		await check('get after deletion fails', () => xy(['event', id], { fail: true }));
+		
+		for (const topic of ['events', 'event', 'event get', 'event create', 'event update', 'event delete', 'event run', 'run']) {
+			await check('help ' + topic, () => assert.ok(xy(['help', ...topic.split(' ')]).length > 100));
+		}
+	}
+	finally {
+		await cleanupFixtures([
+			{ list: 'events', method: 'deleteEvent', match: item => item.id == id || (item.title || '').startsWith(title) }
+		]);
+	}
+});

package/test/jobs.test.js

@@ -0,0 +1,205 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const sdk = require('@pixlcore/xyops-sdk');
+const { loadTestConfig, createCheck, xy, json, call: apiCall, cleanupFixtures } = require('./helpers/common.js');
+
+test('jobs', async t => {
+	loadTestConfig();
+	const check = createCheck(t);
+	
+	// This suite launches short-lived Shell Plugin Jobs, waits for each one to
+	// become final, and records every Job ID immediately for exact cleanup.
+	const stamp = Date.now();
+	const eventID = 'cli_job_test_' + stamp;
+	const eventTitle = 'CLI Job Test ' + stamp;
+	const marker = 'XYCLI_JOB_TEST_' + stamp;
+	const script = 'echo "' + marker + '"';
+	const jobIDs = new Set();
+	let eventCreated = false;
+	
+	async function loadJob(id) {
+		const result = await sdk.api.getJob({ id: id, remove: 'timelines' });
+		if (result.err || !result.data || !result.data.job) return null;
+		return result.data.job;
+	}
+	
+	async function waitForFinalJob(id, timeout = 20000) {
+		const expires = Date.now() + timeout;
+		while (Date.now() < expires) {
+			const job = await loadJob(id);
+			if (job && job.final) return job;
+			await new Promise(resolve => setTimeout(resolve, 200));
+		}
+		throw new Error('Timed out waiting for Job to complete: ' + id);
+	}
+	
+	function launchedJobID(output) {
+		const match = output.match(/Successfully launched job: #(\w+)/i);
+		assert.ok(match, 'CLI printed the launched Job ID');
+		jobIDs.add(match[1]);
+		return match[1];
+	}
+	
+	async function cleanupJobs() {
+		const errors = [];
+		for (const id of jobIDs) {
+			try {
+				let job = await loadJob(id);
+				if (!job) continue;
+				if (!job.final) {
+					await sdk.api.abortJob({ id: id });
+					job = await waitForFinalJob(id, 10000);
+				}
+				const result = await sdk.api.deleteJob({ id: id });
+				if (result.err) throw result.err;
+			}
+			catch (error) { errors.push(error); }
+		}
+		if (errors.length) throw new AggregateError(errors, 'Disposable Job cleanup failed.');
+	}
+	
+	try {
+		let category;
+		let plugin;
+		let serverID;
+		
+		await check('local server can run a Shell Plugin Job', async () => {
+			const data = await apiCall('getMultiple', { lists: 'categories,plugins', servers: 1 });
+			category = data.categories.find(item => item.enabled) || data.categories[0];
+			plugin = data.plugins.find(item => item.id == 'shellplug' && item.enabled);
+			serverID = Object.keys(data.servers || {})[0];
+			assert.ok(category && category.enabled, 'An enabled Category is required');
+			assert.ok(plugin, 'The enabled stock shellplug Event Plugin is required');
+			assert.ok(serverID, 'A connected Server is required');
+		});
+		
+		// Mark cleanup eligibility before creation.  This also covers the rare case
+		// where the server commits the Event but the client loses the response.
+		eventCreated = true;
+		await apiCall('createEvent', {
+			id: eventID,
+			title: eventTitle,
+			enabled: true,
+			category: category.id,
+			plugin: plugin.id,
+			params: { script: script },
+			fields: [],
+			tags: [],
+			targets: [serverID],
+			algo: 'random',
+			notes: 'Disposable CLI Job test Event',
+			actions: [],
+			limits: [],
+			triggers: [{ type: 'manual', enabled: true }]
+		});
+		
+		await check('dry run previews overrides without launching a Job', () => {
+			const req = json(['run', eventID, '--params.script', script, '--input.data.marker', marker, '--dry']);
+			assert.equal(req.id, eventID);
+			assert.equal(req.params.script, script);
+			assert.equal(req.input.data.marker, marker);
+		});
+		
+		const launchOutput = xy(['run', eventID, '--params.script', script, '--input.data.marker', marker]);
+		const firstJobID = launchedJobID(launchOutput);
+		let firstJob = await waitForFinalJob(firstJobID);
+		
+		await check('run launches a successful Event-backed Job', () => {
+			assert.match(launchOutput, /Watch job live:/);
+			assert.equal(firstJob.id, firstJobID);
+			assert.equal(firstJob.event, eventID);
+			assert.equal(firstJob.plugin, plugin.id);
+			assert.equal(firstJob.server, serverID);
+			assert.equal(firstJob.final, true);
+			assert.equal(firstJob.code || 0, 0);
+			assert.equal(firstJob.params.script, script);
+			assert.equal(firstJob.input.data.marker, marker);
+			assert.match(firstJob.output || '', new RegExp(marker));
+		});
+		
+		await check('Job get supports JSON and human reports', () => {
+			assert.deepEqual(json(['job', firstJobID]), firstJob);
+			const out = xy(['job', firstJobID]);
+			assert.match(out, /JOB SUMMARY/);
+			assert.match(out, new RegExp(firstJobID));
+			assert.match(out, /Job completed successfully/i);
+			assert.match(out, /Other Commands:/);
+		});
+		
+		await check('verbose Job detail and Job log include process output', () => {
+			assert.match(xy(['job', firstJobID, '--verbose']), new RegExp(marker));
+			assert.match(xy(['job', 'log', firstJobID]), new RegExp(marker));
+		});
+		
+		await check('completed Job search finds the launched Job', () => {
+			const out = xy(['jobs', '--event', eventID]);
+			assert.match(out, /JOB SEARCH RESULTS/);
+			assert.match(out, new RegExp(firstJobID));
+			assert.match(out, new RegExp(eventTitle));
+		});
+		
+		await check('dry rerun previews the original Job settings', () => {
+			const req = json(['job', 'run', firstJobID, '--dry']);
+			assert.equal(req.id, eventID);
+			assert.equal(req.event, eventID);
+			assert.equal(req.params.script, script);
+			assert.equal(req.input.data.marker, marker);
+		});
+		
+		const rerunOutput = xy(['job', 'run', firstJobID]);
+		const secondJobID = launchedJobID(rerunOutput);
+		const secondJob = await waitForFinalJob(secondJobID);
+		
+		await check('Job rerun launches a distinct successful Job', () => {
+			assert.notEqual(secondJob.id, firstJobID);
+			assert.equal(secondJob.event, eventID);
+			assert.equal(secondJob.code || 0, 0);
+			assert.equal(secondJob.params.script, script);
+			assert.equal(secondJob.input.data.marker, marker);
+			assert.match(secondJob.output || '', new RegExp(marker));
+		});
+		
+		await check('completed Job refuses active-only operations', () => {
+			assert.match(xy(['job', 'abort', firstJobID], { fail: true }), /already completed/i);
+			assert.match(xy(['job', 'resume', firstJobID], { fail: true }), /already completed/i);
+		});
+		
+		await check('unconfirmed Job delete shows its target and warning', () => {
+			const out = xy(['job', 'delete', firstJobID]);
+			assert.match(out, /DELETE JOB/);
+			assert.match(out, new RegExp(firstJobID));
+			assert.match(out, /Please confirm the delete/);
+		});
+		
+		await check('dry Job delete leaves the completed Job intact', async () => {
+			assert.deepEqual(json(['job', 'delete', firstJobID, '--confirm', '--dry']), { id: firstJobID });
+			assert.ok(await loadJob(firstJobID));
+		});
+		
+		for (const id of [firstJobID, secondJobID]) {
+			xy(['job', 'delete', id, '--confirm']);
+		}
+		
+		await check('confirmed Job delete removes both completed Jobs', async () => {
+			assert.equal(await loadJob(firstJobID), null);
+			assert.equal(await loadJob(secondJobID), null);
+			jobIDs.delete(firstJobID);
+			jobIDs.delete(secondJobID);
+		});
+		
+		await apiCall('deleteEvent', { id: eventID });
+		eventCreated = false;
+		
+		for (const topic of ['jobs', 'job', 'job get', 'job log', 'job run', 'job resume', 'job abort', 'job delete']) {
+			await check('help ' + topic, () => assert.ok(xy(['help', ...topic.split(' ')]).length > 100));
+		}
+	}
+	finally {
+		await cleanupJobs();
+		if (eventCreated) {
+			await cleanupFixtures([
+				{ list: 'events', method: 'deleteEvent', match: item => item.id == eventID || (item.title || '').startsWith(eventTitle) }
+			]);
+		}
+	}
+});

package/test/sync-unit.test.js

@@ -217,6 +217,26 @@ test('sync API errors preserve failure status while still sending both notificat
 	}
 });
 
+test('sync skips the entire delete pass after an update or state API failure', t => {
+	const category = { id: 'fixture', title: 'Fixture', notes: 'Remote' };
+	const orphan = { id: 'orphan', title: 'Orphan', notes: 'Delete candidate' };
+	
+	for (const failAPI of ['update_category', 'update_global_state']) {
+		const result = runSync(t, {
+			categories: [category, orphan],
+			source: { ...category, notes: 'Local' },
+			failAPI,
+			args: { up: 'categories', delete: 'categories' }
+		});
+		
+		assert.equal(result.status, 1);
+		assert.equal(result.report.errors.length, 1);
+		assert.match(result.report.warnings[0], /Delete pass skipped/);
+		assert.equal(result.report.calls.includes('update_global_state'), true);
+		assert.deepEqual(result.report.requests.filter(req => req.method.startsWith('delete_')), []);
+	}
+});
+
 test('sync completion-command errors also exit nonzero and notify', t => {
 	const category = { id: 'fixture', title: 'Fixture', notes: 'Remote' };
 	const result = runSync(t, {