@memnexus-ai/cli 1.7.214 → 1.7.216

package/dist/commands/memories.js

@@ -36,7 +36,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BULK_DELETE_LIST_PAGE_SIZE = exports.BULK_DELETE_MAX_RETRIES = exports.BULK_DELETE_PAGE_PAUSE_MS = exports.BULK_DELETE_MAX_IDS = exports.BULK_DELETE_GUARD_WINDOW_MS = exports.BULK_DELETE_GUARD_THRESHOLD = void 0;
+exports.getBulkDeleteGuardPath = getBulkDeleteGuardPath;
+exports.readDeleteGuardTimestamps = readDeleteGuardTimestamps;
+exports.recordDeletion = recordDeletion;
+exports.checkBulkDeleteGuard = checkBulkDeleteGuard;
 exports.parseCodeContextFlag = parseCodeContextFlag;
+exports.parseBatchIds = parseBatchIds;
+exports.isValidIsoDate = isValidIsoDate;
+exports.chunkIds = chunkIds;
+exports.isRateLimitError = isRateLimitError;
+exports.getRetryAfterMs = getRetryAfterMs;
+exports.sleep = sleep;
+exports.bulkDeleteWithRetry = bulkDeleteWithRetry;
+exports.runBulkDeletePaged = runBulkDeletePaged;
+exports.collectAllMemoryIds = collectAllMemoryIds;
 exports.registerMemoriesCommands = registerMemoriesCommands;
 exports.registerMemoryRelationshipCommands = registerMemoryRelationshipCommands;
 exports.registerMemoryTimelineCommand = registerMemoryTimelineCommand;
@@ -55,6 +69,80 @@ const js_yaml_1 = __importDefault(require("js-yaml"));
 const spinner_1 = require("../lib/spinner");
 const date_utils_1 = require("../lib/date-utils");
 const session_reader_1 = require("../lib/commit-context/session-reader");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// ── Cross-process bulk-delete guard (P0 #4144 fix-forward) ─────────────────
+// When an agent pipes `mx memories search | xargs mx memories delete`, each
+// delete is a separate process — a module-level counter resets every time.
+// This guard uses a temp file to track deletion timestamps across invocations.
+// If >BULK_DELETE_GUARD_THRESHOLD deletions happen within BULK_DELETE_GUARD_WINDOW_MS,
+// the CLI refuses to continue unless --yes is passed.
+//
+// The guard file lives in os.tmpdir() scoped to the current user, so concurrent
+// users on a shared machine don't interfere.
+/** Number of deletions within the window that triggers the guard. */
+exports.BULK_DELETE_GUARD_THRESHOLD = 5;
+/** Rolling window in milliseconds (60 seconds). */
+exports.BULK_DELETE_GUARD_WINDOW_MS = 60_000;
+/** Path to the guard file for the current user. */
+function getBulkDeleteGuardPath() {
+    return path.join(os.tmpdir(), `.mx-delete-guard-${process.getuid?.() ?? 'default'}`);
+}
+/**
+ * Read recent deletion timestamps from the guard file, pruning entries
+ * older than the window. Returns the count of recent deletions.
+ *
+ * The file format is one timestamp (ms since epoch) per line. Malformed
+ * lines are silently dropped — the file is advisory, not critical.
+ */
+function readDeleteGuardTimestamps(guardPath, now) {
+    try {
+        const raw = fs.readFileSync(guardPath, 'utf8');
+        const cutoff = now - exports.BULK_DELETE_GUARD_WINDOW_MS;
+        return raw
+            .split('\n')
+            .map((line) => parseInt(line.trim(), 10))
+            .filter((ts) => Number.isFinite(ts) && ts > cutoff);
+    }
+    catch {
+        // File doesn't exist or can't be read — no recent deletions.
+        return [];
+    }
+}
+/**
+ * Record a deletion timestamp in the guard file. Prunes old entries
+ * on write to keep the file small.
+ */
+function recordDeletion(guardPath, now) {
+    const recent = readDeleteGuardTimestamps(guardPath, now);
+    recent.push(now);
+    try {
+        fs.writeFileSync(guardPath, recent.join('\n') + '\n', { mode: 0o600 });
+    }
+    catch {
+        // Best-effort — if we can't write the guard file, the deletion still
+        // proceeds (the guard is a safety net, not a hard gate).
+    }
+}
+/**
+ * Check whether the bulk-delete guard should block. Returns true if the
+ * caller should proceed, false if it should abort.
+ *
+ * When the guard fires, it prints a warning to stderr explaining what
+ * happened and how to override.
+ */
+function checkBulkDeleteGuard(guardPath, now) {
+    const recent = readDeleteGuardTimestamps(guardPath, now);
+    if (recent.length >= exports.BULK_DELETE_GUARD_THRESHOLD) {
+        console.error(chalk_1.default.red(`\n⚠️  Rapid bulk deletion detected: ${recent.length} memories deleted in the last 60s.`));
+        console.error(chalk_1.default.yellow('This guard prevents accidental mass-deletion when piping search results into delete.'));
+        console.error(chalk_1.default.yellow('If this is intentional, use batch mode: mx memories delete --batch <id1> <id2> ... --yes'));
+        console.error(chalk_1.default.yellow('Or pipe via stdin:                      mx memories search --id-only | mx memories delete --stdin --yes'));
+        return false;
+    }
+    return true;
+}
 // ── Client-side recall/digest ceiling (KI-77 client half) ────────────────────
 // Digest is LLM-powered and can take 60-120s on cold calls, so we raise the SDK's
 // default 30s timeout to a 180s ceiling. The SDK enforces this via an AbortController
@@ -154,7 +242,11 @@ async function readIdsFromStdin() {
  * Resolve short ID prefixes to full UUIDs
  * Returns array of resolved IDs (in same order as input)
  */
-async function resolveShortIds(ids) {
+async function resolveShortIds(ids, opts = {}) {
+    // Default warner preserves the existing `get --stdin` behavior (warnings on
+    // stdout). Batch delete injects a stderr warner so short-id resolution
+    // warnings never pollute the pure-JSON stdout stream under --format json.
+    const warn = opts.warn ?? ((msg) => console.log(chalk_1.default.yellow(msg)));
     const MIN_PREFIX_LENGTH = 6;
     const resolvedIds = [];
     const resolvedMemories = new Map();
@@ -164,7 +256,7 @@ async function resolveShortIds(ids) {
             resolvedIds.push(id);
         }
         else if (id.length < MIN_PREFIX_LENGTH) {
-            console.log(chalk_1.default.yellow(`Warning: Skipping ID prefix "${id}" (too short, min ${MIN_PREFIX_LENGTH} chars)`));
+            warn(`Warning: Skipping ID prefix "${id}" (too short, min ${MIN_PREFIX_LENGTH} chars)`);
         }
         else {
             // Resolve short ID
@@ -175,10 +267,10 @@ async function resolveShortIds(ids) {
             });
             const matches = listResponse.data?.data || [];
             if (matches.length === 0) {
-                console.log(chalk_1.default.yellow(`Warning: No memory found with prefix "${id}"`));
+                warn(`Warning: No memory found with prefix "${id}"`);
             }
             else if (matches.length > 1) {
-                console.log(chalk_1.default.yellow(`Warning: Ambiguous prefix "${id}" matches ${matches.length} memories, skipping`));
+                warn(`Warning: Ambiguous prefix "${id}" matches ${matches.length} memories, skipping`);
             }
             else {
                 resolvedIds.push(matches[0].id);
@@ -349,6 +441,344 @@ async function handleBatchMemoryGet(ids, options) {
         throw error;
     }
 }
+// ── Batch delete (PO CLI-latency directive, iteration 1) ─────────────────────
+// Scripted single-deletes hit core-api's deleteRateLimit (20/min for CLI
+// clients): a 53-memory loop issues 53 requests and fails partway. The server's
+// DELETE /api/memories/bulk endpoint counts a whole bulk request as ONE against
+// that limiter (max 100 ids/request, requires confirmDeletion: true), so 500
+// ids = 5 requests — well under 20/min. These helpers implement paging, the
+// 429/Retry-After-honoring retry, and the confirmation gate.
+/** Max ids the server accepts per bulk-delete request (bulk-operations.schema.ts). */
+exports.BULK_DELETE_MAX_IDS = 100;
+/** Pause between sequential 100-id pages, keeps request cadence gentle. */
+exports.BULK_DELETE_PAGE_PAUSE_MS = 250;
+/** Max retries per page on 429 before giving up. */
+exports.BULK_DELETE_MAX_RETRIES = 3;
+/** Page size when listing memories for --all. */
+exports.BULK_DELETE_LIST_PAGE_SIZE = 100;
+/**
+ * Parse `--batch <ids...>` values into a flat, de-duplicated id list.
+ * Commander collects the variadic option into a string[]; each element may
+ * itself be comma- or space-separated, so we split again and trim.
+ */
+function parseBatchIds(values) {
+    if (!values || values.length === 0)
+        return [];
+    const out = [];
+    for (const value of values) {
+        for (const part of value.split(/[,\s]+/)) {
+            const trimmed = part.trim();
+            if (trimmed.length > 0)
+                out.push(trimmed);
+        }
+    }
+    return out;
+}
+/**
+ * True when `value` is a parseable ISO 8601 date. Used to validate the
+ * `--after`/`--before` filters on `--all` before they count as filters — a
+ * malformed date must be rejected, not silently treated as a real filter that
+ * bypasses the delete-everything gate. Requires a date-shaped prefix
+ * (YYYY-MM-DD…) so lenient locale strings like "notadate" or "July" are refused.
+ */
+function isValidIsoDate(value) {
+    if (typeof value !== 'string')
+        return false;
+    if (!/^\d{4}-\d{2}-\d{2}([T ].*)?$/.test(value.trim()))
+        return false;
+    return !Number.isNaN(Date.parse(value));
+}
+/** Split ids into pages of at most `size` (default 100). */
+function chunkIds(ids, size = exports.BULK_DELETE_MAX_IDS) {
+    const chunks = [];
+    for (let i = 0; i < ids.length; i += size) {
+        chunks.push(ids.slice(i, i + size));
+    }
+    return chunks;
+}
+/** True when an error is an HTTP 429 (rate limited). */
+function isRateLimitError(error) {
+    const status = error?.status ?? error?.statusCode ?? error?.response?.status;
+    return status === 429;
+}
+/**
+ * Extract the server's Retry-After hint in milliseconds, or null if absent.
+ * The API surfaces it as a body field (`retryAfter`, seconds) on 429s
+ * (see lib/errors.ts) and may also send a Retry-After header; we honor both.
+ */
+function getRetryAfterMs(error) {
+    const data = error?.data ?? error?.response?.data ?? {};
+    const secs = data?.retryAfter ?? data?.retry_after;
+    if (typeof secs === 'number' && Number.isFinite(secs) && secs >= 0) {
+        return Math.round(secs * 1000);
+    }
+    const headers = error?.headers;
+    let headerVal;
+    if (headers) {
+        if (typeof headers.get === 'function') {
+            headerVal = headers.get('retry-after') ?? headers.get('Retry-After');
+        }
+        else {
+            headerVal = headers['retry-after'] ?? headers['Retry-After'];
+        }
+    }
+    if (headerVal) {
+        const n = parseInt(String(headerVal), 10);
+        if (Number.isFinite(n) && n >= 0)
+            return n * 1000;
+    }
+    return null;
+}
+/** Promise-based sleep. Extracted so tests can inject a no-op/spy. */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Delete a single page, retrying on 429 up to `maxRetries` times. Honors the
+ * server's Retry-After hint; falls back to a linear backoff otherwise.
+ */
+async function bulkDeleteWithRetry(ids, deps) {
+    const maxRetries = deps.maxRetries ?? exports.BULK_DELETE_MAX_RETRIES;
+    const defaultRetryMs = deps.defaultRetryMs ?? 1000;
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await deps.deleteFn(ids);
+        }
+        catch (error) {
+            if (isRateLimitError(error) && attempt < maxRetries) {
+                const waitMs = getRetryAfterMs(error) ?? defaultRetryMs * (attempt + 1);
+                deps.onRateLimited?.(waitMs);
+                await deps.sleep(waitMs);
+                attempt++;
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+/** Best-effort human-readable message for a thrown request error. */
+function errorMessage(error) {
+    return (error?.data?.error ??
+        error?.data?.message ??
+        error?.response?.data?.error ??
+        error?.message ??
+        String(error));
+}
+/**
+ * Delete `ids` in sequential ≤100-id pages with a brief pause between pages and
+ * per-page 429 retry. Aggregates per-page results.
+ *
+ * A page that exhausts its 429 retries (or hits a non-429 error) is CAUGHT here
+ * rather than allowed to throw past the aggregation (QA MAJOR #2): every id in
+ * the failed page is recorded as a failure, `aborted` is set, remaining pages
+ * are counted in `notAttempted`, and paging stops. This guarantees the caller
+ * always receives a structured partial result — earlier pages' real deletions
+ * are never lost, and json-mode callers still get their JSON document.
+ */
+async function runBulkDeletePaged(ids, deps) {
+    const chunks = chunkIds(ids);
+    const agg = {
+        deleted: 0,
+        failed: 0,
+        errors: [],
+        requestCount: 0,
+        rateLimitedCount: 0,
+        aborted: false,
+        notAttempted: 0,
+    };
+    const pagePause = deps.pagePauseMs ?? exports.BULK_DELETE_PAGE_PAUSE_MS;
+    for (let i = 0; i < chunks.length; i++) {
+        if (i > 0 && pagePause > 0)
+            await deps.sleep(pagePause);
+        try {
+            const res = await bulkDeleteWithRetry(chunks[i], {
+                deleteFn: deps.deleteFn,
+                sleep: deps.sleep,
+                maxRetries: deps.maxRetries,
+                defaultRetryMs: deps.defaultRetryMs,
+                onRateLimited: () => {
+                    agg.rateLimitedCount++;
+                },
+            });
+            agg.requestCount++;
+            agg.deleted += res.deleted;
+            agg.failed += res.failed;
+            agg.errors.push(...res.errors);
+            deps.onPage?.(i, chunks.length, res);
+        }
+        catch (error) {
+            // The whole page failed to delete (retries exhausted or non-429). Record
+            // every id in it and stop — continuing after a rate-limit exhaustion just
+            // piles more requests onto an already-throttled limiter.
+            const msg = errorMessage(error);
+            for (const id of chunks[i]) {
+                agg.errors.push({ id, error: msg });
+            }
+            agg.failed += chunks[i].length;
+            agg.aborted = true;
+            for (let j = i + 1; j < chunks.length; j++) {
+                agg.notAttempted += chunks[j].length;
+            }
+            break;
+        }
+    }
+    return agg;
+}
+/**
+ * Page through the caller's memories (optionally filtered) and collect every
+ * id. Used by `--all`. Stops when a page returns fewer than the page size.
+ */
+async function collectAllMemoryIds(listFn, filterParams = {}, pageSize = exports.BULK_DELETE_LIST_PAGE_SIZE) {
+    const ids = [];
+    let offset = 0;
+    for (;;) {
+        const response = await listFn({ ...filterParams, limit: pageSize, offset });
+        const batch = response?.data?.data ?? [];
+        if (batch.length === 0)
+            break;
+        for (const m of batch) {
+            if (m?.id)
+                ids.push(m.id);
+        }
+        if (batch.length < pageSize)
+            break;
+        offset += pageSize;
+    }
+    return ids;
+}
+/** Issue one bulk-delete request via the SDK and normalize the response. */
+async function bulkDeleteViaSdk(ids) {
+    // SDK exposes bulkDeleteMemories (v1.55.1) — no direct-fetch fallback needed
+    // (contrast v1.7.27, which hand-rolled the batch-GET call before the SDK had
+    // it). The global fetch wrapper in index.ts still attaches X-MX-Client, so
+    // rate-limit attribution stays correct.
+    const response = await (0, api_client_1.getSdk)().memories.bulkDeleteMemories({
+        ids,
+        confirmDeletion: true,
+    });
+    const data = response?.data ?? response;
+    return {
+        deleted: data?.deleted ?? 0,
+        failed: data?.failed ?? 0,
+        errors: Array.isArray(data?.errors) ? data.errors : [],
+    };
+}
+/**
+ * Shared batch-delete flow for --batch / --stdin / --all. Handles the
+ * confirmation gate, short-id resolution, paged deletion, and output.
+ */
+async function handleBatchDelete(rawIds, options, mode) {
+    const jsonMode = options.format === 'json';
+    const isNonInteractive = !process.stdin.isTTY || process.env.MX_PROFILE === 'ai';
+    // Status/progress goes to stderr so stdout stays pure under --format json.
+    // (There is no session-preamble printer on this command path, so the
+    // #4176-class stdout-pollution bug cannot occur here — the only stdout write
+    // in json mode is the final JSON object below.)
+    const status = (msg) => console.error(msg);
+    // De-duplicate while preserving order, drop blanks.
+    const uniqueIds = [...new Set(rawIds)].filter((id) => id.trim().length > 0);
+    if (uniqueIds.length === 0) {
+        console.error(chalk_1.default.red('Error: No memory IDs provided for batch delete'));
+        process.exitCode = 1;
+        return;
+    }
+    // Resolve short-id prefixes exactly like single delete. Warnings go to stderr
+    // to preserve JSON purity on stdout.
+    const { resolvedIds } = await resolveShortIds(uniqueIds, {
+        warn: (m) => console.error(chalk_1.default.yellow(m)),
+    });
+    if (resolvedIds.length === 0) {
+        console.error(chalk_1.default.red('Error: No valid memory IDs to delete after resolution'));
+        process.exitCode = 1;
+        return;
+    }
+    const count = resolvedIds.length;
+    // --all always announces the count it is about to delete.
+    if (mode === 'all') {
+        status(chalk_1.default.yellow(`About to delete ${count} mem` + (count === 1 ? 'ory' : 'ories') + '.'));
+    }
+    // Confirmation gate. Batch modes REQUIRE explicit --yes non-interactively;
+    // interactively, --yes bypasses the prompt, otherwise we confirm with a count.
+    if (isNonInteractive) {
+        if (!options.yes) {
+            console.error(chalk_1.default.red(`Error: Batch delete of ${count} memories requires explicit --yes in non-interactive mode.`));
+            console.error(chalk_1.default.yellow('Re-run with --yes to confirm.'));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    else if (!options.yes) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Delete ${count} memor${count === 1 ? 'y' : 'ies'}? This cannot be undone.`,
+                default: false,
+            },
+        ]);
+        if (!answers.confirm) {
+            console.error(chalk_1.default.yellow('Delete cancelled'));
+            return;
+        }
+    }
+    // Gate passed — now (and only now) do we issue requests with confirmDeletion.
+    const spinner = (0, spinner_1.createSpinner)(`Deleting ${count} memories...`, options.format).start();
+    try {
+        const result = await runBulkDeletePaged(resolvedIds, {
+            deleteFn: bulkDeleteViaSdk,
+            sleep,
+            onPage: (i, total) => {
+                if (total > 1 && !jsonMode) {
+                    spinner.text = `Deleting page ${i + 1} of ${total}...`;
+                }
+            },
+        });
+        // Non-zero exit whenever anything failed OR paging aborted early, so
+        // scripts can detect partial failure (QA MAJOR #1). Set before any output
+        // branch so both JSON and human paths honor it.
+        const hadFailure = result.failed > 0 || result.aborted;
+        if (hadFailure) {
+            process.exitCode = 1;
+        }
+        if (result.aborted) {
+            spinner.fail(`Deleted ${result.deleted}, ${result.failed} failed, ${result.notAttempted} not attempted (stopped early)`);
+        }
+        else if (result.failed > 0) {
+            spinner.warn(`Deleted ${result.deleted}, ${result.failed} failed`);
+        }
+        else {
+            spinner.succeed(`Deleted ${result.deleted} memor${result.deleted === 1 ? 'y' : 'ies'}`);
+        }
+        if (jsonMode) {
+            // Pure JSON on stdout — the ONLY stdout write in this mode. Emitted even
+            // on partial failure / early abort so json-mode scripts always get a
+            // structured result (QA MAJOR #2).
+            process.stdout.write(JSON.stringify({
+                deleted: result.deleted,
+                failed: result.failed,
+                errors: result.errors,
+                requestCount: result.requestCount,
+                aborted: result.aborted,
+                notAttempted: result.notAttempted,
+            }) + '\n');
+            return;
+        }
+        if (result.errors.length > 0) {
+            console.log(chalk_1.default.yellow(`\n${result.errors.length} failure(s):`));
+            for (const e of result.errors) {
+                console.log(`  ${e.id}: ${e.error}`);
+            }
+        }
+        if (result.aborted && result.notAttempted > 0) {
+            console.log(chalk_1.default.yellow(`\nStopped early — ${result.notAttempted} id(s) were not attempted. Re-run to retry them.`));
+        }
+    }
+    catch (error) {
+        spinner.fail('Batch delete failed');
+        throw error;
+    }
+}
 /**
  * Register memory management commands
  * @param program - Commander program instance
@@ -1083,12 +1513,136 @@ function registerMemoriesCommands(program) {
      * Delete a memory
      */
     memories
-        .command('delete <id>')
-        .description('Delete a memory')
-        .option('--force', 'Skip confirmation prompt')
+        .command('delete [id]')
+        .description('Delete one or more memories (single, or --batch/--stdin/--all)')
+        .option('--force', 'Skip confirmation prompt (single delete only)')
+        .option('--batch <ids...>', 'Batch delete multiple memories by ID (space- or comma-separated)')
+        .option('--stdin', 'Batch delete memory IDs read from stdin (one per line or space-separated)')
+        .option('--all', 'Batch delete ALL of your memories (supports --recent/--topics/--before/--after filters)')
+        .option('--yes', 'Confirm batch deletion (required for --batch/--stdin/--all in non-interactive mode)')
+        .option('--i-know-this-deletes-everything', 'Required (with --yes) for unfiltered --all in non-interactive mode')
+        .option('--recent <duration>', 'Filter for --all: memories from last duration (e.g. 7d, 2w, 1h)')
+        .option('--topics <topics>', 'Filter for --all: comma-separated topics (matches ANY)')
+        .option('--before <date>', 'Filter for --all: created before this date (ISO 8601)')
+        .option('--after <date>', 'Filter for --all: created after this date (ISO 8601)')
+        .option('--format <format>', 'Output format (json for pure-JSON scripting output)')
         .action(async (id, options) => {
         try {
             const isNonInteractive = !process.stdin.isTTY || process.env.MX_PROFILE === 'ai';
+            // ── Batch modes: --batch / --stdin / --all (mutually exclusive) ─────
+            const batchProvided = options.batch !== undefined;
+            const stdinProvided = !!options.stdin;
+            const allProvided = !!options.all;
+            const batchModeCount = [batchProvided, stdinProvided, allProvided].filter(Boolean).length;
+            if (batchModeCount > 1) {
+                console.error(chalk_1.default.red('Error: --batch, --stdin, and --all are mutually exclusive; use only one.'));
+                process.exitCode = 1;
+                return;
+            }
+            if (batchModeCount === 1) {
+                if (id) {
+                    console.error(chalk_1.default.red('Error: Do not pass a positional <id> together with --batch/--stdin/--all.'));
+                    process.exitCode = 1;
+                    return;
+                }
+                if (allProvided) {
+                    // List-then-delete. Compose the existing list filters when supplied;
+                    // otherwise --all deletes everything.
+                    const listParams = {};
+                    if (options.recent) {
+                        const recentTs = (0, date_utils_1.getRecentTimestamp)(options.recent);
+                        if (!recentTs) {
+                            console.error(chalk_1.default.red(`Error: Invalid duration format: ${options.recent}`));
+                            console.error(chalk_1.default.yellow('Supported formats: 30m, 1h, 7d, 2w'));
+                            process.exitCode = 1;
+                            return;
+                        }
+                        listParams.from = recentTs;
+                    }
+                    else if (options.after) {
+                        // Validate BEFORE treating as a filter (SEC delta): a typo'd date
+                        // (e.g. --after notadate) must NOT silently count toward
+                        // hasFilters and skip the --i-know-this-deletes-everything gate —
+                        // if the server then ignored the unparseable bound, --all would
+                        // wipe everything past the extra-token guard on an operator typo.
+                        // Mirror --recent: error and exit on parse failure.
+                        if (!isValidIsoDate(options.after)) {
+                            console.error(chalk_1.default.red(`Error: --after is not a valid date: ${options.after}`));
+                            console.error(chalk_1.default.yellow('Provide an ISO 8601 date (e.g. 2026-07-01 or 2026-07-01T00:00:00Z).'));
+                            process.exitCode = 1;
+                            return;
+                        }
+                        listParams.from = options.after;
+                    }
+                    if (options.before) {
+                        if (!isValidIsoDate(options.before)) {
+                            console.error(chalk_1.default.red(`Error: --before is not a valid date: ${options.before}`));
+                            console.error(chalk_1.default.yellow('Provide an ISO 8601 date (e.g. 2026-07-01 or 2026-07-01T00:00:00Z).'));
+                            process.exitCode = 1;
+                            return;
+                        }
+                        listParams.to = options.before;
+                    }
+                    if (options.topics) {
+                        listParams.topics = options.topics
+                            .split(',')
+                            .map((t) => t.trim())
+                            .filter((t) => t.length > 0)
+                            .join(',');
+                    }
+                    const hasFilters = Object.keys(listParams).length > 0;
+                    if (!hasFilters) {
+                        // Emit the "delete EVERYTHING" warning to stderr REGARDLESS of
+                        // format — the automation (--format json) path is exactly where it
+                        // matters most, and stderr keeps stdout pure (SEC SHOULD-FIX).
+                        console.error(chalk_1.default.yellow('--all: no filters supplied — this will delete EVERY memory you own.'));
+                        // Unfiltered --all in non-interactive mode requires a DISTINCT
+                        // explicit token in addition to --yes (mirrors the --force
+                        // non-interactive block). No bypass.
+                        const nonInteractive = !process.stdin.isTTY || process.env.MX_PROFILE === 'ai';
+                        if (nonInteractive && !options.iKnowThisDeletesEverything) {
+                            console.error(chalk_1.default.red('Error: Unfiltered --all in non-interactive mode requires --i-know-this-deletes-everything (in addition to --yes).'));
+                            console.error(chalk_1.default.yellow('Add a filter (--recent/--topics/--before/--after) or pass --i-know-this-deletes-everything to proceed.'));
+                            process.exitCode = 1;
+                            return;
+                        }
+                    }
+                    const listSpinner = (0, spinner_1.createSpinner)('Collecting memories to delete...', options.format).start();
+                    const allIds = await collectAllMemoryIds((params) => (0, api_client_1.getSdk)().memories.listMemories(params), listParams);
+                    listSpinner.stop();
+                    if (allIds.length === 0) {
+                        console.error(chalk_1.default.yellow('No memories matched — nothing to delete.'));
+                        if (options.format === 'json') {
+                            process.stdout.write(JSON.stringify({
+                                deleted: 0,
+                                failed: 0,
+                                errors: [],
+                                requestCount: 0,
+                                aborted: false,
+                                notAttempted: 0,
+                            }) + '\n');
+                        }
+                        return;
+                    }
+                    await handleBatchDelete(allIds, options, 'all');
+                    return;
+                }
+                let batchIds = [];
+                if (batchProvided) {
+                    batchIds = parseBatchIds(options.batch);
+                }
+                else if (stdinProvided) {
+                    batchIds = await readIdsFromStdin();
+                }
+                await handleBatchDelete(batchIds, options, batchProvided ? 'batch' : 'stdin');
+                return;
+            }
+            // ── Single delete (unchanged behavior) ──────────────────────────────
+            if (!id) {
+                console.error(chalk_1.default.red('Error: Provide a memory ID, or use --batch/--stdin/--all.'));
+                process.exitCode = 1;
+                return;
+            }
             // Block --force in non-interactive/agent mode to prevent automated bulk deletion
             if (options.force && isNonInteractive) {
                 console.error(chalk_1.default.red('Error: The --force flag is blocked in non-interactive/agent mode for safety.'));
@@ -1110,9 +1664,25 @@ function registerMemoriesCommands(program) {
                     return;
                 }
             }
-            // Non-interactive without --force: auto-confirm single delete
+            // Non-interactive without --force: auto-confirm single delete — but
+            // check the cross-process bulk-delete guard first (P0 #4144 fix-forward).
+            // An agent looping `mx memories delete <id>` in separate processes would
+            // bypass any in-process counter; this file-based guard catches it.
+            if (isNonInteractive) {
+                const guardPath = getBulkDeleteGuardPath();
+                const now = Date.now();
+                if (!checkBulkDeleteGuard(guardPath, now)) {
+                    process.exitCode = 1;
+                    return;
+                }
+            }
             const spinner = (0, spinner_1.createSpinner)('Deleting memory...', 'table').start();
             await (0, api_client_1.getSdk)().memories.deleteMemory(id);
+            // Record this deletion in the cross-process guard file so the next
+            // invocation's threshold check reflects it.
+            if (isNonInteractive) {
+                recordDeletion(getBulkDeleteGuardPath(), Date.now());
+            }
             spinner.succeed(`Memory ${id} deleted successfully`);
         }
         catch (error) {