@xioflow/kernel 0.3.0 → 0.4.0

package/dist/supervisor/supervisor.js

@@ -1,7 +1,25 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { UnsupportedCapabilityError, OperationNotActiveError, OperationIdConflictError, RecoveryRequiredError, } from '../types.js';
+import { UnsupportedCapabilityError, OperationNotActiveError, OperationIdConflictError, RecoveryRequiredError, ResourceConflictError, } from '../types.js';
+import { NodePlatformDriver } from '../driver/node-driver.js';
+import { GitShadowSnapshotDriver } from '../snapshot/git-shadow.js';
+import { ServiceSupervisor } from './service.js';
+import { setupStreamDrainer } from './drainer.js';
+import { isPathContained } from '../capability/index.js';
+import { createConfinementDriver } from '../confinement/index.js';
+export function normalizeResourceName(res) {
+    if (res.startsWith('workspace:write:')) {
+        const raw = res.slice('workspace:write:'.length);
+        try {
+            return `workspace:write:${fs.realpathSync(raw)}`;
+        }
+        catch {
+            return `workspace:write:${path.resolve(raw)}`;
+        }
+    }
+    return res;
+}
 /**
  * 规范化计算完整输入的 SHA-256 指纹 (ARCHITECTURE §2 / P0-12)
  * 覆盖 execPath, args, cwd, 键排序的 envWhiteList, inheritEnv, sha256(stdin), 排序后的 requiredResources, timeoutMs, resourceBudget.
@@ -35,42 +53,26 @@ export function computeInputFingerprint(options) {
             : null,
         stdinHash,
         timeoutMs: options.timeoutMs ?? null,
+        capabilityId: options.capabilityId ?? null,
     };
     const canonicalJson = JSON.stringify(canonical);
     return crypto.createHash('sha256').update(canonicalJson).digest('hex');
 }
-function trimToValidUtf8(buf) {
-    const len = buf.length;
-    for (let i = 1; i <= Math.min(3, len); i++) {
-        const b = buf[len - i];
-        if ((b & 0xc0) === 0xc0) {
-            const needed = (b & 0xe0) === 0xc0 ? 2 : (b & 0xf0) === 0xe0 ? 3 : (b & 0xf8) === 0xf0 ? 4 : 1;
-            if (i < needed) {
-                return Buffer.from(buf.subarray(0, len - i));
-            }
-            break;
-        }
-        else if ((b & 0x80) === 0) {
-            break;
-        }
-    }
-    return buf;
-}
-function trimStartToValidUtf8(buf) {
-    let start = 0;
-    while (start < buf.length && (buf[start] & 0xc0) === 0x80) {
-        start++;
-    }
-    return Buffer.from(buf.subarray(start));
-}
 export class ProcessSupervisor {
     domain;
     driver;
     activeOperations = new Map();
-    constructor(domain, driver) {
+    serviceSupervisor;
+    snapshotDriver;
+    confinementDriver;
+    constructor(domain, driver = domain.getDriver?.() || new NodePlatformDriver(), snapshotDriver, confinementDriver) {
         this.domain = domain;
         this.driver = driver;
         this.domain.setDriver?.(driver);
+        this.serviceSupervisor = new ServiceSupervisor(domain, driver, this);
+        this.snapshotDriver = snapshotDriver || new GitShadowSnapshotDriver();
+        this.confinementDriver = confinementDriver;
+        this.domain.setSnapshotDriver?.(this.snapshotDriver);
     }
     getDomain() {
         return this.domain;
@@ -78,10 +80,509 @@ export class ProcessSupervisor {
     getDriver() {
         return this.driver;
     }
+    getSnapshotDriver() {
+        return this.snapshotDriver;
+    }
+    setConfinementDriver(driver) {
+        this.confinementDriver = driver;
+    }
+    getConfinementDriver() {
+        return this.confinementDriver;
+    }
+    async startService(spec) {
+        return this.serviceSupervisor.startService(spec);
+    }
+    /**
+     * 快照捕获协议 (ARCHITECTURE §3.5 / 契约 #32, #53)
+     */
+    async captureSnapshot(options) {
+        const startTime = Date.now();
+        let targetRoots = options.roots;
+        let capAdmission;
+        if (options.capabilityId) {
+            capAdmission = this.domain.checkCapabilityAdmission({
+                capabilityId: options.capabilityId,
+                mutationRoots: targetRoots,
+                runId: options.runId,
+                opId: options.opId,
+            });
+            if (!targetRoots || targetRoots.length === 0) {
+                targetRoots = capAdmission.effectiveMutationRoots;
+            }
+        }
+        if (!targetRoots || targetRoots.length === 0) {
+            throw new Error('captureSnapshot requires at least one root directory');
+        }
+        const realRoots = targetRoots.map((r) => path.resolve(r));
+        const requiredResources = realRoots.map((r) => `workspace:write:${r}`);
+        if (this.snapshotDriver instanceof GitShadowSnapshotDriver) {
+            try {
+                const { commonDir } = await this.snapshotDriver.assertGitRepo(realRoots[0]);
+                requiredResources.push(`git:objects:${commonDir}`);
+            }
+            catch { }
+        }
+        const inputFingerprint = crypto
+            .createHash('sha256')
+            .update(JSON.stringify({
+            kind: 'snapshot',
+            roots: realRoots,
+            includeIgnored: !!options.includeIgnored,
+            maxTreeSizeBytes: options.maxTreeSizeBytes,
+            capabilityId: options.capabilityId ?? null,
+        }))
+            .digest('hex');
+        const op = {
+            id: options.opId,
+            runId: options.runId,
+            kind: 'snapshot',
+            name: `snapshot:${realRoots[0]}`,
+            inputFingerprint,
+            requiredResources,
+            mutationRoots: realRoots,
+            capabilityId: options.capabilityId,
+            timeoutMs: options.timeoutMs,
+            status: 'intent_registered',
+        };
+        this.domain.registerOperationIntent(op);
+        this.domain.getStore().updateOperationStatus(options.opId, 'active');
+        this.domain.getStore().recordEventAndTransitionState({
+            domainId: this.domain.domainId,
+            runId: options.runId,
+            operationId: options.opId,
+            type: 'OPERATION_STATUS_TRANSITION',
+            payload: { status: 'active' },
+            timestamp: new Date().toISOString(),
+        });
+        if (options.capabilityId && capAdmission) {
+            this.domain.getStore().recordJournalEvent({
+                domainId: this.domain.domainId,
+                runId: options.runId,
+                operationId: options.opId,
+                type: 'CAPABILITY_USED',
+                payload: {
+                    capabilityId: options.capabilityId,
+                    scope: capAdmission.capability.scope,
+                    actor: capAdmission.capability.issuedBy,
+                },
+                timestamp: new Date().toISOString(),
+            });
+        }
+        try {
+            const snapRef = await this.snapshotDriver.capture(realRoots, {
+                id: options.opId,
+                domainId: this.domain.domainId,
+                opId: options.opId,
+                includeIgnored: options.includeIgnored,
+                maxTreeSizeBytes: options.maxTreeSizeBytes,
+            });
+            let result;
+            this.domain.getStore().transaction(() => {
+                const seq = this.domain.getStore().recordEventAndTransitionState({
+                    domainId: this.domain.domainId,
+                    runId: options.runId,
+                    operationId: options.opId,
+                    type: 'SNAPSHOT_CAPTURED',
+                    payload: {
+                        snapshotId: snapRef.id,
+                        roots: snapRef.roots,
+                        treeFingerprint: snapRef.treeFingerprint,
+                        commitHash: snapRef.commitHash,
+                    },
+                    timestamp: new Date().toISOString(),
+                });
+                snapRef.journalSeq = seq;
+                this.domain.getStore().recordSnapshot(snapRef);
+                result = {
+                    kind: 'snapshot',
+                    status: 'succeeded',
+                    snapshot: snapRef,
+                    capabilityId: options.capabilityId,
+                    durationMs: Date.now() - startTime,
+                    completedAt: new Date().toISOString(),
+                };
+                this.domain.getStore().recordOperationResult(options.opId, result);
+                this.domain.getStore().updateOperationStatus(options.opId, 'done');
+                this.domain.getStore().recordEventAndTransitionState({
+                    domainId: this.domain.domainId,
+                    runId: options.runId,
+                    operationId: options.opId,
+                    type: 'OPERATION_RESULT_RECORDED',
+                    payload: { status: 'succeeded', snapshotId: snapRef.id },
+                    timestamp: new Date().toISOString(),
+                });
+            });
+            this.domain.internalReleaseResources(options.opId);
+            return result;
+        }
+        catch (err) {
+            const failResult = {
+                kind: 'snapshot',
+                status: 'failed',
+                errorMessage: err.message,
+                durationMs: Date.now() - startTime,
+                completedAt: new Date().toISOString(),
+            };
+            let recordError;
+            try {
+                this.domain.getStore().recordOperationResult(options.opId, failResult);
+                this.domain.getStore().updateOperationStatus(options.opId, 'done');
+            }
+            catch (recErr) {
+                recordError = recErr;
+            }
+            this.domain.internalReleaseResources(options.opId);
+            if (recordError !== undefined) {
+                // 失败事实没能落盘时不能只抛原始错误：调用方需要知道 journal 里没有这条结果
+                const recMsg = recordError instanceof Error ? recordError.message : String(recordError);
+                throw new Error(`${err.message} (additionally, recording the failed snapshot result failed: ${recMsg})`, {
+                    cause: err,
+                });
+            }
+            throw err;
+        }
+    }
+    /**
+     * 回滚协议 (ARCHITECTURE §3.5 / 契约 #28–#30, #56)
+     */
+    async rollback(options) {
+        const startTime = Date.now();
+        const snapshot = this.domain.getStore().getSnapshot(options.snapshotId);
+        if (!snapshot) {
+            throw new Error(`Snapshot not found: ${options.snapshotId}`);
+        }
+        let targetRoots = (options.roots || snapshot.roots).map((r) => path.resolve(r));
+        let capAdmission;
+        if (options.capabilityId) {
+            capAdmission = this.domain.checkCapabilityAdmission({
+                capabilityId: options.capabilityId,
+                mutationRoots: targetRoots,
+                runId: options.runId,
+                opId: options.opId,
+            });
+            targetRoots = capAdmission.effectiveMutationRoots;
+        }
+        // 0. 前置条件检查（契约 #30）：目标根目录上不存在 active / stopping / 未裁决 indeterminate 的操作
+        for (const root of targetRoots) {
+            let realRoot = root;
+            try {
+                realRoot = fs.realpathSync(root);
+            }
+            catch { }
+            const res1 = `workspace:write:${root}`;
+            const res2 = `workspace:write:${realRoot}`;
+            if (this.domain.isResourceLocked(res1)) {
+                throw new ResourceConflictError(res1, this.domain.getResourceOwner(res1) || 'unknown', options.opId, 0);
+            }
+            if (this.domain.isResourceLocked(res2)) {
+                throw new ResourceConflictError(res2, this.domain.getResourceOwner(res2) || 'unknown', options.opId, 0);
+            }
+        }
+        const unfinishedOps = this.domain.getStore().getUnfinishedOperations(this.domain.domainId);
+        for (const op of unfinishedOps) {
+            if (op.id === options.opId)
+                continue;
+            for (const root of targetRoots) {
+                let realRoot = root;
+                try {
+                    realRoot = fs.realpathSync(root);
+                }
+                catch { }
+                const writeRes1 = `workspace:write:${root}`;
+                const writeRes2 = `workspace:write:${realRoot}`;
+                if (op.requiredResources.includes(writeRes1) ||
+                    op.requiredResources.includes(writeRes2) ||
+                    op.mutationRoots?.some((mr) => {
+                        const resolved = path.resolve(mr);
+                        return resolved === root || resolved === realRoot;
+                    })) {
+                    throw new ResourceConflictError(writeRes1, op.id, options.opId, 0);
+                }
+            }
+        }
+        // 检查是否有未裁决的 indeterminate op 占用该 root
+        const leases = this.domain.getStore().getPersistedResourceLeases(this.domain.domainId);
+        for (const lease of leases) {
+            for (const root of targetRoots) {
+                let realRoot = root;
+                try {
+                    realRoot = fs.realpathSync(root);
+                }
+                catch { }
+                const writeRes1 = `workspace:write:${root}`;
+                const writeRes2 = `workspace:write:${realRoot}`;
+                if ((lease.resourceId === writeRes1 || lease.resourceId === writeRes2) && lease.operationId !== options.opId) {
+                    throw new ResourceConflictError(lease.resourceId, lease.operationId, options.opId, 0);
+                }
+            }
+        }
+        const requiredResources = targetRoots.map((r) => `workspace:write:${r}`);
+        const inputFingerprint = crypto
+            .createHash('sha256')
+            .update(JSON.stringify({
+            kind: 'rollback',
+            snapshotId: options.snapshotId,
+            targetRoots,
+            capabilityId: options.capabilityId ?? null,
+        }))
+            .digest('hex');
+        const op = {
+            id: options.opId,
+            runId: options.runId,
+            kind: 'rollback',
+            name: `rollback:${options.snapshotId}`,
+            inputFingerprint,
+            requiredResources,
+            mutationRoots: targetRoots,
+            capabilityId: options.capabilityId,
+            outputRef: options.snapshotId,
+            timeoutMs: options.timeoutMs,
+            status: 'intent_registered',
+        };
+        this.domain.registerOperationIntent(op);
+        this.domain.getStore().updateOperationStatus(options.opId, 'active');
+        this.domain.getStore().recordEventAndTransitionState({
+            domainId: this.domain.domainId,
+            runId: options.runId,
+            operationId: options.opId,
+            type: 'OPERATION_STATUS_TRANSITION',
+            payload: { status: 'active' },
+            timestamp: new Date().toISOString(),
+        });
+        if (options.capabilityId && capAdmission) {
+            this.domain.getStore().recordJournalEvent({
+                domainId: this.domain.domainId,
+                runId: options.runId,
+                operationId: options.opId,
+                type: 'CAPABILITY_USED',
+                payload: {
+                    capabilityId: options.capabilityId,
+                    scope: capAdmission.capability.scope,
+                    actor: capAdmission.capability.issuedBy,
+                },
+                timestamp: new Date().toISOString(),
+            });
+        }
+        try {
+            const { unrestoredPaths } = await this.snapshotDriver.restore(snapshot, { force: options.force });
+            const currentFp = await this.snapshotDriver.fingerprint(targetRoots, { against: snapshot });
+            const isMatch = currentFp === snapshot.treeFingerprint;
+            let status;
+            if (!isMatch) {
+                status = 'failed';
+            }
+            else if (unrestoredPaths.length > 0) {
+                status = 'partial';
+            }
+            else {
+                status = 'restored';
+            }
+            let allOpsConfined = false;
+            const eventsSince = snapshot.journalSeq !== undefined
+                ? this.domain.getStore().getJournalEvents(this.domain.domainId, snapshot.journalSeq)
+                : [];
+            const opResults = eventsSince.filter((e) => e.type === 'OPERATION_RESULT_RECORDED' && e.operationId !== options.opId);
+            if (opResults.length === 0) {
+                allOpsConfined = true;
+            }
+            else {
+                allOpsConfined = opResults.every((e) => {
+                    const res = e.payload?.result || e.payload;
+                    const storedOp = this.domain.getStore().getOperation(e.operationId);
+                    if (storedOp?.kind === 'snapshot' || storedOp?.kind === 'rollback') {
+                        return true;
+                    }
+                    if (res?.confined !== true) {
+                        return false;
+                    }
+                    const opRoots = storedOp?.mutationRoots || [];
+                    if (opRoots.length === 0)
+                        return true;
+                    return opRoots.every((opr) => targetRoots.some((sr) => isPathContained(sr, opr)));
+                });
+            }
+            let coverage;
+            let outOfScopeEffects;
+            if (status !== 'restored') {
+                coverage = status === 'partial' ? 'declared_roots' : 'none';
+                outOfScopeEffects = 'possible';
+            }
+            else if (allOpsConfined) {
+                coverage = 'complete';
+                outOfScopeEffects = 'none_possible';
+            }
+            else {
+                coverage = 'declared_roots';
+                outOfScopeEffects = 'possible';
+            }
+            let result;
+            this.domain.getStore().transaction(() => {
+                result = {
+                    kind: 'rollback',
+                    status,
+                    snapshotId: options.snapshotId,
+                    unrestoredPaths: unrestoredPaths.length > 0 ? unrestoredPaths : undefined,
+                    coverage,
+                    outOfScopeEffects,
+                    capabilityId: options.capabilityId,
+                    durationMs: Date.now() - startTime,
+                    completedAt: new Date().toISOString(),
+                };
+                this.domain.getStore().recordOperationResult(options.opId, result);
+                this.domain.getStore().updateOperationStatus(options.opId, 'done');
+            });
+            this.domain.internalReleaseResources(options.opId);
+            return result;
+        }
+        catch (err) {
+            this.domain.internalReleaseResources(options.opId);
+            throw err;
+        }
+    }
+    /**
+     * 分叉工作区 Materialize (ARCHITECTURE §3.5 / 契约 #54)
+     */
+    async materialize(snapshotId, newRoot) {
+        const absNewRoot = path.resolve(newRoot);
+        const writeRes = `workspace:write:${absNewRoot}`;
+        if (this.domain.isResourceLocked(writeRes)) {
+            throw new ResourceConflictError(writeRes, this.domain.getResourceOwner(writeRes) || 'unknown', 'materialize');
+        }
+        const opId = `mat-${snapshotId}-${Date.now()}`;
+        this.domain.allocateResources(opId, [writeRes]);
+        try {
+            if (!this.snapshotDriver.materialize) {
+                throw new Error(`Snapshot driver ${this.snapshotDriver.name} does not support materialize`);
+            }
+            const snapshot = this.domain.getStore().getSnapshot(snapshotId);
+            const repoRoot = snapshot?.roots[0];
+            return await this.snapshotDriver.materialize(snapshotId, absNewRoot, { repoRoot });
+        }
+        catch (err) {
+            this.domain.internalReleaseResources(opId);
+            throw err;
+        }
+    }
+    /**
+     * 回收分叉工作区 Dematerialize (ARCHITECTURE §3.5 / 契约 #54)
+     */
+    async dematerialize(newRoot, options) {
+        const absNewRoot = path.resolve(newRoot);
+        let realNewRoot = absNewRoot;
+        try {
+            realNewRoot = fs.realpathSync(absNewRoot);
+        }
+        catch { }
+        if (!this.snapshotDriver.dematerialize) {
+            throw new Error(`Snapshot driver ${this.snapshotDriver.name} does not support dematerialize`);
+        }
+        await this.snapshotDriver.dematerialize(absNewRoot, options);
+        const writeRes = `workspace:write:${absNewRoot}`;
+        const writeResReal = `workspace:write:${realNewRoot}`;
+        const owner1 = this.domain.getResourceOwner(writeRes);
+        const owner2 = this.domain.getResourceOwner(writeResReal);
+        if (owner1) {
+            this.domain.internalReleaseResources(owner1, [writeRes]);
+        }
+        if (owner2 && owner2 !== owner1) {
+            this.domain.internalReleaseResources(owner2, [writeResReal]);
+        }
+        const leases = this.domain.getStore().getPersistedResourceLeases(this.domain.domainId);
+        for (const lease of leases) {
+            if (lease.resourceId === writeRes || lease.resourceId === writeResReal) {
+                this.domain.internalReleaseResources(lease.operationId, [lease.resourceId]);
+            }
+        }
+    }
+    /**
+     * 回收快照：删除驱动侧的私有 ref 与 store 记录，并写 SNAPSHOT_PRUNED。
+     * 宿主按自己的保留策略调用（例如每轮只保留会话基线与当前轮检查点），否则快照 ref 会无限累积。
+     * 未知 id 视为已回收（幂等）；驱动删除失败直接抛出，store 记录保留，便于重试。
+     */
+    async pruneSnapshots(snapshotIds, options) {
+        const store = this.domain.getStore();
+        const pruned = [];
+        for (const id of snapshotIds) {
+            const snapshot = store.getSnapshot(id);
+            if (!snapshot)
+                continue;
+            store.verifyEpochFencing(this.domain.domainId);
+            const repoRoot = this.snapshotDriver instanceof GitShadowSnapshotDriver
+                ? (await this.snapshotDriver.assertGitRepo(snapshot.roots[0])).repoRoot
+                : undefined;
+            await this.snapshotDriver.prune([id], { repoRoot });
+            store.transaction(() => {
+                store.deleteSnapshot(id);
+                store.recordEventAndTransitionState({
+                    domainId: this.domain.domainId,
+                    runId: options?.runId,
+                    type: 'SNAPSHOT_PRUNED',
+                    payload: { snapshotId: id, roots: snapshot.roots },
+                    timestamp: new Date().toISOString(),
+                });
+            });
+            pruned.push(id);
+        }
+        return pruned;
+    }
     /**
      * 启动协议：准入检查 -> 先持久化意图 -> 请求驱动启动 -> 登记身份并转 active -> 监督运行 -> 记录结果
      */
     async executeProcess(options) {
+        // 0. Capability 准入校验与字段推导（契约 #55）
+        let effectiveMutationRoots = options.mutationRoots;
+        let capAdmission;
+        if (options.capabilityId) {
+            let candidateRoots = options.mutationRoots ? [...options.mutationRoots] : [];
+            if (candidateRoots.length === 0 && options.command.cwd) {
+                candidateRoots = [options.command.cwd];
+            }
+            capAdmission = this.domain.checkCapabilityAdmission({
+                capabilityId: options.capabilityId,
+                requiredResources: options.requiredResources,
+                mutationRoots: candidateRoots.length > 0 ? candidateRoots : undefined,
+                runId: options.runId,
+                opId: options.opId,
+            });
+            options.requiredResources = capAdmission.effectiveResources;
+            effectiveMutationRoots = capAdmission.effectiveMutationRoots;
+        }
+        else {
+            options.requiredResources = (options.requiredResources || []).map(normalizeResourceName);
+            if (!effectiveMutationRoots || effectiveMutationRoots.length === 0) {
+                effectiveMutationRoots = options.requiredResources
+                    .filter((r) => r.startsWith('workspace:write:'))
+                    .map((r) => r.slice('workspace:write:'.length));
+            }
+        }
+        // 0. ConfinementDriver 驱动解析与包装（契约 #56）
+        let activeConfinementDriver;
+        if (options.confinementDriver) {
+            activeConfinementDriver = options.confinementDriver;
+        }
+        else if (typeof options.confinement === 'string') {
+            const driver = createConfinementDriver(options.confinement);
+            if (!driver) {
+                throw new Error(`Confinement driver '${options.confinement}' is not available on this platform`);
+            }
+            activeConfinementDriver = driver;
+        }
+        else if (options.confinement === true) {
+            const driver = this.confinementDriver || createConfinementDriver();
+            if (!driver) {
+                throw new Error('Confinement was requested but no confinement driver is available on this platform');
+            }
+            activeConfinementDriver = driver;
+        }
+        else if (this.confinementDriver) {
+            activeConfinementDriver = this.confinementDriver;
+        }
+        let effectiveCommand = options.command;
+        const isConfined = activeConfinementDriver !== undefined;
+        const confinementDriverName = activeConfinementDriver?.name;
+        if (activeConfinementDriver) {
+            effectiveCommand = activeConfinementDriver.wrap(options.command, effectiveMutationRoots || []);
+        }
         const startTime = Date.now();
         const maxBytes = options.maxOutputBytes ?? 10 * 1024 * 1024; // 默认 10MB
         const drainTimeoutMs = options.drainTimeoutMs ?? 2000; // 默认 2000ms
@@ -195,7 +696,9 @@ export class ProcessSupervisor {
             kind: 'process',
             name: options.name,
             inputFingerprint,
-            requiredResources: options.requiredResources,
+            requiredResources: options.requiredResources || [],
+            mutationRoots: effectiveMutationRoots,
+            capabilityId: options.capabilityId,
             timeoutMs: options.timeoutMs,
             resourceBudget: options.resourceBudget,
             status: 'pending',
@@ -253,9 +756,9 @@ export class ProcessSupervisor {
                 opState.phase = 'spawning';
                 try {
                     // 3. [启动协议步骤 2] 请求平台驱动启动
-                    handle = await this.driver.spawn(options.command);
+                    handle = await this.driver.spawn(effectiveCommand);
                     opState.handle = handle;
-                    opState.command = options.command;
+                    opState.command = effectiveCommand;
                 }
                 catch (spawnError) {
                     opState.phase = 'done';
@@ -270,6 +773,9 @@ export class ProcessSupervisor {
                         stdout: '',
                         stderr: spawnError?.message || String(spawnError),
                         spawnFailure: spawnError?.message || String(spawnError),
+                        capabilityId: options.capabilityId,
+                        confined: isConfined,
+                        confinementDriver: confinementDriverName,
                         isTruncated: false,
                         identityVerification: 'not_original_process',
                         durationMs: Date.now() - startTime,
@@ -282,6 +788,20 @@ export class ProcessSupervisor {
                     this.domain.getStore().updateOperationStatus(options.opId, 'active', handle.identity);
                     opState.phase = 'active';
                     handle.releaseGate?.();
+                    if (options.capabilityId && capAdmission) {
+                        this.domain.getStore().recordJournalEvent({
+                            domainId: this.domain.domainId,
+                            runId: options.runId,
+                            operationId: options.opId,
+                            type: 'CAPABILITY_USED',
+                            payload: {
+                                capabilityId: options.capabilityId,
+                                scope: capAdmission.capability.scope,
+                                actor: capAdmission.capability.issuedBy,
+                            },
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
                 }
                 catch (statusError) {
                     handle.destroyGate?.();
@@ -369,8 +889,8 @@ export class ProcessSupervisor {
                         }
                     }
                 };
-                stdoutDrainer = this.setupStreamDrainer(handle.stdout, maxBytes, stdoutSpillPath, onChunk, forwardChunk('stdout'), artifactsDirError);
-                stderrDrainer = this.setupStreamDrainer(handle.stderr, maxBytes, stderrSpillPath, onChunk, forwardChunk('stderr'), artifactsDirError);
+                stdoutDrainer = setupStreamDrainer(handle.stdout, maxBytes, stdoutSpillPath, onChunk, forwardChunk('stdout'), artifactsDirError);
+                stderrDrainer = setupStreamDrainer(handle.stderr, maxBytes, stderrSpillPath, onChunk, forwardChunk('stderr'), artifactsDirError);
                 // 检查在 spawn 途中是否已被请求取消：若已请求取消，立即触发停止流水线向底层发送终止信号
                 if (opState.cancelRequested) {
                     this.handleStopPipeline(options.opId, 'user_cancelled', opState.cancelGraceMs ?? 2000).catch(() => { });
@@ -538,6 +1058,19 @@ export class ProcessSupervisor {
                     // 排空超时路径强制调用 fsyncSync + closeSync 结清刷盘
                     stdoutDrainer.forceFinalize();
                     stderrDrainer.forceFinalize();
+                    // 走到这里时进程组已被确认停止，管道写端却仍被持有：
+                    // 必然存在一个驱动未观测到的逃逸进程（例如 setsid 后被 init 收养、采样器没来得及记录）。
+                    // 无法确认隔离，不能报告 succeeded / residualProcessesReaped，必须如实判 indeterminate 并保留租约。
+                    const indetResult = {
+                        kind: 'indeterminate',
+                        status: 'indeterminate',
+                        reason: `Process ${handle.identity.pid} exited (exitCode=${exitResult.exitCode}, signal=${exitResult.signal}) and its process group was confirmed stopped, but stdout/stderr pipes are still held by an unobserved escaped process`,
+                        recoveryGuidance: 'An escaped process outside the observed process tree still holds the output pipes. Inspect system processes manually before adjudicating and releasing resources.',
+                        capabilityId: options.capabilityId,
+                        durationMs: Date.now() - startTime,
+                        completedAt: new Date().toISOString(),
+                    };
+                    return this.finalizeOperation(options.opId, indetResult, options.requiredResources, false);
                 }
                 const stdoutData = stdoutDrainer.getResult();
                 const stderrData = stderrDrainer.getResult();
@@ -570,6 +1103,9 @@ export class ProcessSupervisor {
                     signal: exitResult.signal,
                     stdout: stdoutData.content,
                     stderr: stderrData.content,
+                    capabilityId: options.capabilityId,
+                    confined: isConfined,
+                    confinementDriver: confinementDriverName,
                     isTruncated,
                     stdoutTruncated: stdoutData.isTruncated,
                     stderrTruncated: stderrData.isTruncated,
@@ -605,6 +1141,7 @@ export class ProcessSupervisor {
                             status: 'indeterminate',
                             reason: `Process ${handle.identity.pid} was cancelled or stopped but could not be confirmed: ${stopRes.errorDetails || 'residual processes still alive'}`,
                             recoveryGuidance: 'Residual PID detected. Inspect system processes manually before releasing resources.',
+                            capabilityId: options.capabilityId,
                             durationMs: Date.now() - startTime,
                             completedAt: new Date().toISOString(),
                         };
@@ -731,6 +1268,7 @@ export class ProcessSupervisor {
             signal: null,
             stdout: '',
             stderr: '',
+            capabilityId: options.capabilityId,
             isTruncated: false,
             terminationReason: 'user_cancelled',
             evidence: 'unobserved',
@@ -768,6 +1306,9 @@ export class ProcessSupervisor {
         }
         if (existing) {
             result.runId = existing.runId;
+            if (existing.capabilityId && !result.capabilityId) {
+                result.capabilityId = existing.capabilityId;
+            }
         }
         if (result.kind === 'process') {
             const procRes = result;
@@ -807,178 +1348,5 @@ export class ProcessSupervisor {
         }
         return result;
     }
-    setupStreamDrainer(stream, maxBytes, spillFilePath, onChunk, onData, spillInitError) {
-        const overhead = maxBytes >= 80 ? Math.min(64, Math.floor(maxBytes / 4)) : 0;
-        const effectiveMax = maxBytes - overhead;
-        const headMaxBytes = overhead > 0 ? Math.floor(effectiveMax * 0.75) : maxBytes;
-        const tailMaxBytes = overhead > 0 ? Math.max(0, effectiveMax - headMaxBytes) : 0;
-        const headChunks = [];
-        let headBytes = 0;
-        let bytesSeen = 0;
-        let isTruncated = false;
-        let spillFd = null;
-        let spillError = spillInitError;
-        const hash = crypto.createHash('sha256');
-        let isFinalized = false;
-        let outputHash = undefined;
-        const tailRing = tailMaxBytes > 0 ? Buffer.alloc(tailMaxBytes) : null;
-        let tailHead = 0;
-        let tailCount = 0;
-        if (spillFilePath && !spillError) {
-            try {
-                spillFd = fs.openSync(spillFilePath, 'w');
-            }
-            catch (openErr) {
-                spillError = openErr.message || String(openErr);
-                spillFd = null;
-            }
-        }
-        const doFinalize = () => {
-            if (isFinalized)
-                return;
-            isFinalized = true;
-            if (spillFd !== null) {
-                try {
-                    fs.fsyncSync(spillFd);
-                    fs.closeSync(spillFd);
-                }
-                catch (syncErr) {
-                    spillError = spillError || syncErr.message || String(syncErr);
-                }
-                spillFd = null;
-            }
-            if (!spillError) {
-                try {
-                    outputHash = hash.digest('hex');
-                }
-                catch { }
-            }
-            else {
-                outputHash = undefined;
-            }
-        };
-        const finishPromise = new Promise((resolve) => {
-            const finalize = () => {
-                doFinalize();
-                resolve();
-            };
-            stream.on('data', (chunk) => {
-                if (isFinalized) {
-                    // finalize 之后，流继续读走数据避免堵塞或 SIGPIPE，但跳过 hash、落盘和转发
-                    return;
-                }
-                const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-                bytesSeen += buf.length;
-                if (onChunk) {
-                    try {
-                        onChunk(buf.length);
-                    }
-                    catch { }
-                }
-                // 持续落盘转储全部流与写盘同链哈希 (P0-9)
-                if (spillFd !== null) {
-                    try {
-                        fs.writeSync(spillFd, buf);
-                        hash.update(buf);
-                    }
-                    catch (writeErr) {
-                        spillError = spillError || writeErr.message || String(writeErr);
-                        try {
-                            fs.closeSync(spillFd);
-                        }
-                        catch { }
-                        spillFd = null;
-                    }
-                }
-                else if (!spillFilePath && !spillError) {
-                    try {
-                        hash.update(buf);
-                    }
-                    catch { }
-                }
-                if (onData) {
-                    onData(buf);
-                }
-                // Head 内存有界保留
-                if (headBytes < headMaxBytes) {
-                    if (headBytes + buf.length <= headMaxBytes) {
-                        headChunks.push(buf);
-                        headBytes += buf.length;
-                    }
-                    else {
-                        const remaining = headMaxBytes - headBytes;
-                        if (remaining > 0) {
-                            headChunks.push(buf.subarray(0, remaining));
-                            headBytes += remaining;
-                        }
-                        isTruncated = true;
-                    }
-                }
-                else {
-                    isTruncated = true;
-                }
-                if (bytesSeen > maxBytes) {
-                    isTruncated = true;
-                }
-                // Tail 环形缓冲保留
-                if (tailRing !== null && tailMaxBytes > 0) {
-                    if (buf.length >= tailMaxBytes) {
-                        buf.copy(tailRing, 0, buf.length - tailMaxBytes);
-                        tailHead = 0;
-                        tailCount = tailMaxBytes;
-                    }
-                    else {
-                        for (let i = 0; i < buf.length; i++) {
-                            tailRing[tailHead] = buf[i];
-                            tailHead = (tailHead + 1) % tailMaxBytes;
-                        }
-                        tailCount = Math.min(tailMaxBytes, tailCount + buf.length);
-                    }
-                }
-            });
-            stream.on('end', finalize);
-            stream.on('close', finalize);
-            stream.on('error', finalize);
-        });
-        return {
-            getResult: () => {
-                doFinalize();
-                let content;
-                if (bytesSeen <= maxBytes) {
-                    content = Buffer.concat(headChunks).toString('utf8');
-                }
-                else {
-                    const rawHead = trimToValidUtf8(Buffer.concat(headChunks));
-                    let cleanTail = Buffer.alloc(0);
-                    if (tailRing !== null && tailCount > 0) {
-                        const rawTail = Buffer.alloc(tailCount);
-                        if (tailCount < tailMaxBytes) {
-                            tailRing.copy(rawTail, 0, 0, tailCount);
-                        }
-                        else {
-                            const part1 = tailRing.subarray(tailHead, tailMaxBytes);
-                            const part2 = tailRing.subarray(0, tailHead);
-                            part1.copy(rawTail, 0);
-                            part2.copy(rawTail, part1.length);
-                        }
-                        cleanTail = trimStartToValidUtf8(rawTail);
-                    }
-                    const truncatedBytes = Math.max(0, bytesSeen - rawHead.length - cleanTail.length);
-                    const marker = `\n[... truncated ${truncatedBytes} bytes ...]\n`;
-                    content = rawHead.toString('utf8') + marker + cleanTail.toString('utf8');
-                }
-                return {
-                    content,
-                    isTruncated,
-                    outputRef: isTruncated && spillFilePath && !spillError ? spillFilePath : undefined,
-                    outputHash: !spillError ? outputHash : undefined,
-                    bytesSeen,
-                    spillError,
-                };
-            },
-            finishPromise,
-            forceFinalize: doFinalize,
-        };
-    }
 }
 //# sourceMappingURL=supervisor.js.map