monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/dist/src/utils/input-guards.d.ts

@@ -1,66 +0,0 @@
-/**
- * Input validation and prompt-injection guards.
- *
- * Inlined from the former @monomind/security package. Provides a single
- * typed entry point for input validation covering string, number, path,
- * url, and orgName types, plus a heuristic prompt-injection detector
- * for untrusted external content.
- *
- * @module @monomind/cli/utils/input-guards
- */
-export interface ValidationResult {
-    valid: boolean;
-    error?: string;
-    sanitized?: string;
-}
-export interface ValidateInputOpts {
-    type: 'string' | 'number' | 'path' | 'url' | 'orgName';
-    maxLength?: number;
-    required?: boolean;
-}
-/** Resolve symlinks so the containment check below can't be bypassed by a
- * link that lexically resolves inside cwd but physically points outside it
- * (e.g. `./link -> /etc`). `realpathSync` requires the full path to exist,
- * which a not-yet-created file (or a symlinked *directory* holding a
- * not-yet-created file) would fail — so walk up to the longest existing
- * ancestor, realpath *that* (resolving any symlink components in it), and
- * re-append the non-existent tail. Falls back to the lexical path only when
- * no ancestor at all can be resolved. */
-export declare function realOrResolved(p: string): string;
-/**
- * Validate and sanitize an input value.
- *
- * @example
- * const result = validateInput(req.body.name, { type: 'orgName' });
- * if (!result.valid) throw new Error(result.error);
- * const safeName = result.sanitized!;
- */
-export declare function validateInput(value: unknown, opts: ValidateInputOpts): ValidationResult;
-export interface ExternalContentResult {
-    safe: boolean;
-    reason?: string;
-}
-/**
- * Heuristically check whether `content` contains prompt-injection
- * patterns. This is a structural / regex-based guard — it does not
- * call any LLM.
- *
- * This is defense-in-depth, not a security boundary: a rephrased or
- * non-English injection attempt can trivially evade a fixed pattern list.
- * Do not rely on this as the sole safeguard for content that then gets
- * treated as trusted/authoritative — pair it with least-privilege handling
- * of whatever downstream action the content can influence.
- *
- * @param content - The untrusted string to inspect.
- * @param source  - Optional label describing where the content came
- *                  from (used only in log-friendly diagnostics, not
- *                  in the returned reason).
- * @returns `{ safe: true }` when no injection signal is found, or
- *          `{ safe: false, reason }` describing the first match.
- *
- * @example
- * const check = await validateExternalContent(userQuery, 'memory search');
- * if (!check.safe) throw new Error(`Blocked: ${check.reason}`);
- */
-export declare function validateExternalContent(content: string, source?: string): Promise<ExternalContentResult>;
-//# sourceMappingURL=input-guards.d.ts.map

package/packages/@monomind/cli/dist/src/utils/input-guards.js

@@ -1,263 +0,0 @@
-/**
- * Input validation and prompt-injection guards.
- *
- * Inlined from the former @monomind/security package. Provides a single
- * typed entry point for input validation covering string, number, path,
- * url, and orgName types, plus a heuristic prompt-injection detector
- * for untrusted external content.
- *
- * @module @monomind/cli/utils/input-guards
- */
-import { resolve, isAbsolute, relative, dirname, basename } from 'node:path';
-import { cwd } from 'node:process';
-import { realpathSync } from 'node:fs';
-/**
- * Strip C0 and C1 control characters (U+0000–U+001F, U+007F–U+009F)
- * but preserve printable ASCII and extended Unicode.
- */
-function stripControlChars(s) {
-    // eslint-disable-next-line no-control-regex
-    return s.replace(/[\x00-\x1F\x7F-\x9F]/g, '');
-}
-function validateString(value, opts) {
-    if (typeof value !== 'string') {
-        if (opts.required !== false && value == null) {
-            return { valid: false, error: 'Value is required' };
-        }
-        return { valid: false, error: 'Value must be a string' };
-    }
-    if (opts.required !== false && value.length === 0) {
-        return { valid: false, error: 'Value must not be empty' };
-    }
-    const maxLen = opts.maxLength ?? 4096;
-    if (value.length > maxLen) {
-        return {
-            valid: false,
-            error: `Value exceeds maximum length of ${maxLen}`,
-        };
-    }
-    const sanitized = stripControlChars(value);
-    return { valid: true, sanitized };
-}
-function validateNumber(value, opts) {
-    const parsed = typeof value === 'number'
-        ? value
-        : typeof value === 'string' && value.trim() !== ''
-            ? Number(value)
-            : NaN;
-    if (!Number.isFinite(parsed)) {
-        if (opts.required === false && value == null) {
-            return { valid: true };
-        }
-        return { valid: false, error: 'Value must be a finite number' };
-    }
-    return { valid: true, sanitized: String(parsed) };
-}
-/** Resolve symlinks so the containment check below can't be bypassed by a
- * link that lexically resolves inside cwd but physically points outside it
- * (e.g. `./link -> /etc`). `realpathSync` requires the full path to exist,
- * which a not-yet-created file (or a symlinked *directory* holding a
- * not-yet-created file) would fail — so walk up to the longest existing
- * ancestor, realpath *that* (resolving any symlink components in it), and
- * re-append the non-existent tail. Falls back to the lexical path only when
- * no ancestor at all can be resolved. */
-export function realOrResolved(p) {
-    let cur = p;
-    const tail = [];
-    // eslint-disable-next-line no-constant-condition
-    for (let i = 0; i < 64; i++) {
-        try {
-            const real = realpathSync(cur);
-            return tail.length ? resolve(real, ...tail.reverse()) : real;
-        }
-        catch {
-            const parent = dirname(cur);
-            if (parent === cur)
-                return p; // reached filesystem root, nothing resolvable
-            tail.push(basename(cur));
-            cur = parent;
-        }
-    }
-    return p;
-}
-function validatePath(value, opts) {
-    if (typeof value !== 'string') {
-        return { valid: false, error: 'Path must be a string' };
-    }
-    if (value.includes('\0')) {
-        return { valid: false, error: 'Path must not contain null bytes' };
-    }
-    // Reject traversal segments
-    if (/(^|[\\/])\.\.($|[\\/])/.test(value)) {
-        return { valid: false, error: 'Path must not contain directory traversal (..)' };
-    }
-    // Reject absolute paths that escape cwd. Uses path.relative (platform-correct
-    // separator handling — the previous `startsWith(cwd + '/')` hardcoded POSIX
-    // '/' and rejected every legitimate path on Windows) plus realpathSync on
-    // both sides so a symlink that's lexically inside cwd but physically points
-    // outside it is caught too. Mirrors the pattern in
-    // src/memory/memory-bridge.ts's getDbPath().
-    if (isAbsolute(value)) {
-        const cwdPath = realOrResolved(cwd());
-        const resolved = realOrResolved(resolve(value));
-        const rel = relative(cwdPath, resolved);
-        if (rel.startsWith('..') || isAbsolute(rel)) {
-            return { valid: false, error: 'Absolute path must not escape the current working directory' };
-        }
-    }
-    const maxLen = opts.maxLength ?? 4096;
-    if (value.length > maxLen) {
-        return { valid: false, error: `Path exceeds maximum length of ${maxLen}` };
-    }
-    return { valid: true, sanitized: value };
-}
-function validateUrl(value, opts) {
-    if (typeof value !== 'string') {
-        return { valid: false, error: 'URL must be a string' };
-    }
-    let parsed;
-    try {
-        parsed = new URL(value);
-    }
-    catch {
-        return { valid: false, error: 'Value is not a valid URL' };
-    }
-    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-        return { valid: false, error: 'URL must use http or https protocol' };
-    }
-    const maxLen = opts.maxLength ?? 4096;
-    if (value.length > maxLen) {
-        return { valid: false, error: `URL exceeds maximum length of ${maxLen}` };
-    }
-    return { valid: true, sanitized: parsed.toString() };
-}
-/** Org name: lowercase alphanumeric + hyphens, 1–64 chars, must start with alnum */
-const ORG_NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
-function validateOrgName(value, _opts) {
-    if (typeof value !== 'string') {
-        return { valid: false, error: 'Org name must be a string' };
-    }
-    if (!ORG_NAME_RE.test(value)) {
-        return {
-            valid: false,
-            error: 'Org name must match ^[a-z0-9][a-z0-9-]{0,63}$ (lowercase, alphanumeric + hyphens, 1–64 chars)',
-        };
-    }
-    return { valid: true, sanitized: value };
-}
-/**
- * Validate and sanitize an input value.
- *
- * @example
- * const result = validateInput(req.body.name, { type: 'orgName' });
- * if (!result.valid) throw new Error(result.error);
- * const safeName = result.sanitized!;
- */
-export function validateInput(value, opts) {
-    switch (opts.type) {
-        case 'string':
-            return validateString(value, opts);
-        case 'number':
-            return validateNumber(value, opts);
-        case 'path':
-            return validatePath(value, opts);
-        case 'url':
-            return validateUrl(value, opts);
-        case 'orgName':
-            return validateOrgName(value, opts);
-    }
-}
-/**
- * Case-insensitive patterns that indicate an attempt to override
- * system-level instructions or inject prompt directives.
- */
-const INJECTION_PATTERNS = [
-    { re: /ignore\s+(all\s+)?previous\s+instructions/i, label: 'instruction override ("ignore previous instructions")' },
-    { re: /ignore\s+(all\s+)?prior\s+instructions/i, label: 'instruction override ("ignore prior instructions")' },
-    { re: /disregard\s+(all\s+)?(previous|prior|above)\s+instructions/i, label: 'instruction override ("disregard instructions")' },
-    { re: /forget\s+(all\s+)?(previous|prior|above)\s+(instructions|context)/i, label: 'instruction override ("forget instructions")' },
-    { re: /you\s+are\s+now\b/i, label: 'identity hijack ("you are now")' },
-    { re: /act\s+as\s+(if\s+you\s+are|a|an)\b/i, label: 'identity hijack ("act as")' },
-    { re: /pretend\s+(you\s+are|to\s+be)\b/i, label: 'identity hijack ("pretend to be")' },
-    { re: /^system\s*:/im, label: 'system prompt injection ("system:")' },
-    { re: /\[system\]/i, label: 'system prompt injection ("[system]")' },
-    { re: /<<\s*system\s*>>/i, label: 'system prompt injection ("<<system>>")' },
-    { re: /^IMPORTANT\s*:/im, label: 'directive injection ("IMPORTANT:")' },
-    { re: /^INSTRUCTION\s*:/im, label: 'directive injection ("INSTRUCTION:")' },
-    { re: /^OVERRIDE\s*:/im, label: 'directive injection ("OVERRIDE:")' },
-    { re: /\bdo\s+not\s+follow\s+(any\s+)?(previous|prior|earlier)\b/i, label: 'instruction override ("do not follow previous")' },
-    { re: /\bnew\s+instructions?\s*:/i, label: 'directive injection ("new instructions:")' },
-];
-/**
- * Suspicious encoding patterns that may attempt to smuggle directives
- * through Base64, hex escapes, or Unicode homoglyphs.
- */
-const ENCODING_PATTERNS = [
-    // Large Base64 blobs (>80 chars of contiguous base64 alphabet)
-    { re: /[A-Za-z0-9+/=]{80,}/, label: 'suspicious Base64-encoded blob' },
-    // Excessive hex escapes (\x41\x42...)
-    { re: /(\\x[0-9a-fA-F]{2}){6,}/, label: 'suspicious hex-escape sequence' },
-    // Excessive Unicode escapes (AB...)
-    { re: /(\\u[0-9a-fA-F]{4}){6,}/, label: 'suspicious Unicode-escape sequence' },
-];
-/** Threshold ratio of uppercase + directive-like words to total words. */
-const DIRECTIVE_DENSITY_THRESHOLD = 0.4;
-const DIRECTIVE_WORDS = /\b(MUST|SHALL|ALWAYS|NEVER|IMPORTANT|OVERRIDE|IMMEDIATELY|MANDATORY|REQUIRED|CRITICAL)\b/g;
-/**
- * Heuristically check whether `content` contains prompt-injection
- * patterns. This is a structural / regex-based guard — it does not
- * call any LLM.
- *
- * This is defense-in-depth, not a security boundary: a rephrased or
- * non-English injection attempt can trivially evade a fixed pattern list.
- * Do not rely on this as the sole safeguard for content that then gets
- * treated as trusted/authoritative — pair it with least-privilege handling
- * of whatever downstream action the content can influence.
- *
- * @param content - The untrusted string to inspect.
- * @param source  - Optional label describing where the content came
- *                  from (used only in log-friendly diagnostics, not
- *                  in the returned reason).
- * @returns `{ safe: true }` when no injection signal is found, or
- *          `{ safe: false, reason }` describing the first match.
- *
- * @example
- * const check = await validateExternalContent(userQuery, 'memory search');
- * if (!check.safe) throw new Error(`Blocked: ${check.reason}`);
- */
-export async function validateExternalContent(content, source) {
-    if (typeof content !== 'string') {
-        return { safe: false, reason: 'Content must be a string' };
-    }
-    // Empty / very short content is trivially safe.
-    if (content.length === 0) {
-        return { safe: true };
-    }
-    // --- 1. Direct injection patterns ---
-    for (const { re, label } of INJECTION_PATTERNS) {
-        if (re.test(content)) {
-            return { safe: false, reason: `Prompt injection detected: ${label}` };
-        }
-    }
-    // --- 2. Suspicious encoding ---
-    for (const { re, label } of ENCODING_PATTERNS) {
-        if (re.test(content)) {
-            return { safe: false, reason: `Suspicious encoding: ${label}` };
-        }
-    }
-    // --- 3. Directive density ---
-    // Only check strings long enough to be meaningful (>20 words).
-    const words = content.split(/\s+/).filter(Boolean);
-    if (words.length > 20) {
-        const matches = content.match(DIRECTIVE_WORDS);
-        const density = (matches?.length ?? 0) / words.length;
-        if (density >= DIRECTIVE_DENSITY_THRESHOLD) {
-            return {
-                safe: false,
-                reason: `Excessive directive density (${(density * 100).toFixed(0)}% directive keywords)`,
-            };
-        }
-    }
-    return { safe: true };
-}
-//# sourceMappingURL=input-guards.js.map

package/packages/@monomind/cli/dist/src/utils/json-file.d.ts

@@ -1,33 +0,0 @@
-/**
- * Shared atomic JSON file I/O utility.
- *
- * Previously duplicated across 10+ files with the same
- * writeFileSync(tmp) + renameSync(tmp, path) pattern:
- *   - mcp-tools/neural-tools.ts
- *   - memory/intelligence.ts
- *   - autopilot-state.ts
- *   - commands/claims.ts
- *   - commands/swarm.ts
- *   - commands/neural-optimize.ts
- *   - commands/neural-registry.ts
- *   - commands/agent-lifecycle.ts
- *   - commands/memory-admin.ts
- *   - commands/memory-list.ts
- *   - commands/security-cve.ts
- *
- * This is the single canonical implementation. Uses atomic
- * rename to prevent partial writes on crash.
- */
-/**
- * Read and parse a JSON file. Returns `fallback` if file doesn't exist,
- * exceeds maxBytes, or fails to parse.
- */
-export declare function readJsonFileSync<T>(filePath: string, fallback: T, maxBytes?: number): T;
-/**
- * Atomically write a JSON value to disk.
- *
- * Writes to a temporary file first (PID + timestamp suffix to avoid
- * collisions), then renames into place. Ensures the directory exists.
- */
-export declare function writeJsonFileAtomic(filePath: string, data: unknown, pretty?: boolean): void;
-//# sourceMappingURL=json-file.d.ts.map

package/packages/@monomind/cli/dist/src/utils/json-file.js

@@ -1,57 +0,0 @@
-/**
- * Shared atomic JSON file I/O utility.
- *
- * Previously duplicated across 10+ files with the same
- * writeFileSync(tmp) + renameSync(tmp, path) pattern:
- *   - mcp-tools/neural-tools.ts
- *   - memory/intelligence.ts
- *   - autopilot-state.ts
- *   - commands/claims.ts
- *   - commands/swarm.ts
- *   - commands/neural-optimize.ts
- *   - commands/neural-registry.ts
- *   - commands/agent-lifecycle.ts
- *   - commands/memory-admin.ts
- *   - commands/memory-list.ts
- *   - commands/security-cve.ts
- *
- * This is the single canonical implementation. Uses atomic
- * rename to prevent partial writes on crash.
- */
-import { readFileSync, writeFileSync, renameSync, existsSync, statSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
-/**
- * Read and parse a JSON file. Returns `fallback` if file doesn't exist,
- * exceeds maxBytes, or fails to parse.
- */
-export function readJsonFileSync(filePath, fallback, maxBytes = 50 * 1024 * 1024) {
-    try {
-        if (!existsSync(filePath))
-            return fallback;
-        const stat = statSync(filePath);
-        if (stat.size > maxBytes)
-            return fallback;
-        const raw = readFileSync(filePath, 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return fallback;
-    }
-}
-/**
- * Atomically write a JSON value to disk.
- *
- * Writes to a temporary file first (PID + timestamp suffix to avoid
- * collisions), then renames into place. Ensures the directory exists.
- */
-export function writeJsonFileAtomic(filePath, data, pretty = true) {
-    const dir = dirname(filePath);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    const content = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
-    const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tmp, content, 'utf-8');
-    renameSync(tmp, filePath);
-}
-//# sourceMappingURL=json-file.js.map

package/packages/@monomind/cli/dist/src/utils/parse-jsonl.d.ts

@@ -1,6 +0,0 @@
-/**
- * Parse a JSONL (newline-delimited JSON) string, skipping malformed lines.
- * Never throws — bad lines are silently dropped.
- */
-export declare function parseJsonl<T>(content: string): T[];
-//# sourceMappingURL=parse-jsonl.d.ts.map

package/packages/@monomind/cli/dist/src/utils/parse-jsonl.js

@@ -1,22 +0,0 @@
-/**
- * Parse a JSONL (newline-delimited JSON) string, skipping malformed lines.
- * Never throws — bad lines are silently dropped.
- */
-export function parseJsonl(content) {
-    if (!content.trim())
-        return [];
-    return content
-        .split('\n')
-        .flatMap((line) => {
-        const trimmed = line.trim();
-        if (!trimmed)
-            return [];
-        try {
-            return [JSON.parse(trimmed)];
-        }
-        catch {
-            return [];
-        }
-    });
-}
-//# sourceMappingURL=parse-jsonl.js.map

package/packages/@monomind/cli/dist/src/utils/resource-governor.d.ts

@@ -1,32 +0,0 @@
-export interface ResourceLimits {
-    /** Minimum free memory (bytes) required before spawning. Default: 15% of total. */
-    minFreeMemBytes: number;
-    /** Maximum concurrent claude-agent-sdk processes across all orgs. Default: cpus - 2, min 2. */
-    maxSdkProcesses: number;
-    /** Delay between sequential agent spawns (ms). Default: 2000. */
-    spawnStaggerMs: number;
-}
-export declare function configureResourceLimits(o: Partial<ResourceLimits>): void;
-export declare function getResourceLimits(): ResourceLimits;
-/** Available memory in bytes — free + reclaimable (inactive/speculative/purgeable on macOS).
- *  os.freemem() on macOS returns only wired-free pages, which is near-zero on
- *  a warm system even though GB of file-cache are instantly reclaimable. */
-export declare function getAvailableMemBytes(): number;
-export declare function countSdkProcesses(): number;
-export interface ResourceCheck {
-    ok: boolean;
-    freeMemMB: number;
-    freeMemPct: number;
-    sdkProcesses: number;
-    maxSdkProcesses: number;
-    reason?: string;
-}
-export declare function checkResources(): ResourceCheck;
-/** Wait until resources are available, with a timeout. Returns false if timed out. */
-export declare function waitForCapacity(timeoutMs?: number): Promise<ResourceCheck>;
-/** Kill orphaned claude-agent-sdk processes.
- *  @param protectedPids PIDs to never kill (e.g. sibling org agents).
- *  @param ownerPid Only kill SDK processes whose parent is this PID.
- *    Prevents killing agents from OTHER monomind org processes. */
-export declare function reapOrphanedSdkProcesses(protectedPids: Set<number>, ownerPid?: number): number;
-//# sourceMappingURL=resource-governor.d.ts.map

package/packages/@monomind/cli/dist/src/utils/resource-governor.js

@@ -1,115 +0,0 @@
-// packages/@monomind/cli/src/utils/resource-governor.ts
-// monolean: single-module resource gate — upgrade path = cgroup integration
-import { freemem, totalmem, cpus, platform } from 'node:os';
-import { execSync } from 'node:child_process';
-const defaults = () => ({
-    minFreeMemBytes: parseInt(process.env.MONOMIND_MIN_FREE_MEM_MB || '0', 10) * 1024 * 1024
-        || Math.floor(totalmem() * 0.15),
-    maxSdkProcesses: parseInt(process.env.MONOMIND_MAX_SDK_PROCS || '0', 10)
-        || Math.max(2, cpus().length - 2),
-    spawnStaggerMs: parseInt(process.env.MONOMIND_SPAWN_STAGGER_MS || '0', 10) || 2000,
-});
-let overrides = {};
-export function configureResourceLimits(o) {
-    overrides = { ...overrides, ...o };
-}
-export function getResourceLimits() {
-    return { ...defaults(), ...overrides };
-}
-/** Available memory in bytes — free + reclaimable (inactive/speculative/purgeable on macOS).
- *  os.freemem() on macOS returns only wired-free pages, which is near-zero on
- *  a warm system even though GB of file-cache are instantly reclaimable. */
-export function getAvailableMemBytes() {
-    if (platform() === 'darwin') {
-        try {
-            const out = execSync('vm_stat', { encoding: 'utf8', timeout: 3000 });
-            const page = (out.match(/page size of (\d+)/) ?? [])[1];
-            const free = (out.match(/Pages free:\s+(\d+)/) ?? [])[1];
-            const inactive = (out.match(/Pages inactive:\s+(\d+)/) ?? [])[1];
-            const speculative = (out.match(/Pages speculative:\s+(\d+)/) ?? [])[1];
-            const purgeable = (out.match(/Pages purgeable:\s+(\d+)/) ?? [])[1];
-            if (page && free) {
-                const ps = parseInt(page, 10);
-                return ps * (parseInt(free, 10) + parseInt(inactive || '0', 10) + parseInt(speculative || '0', 10) + parseInt(purgeable || '0', 10));
-            }
-        }
-        catch { /* fall through */ }
-    }
-    return freemem();
-}
-export function countSdkProcesses() {
-    try {
-        // Match only actual SDK agent binaries (have --output-format in argv),
-        // not processes that merely reference the SDK package path.
-        const out = execSync('pgrep -f "claude-agent-sdk.*--output-format"', { encoding: 'utf8', timeout: 5000 });
-        return out.trim().split('\n').filter(Boolean).length;
-    }
-    catch {
-        return 0;
-    } // pgrep exits 1 when no matches
-}
-export function checkResources() {
-    const limits = getResourceLimits();
-    const free = getAvailableMemBytes();
-    const total = totalmem();
-    const freeMemMB = Math.round(free / 1024 / 1024);
-    const freeMemPct = Math.round((free / total) * 100);
-    const sdkProcesses = countSdkProcesses();
-    if (free < limits.minFreeMemBytes) {
-        return {
-            ok: false, freeMemMB, freeMemPct, sdkProcesses,
-            maxSdkProcesses: limits.maxSdkProcesses,
-            reason: `low memory: ${freeMemMB}MB free (${freeMemPct}%), need ${Math.round(limits.minFreeMemBytes / 1024 / 1024)}MB`,
-        };
-    }
-    if (sdkProcesses >= limits.maxSdkProcesses) {
-        return {
-            ok: false, freeMemMB, freeMemPct, sdkProcesses,
-            maxSdkProcesses: limits.maxSdkProcesses,
-            reason: `too many SDK processes: ${sdkProcesses}/${limits.maxSdkProcesses}`,
-        };
-    }
-    return { ok: true, freeMemMB, freeMemPct, sdkProcesses, maxSdkProcesses: limits.maxSdkProcesses };
-}
-/** Wait until resources are available, with a timeout. Returns false if timed out. */
-export async function waitForCapacity(timeoutMs = 60_000) {
-    const start = Date.now();
-    while (Date.now() - start < timeoutMs) {
-        const check = checkResources();
-        if (check.ok)
-            return check;
-        await new Promise(r => { const t = setTimeout(r, 3000); t.unref?.(); });
-    }
-    return checkResources();
-}
-/** Kill orphaned claude-agent-sdk processes.
- *  @param protectedPids PIDs to never kill (e.g. sibling org agents).
- *  @param ownerPid Only kill SDK processes whose parent is this PID.
- *    Prevents killing agents from OTHER monomind org processes. */
-export function reapOrphanedSdkProcesses(protectedPids, ownerPid) {
-    try {
-        const out = execSync('ps -eo pid,ppid,command', { encoding: 'utf8', timeout: 5000 });
-        let reaped = 0;
-        for (const line of out.split('\n')) {
-            if (!line.includes('claude-agent-sdk') || !line.includes('--output-format'))
-                continue;
-            const parts = line.trim().split(/\s+/);
-            const pid = parseInt(parts[0], 10);
-            const ppid = parseInt(parts[1], 10);
-            if (isNaN(pid) || protectedPids.has(pid))
-                continue;
-            if (ownerPid != null && ppid !== ownerPid)
-                continue;
-            try {
-                process.kill(pid, 'SIGTERM');
-                reaped++;
-            }
-            catch { /* already dead */ }
-        }
-        return reaped;
-    }
-    catch {
-        return 0;
-    }
-}
-//# sourceMappingURL=resource-governor.js.map