agl 40.5.1 → 41.0.0

package/dist_ts/classes.workercallerbindings.d.ts

@@ -0,0 +1,66 @@
+import * as plugins from './plugins.js';
+import type { IWorkerBridgeCommand, IWorkerProcessSnapshot } from './functions.workerprocessproof.js';
+/** The Claude process a kept binding was last proved against: its PID, start and the digest of its whole snapshot. */
+export interface IWorkerCallerBindingProcess {
+    pid: number;
+    startTicks: string;
+    snapshotDigest: string;
+}
+/**
+ * What the controller keeps of a fleet Claude worker's current caller launch, so a restarted controller proves the
+ * worker's bridge again instead of forgetting it. Never a credential, never the launch id or generation themselves:
+ * the overlay holds those, and a bridge presents them; the record keeps their digests to find and check the launch.
+ */
+export interface IWorkerCallerBindingDocument {
+    /** The fleet worker's id: a worker keeps one binding, its current launch's. */
+    id: string;
+    projectId: string;
+    harnessId: 'claude';
+    /** SHA-256 digests (base64url) of the launch id and of its generation. */
+    launchDigest: string;
+    generationDigest: string;
+    /** The bridge command approved when the launch was prepared, and the Claude Code executable it was proved against. */
+    command: IWorkerBridgeCommand;
+    claudeExecutable: string;
+    revision: number;
+    /** Once bound: the background job, its session, and the job's process when one was proved. */
+    binding?: {
+        nativeSessionId: string;
+        jobId: string;
+        process?: IWorkerCallerBindingProcess;
+    };
+    updateId: string;
+}
+export type TWorkerCallerBindingRecord = Omit<IWorkerCallerBindingDocument, 'updateId'>;
+/** Where the controller keeps the bindings of fleet Claude launches. */
+export interface IWorkerCallerBindingStore {
+    /** The binding kept for the launch whose id has the digest `launchDigestArg`. */
+    find(launchDigestArg: string): Promise<TWorkerCallerBindingRecord | undefined>;
+    /** Keeps `recordArg` as its worker's binding; another launch's binding of the worker is replaced. */
+    save(recordArg: TWorkerCallerBindingRecord): Promise<void>;
+    /** Deletes the worker's binding; with `launchDigestArg`, only while it is that launch's. */
+    delete(workerIdArg: string, launchDigestArg?: string): Promise<void>;
+}
+export declare const workerCallerDigest: (valueArg: string) => string;
+export declare const workerProcessSnapshotDigest: (snapshotArg: IWorkerProcessSnapshot) => string;
+export declare class WorkerCallerBindingModel extends plugins.nosqldb.SmartDataDbDoc<WorkerCallerBindingModel, IWorkerCallerBindingDocument> {
+    static exact: plugins.nosqldb.TExact<WorkerCallerBindingModel>;
+    id: string;
+    projectId: string;
+    harnessId: 'claude';
+    launchDigest: string;
+    generationDigest: string;
+    command: IWorkerBridgeCommand;
+    claudeExecutable: string;
+    revision: number;
+    binding?: IWorkerCallerBindingDocument['binding'];
+    updateId: string;
+}
+/** The kept bindings in the controller's store; the auth store owns the model manager and database. Writes run one at a time. */
+export declare class WorkerCallerBindingStore implements IWorkerCallerBindingStore {
+    private mutationTail;
+    find(launchDigestArg: string): Promise<TWorkerCallerBindingRecord | undefined>;
+    save(recordArg: TWorkerCallerBindingRecord): Promise<void>;
+    delete(workerIdArg: string, launchDigestArg?: string): Promise<void>;
+    private mutate;
+}

package/dist_ts/classes.workercallerbindings.js

@@ -0,0 +1,211 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import * as plugins from './plugins.js';
+export const workerCallerDigest = (valueArg) => plugins.crypto.createHash('sha256').update(valueArg).digest('base64url');
+export const workerProcessSnapshotDigest = (snapshotArg) => workerCallerDigest(JSON.stringify([
+    snapshotArg.pid, snapshotArg.parentPid, snapshotArg.startTicks, snapshotArg.executable, snapshotArg.arguments
+]));
+const digest = plugins.z.string().regex(/^[A-Za-z0-9_-]{43}$/u);
+const absolutePath = plugins.z.string().min(2).max(4096).refine((valueArg) => plugins.path.isAbsolute(valueArg) && !valueArg.includes('\0'));
+const documentSchema = plugins.z.object({
+    id: plugins.z.string().min(3).max(1024), projectId: plugins.z.string().regex(/^[A-Za-z0-9_.:-]{1,256}$/u),
+    harnessId: plugins.z.literal('claude'), launchDigest: digest, generationDigest: digest,
+    command: plugins.z.object({ executable: absolutePath, entry: absolutePath,
+        arguments: plugins.z.array(plugins.z.string().max(4096)).max(64) }).strict(),
+    claudeExecutable: absolutePath, revision: plugins.z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    binding: plugins.z.object({ nativeSessionId: plugins.z.string().uuid(), jobId: plugins.z.string().regex(/^[A-Za-z0-9_.:-]{1,256}$/u),
+        process: plugins.z.object({ pid: plugins.z.number().int().min(2), startTicks: plugins.z.string().regex(/^\d{1,32}$/u),
+            snapshotDigest: digest }).strict().optional() }).strict().optional(),
+    updateId: plugins.z.string().uuid(),
+}).strict();
+let WorkerCallerBindingModel = (() => {
+    let _classDecorators = [plugins.nosqldb.namedIndex({ name: 'worker_caller_launch', key: { launchDigest: 1 }, options: { unique: true } }), plugins.nosqldb.managed({ collectionName: 'agl_worker_caller_bindings' }), plugins.nosqldb.exactPersistence({ assertDocument: (input) => {
+                const doc = documentSchema.parse(input);
+                if (!doc.id.startsWith(`${doc.projectId}:`))
+                    throw new Error('Worker caller binding identity mismatch.');
+                if (doc.binding && doc.revision < 1)
+                    throw new Error('Worker caller binding revision mismatch.');
+            } })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = plugins.nosqldb.SmartDataDbDoc;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _projectId_decorators;
+    let _projectId_initializers = [];
+    let _projectId_extraInitializers = [];
+    let _harnessId_decorators;
+    let _harnessId_initializers = [];
+    let _harnessId_extraInitializers = [];
+    let _launchDigest_decorators;
+    let _launchDigest_initializers = [];
+    let _launchDigest_extraInitializers = [];
+    let _generationDigest_decorators;
+    let _generationDigest_initializers = [];
+    let _generationDigest_extraInitializers = [];
+    let _command_decorators;
+    let _command_initializers = [];
+    let _command_extraInitializers = [];
+    let _claudeExecutable_decorators;
+    let _claudeExecutable_initializers = [];
+    let _claudeExecutable_extraInitializers = [];
+    let _revision_decorators;
+    let _revision_initializers = [];
+    let _revision_extraInitializers = [];
+    let _binding_decorators;
+    let _binding_initializers = [];
+    let _binding_extraInitializers = [];
+    let _updateId_decorators;
+    let _updateId_initializers = [];
+    let _updateId_extraInitializers = [];
+    var WorkerCallerBindingModel = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _id_decorators = [plugins.nosqldb.unI()];
+            _projectId_decorators = [plugins.nosqldb.svDb()];
+            _harnessId_decorators = [plugins.nosqldb.svDb()];
+            _launchDigest_decorators = [plugins.nosqldb.svDb()];
+            _generationDigest_decorators = [plugins.nosqldb.svDb()];
+            _command_decorators = [plugins.nosqldb.svDb()];
+            _claudeExecutable_decorators = [plugins.nosqldb.svDb()];
+            _revision_decorators = [plugins.nosqldb.svDb()];
+            _binding_decorators = [plugins.nosqldb.svDb()];
+            _updateId_decorators = [plugins.nosqldb.svDb()];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _projectId_decorators, { kind: "field", name: "projectId", static: false, private: false, access: { has: obj => "projectId" in obj, get: obj => obj.projectId, set: (obj, value) => { obj.projectId = value; } }, metadata: _metadata }, _projectId_initializers, _projectId_extraInitializers);
+            __esDecorate(null, null, _harnessId_decorators, { kind: "field", name: "harnessId", static: false, private: false, access: { has: obj => "harnessId" in obj, get: obj => obj.harnessId, set: (obj, value) => { obj.harnessId = value; } }, metadata: _metadata }, _harnessId_initializers, _harnessId_extraInitializers);
+            __esDecorate(null, null, _launchDigest_decorators, { kind: "field", name: "launchDigest", static: false, private: false, access: { has: obj => "launchDigest" in obj, get: obj => obj.launchDigest, set: (obj, value) => { obj.launchDigest = value; } }, metadata: _metadata }, _launchDigest_initializers, _launchDigest_extraInitializers);
+            __esDecorate(null, null, _generationDigest_decorators, { kind: "field", name: "generationDigest", static: false, private: false, access: { has: obj => "generationDigest" in obj, get: obj => obj.generationDigest, set: (obj, value) => { obj.generationDigest = value; } }, metadata: _metadata }, _generationDigest_initializers, _generationDigest_extraInitializers);
+            __esDecorate(null, null, _command_decorators, { kind: "field", name: "command", static: false, private: false, access: { has: obj => "command" in obj, get: obj => obj.command, set: (obj, value) => { obj.command = value; } }, metadata: _metadata }, _command_initializers, _command_extraInitializers);
+            __esDecorate(null, null, _claudeExecutable_decorators, { kind: "field", name: "claudeExecutable", static: false, private: false, access: { has: obj => "claudeExecutable" in obj, get: obj => obj.claudeExecutable, set: (obj, value) => { obj.claudeExecutable = value; } }, metadata: _metadata }, _claudeExecutable_initializers, _claudeExecutable_extraInitializers);
+            __esDecorate(null, null, _revision_decorators, { kind: "field", name: "revision", static: false, private: false, access: { has: obj => "revision" in obj, get: obj => obj.revision, set: (obj, value) => { obj.revision = value; } }, metadata: _metadata }, _revision_initializers, _revision_extraInitializers);
+            __esDecorate(null, null, _binding_decorators, { kind: "field", name: "binding", static: false, private: false, access: { has: obj => "binding" in obj, get: obj => obj.binding, set: (obj, value) => { obj.binding = value; } }, metadata: _metadata }, _binding_initializers, _binding_extraInitializers);
+            __esDecorate(null, null, _updateId_decorators, { kind: "field", name: "updateId", static: false, private: false, access: { has: obj => "updateId" in obj, get: obj => obj.updateId, set: (obj, value) => { obj.updateId = value; } }, metadata: _metadata }, _updateId_initializers, _updateId_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            WorkerCallerBindingModel = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        id = __runInitializers(this, _id_initializers, void 0);
+        projectId = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _projectId_initializers, void 0));
+        harnessId = (__runInitializers(this, _projectId_extraInitializers), __runInitializers(this, _harnessId_initializers, void 0));
+        launchDigest = (__runInitializers(this, _harnessId_extraInitializers), __runInitializers(this, _launchDigest_initializers, void 0));
+        generationDigest = (__runInitializers(this, _launchDigest_extraInitializers), __runInitializers(this, _generationDigest_initializers, void 0));
+        command = (__runInitializers(this, _generationDigest_extraInitializers), __runInitializers(this, _command_initializers, void 0));
+        claudeExecutable = (__runInitializers(this, _command_extraInitializers), __runInitializers(this, _claudeExecutable_initializers, void 0));
+        revision = (__runInitializers(this, _claudeExecutable_extraInitializers), __runInitializers(this, _revision_initializers, void 0));
+        binding = (__runInitializers(this, _revision_extraInitializers), __runInitializers(this, _binding_initializers, void 0));
+        updateId = (__runInitializers(this, _binding_extraInitializers), __runInitializers(this, _updateId_initializers, void 0));
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _updateId_extraInitializers);
+        }
+    };
+    return WorkerCallerBindingModel = _classThis;
+})();
+export { WorkerCallerBindingModel };
+const ambiguous = (errorArg) => errorArg instanceof plugins.nosqldb.SmartdataExactPersistenceError && errorArg.code === 'ambiguous_write';
+const record = (documentArg) => {
+    const { updateId: _updateId, ...rest } = structuredClone(documentArg);
+    return rest;
+};
+/** The kept bindings in the controller's store; the auth store owns the model manager and database. Writes run one at a time. */
+export class WorkerCallerBindingStore {
+    mutationTail = Promise.resolve();
+    async find(launchDigestArg) {
+        const stored = await WorkerCallerBindingModel.exact.findStoredOne({ launchDigest: launchDigestArg });
+        return stored ? record(WorkerCallerBindingModel.exact.toPersisted(stored)) : undefined;
+    }
+    save(recordArg) {
+        return this.mutate(async () => {
+            const candidate = { ...structuredClone(recordArg), updateId: plugins.crypto.randomUUID() };
+            const stored = await WorkerCallerBindingModel.exact.findStoredOne({ id: candidate.id });
+            try {
+                if (stored) {
+                    const current = WorkerCallerBindingModel.exact.toPersisted(stored);
+                    if (current.launchDigest === candidate.launchDigest) {
+                        // A launch's binding only gains or renews its job; it is never unbound again.
+                        if (current.binding && !candidate.binding)
+                            throw new Error('A kept worker caller binding cannot lose its job.');
+                        const result = await WorkerCallerBindingModel.exact.transition({ current: stored, change: (model) => { Object.assign(model, candidate); } });
+                        if (result.status !== 'transitioned')
+                            throw new Error('The kept worker caller binding changed concurrently.');
+                        return;
+                    }
+                    const deleted = await WorkerCallerBindingModel.exact.delete({ current: stored });
+                    if (deleted.status !== 'deleted')
+                        throw new Error('The kept worker caller binding changed concurrently.');
+                }
+                const inserted = await WorkerCallerBindingModel.exact.insert(candidate);
+                if (WorkerCallerBindingModel.exact.toPersisted(inserted.document).updateId !== candidate.updateId) {
+                    throw new Error('Another worker caller binding holds this launch.');
+                }
+            }
+            catch (error) {
+                if (!ambiguous(error))
+                    throw error;
+                const after = await WorkerCallerBindingModel.exact.findStoredOne({ id: candidate.id });
+                if (!after || WorkerCallerBindingModel.exact.toPersisted(after).updateId !== candidate.updateId) {
+                    throw new Error('Keeping the worker caller binding has an uncertain outcome.', { cause: error });
+                }
+            }
+        });
+    }
+    delete(workerIdArg, launchDigestArg) {
+        return this.mutate(async () => {
+            const stored = await WorkerCallerBindingModel.exact.findStoredOne({ id: workerIdArg });
+            if (!stored || launchDigestArg !== undefined && WorkerCallerBindingModel.exact.toPersisted(stored).launchDigest !== launchDigestArg)
+                return;
+            try {
+                const result = await WorkerCallerBindingModel.exact.delete({ current: stored });
+                if (result.status !== 'deleted')
+                    throw new Error('The kept worker caller binding changed concurrently.');
+            }
+            catch (error) {
+                if (!ambiguous(error) || await WorkerCallerBindingModel.exact.findStoredOne({ id: workerIdArg }))
+                    throw error;
+            }
+        });
+    }
+    mutate(operationArg) {
+        const task = this.mutationTail.then(operationArg);
+        this.mutationTail = task.then(() => undefined, () => undefined);
+        return task;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.workercallerbindings.js","sourceRoot":"","sources":["../../ts/classes.workercallerbindings.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.workercallers.d.ts

@@ -1,6 +1,7 @@
-import { type IFleetWorkerCallerHooks, type TFleetWorkerCallerLaunch, type TFleetWorkerCallerBinding, type IWorkerCallerReadiness, type TWorkerCallerEnrollment, type IWorkerCallerEnrollmentResponse, type IConfigurationMaster, type IControllerMcpCaller, type IControllerMcpWireCaller } from '../dist_ts_interfaces/index.js';
+import { type IFleetWorkerCallerHooks, type TFleetWorkerCallerLaunch, type TFleetWorkerCallerBinding, type IWorkerCallerReadiness, type TWorkerCallerEnrollment, type IWorkerCallerEnrollmentResponse, type IConfigurationMaster, type IControllerMcpCaller, type IControllerMcpWireCaller, type IWorkerClaudeJobRequest, type TWorkerClaudeJobObservation } from '../dist_ts_interfaces/index.js';
 import { ControllerMcpCallerRegistry } from './classes.mcpcallerregistry.js';
-import { resolveWorkerBridgeCommand, resolveClaudeWorkerExecutable, verifyClaudeWorkerProcess, verifyWorkerBridge, type IWorkerCallerConnection, type IWorkerProcessSnapshot } from './functions.workerprocessproof.js';
+import { resolveWorkerBridgeCommand, resolveClaudeWorkerExecutable, verifyClaudeWorkerProcess, readWorkerBridge, verifyWorkerBridge, type IWorkerCallerConnection, type IWorkerProcessSnapshot } from './functions.workerprocessproof.js';
+import { type IWorkerCallerBindingStore } from './classes.workercallerbindings.js';
 export interface IWorkerCodexCallerOrigin {
     parent: IWorkerProcessSnapshot;
     isCurrent(): Promise<boolean>;
@@ -18,11 +19,21 @@ export interface IControllerWorkerCallerOptions {
         harnessId: 'codex';
     }>): Promise<IWorkerCodexCallerOrigin>;
     processProof?: IWorkerCallerProcessProof;
+    /** Keeps the bindings of fleet Claude launches, so a restarted controller proves their bridges again; absent keeps them in memory. */
+    bindings?: IWorkerCallerBindingStore;
+    /**
+     * A fresh read of the Claude background job a launch is bound to, from the fleet's own inventory, one read at a time.
+     * Without it a bridge of a process that replaced the bound one stays pending.
+     */
+    observeClaudeJob?(request: IWorkerClaudeJobRequest): Promise<TWorkerClaudeJobObservation>;
+    /** Where the reason a worker enrollment stays pending is written once; the controller log by default. */
+    log?(line: string): void;
 }
 export interface IWorkerCallerProcessProof {
     resolveCommand: typeof resolveWorkerBridgeCommand;
     resolveClaude: typeof resolveClaudeWorkerExecutable;
     verifyClaude: typeof verifyClaudeWorkerProcess;
+    readBridge: typeof readWorkerBridge;
     verifyBridge: typeof verifyWorkerBridge;
 }
 export declare class ControllerWorkerCallers implements IFleetWorkerCallerHooks {
@@ -30,8 +41,15 @@ export declare class ControllerWorkerCallers implements IFleetWorkerCallerHooks
     private readonly launches;
     private readonly sessions;
     private readonly challenges;
+    /** Each worker's current launch, prepared by this controller or kept from before its restart. */
+    private readonly workers;
+    /** Per worker, the chain its kept binding's writes, deletion and restoration run on, one at a time. */
+    private readonly workerTails;
+    /** Pending reasons logged for launches this controller does not hold, by launch digest and reason. */
+    private readonly loggedUnknown;
     private closed;
     private readonly proof;
+    private readonly log;
     constructor(options: IControllerWorkerCallerOptions);
     prepareWorkerCaller(launchArg: TFleetWorkerCallerLaunch): ReturnType<IFleetWorkerCallerHooks['prepareWorkerCaller']>;
     bindWorkerCaller(bindingArg: TFleetWorkerCallerBinding): ReturnType<IFleetWorkerCallerHooks['bindWorkerCaller']>;
@@ -40,6 +58,49 @@ export declare class ControllerWorkerCallers implements IFleetWorkerCallerHooks
     enroll(requestArg: TWorkerCallerEnrollment, connectionArg?: IWorkerCallerConnection): Promise<IWorkerCallerEnrollmentResponse>;
     admit(wireArg: IControllerMcpWireCaller | undefined, connectionArg?: IWorkerCallerConnection): Promise<IWorkerCallerLease>;
     close(): Promise<void>;
+    /**
+     * Binds `recordArg` to `bindingArg`, inside its serial chain: a Claude launch to its background job and, when it has
+     * one, the job's process; a Codex launch to its thread on the proved origin. The kept binding is written first.
+     */
+    private bind;
+    /**
+     * Enrolls the bridge of a Claude launch: against the process the launch is bound to, or, when that process is gone or
+     * replaced, after the fleet proved the bridge's process to be the next process of the same job.
+     */
+    private enrollClaude;
+    /**
+     * Proves the bridge's process to be the current process of the job the launch is bound to, from a fresh inventory the
+     * fleet reads, and binds the launch to it at the current revision. A bridge refused for good is remembered for its
+     * process's life, one refused for a reason that may pass for a short while; neither is proved again at every call.
+     */
+    private reprove;
+    /** Whether the Claude process `processArg` the launch was proved against still runs, unchanged. */
+    private processStands;
+    /**
+     * The launch a restarted controller kept for a bridge that presents it, as it was bound: found by its id's digest,
+     * checked against its generation's, and only while it is still its worker's current launch. It is restored
+     * unverified: its bridge enrolls only after a fresh inventory shows the job still the worker's, in the kept process
+     * when that still runs unchanged, or in the bridge's process, which then proves itself as the job's next process.
+     */
+    private restore;
+    /** The kept process of a restored launch while it still runs as it was proved: the same PID, start and snapshot. */
+    private keptProcess;
+    /** Keeps the binding of a Claude launch at `revisionArg`: prepared, or bound to `bindingArg`. Refused once the launch is revoked. */
+    private keep;
+    /** The one non-secret stdio `agl` MCP server the Configuration master defines for `harnessArg`. */
+    private approvedServer;
+    /** The bridge command this controller approves now for Claude launches, resolved from its own configured `agl` entry. */
+    private currentCommand;
+    /** Runs `operationArg` on the worker's chain: kept-binding writes, deletion and restoration of one worker never interleave. */
+    private withWorker;
+    /** Whether the launch was revoked, also by this controller closing; a method, so a check after an await reads the state again. */
+    private revoked;
+    private markRevoked;
+    private settleRevocation;
+    /** Writes once per launch and reason why its bridge's enrollment stays pending; never a credential or the launch id. */
+    private logPending;
+    /** As `logPending`, for a launch this controller does not hold. */
+    private logUnknown;
     private enrollCredential;
     private challenge;
     private runChallenge;