oh-my-super-agent 0.1.0

package/dist/src/conductor/bridge.js

@@ -0,0 +1,652 @@
+import { once } from "node:events";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { readOmsConfig } from "../config.js";
+import { assertConductorBridgeSession } from "./start.js";
+import { captureStoredDispatchIntent } from "../dispatch/authority.js";
+import { createRuntimeDispatchAuthorities } from "../dispatch/runtime-authority.js";
+import { assertActorId, assertOpaqueId } from "../domain/records.js";
+import { createGoalWithReplay, readGoal } from "../goals/authority.js";
+import { assertCurrentGithubDispatchEligibility } from "../github/dispatch-eligibility.js";
+import { assertShippedSubscriptionRole, resolveConfiguredRole } from "../providers/preflight.js";
+import { acquireDirectoryLock } from "../runtime/lock.js";
+import { assertSchema, loadJsonSchema, SchemaValidationError } from "../runtime/schema.js";
+import { createStableId } from "../runtime/stable-id.js";
+import { admitReadyGithubTickets } from "../tickets/admission.js";
+import { isRecord, readJsonFileNoFollow, validateExistingDirectory, writeJsonAtomicNoReplace } from "../utils/fs.js";
+export const CONDUCTOR_BRIDGE_TOOLS = Object.freeze([
+    "propose_goal",
+    "prepare_dispatch",
+    "advise_dispatch",
+    "propose_dispatch",
+    "manage_worker",
+    "start_team",
+    "process_result",
+]);
+export const MAX_CONDUCTOR_BRIDGE_FRAME_BYTES = 128 * 1024;
+export const CONDUCTOR_BRIDGE_TOOL_SCHEMA_FILES = Object.freeze({
+    propose_goal: "conductor-goal-proposal.schema.json",
+    prepare_dispatch: "conductor-dispatch-preparation.schema.json",
+    advise_dispatch: "conductor-dispatch-intent.schema.json",
+    propose_dispatch: "conductor-dispatch-proposal.schema.json",
+    manage_worker: "conductor-manage-worker.schema.json",
+    start_team: "conductor-start-team.schema.json",
+    process_result: "conductor-process-result.schema.json",
+});
+export function createConductorBridge(options) {
+    const packageRoot = validateExistingDirectory(options.packageRoot, "package root");
+    const configRoot = validateExistingDirectory(options.configRoot ?? packageRoot, "configuration root");
+    const workspaceRoot = validateExistingDirectory(options.workspaceRoot, "conductor workspace root");
+    const stateRoot = validateExistingDirectory(options.stateRoot, "conductor state root");
+    const preparationsRoot = validateExistingDirectory(join(stateRoot, "dispatch-preparations"), "dispatch preparations root");
+    const locksRoot = validateExistingDirectory(join(stateRoot, "locks"), "conductor locks root");
+    assertOpaqueId(options.sessionId, "conductor session id");
+    const binding = assertConductorBridgeSession({ workspaceRoot, stateRoot, sessionId: options.sessionId });
+    const actorId = assertActorId(options.actorId, "conductor actor id");
+    if (actorId !== binding.actor_id)
+        throw new Error("conductor bridge actor does not match its launch binding");
+    const clock = options.clock ?? (() => new Date().toISOString());
+    const tools = loadToolDefinitions(packageRoot);
+    const schemas = Object.freeze({
+        propose_goal: tools[0].inputSchema,
+        prepare_dispatch: tools[1].inputSchema,
+        advise_dispatch: tools[2].inputSchema,
+        propose_dispatch: tools[3].inputSchema,
+        manage_worker: tools[4].inputSchema,
+        start_team: tools[5].inputSchema,
+        process_result: tools[6].inputSchema,
+    });
+    const runtime = createRuntimeDispatchAuthorities({
+        packageRoot,
+        configRoot,
+        workspaceRoot,
+        stateRoot,
+        actorId,
+        clock,
+    });
+    function prepareDispatch(request) {
+        const preparationId = createStableId("disp-prep", request.ticket_id, String(request.attempt), request.operation_nonce);
+        const requestPath = join(preparationsRoot, `${preparationId}.request.json`);
+        const resultPath = join(preparationsRoot, `${preparationId}.result.json`);
+        const lock = acquireDirectoryLock({
+            locksRoot,
+            lockId: createStableId("disp-prep-lock", request.ticket_id, String(request.attempt)),
+            ownerId: actorId,
+            note: preparationId,
+        });
+        try {
+            const goal = readGoal(runtime.goals.authority, request.goal_id);
+            if (goal.state !== "active"
+                || goal.version !== request.goal_version
+                || goal.payload.repository_scope !== workspaceRoot)
+                throw new Error("dispatch preparation goal authority is stale");
+            const before = runtime.tickets.lifecycle.read(request.ticket_id);
+            if (before.payload.source !== "github"
+                || before.payload.content_sha256 !== request.ticket_content_sha256
+                || (before.state !== "pending" && before.state !== "retryable" && before.state !== "leased"))
+                throw new Error("dispatch preparation ticket authority is stale");
+            const targetAttempt = before.state === "retryable" ? before.attempt + 1 : before.attempt;
+            if (targetAttempt !== request.attempt || targetAttempt > before.max_attempts) {
+                throw new Error("dispatch preparation attempt authority is stale");
+            }
+            const content = readTicketWithinGoalScope(runtime, before, goal.payload.queue_scope);
+            const resolved = resolveConfiguredRole(readOmsConfig(configRoot), request.role_id);
+            assertShippedSubscriptionRole(resolved.role);
+            if (resolved.role.sandbox !== "ticket-worktree-write"
+                || (resolved.role.transport !== "claude_interactive" && resolved.role.transport !== "codex_goal"))
+                throw new Error("dispatch preparation role is not a writable executor");
+            const storedRequest = readPreparationRequest(requestPath, preparationId, schemas.prepare_dispatch);
+            if (storedRequest) {
+                if (!isDeepStrictEqual(storedRequest.request, request)) {
+                    throw new Error("dispatch preparation nonce was reused with different authority");
+                }
+                assertPreparationRecoveryState(storedRequest, before);
+            }
+            const storedResult = readPreparationResult(resultPath, preparationId, schemas.advise_dispatch);
+            if (storedResult) {
+                if (!storedRequest)
+                    throw new Error("stored dispatch preparation result has no request authority");
+                const captured = runtime.dispatch.captureIntent(storedResult.intent);
+                if (captured.dispatch_intent_sha256 !== storedResult.dispatch_intent_sha256) {
+                    throw new Error("stored dispatch preparation intent digest changed");
+                }
+                assertNoConflictingDispatch(runtime, captured);
+                return Object.freeze({ status: "replayed", intent: deepFreeze(structuredClone(storedResult.intent)) });
+            }
+            assertCurrentGithubDispatchEligibility({
+                stateRoot,
+                outbox: runtime.outbox,
+                content,
+                queueScope: goal.payload.queue_scope,
+                conductorSessionId: options.sessionId,
+            });
+            if (!storedRequest) {
+                if (before.version !== request.expected_ticket_version) {
+                    throw new Error("dispatch preparation selected a stale ticket version");
+                }
+                const createdAt = clock();
+                writeJsonAtomicNoReplace(requestPath, {
+                    schema_version: 1,
+                    preparation_id: preparationId,
+                    request_sha256: preparationRequestSha256(request, before.state, isPreparedTicket(before)),
+                    request: structuredClone(request),
+                    selected_ticket_state: before.state,
+                    selected_ticket_prepared: isPreparedTicket(before),
+                    created_at: createdAt,
+                });
+            }
+            const [admission] = admitReadyGithubTickets({
+                packageRoot,
+                configRoot,
+                workspaceRoot,
+                stateRoot,
+                tickets: runtime.tickets,
+                ticketIds: [before.record_id],
+                at: clock(),
+            });
+            if (!admission)
+                throw new Error("dispatch preparation did not admit exactly one ticket");
+            const ticket = runtime.tickets.lifecycle.read(admission.ticket_id);
+            if (ticket.state !== "leased"
+                || ticket.version !== admission.ticket_version
+                || ticket.attempt !== request.attempt
+                || ticket.payload.content_sha256 !== request.ticket_content_sha256)
+                throw new Error("dispatch preparation lease binding changed");
+            const intent = Object.freeze({
+                goal_id: goal.record_id,
+                goal_version: goal.version,
+                ticket_id: admission.ticket_id,
+                ticket_version: admission.ticket_version,
+                lease_token: admission.lease_token,
+                attempt: admission.attempt,
+                worker_id: admission.worker_id,
+                role_id: request.role_id,
+                model_id: resolved.modelId,
+                provider_mode: resolved.role.transport,
+                worktree_id: admission.worktree_id,
+                worktree_path: admission.worktree_path,
+                capabilities: ["repository-read", "ticket-worktree-write"],
+                budget_snapshot: {
+                    profile: "subscription-only",
+                    remaining_attempts: ticket.max_attempts - ticket.attempt + 1,
+                    policy_digest: ticket.payload.policy_digest,
+                },
+                acceptance_criteria: [...request.acceptance_criteria],
+                evidence_requirements: [...request.evidence_requirements],
+                task_body: request.task_body,
+                operation_nonce: request.operation_nonce,
+            });
+            const captured = runtime.dispatch.captureIntent(intent);
+            assertNoConflictingDispatch(runtime, captured);
+            writeJsonAtomicNoReplace(resultPath, {
+                schema_version: 1,
+                preparation_id: preparationId,
+                dispatch_intent_sha256: captured.dispatch_intent_sha256,
+                intent: structuredClone(intent),
+                prepared_at: clock(),
+            });
+            return Object.freeze({ status: storedRequest ? "replayed" : "prepared", intent });
+        }
+        finally {
+            lock.release();
+        }
+    }
+    function handleMessage(message) {
+        const request = parseRequest(message);
+        if (!request)
+            return invalidRequest(null);
+        if (request.method === "notifications/initialized")
+            return undefined;
+        if (request.method === "initialize") {
+            if (request.id === undefined)
+                return undefined;
+            return success(request.id, {
+                protocolVersion: "2025-06-18",
+                capabilities: { tools: { listChanged: false } },
+                serverInfo: { name: "oms-conductor-bridge", version: "0.1.0" },
+            });
+        }
+        if (request.method === "ping") {
+            if (request.id === undefined)
+                return undefined;
+            return success(request.id, {});
+        }
+        if (request.method === "tools/list") {
+            if (request.id === undefined)
+                return undefined;
+            return success(request.id, { tools: structuredClone(tools) });
+        }
+        if (request.method === "tools/call") {
+            if (request.id === undefined)
+                return undefined;
+            const call = parseToolCall(request.params);
+            if (!call)
+                return failure(request.id, -32602, "invalid tool call");
+            const schema = schemas[call.name];
+            try {
+                assertSchema(call.arguments, schema, `${call.name} input`);
+            }
+            catch (error) {
+                if (error instanceof SchemaValidationError)
+                    return failure(request.id, -32602, "invalid tool input");
+                return failure(request.id, -32603, "tool validation failed");
+            }
+            if (call.name === "prepare_dispatch") {
+                try {
+                    return success(request.id, toolResult(prepareDispatch(call.arguments)));
+                }
+                catch {
+                    return success(request.id, toolResult({ status: "preparation-conflict" }, true));
+                }
+            }
+            if (call.name === "advise_dispatch") {
+                try {
+                    if (!options.adviseDispatch)
+                        throw new Error("dispatch advice is unavailable");
+                    const progress = options.adviseDispatch(call.arguments);
+                    return success(request.id, toolResult({
+                        ...progress,
+                    }, progress.status === "blocked"));
+                }
+                catch {
+                    return success(request.id, toolResult({ status: "blocked", reason: "dispatch advice is unavailable" }, true));
+                }
+            }
+            if (call.name === "propose_dispatch") {
+                try {
+                    const proposed = runtime.dispatch.propose(call.arguments);
+                    const deliveryEventId = proposed.record.payload.delivery_event_id;
+                    let delivery;
+                    if (deliveryEventId && options.deliverAcceptedDispatch) {
+                        try {
+                            delivery = options.deliverAcceptedDispatch(deliveryEventId);
+                        }
+                        catch {
+                            delivery = { status: "delivery-blocked" };
+                        }
+                    }
+                    return success(request.id, toolResult({
+                        status: proposed.status,
+                        dispatch_id: proposed.record.record_id,
+                        version: proposed.record.version,
+                        ...(delivery === undefined ? {} : { delivery }),
+                    }));
+                }
+                catch {
+                    return success(request.id, toolResult({ status: "dispatch-conflict" }, true));
+                }
+            }
+            if (call.name === "manage_worker") {
+                const control = call.arguments;
+                if (!isValidWorkerControl(control))
+                    return failure(request.id, -32602, "invalid tool input");
+                try {
+                    if (!options.manageWorker)
+                        throw new Error("worker control is unavailable");
+                    return success(request.id, toolResult({ status: "worker-control-complete", result: options.manageWorker(control) }));
+                }
+                catch {
+                    return success(request.id, toolResult({ status: "worker-control-blocked" }, true));
+                }
+            }
+            if (call.name === "start_team") {
+                const dispatchIds = call.arguments.dispatch_ids;
+                if (new Set(dispatchIds).size !== dispatchIds.length)
+                    return failure(request.id, -32602, "invalid tool input");
+                try {
+                    if (!options.startTeam)
+                        throw new Error("Team start is unavailable");
+                    return success(request.id, toolResult({ status: "team-start-complete", result: options.startTeam(dispatchIds) }));
+                }
+                catch {
+                    return success(request.id, toolResult({ status: "team-start-blocked" }, true));
+                }
+            }
+            if (call.name === "process_result") {
+                try {
+                    if (!options.processResult)
+                        throw new Error("protected result processing is unavailable");
+                    const dispatchId = String(call.arguments.dispatch_id);
+                    return success(request.id, toolResult({
+                        status: "result-processing-complete",
+                        result: options.processResult(dispatchId),
+                    }));
+                }
+                catch {
+                    return success(request.id, toolResult({ status: "result-processing-blocked" }, true));
+                }
+            }
+            const proposal = call.arguments;
+            if (proposal.repository_scope !== workspaceRoot) {
+                return success(request.id, toolResult({ status: "repository-scope-mismatch" }, true));
+            }
+            try {
+                const created = createGoalWithReplay(runtime.goals.authority, {
+                    objective: proposal.objective,
+                    repositoryScope: proposal.repository_scope,
+                    queueScope: proposal.queue_scope,
+                    stoppingCondition: proposal.stopping_condition,
+                    runtimeHorizon: proposal.runtime_horizon,
+                    budgetProfile: proposal.budget_profile,
+                    policyProfile: proposal.policy_profile,
+                    creationNonce: proposal.creation_nonce,
+                    leaderId: actorId,
+                    createdAt: clock(),
+                });
+                return success(request.id, toolResult({
+                    status: created.status,
+                    goal_id: created.goal.record_id,
+                    version: created.goal.version,
+                }));
+            }
+            catch {
+                return success(request.id, toolResult({ status: "goal-conflict" }, true));
+            }
+        }
+        if (request.id === undefined)
+            return undefined;
+        return failure(request.id, -32601, "method not found");
+    }
+    return Object.freeze({
+        handleMessage,
+        handleLine(line) {
+            const bytes = Buffer.isBuffer(line) ? line : Buffer.from(line, "utf8");
+            if (bytes.byteLength > MAX_CONDUCTOR_BRIDGE_FRAME_BYTES) {
+                return serializeResponse(failure(null, -32700, "frame too large"));
+            }
+            let message;
+            try {
+                message = JSON.parse(bytes.toString("utf8"));
+            }
+            catch {
+                return serializeResponse(failure(null, -32700, "parse error"));
+            }
+            const response = handleMessage(message);
+            return response ? serializeResponse(response) : undefined;
+        },
+    });
+}
+export async function runConductorBridge(options) {
+    const bridge = createConductorBridge(options);
+    let fragments = [];
+    let frameBytes = 0;
+    let discardingOversizedFrame = false;
+    for await (const rawChunk of options.input) {
+        const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(String(rawChunk), "utf8");
+        let offset = 0;
+        while (offset < chunk.byteLength) {
+            const newline = chunk.indexOf(0x0a, offset);
+            const end = newline === -1 ? chunk.byteLength : newline;
+            const fragment = chunk.subarray(offset, end);
+            if (!discardingOversizedFrame) {
+                if (frameBytes + fragment.byteLength > MAX_CONDUCTOR_BRIDGE_FRAME_BYTES) {
+                    fragments = [];
+                    frameBytes = 0;
+                    discardingOversizedFrame = true;
+                    await writeResponse(options.output, serializeResponse(failure(null, -32700, "frame too large")));
+                }
+                else if (fragment.byteLength > 0) {
+                    fragments.push(fragment);
+                    frameBytes += fragment.byteLength;
+                }
+            }
+            if (newline === -1)
+                break;
+            if (discardingOversizedFrame) {
+                discardingOversizedFrame = false;
+            }
+            else {
+                const response = bridge.handleLine(joinFrame(fragments, frameBytes));
+                if (response)
+                    await writeResponse(options.output, response);
+            }
+            fragments = [];
+            frameBytes = 0;
+            offset = newline + 1;
+        }
+    }
+    if (!discardingOversizedFrame && frameBytes > 0) {
+        const response = bridge.handleLine(joinFrame(fragments, frameBytes));
+        if (response)
+            await writeResponse(options.output, response);
+    }
+}
+function joinFrame(fragments, byteLength) {
+    const frame = Buffer.concat(fragments, byteLength);
+    return frame.at(-1) === 0x0d ? frame.subarray(0, -1) : frame;
+}
+async function writeResponse(output, serialized) {
+    if (!output.write(`${serialized}\n`, "utf8"))
+        await once(output, "drain");
+}
+function serializeResponse(response) {
+    return JSON.stringify(response);
+}
+function readPreparationRequest(path, preparationId, requestSchema) {
+    if (!existsSync(path))
+        return undefined;
+    const value = readJsonFileNoFollow(path, 128 * 1024);
+    if (!isRecord(value)
+        || Object.keys(value).sort().join("\0") !== [
+            "created_at",
+            "preparation_id",
+            "request",
+            "request_sha256",
+            "schema_version",
+            "selected_ticket_prepared",
+            "selected_ticket_state",
+        ].join("\0")
+        || value.schema_version !== 1
+        || value.preparation_id !== preparationId
+        || typeof value.request_sha256 !== "string"
+        || typeof value.created_at !== "string"
+        || !["pending", "retryable", "leased"].includes(String(value.selected_ticket_state))
+        || typeof value.selected_ticket_prepared !== "boolean"
+        || !isRecord(value.request))
+        throw new Error("stored dispatch preparation request is invalid");
+    if (value.selected_ticket_state !== "pending" && value.selected_ticket_prepared !== true) {
+        throw new Error("stored dispatch preparation selected an unprepared active ticket");
+    }
+    assertSchema(value.request, requestSchema, "stored dispatch preparation request");
+    if (preparationRequestSha256(value.request, value.selected_ticket_state, value.selected_ticket_prepared) !== value.request_sha256) {
+        throw new Error("stored dispatch preparation request digest changed");
+    }
+    return value;
+}
+function readPreparationResult(path, preparationId, intentSchema) {
+    if (!existsSync(path))
+        return undefined;
+    const value = readJsonFileNoFollow(path, 256 * 1024);
+    if (!isRecord(value)
+        || Object.keys(value).sort().join("\0") !== ["dispatch_intent_sha256", "intent", "preparation_id", "prepared_at", "schema_version"].join("\0")
+        || value.schema_version !== 1
+        || value.preparation_id !== preparationId
+        || typeof value.dispatch_intent_sha256 !== "string"
+        || typeof value.prepared_at !== "string"
+        || !isRecord(value.intent))
+        throw new Error("stored dispatch preparation result is invalid");
+    assertSchema(value.intent, intentSchema, "stored dispatch preparation intent");
+    return value;
+}
+function readTicketWithinGoalScope(runtime, ticket, queueScope) {
+    const prefix = "github:label=";
+    if (!queueScope.startsWith(prefix) || queueScope.length === prefix.length) {
+        throw new Error("dispatch preparation goal queue scope is not a GitHub label scope");
+    }
+    const label = queueScope.slice(prefix.length);
+    const content = runtime.tickets.materializer.readContent({
+        ticket_id: ticket.record_id,
+        sha256: ticket.payload.content_sha256,
+        file_name: ticket.payload.content_file,
+    });
+    if (content.source !== "github"
+        || content.repository === null
+        || !content.labels.includes(label))
+        throw new Error("dispatch preparation ticket is outside the goal queue scope");
+    return content;
+}
+function assertPreparationRecoveryState(stored, current) {
+    const selectedVersion = stored.request.expected_ticket_version;
+    const selectedAttempt = stored.selected_ticket_state === "retryable"
+        ? stored.request.attempt - 1
+        : stored.request.attempt;
+    const currentPrepared = isPreparedTicket(current);
+    const exactSelected = current.version === selectedVersion
+        && current.state === stored.selected_ticket_state
+        && current.attempt === selectedAttempt
+        && currentPrepared === stored.selected_ticket_prepared;
+    const preparedPending = stored.selected_ticket_state === "pending"
+        && !stored.selected_ticket_prepared
+        && current.version === selectedVersion + 1
+        && current.state === "pending"
+        && current.attempt === selectedAttempt
+        && currentPrepared;
+    const leasedVersion = selectedVersion + (stored.selected_ticket_state === "pending" && !stored.selected_ticket_prepared ? 2 : 1);
+    const admittedLease = stored.selected_ticket_state !== "leased"
+        && current.version === leasedVersion
+        && current.state === "leased"
+        && current.attempt === stored.request.attempt
+        && currentPrepared;
+    if (!exactSelected && !preparedPending && !admittedLease) {
+        throw new Error("dispatch preparation request-only recovery found ticket version drift");
+    }
+}
+function isPreparedTicket(ticket) {
+    const prepared = ticket.payload.verification_plan_ref !== null;
+    if (prepared !== (ticket.payload.worktree !== null)
+        || prepared !== (ticket.payload.gate_digest !== null))
+        throw new Error("dispatch preparation ticket has partial preparation authority");
+    return prepared;
+}
+function assertNoConflictingDispatch(runtime, captured) {
+    const existing = runtime.dispatch.readIfExists(captured.canonical.dispatch_id);
+    if (!existing)
+        return;
+    if (captureStoredDispatchIntent(existing.payload).dispatch_intent_sha256 !== captured.dispatch_intent_sha256) {
+        throw new Error("dispatch preparation conflicts with an existing dispatch");
+    }
+}
+function preparationRequestSha256(request, selectedTicketState, selectedTicketPrepared) {
+    return sha256Canonical({
+        request,
+        selected_ticket_state: selectedTicketState,
+        selected_ticket_prepared: selectedTicketPrepared,
+    });
+}
+function sha256Canonical(value) {
+    return createHash("sha256").update(canonicalJson(value), "utf8").digest("hex");
+}
+function canonicalJson(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (!isRecord(value))
+        throw new Error("dispatch preparation contains a non-JSON value");
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+}
+function deepFreeze(value) {
+    if (typeof value !== "object" || value === null || Object.isFrozen(value))
+        return value;
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    return Object.freeze(value);
+}
+function parseToolCall(value) {
+    if (!isRecord(value) || Object.keys(value).some((key) => key !== "name" && key !== "arguments" && key !== "_meta")) {
+        return undefined;
+    }
+    if (value._meta !== undefined && !isRecord(value._meta))
+        return undefined;
+    if (value.name !== "propose_goal"
+        && value.name !== "prepare_dispatch"
+        && value.name !== "advise_dispatch"
+        && value.name !== "propose_dispatch"
+        && value.name !== "manage_worker"
+        && value.name !== "start_team"
+        && value.name !== "process_result")
+        return undefined;
+    if (!isRecord(value.arguments))
+        return undefined;
+    return { name: value.name, arguments: value.arguments };
+}
+function toolResult(payload, isError = false) {
+    const result = {
+        content: [{ type: "text", text: JSON.stringify(payload) }],
+    };
+    if (isError)
+        result.isError = true;
+    return result;
+}
+function loadToolDefinitions(packageRoot) {
+    return Object.freeze([
+        Object.freeze({
+            name: "propose_goal",
+            description: "Propose one canonical OMS goal bound to this conductor session.",
+            inputSchema: loadJsonSchema(join(packageRoot, "schemas", CONDUCTOR_BRIDGE_TOOL_SCHEMA_FILES.propose_goal)),
+        }),
+        Object.freeze({
+            name: "prepare_dispatch",
+            description: "Prepare and lease one exact goal-selected ticket, returning the server-derived dispatch intent.",
+            inputSchema: loadJsonSchema(join(packageRoot, "schemas", CONDUCTOR_BRIDGE_TOOL_SCHEMA_FILES.prepare_dispatch)),
+        }),
+        Object.freeze({
+            name: "advise_dispatch",
+            description: "Request one fresh, read-only OMS advisor decision for an exact dispatch intent before proposing it.",
+            inputSchema: loadJsonSchema(join(packageRoot, "schemas", CONDUCTOR_BRIDGE_TOOL_SCHEMA_FILES.advise_dispatch)),
+        }),
+        Object.freeze({
+            name: "propose_dispatch",
+            description: "Propose one OMS dispatch bound to existing authority and its approved advisor evidence.",
+            inputSchema: loadJsonSchema(join(packageRoot, "schemas", CONDUCTOR_BRIDGE_TOOL_SCHEMA_FILES.propose_dispatch)),
+        }),
+        Object.freeze({
+            name: "manage_worker",
+            description: "Observe, park, resume, or stop one accepted OMS worker dispatch through typed lifecycle authority.",
+            inputSchema: loadJsonSchema(join(packageRoot, "schemas", CONDUCTOR_BRIDGE_TOOL_SCHEMA_FILES.manage_worker)),
+        }),
+        Object.freeze({
+            name: "start_team",
+            description: "Persist and start one executor-only OMS group from accepted dispatch IDs.",
+            inputSchema: loadJsonSchema(join(packageRoot, "schemas", CONDUCTOR_BRIDGE_TOOL_SCHEMA_FILES.start_team)),
+        }),
+        Object.freeze({
+            name: "process_result",
+            description: "Advance one resolved OMS worker result through protected verification, one cross-engine grade, bounded retry authority, and the fixed draft-review handoff.",
+            inputSchema: loadJsonSchema(join(packageRoot, "schemas", CONDUCTOR_BRIDGE_TOOL_SCHEMA_FILES.process_result)),
+        }),
+    ]);
+}
+function isValidWorkerControl(request) {
+    if (request.action === "park") {
+        return request.reason !== null && request.reason.trim().length > 0 && request.parked_until !== null;
+    }
+    if (request.action === "stop") {
+        return request.reason !== null && request.reason.trim().length > 0 && request.parked_until === null;
+    }
+    return request.reason === null && request.parked_until === null;
+}
+function parseRequest(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const candidate = value;
+    if (candidate.jsonrpc !== "2.0" || typeof candidate.method !== "string")
+        return undefined;
+    if (candidate.id !== undefined && candidate.id !== null
+        && typeof candidate.id !== "string" && typeof candidate.id !== "number")
+        return undefined;
+    return candidate;
+}
+function success(id, result) {
+    return { jsonrpc: "2.0", id, result };
+}
+function invalidRequest(id) {
+    return failure(id, -32600, "invalid request");
+}
+function failure(id, code, message) {
+    return { jsonrpc: "2.0", id, error: { code, message } };
+}
+//# sourceMappingURL=bridge.js.map