@actiondock/core 2.10.0 → 2.11.0

package/dist/process/process-manager.js

@@ -1,121 +1,22 @@
-import { createHash } from "node:crypto";
 import { decodeBytes, encodeBytes, } from "@actiondock/sdk";
-import { ACCESS_DENIED, CONTROL_BUSY, CONTROL_REVOKED, INPUT_VALIDATION_FAILED, NOT_FOUND, PROCESS_CANCELLED, PROCESS_LOST, PROCESS_QUARANTINED, PROCESS_SPAWN_ERROR, QUOTA_EXCEEDED, REQUEST_CONFLICT, SERVER_ERROR, UNSUPPORTED_CAPABILITY, INVALID_CURSOR, OUTPUT_UNAVAILABLE, ProcessError, } from "../errors.js";
-import { parseCursor, compareCursorPos } from "./cursor.js";
+import { NOT_FOUND, PROCESS_CANCELLED, PROCESS_LOST, PROCESS_SPAWN_ERROR, REQUEST_CONFLICT, SERVER_ERROR, UNSUPPORTED_CAPABILITY, OUTPUT_UNAVAILABLE, ProcessError, } from "../errors.js";
+import { formatProcessScope, checkOwnerAuthorized, hashRequestPayload, toSdkProcessInfo, toStoredProcessRecord } from "./converters.js";
+import { DiagnosticsSink } from "./diagnostics.js";
+import { ProcessQuotaTracker } from "./quotas.js";
+import { ProcessControlManager } from "./control.js";
 import { ContextProcessAPI } from "./context-process.js";
-import { ControlArbiter } from "./control-arbiter.js";
 import { InputDispatcher } from "./input-dispatcher.js";
-import { DiagnosticsSink } from "./diagnostics-sink.js";
 import { MemoryProcessMetadataStore, } from "./metadata-store.js";
 import { ProcessOutputLog } from "./output-log.js";
 import { ReservationTable, } from "./reservation-table.js";
 import { RunExecutor } from "./run-executor.js";
 import { TerminalOutputCache } from "./terminal-output-cache.js";
-/**
- * 格式化生成作用域唯一隔离字符串。
- */
-export function formatProcessScope(owner) {
-    return `${owner.tenantId}:${owner.principalId}:${owner.packageInstanceId}:${owner.generationId}`;
-}
-/**
- * 校验调用方所有者凭据与目标记录是否完全匹配。
- */
-function checkOwnerAuthorized(owner, target) {
-    if (!owner ||
-        !owner.tenantId ||
-        !owner.principalId ||
-        !owner.packageInstanceId ||
-        !owner.generationId) {
-        throw new ProcessError(ACCESS_DENIED, "Missing required owner identity fields");
-    }
-    if (owner.tenantId !== target.tenantId ||
-        owner.principalId !== target.principalId ||
-        owner.packageInstanceId !== target.packageInstanceId ||
-        owner.generationId !== target.generationId) {
-        throw new ProcessError(ACCESS_DENIED, "Access denied: owner identity mismatch");
-    }
-}
-/**
- * 计算任意 JSON 负载对象的 SHA-256 哈希值。
- */
-function hashRequestPayload(payload) {
-    return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
-}
-/**
- * 将持久化记录转换为 SDK 标准 ProcessInfo 快照。
- */
-function toSdkProcessInfo(record) {
-    const ctrl = (record.control ?? record.controlState ?? "free");
-    const exitDetails = record.exitCode !== undefined || record.exitSignal !== undefined
-        ? { code: record.exitCode ?? null, signal: record.exitSignal ?? null }
-        : undefined;
-    return {
-        id: record.processId,
-        hostEpoch: record.hostEpoch,
-        state: record.state,
-        control: ctrl,
-        io: (record.ioConfig ?? { mode: "pipe" }),
-        capabilities: (record.capabilities ?? {
-            pty: false,
-            resize: false,
-            inputEOF: false,
-            interruptForeground: false,
-            terminationScope: "process",
-        }),
-        createdAt: record.createdAt ?? new Date().toISOString(),
-        exit: exitDetails,
-        endReason: record.endReason,
-        outputClosed: Boolean(record.outputClosed),
-        outputEndReason: record.outputEndReason,
-        effectiveLimits: (record.effectiveLimits ?? {
-            idleMs: 60000,
-            lifetimeMs: 3600000,
-            outputBufferBytes: 4 * 1024 * 1024,
-        }),
-    };
-}
-/**
- * 将内部模型转换为持久化记录。
- */
-function toStoredProcessRecord(owner, info, startRequestId) {
-    return {
-        processId: info.id,
-        tenantId: owner.tenantId,
-        principalId: owner.principalId,
-        packageInstanceId: owner.packageInstanceId,
-        generationId: owner.generationId,
-        hostEpoch: info.hostEpoch,
-        state: info.state,
-        controlState: info.control,
-        control: info.control,
-        ioConfig: info.io,
-        capabilities: info.capabilities,
-        createdAt: info.createdAt,
-        exitCode: info.exit ? info.exit.code : null,
-        exitSignal: info.exit ? info.exit.signal : null,
-        endReason: info.endReason ?? null,
-        outputClosed: info.outputClosed,
-        outputEndReason: info.outputEndReason ?? null,
-        inputClosed: false,
-        effectiveLimits: info.effectiveLimits,
-        startRequestId,
-    };
-}
-/**
- * 校验正整数毫秒时长参数，非法时抛出参数错误。
- */
-function checkPositiveDurationMs(value, field) {
-    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-        throw new ProcessError(INPUT_VALIDATION_FAILED, `Invalid ${field}: must be a positive integer (milliseconds)`, {
-            [field]: value,
-        });
-    }
-}
+export { formatProcessScope } from "./converters.js";
 /**
  * 受管进程核心管理器。
  *
  * 职责范畴：
- * - 宿主身份与配额检查（每作用域活跃进程、每宿主进程、输出缓冲预算、等待者上限、输入队列容量）。
+ * - 宿主身份与配额检查（每宿主进程、单进程输出缓冲上限）。
  * - 严格归属所有者鉴权校验（基于 tenantId, principalId, packageInstanceId, generationId）。
  * - 控制权状态机推进（free -> held -> quarantined -> closed）。
  * - 输入队列去重与串行调度执行。
@@ -139,9 +40,10 @@ export class ProcessManager {
     /** 一次性 run 执行器：仅依赖驱动、错误映射与输入校验，不触碰进程注册表 */
     runExecutor;
     /** 控制权仲裁器：独占控制权状态机全部推进路径的唯一持有者 */
-    controlArbiter;
     /** 输入调度器：输入队列入队、串行调度与接管原语的唯一持有者 */
     inputDispatcher;
+    quotaTracker;
+    controlManager;
     initPromise;
     isShutdown = false;
     constructor(options) {
@@ -149,14 +51,8 @@ export class ProcessManager {
         this.driver = options.driver;
         this.metadataStore = options.metadataStore ?? new MemoryProcessMetadataStore();
         this.quotas = {
-            maxActiveProcessesPerScope: options.quotas?.maxActiveProcessesPerScope ?? 8,
             maxActiveProcessesPerHost: options.quotas?.maxActiveProcessesPerHost ?? 64,
             maxOutputBufferBytesPerProcess: options.quotas?.maxOutputBufferBytesPerProcess ?? 4 * 1024 * 1024,
-            maxOutputBufferBytesPerHost: options.quotas?.maxOutputBufferBytesPerHost ?? 128 * 1024 * 1024,
-            maxPendingQueueBytesPerProcess: options.quotas?.maxPendingQueueBytesPerProcess ?? 1 * 1024 * 1024,
-            maxPendingQueueBytesPerHost: options.quotas?.maxPendingQueueBytesPerHost ?? 16 * 1024 * 1024,
-            maxWaitersPerProcess: options.quotas?.maxWaitersPerProcess ?? 8,
-            maxWaitersPerHost: options.quotas?.maxWaitersPerHost ?? 256,
         };
         this.defaultLimits = {
             idleMs: options.defaultLimits?.idleMs ?? 60000,
@@ -169,33 +65,24 @@ export class ProcessManager {
         this.reservationTable = new ReservationTable();
         this.terminalOutputCache = new TerminalOutputCache({
             retentionMs: this.terminalLogRetentionMs,
-            maxHostBufferBytes: this.quotas.maxOutputBufferBytesPerHost,
         });
         this.runExecutor = new RunExecutor(this.driver);
-        this.controlArbiter = new ControlArbiter({
-            persistState: (processId, patch) => this.persistState(processId, patch),
-            persistGrantReceipt: (grant, wait, proc) => this.persistReceipt({
-                hostEpoch: this.hostEpoch,
-                scope: proc.scope,
-                processId: proc.info.id,
-                requestId: wait.requestId,
-            }, grant, hashRequestPayload({ waitMs: wait.waitMs, ttlMs: wait.ttlMs })),
-            refreshIdleTimer: (proc) => this.refreshIdleTimer(proc),
-            quarantineProcess: (owner, processId, token, reason) => this.quarantineProcess(owner, processId, token, reason),
-            countHostAcquireWaiters: () => this.countHostAcquireWaiters(),
-            maxWaitersPerProcess: this.quotas.maxWaitersPerProcess,
-            maxWaitersPerHost: this.quotas.maxWaitersPerHost,
-        });
         this.inputDispatcher = new InputDispatcher({
             persistReceipt: (key, receipt, payloadHash) => this.persistReceipt(key, receipt, payloadHash),
             persistState: (processId, patch) => this.persistState(processId, patch),
-            quarantineProcess: (owner, processId, token, reason) => this.quarantineProcess(owner, processId, token, reason),
+            quarantineProcess: (owner, processId, reason) => this.quarantineProcess(owner, processId, reason),
             refreshIdleTimer: (proc) => this.refreshIdleTimer(proc),
             recordDiagnostic: (message, err) => this.recordDiagnostic(message, err),
-            countHostPendingInputBytes: () => this.countHostPendingInputBytes(),
-            maxPendingQueueBytesPerProcess: this.quotas.maxPendingQueueBytesPerProcess,
-            maxPendingQueueBytesPerHost: this.quotas.maxPendingQueueBytesPerHost,
-        }, this.controlArbiter);
+        });
+        this.quotaTracker = new ProcessQuotaTracker({
+            processes: this.processes,
+            quotas: this.quotas,
+            defaultLimits: this.defaultLimits,
+        });
+        this.controlManager = new ProcessControlManager({
+            persistState: (processId, patch) => this.persistState(processId, patch),
+            takeoverQueue: (proc, reason) => this.inputDispatcher.takeoverQueue(proc, reason)
+        });
     }
     /**
      * 初始化宿主环境，原子性收敛旧宿主遗留的非终态进程。
@@ -293,10 +180,6 @@ export class ProcessManager {
         }
         // 防御性清理残余定时器（stop 内部已清理，此处兜底）
         for (const proc of this.processes.values()) {
-            if (proc.ttlTimer) {
-                clearTimeout(proc.ttlTimer);
-                proc.ttlTimer = undefined;
-            }
             if (proc.idleTimer) {
                 clearTimeout(proc.idleTimer);
                 proc.idleTimer = undefined;
@@ -356,7 +239,7 @@ export class ProcessManager {
                 return cached;
             }
             // 宿主与作用域配额检查
-            this.checkSpawnQuotas(scope, input.limits?.outputBufferBytes);
+            this.quotaTracker.checkSpawnQuotas(scope, input.limits?.outputBufferBytes);
             // 驱动能力校验
             const caps = this.driver.getCapabilities();
             if (input.spec.io.mode === "pty" && !caps.pty) {
@@ -370,7 +253,6 @@ export class ProcessManager {
             };
             const outputLog = new ProcessOutputLog(this.hostEpoch, processId, {
                 maxBufferBytes: effectiveLimits.outputBufferBytes,
-                maxWaiters: this.quotas.maxWaitersPerProcess,
             });
             const info = {
                 id: processId,
@@ -388,11 +270,8 @@ export class ProcessManager {
                 owner: { ...owner },
                 scope,
                 outputLog,
-                controlEpoch: 0,
                 cancelEpoch: 0,
                 inputQueue: [],
-                pendingInputBytes: 0,
-                acquireWaiters: [],
                 inputClosed: false,
                 isDispatching: false,
                 effectiveLimits,
@@ -552,106 +431,6 @@ export class ProcessManager {
             nextPageToken: res.nextPageToken,
         };
     }
-    /**
-     * 申请指定受管进程的独占控制令牌。
-     */
-    async acquire(owner, id, input, call, runId) {
-        checkPositiveDurationMs(input.waitMs, "waitMs");
-        checkPositiveDurationMs(input.ttlMs, "ttlMs");
-        await this.ensureInitialized();
-        this.assertNotShutdown();
-        const proc = await this.getOrLoadProcess(owner, id);
-        if (proc.info.state === "exited" ||
-            proc.info.state === "failed" ||
-            proc.info.state === "lost") {
-            throw new ProcessError(CONTROL_REVOKED, "Process has terminated");
-        }
-        if (proc.info.control === "quarantined") {
-            throw new ProcessError(PROCESS_QUARANTINED, "Process is in quarantined state");
-        }
-        if (proc.info.control === "closed") {
-            throw new ProcessError(CONTROL_REVOKED, "Process control is closed");
-        }
-        const key = {
-            hostEpoch: this.hostEpoch,
-            scope: proc.scope,
-            processId: id,
-            requestId: input.requestId,
-        };
-        const payloadHash = hashRequestPayload({ waitMs: input.waitMs, ttlMs: input.ttlMs });
-        // 同步预占幂等请求，跨 await 窗口内拦截并发同 requestId 双重授权
-        const inFlight = this.reserveRequest(key, payloadHash, "acquire");
-        if (inFlight) {
-            return (await inFlight.promise);
-        }
-        try {
-            // 幂等去重检查
-            const existing = await this.metadataStore.getRequest(key);
-            if (existing) {
-                if (existing.payloadHash !== payloadHash) {
-                    throw new ProcessError(REQUEST_CONFLICT, "Request conflict: identical requestId with different payload", {
-                        requestId: input.requestId,
-                    });
-                }
-                const cached = existing.receipt;
-                this.commitReservation(key, "acquire", cached);
-                return cached;
-            }
-            // 控制权仲裁：空闲且无等待者时直接授予，否则 FIFO 排队等待
-            // 排队路径凭据由唤醒方落盘；原请求 resolve 后在此处结算预约，保持两阶段时序不变
-            const outcome = this.controlArbiter.tryAcquire(proc, { requestId: input.requestId, waitMs: input.waitMs, ttlMs: input.ttlMs }, call, runId);
-            const grant = await outcome.waiter;
-            if (outcome.granted) {
-                await this.metadataStore.recordRequest(key, grant, payloadHash);
-            }
-            this.commitReservation(key, "acquire", grant);
-            return grant;
-        }
-        catch (err) {
-            // 失败路径：以原始错误结算预占，等待同 requestId 的并发调用方收到真实失败原因而非固定冲突错误
-            this.rejectReservation(key, "acquire", err);
-            throw err;
-        }
-        finally {
-            // 成功路径已在 commit 中移除预占；失败路径已在 catch 中以原始错误结算；
-            // 此处仅为既未 commit 也未 reject 的异常逃逸路径释放预占并唤醒等待方
-            this.rejectReservation(key, "acquire", new ProcessError(REQUEST_CONFLICT, "Concurrent acquire request did not produce a result", { requestId: input.requestId }));
-        }
-    }
-    /**
-     * 延长当前有效控制令牌的存活时间。
-     */
-    async renew(owner, id, token, ttlMs, call) {
-        checkPositiveDurationMs(ttlMs, "ttlMs");
-        await this.ensureInitialized();
-        const proc = await this.getOrLoadProcess(owner, id);
-        // 提交前校验持有凭据有效性，随后由仲裁器清理旧定时器并设置新定时器
-        this.controlArbiter.validateHeldGrant(proc, token);
-        return this.controlArbiter.renewGrant(proc, ttlMs);
-    }
-    /**
-     * 显式释放控制令牌，允许后续控制者申请。
-     */
-    async release(owner, id, token, call) {
-        await this.ensureInitialized();
-        const proc = await this.getOrLoadProcess(owner, id);
-        // 提交前校验持有凭据有效性
-        if (proc.info.control === "quarantined") {
-            throw new ProcessError(PROCESS_QUARANTINED, "Process is in quarantined state");
-        }
-        if (proc.info.control !== "held" || !proc.currentGrant) {
-            throw new ProcessError(CONTROL_REVOKED, "Process control is not currently held");
-        }
-        if (proc.currentGrant.token !== token) {
-            throw new ProcessError(ACCESS_DENIED, "Invalid control token");
-        }
-        // 当队列中存在待 dispatch 的操作时抛出 CONTROL_BUSY 拒绝 release
-        if (proc.inputQueue.length > 0) {
-            throw new ProcessError(CONTROL_BUSY, "Cannot release control while operations are pending in queue");
-        }
-        // 仲裁器完成清理定时器、凭据置空与唯一唤醒下一个等待者
-        this.controlArbiter.releaseGrant(proc);
-    }
     /**
      * 向受管进程输入流写入原始字节数据。
      */
@@ -664,7 +443,7 @@ export class ProcessManager {
             processId: id,
             requestId: input.requestId,
         };
-        const payloadHash = hashRequestPayload({ token: input.token, data: input.data });
+        const payloadHash = hashRequestPayload({ data: input.data });
         // 同步预占幂等请求，跨 await 窗口内拦截并发同 requestId 双重入队
         const inFlight = this.reserveRequest(key, payloadHash, "write");
         if (inFlight) {
@@ -687,7 +466,6 @@ export class ProcessManager {
             const rawBytes = decodeBytes(input.data);
             const queued = await this.inputDispatcher.enqueueWrite(proc, {
                 requestId: input.requestId,
-                token: input.token,
                 data: rawBytes,
                 key,
                 payloadHash,
@@ -718,7 +496,7 @@ export class ProcessManager {
             processId: id,
             requestId: input.requestId,
         };
-        const payloadHash = hashRequestPayload({ token: input.token, action: input.action });
+        const payloadHash = hashRequestPayload({ action: input.action });
         // 同步预占幂等请求，跨 await 窗口内拦截并发同 requestId 双重入队
         const inFlight = this.reserveRequest(key, payloadHash, "control");
         if (inFlight) {
@@ -752,7 +530,6 @@ export class ProcessManager {
             // 输入调度器完成授权校验、落盘与入队
             const queued = await this.inputDispatcher.enqueueControl(proc, {
                 requestId: input.requestId,
-                token: input.token,
                 action: input.action,
                 key,
                 payloadHash,
@@ -796,43 +573,6 @@ export class ProcessManager {
         await this.ensureInitialized();
         const proc = await this.getOrLoadProcess(owner, id);
         if (proc.outputUnavailable) {
-            const requestedPos = parseCursor(input.cursor, proc.info.hostEpoch, id);
-            const tombstone = proc.outputTombstone ?? this.terminalOutputCache.getTombstone(id);
-            if (tombstone) {
-                const tailPos = parseCursor(tombstone.tailCursor, proc.info.hostEpoch, id);
-                const cmp = compareCursorPos(requestedPos, tailPos);
-                if (cmp > 0) {
-                    throw new ProcessError(INVALID_CURSOR, "Requested cursor is beyond the end of the output log", {
-                        cursor: input.cursor,
-                        tailCursor: tombstone.tailCursor,
-                    });
-                }
-                if (cmp === 0) {
-                    return {
-                        chunks: [],
-                        nextCursor: tombstone.tailCursor,
-                        earliestCursor: tombstone.tailCursor,
-                        tailCursor: tombstone.tailCursor,
-                        truncated: false,
-                        eof: true,
-                        process: { ...proc.info },
-                    };
-                }
-                const gapMode = input.onGap ?? "error";
-                if (gapMode === "error") {
-                    throw new ProcessError(OUTPUT_UNAVAILABLE, `Process output for '${id}' is unavailable because it has been evicted from memory`, { processId: id });
-                }
-                return {
-                    chunks: [],
-                    nextCursor: tombstone.tailCursor,
-                    earliestCursor: tombstone.tailCursor,
-                    tailCursor: tombstone.tailCursor,
-                    truncated: true,
-                    gap: { fromCursor: input.cursor, toCursor: tombstone.tailCursor },
-                    eof: true,
-                    process: { ...proc.info },
-                };
-            }
             throw new ProcessError(OUTPUT_UNAVAILABLE, `Process output for '${id}' is unavailable because it has been evicted from memory`, { processId: id });
         }
         const logResult = await proc.outputLog.waitForData(input.cursor, input.waitMs, call?.signal, {
@@ -866,8 +606,6 @@ export class ProcessManager {
             proc.info.state === "lost") {
             return { ...proc.info };
         }
-        // 撤销控制权与定时器
-        this.controlArbiter.disposeProcess(proc);
         if (proc.idleTimer) {
             clearTimeout(proc.idleTimer);
             proc.idleTimer = undefined;
@@ -882,11 +620,6 @@ export class ProcessManager {
         }
         // 调度器同步原子接管输入队列：纪元递增、标记失败、登记落盘、清空与字节归零
         this.inputDispatcher.takeoverQueue(proc, PROCESS_CANCELLED);
-        // 终态拒绝全部排队等待者
-        this.controlArbiter.revokeAllWaiters(proc, {
-            code: CONTROL_REVOKED,
-            message: "Process was stopped",
-        });
         proc.info.endReason = proc.info.endReason ?? "requested";
         proc.info.state = "stopping";
         proc.info.control = "closed";
@@ -910,35 +643,12 @@ export class ProcessManager {
     /**
      * 将进程置入隔离状态，撤销有效控制权并取消待 dispatch 的输入队列。
      */
-    async quarantineProcess(owner, processId, token, reason) {
+    async quarantineProcess(owner, processId, reason) {
         const proc = this.processes.get(processId);
         if (!proc) {
             return;
         }
-        checkOwnerAuthorized(owner, proc.owner);
-        if (token && proc.currentGrant && proc.currentGrant.token !== token) {
-            return;
-        }
-        if (proc.info.control === "quarantined" || proc.info.control === "closed") {
-            return;
-        }
-        proc.info.control = "quarantined";
-        if (proc.ttlTimer) {
-            clearTimeout(proc.ttlTimer);
-            proc.ttlTimer = undefined;
-        }
-        proc.currentGrant = undefined;
-        // 调度器同步原子接管输入队列：纪元递增、标记失败、登记落盘、清空与字节归零
-        this.inputDispatcher.takeoverQueue(proc, CONTROL_REVOKED);
-        // 终态拒绝全部排队等待者
-        this.controlArbiter.revokeAllWaiters(proc, {
-            code: PROCESS_QUARANTINED,
-            message: reason || "Process entered quarantined state",
-        });
-        await this.persistState(processId, {
-            control: "quarantined",
-            controlState: "quarantined",
-        });
+        await this.controlManager.quarantine(proc, owner, reason);
     }
     /**
      * 一次性运行外部命令，收集有限输出并支持协作式取消与超时回收。
@@ -1039,20 +749,12 @@ export class ProcessManager {
             clearTimeout(proc.idleTimer);
         if (proc.lifetimeTimer)
             clearTimeout(proc.lifetimeTimer);
-        if (proc.ttlTimer)
-            clearTimeout(proc.ttlTimer);
         proc.info.state = "exited";
         proc.info.control = "closed";
         proc.info.exit = { code: exit.code, signal: exit.signal };
         if (!proc.info.endReason) {
             proc.info.endReason = "natural";
         }
-        proc.currentGrant = undefined;
-        // 终态拒绝全部排队等待者（单一入口）
-        this.controlArbiter.revokeAllWaiters(proc, {
-            code: CONTROL_REVOKED,
-            message: "Process has exited",
-        });
         void this.persistState(proc.info.id, {
             state: "exited",
             control: "closed",
@@ -1110,18 +812,11 @@ export class ProcessManager {
             clearTimeout(proc.idleTimer);
         if (proc.lifetimeTimer)
             clearTimeout(proc.lifetimeTimer);
-        if (proc.ttlTimer)
-            clearTimeout(proc.ttlTimer);
         proc.info.state = "failed";
         proc.info.control = "closed";
         proc.info.endReason = "natural";
         proc.outputLog.closeOutput("natural");
         proc.info.outputClosed = true;
-        // 终态拒绝全部排队等待者（单一入口）
-        this.controlArbiter.revokeAllWaiters(proc, {
-            code: CONTROL_REVOKED,
-            message: `Process error: ${err.message}`,
-        });
         void this.persistState(proc.info.id, {
             state: "failed",
             control: "closed",
@@ -1163,13 +858,11 @@ export class ProcessManager {
         }
         const info = toSdkProcessInfo(record);
         const retainedLog = this.terminalOutputCache.get(processId);
-        const tombstone = this.terminalOutputCache.getTombstone(processId);
         const isTerminalLoaded = info.state === "exited" || info.state === "failed" || info.state === "lost";
-        const isOutputUnavailable = !retainedLog && (Boolean(tombstone) || (isTerminalLoaded && Boolean(record.outputClosed)));
+        const isOutputUnavailable = !retainedLog && (isTerminalLoaded && Boolean(record.outputClosed));
         const outputLog = retainedLog ??
             new ProcessOutputLog(record.hostEpoch, processId, {
                 maxBufferBytes: info.effectiveLimits.outputBufferBytes,
-                maxWaiters: this.quotas.maxWaitersPerProcess,
             });
         if (record.outputClosed && !outputLog.outputClosed) {
             outputLog.closeOutput(record.outputEndReason ?? "natural");
@@ -1185,12 +878,8 @@ export class ProcessManager {
             scope: formatProcessScope(owner),
             outputLog,
             outputUnavailable: isOutputUnavailable,
-            outputTombstone: tombstone,
-            controlEpoch: 0,
             cancelEpoch: 0,
             inputQueue: [],
-            pendingInputBytes: 0,
-            acquireWaiters: [],
             inputClosed: Boolean(record.inputClosed),
             isDispatching: false,
             effectiveLimits: info.effectiveLimits,
@@ -1202,12 +891,6 @@ export class ProcessManager {
         this.processes.set(processId, loaded);
         return loaded;
     }
-    /**
-     * 统计终态保留日志当前在内存中实际占用的输出缓冲字节总数。
-     */
-    countRetainedOutputBufferBytes() {
-        return this.terminalOutputCache.retainedBytes();
-    }
     /**
      * 终态驱逐与驱动释放：进程到达终态且输出已关闭后移除内存记录，
      * 并防御性释放底层驱动句柄（失败仅记录诊断不中断）。
@@ -1217,8 +900,8 @@ export class ProcessManager {
         if (!isTerminal || !proc.info.outputClosed) {
             return;
         }
-        // 仍存在排队等待者或未结算输入时暂缓驱逐
-        if (proc.acquireWaiters.length > 0 || proc.inputQueue.length > 0) {
+        // 仍存在未结算输入时暂缓驱逐
+        if (proc.inputQueue.length > 0) {
             return;
         }
         this.processes.delete(proc.info.id);
@@ -1238,76 +921,4 @@ export class ProcessManager {
             }
         }
     }
-    /**
-     * 启动受管进程时的配额容量校验。
-     */
-    checkSpawnQuotas(scope, requestedBufferBytes) {
-        let scopeActive = 0;
-        let hostActive = 0;
-        let totalBuffer = 0;
-        for (const p of this.processes.values()) {
-            if (p.info.state === "starting" ||
-                p.info.state === "running" ||
-                p.info.state === "stopping") {
-                hostActive += 1;
-                totalBuffer += p.effectiveLimits.outputBufferBytes;
-                if (p.scope === scope) {
-                    scopeActive += 1;
-                }
-            }
-        }
-        if (scopeActive >= this.quotas.maxActiveProcessesPerScope) {
-            throw new ProcessError(QUOTA_EXCEEDED, "Scope active process quota exceeded", {
-                scope,
-                limit: this.quotas.maxActiveProcessesPerScope,
-            });
-        }
-        if (hostActive >= this.quotas.maxActiveProcessesPerHost) {
-            throw new ProcessError(QUOTA_EXCEEDED, "Host active process quota exceeded", {
-                limit: this.quotas.maxActiveProcessesPerHost,
-            });
-        }
-        const perProcBuf = requestedBufferBytes ?? this.defaultLimits.outputBufferBytes;
-        if (perProcBuf > this.quotas.maxOutputBufferBytesPerProcess) {
-            throw new ProcessError(QUOTA_EXCEEDED, "Output buffer per process quota exceeded", {
-                requested: perProcBuf,
-                limit: this.quotas.maxOutputBufferBytesPerProcess,
-            });
-        }
-        // 终态保留输出日志实际占用字节数纳入宿主预算
-        const retainedBefore = this.countRetainedOutputBufferBytes();
-        totalBuffer += retainedBefore;
-        // 若新进程申请的缓冲使总预算超限，优先淘汰已有的终态保留日志（LRU 策略）
-        // 淘汰门槛为宿主预算扣除活跃进程已占字节与新申请字节，淘汰释放的字节数同步回扣宿主预算
-        if (totalBuffer + perProcBuf > this.quotas.maxOutputBufferBytesPerHost) {
-            const activeBufferBytes = totalBuffer - retainedBefore;
-            const evictedBytes = this.terminalOutputCache.evictLRUUntil(this.quotas.maxOutputBufferBytesPerHost - perProcBuf - activeBufferBytes);
-            totalBuffer -= evictedBytes;
-        }
-        if (totalBuffer + perProcBuf > this.quotas.maxOutputBufferBytesPerHost) {
-            throw new ProcessError(QUOTA_EXCEEDED, "Host output buffer quota exceeded", {
-                limit: this.quotas.maxOutputBufferBytesPerHost,
-            });
-        }
-    }
-    /**
-     * 统计当前宿主所有活跃进程累计排队等待控制权的调用者总数。
-     */
-    countHostAcquireWaiters() {
-        let total = 0;
-        for (const p of this.processes.values()) {
-            total += p.acquireWaiters.length;
-        }
-        return total;
-    }
-    /**
-     * 统计当前宿主所有活跃进程累计输入队列待写入字节总数。
-     */
-    countHostPendingInputBytes() {
-        let total = 0;
-        for (const p of this.processes.values()) {
-            total += p.pendingInputBytes;
-        }
-        return total;
-    }
 }

package/dist/process/quotas.d.ts

@@ -0,0 +1,14 @@
+import type { ManagedProcessRecord } from "./managed-record.js";
+import type { ProcessManagerQuotas } from "./process-manager.js";
+export interface QuotaContext {
+    processes: Map<string, ManagedProcessRecord>;
+    quotas: ProcessManagerQuotas;
+    defaultLimits: {
+        outputBufferBytes: number;
+    };
+}
+export declare class ProcessQuotaTracker {
+    private readonly ctx;
+    constructor(ctx: QuotaContext);
+    checkSpawnQuotas(_scope?: string, requestedBufferBytes?: number): void;
+}