@zq-silk/yui 0.6.2 → 0.6.4

package/dist/controller/claudeLifecycleHook.js

@@ -1,203 +0,0 @@
-import { callController } from "../core/controllerClient.js";
-import { runtimeLifecycleSignalKey } from "../runtime/lifecycleReservation.js";
-import { FileRuntimeEventInbox, MAX_RUNTIME_EVENT_FILE_BYTES } from "./runtimeEventInbox.js";
-import { resolveProviderHookRunFence } from "./providerHookRunFence.js";
-/**
- * Hidden CLI entrypoint used by the managed Claude lifecycle plugin. It parses
- * by hook_event_name and writes one immutable runtime-inbox event per fact:
- * SessionStart → native-session-lifecycle (carrying the source variant),
- * UserPromptSubmit → native-prompt-accepted (the exact provider-accepted fence),
- * PostToolUse → native-turn-progress (the exact provider/tool progress fence),
- * StopFailure → claude-stop-failure. The durable write is authoritative; the
- * socket call is only a wake-up hint.
- */
-export async function runClaudeLifecycleHookCommand(stdinJson, environment = process.env, call = callController) {
-    const home = requireIdentity(environment.YUI_HOME, "YUI_HOME");
-    const inbox = new FileRuntimeEventInbox(home);
-    const envelope = parseClaudeHookEnvelope(stdinJson, environment);
-    if (envelope.kind === "session-start") {
-        inbox.enqueueSessionLifecycle({
-            scope: "task",
-            taskId: envelope.taskId,
-            roleName: envelope.roleName,
-            agentId: envelope.agentId,
-            adapterId: "claude",
-            launchId: envelope.launchId,
-            nativeSessionId: envelope.nativeSessionId,
-            runId: envelope.runId,
-            sessionSource: envelope.sessionSource
-        });
-    }
-    else if (envelope.kind === "prompt-submit") {
-        inbox.enqueuePromptAccepted({
-            scope: "task",
-            taskId: envelope.taskId,
-            roleName: envelope.roleName,
-            agentId: envelope.agentId,
-            adapterId: "claude",
-            launchId: envelope.launchId,
-            nativeSessionId: envelope.nativeSessionId,
-            runId: envelope.runId,
-            receiptId: envelope.receiptId
-        });
-    }
-    else if (envelope.kind === "turn-progress") {
-        inbox.enqueueProviderProgress({
-            scope: "task",
-            taskId: envelope.taskId,
-            roleName: envelope.roleName,
-            agentId: envelope.agentId,
-            adapterId: "claude",
-            launchId: envelope.launchId,
-            nativeSessionId: envelope.nativeSessionId,
-            runId: envelope.runId,
-            progressId: envelope.progressId
-        });
-    }
-    else {
-        inbox.enqueueClaudeStopFailure({
-            scope: "task",
-            taskId: envelope.taskId,
-            roleName: envelope.roleName,
-            agentId: envelope.agentId,
-            adapterId: "claude",
-            launchId: envelope.launchId,
-            nativeSessionId: envelope.nativeSessionId,
-            runId: envelope.runId,
-            error: envelope.error,
-            ...(envelope.errorDetails === undefined
-                ? {}
-                : { errorDetails: envelope.errorDetails }),
-            ...(envelope.lastAssistantMessage === undefined
-                ? {}
-                : { lastAssistantMessage: envelope.lastAssistantMessage })
-        });
-    }
-    // The immutable event is authoritative; the socket call is only a hint.
-    await call(home, "scheduler.signal", {
-        key: runtimeLifecycleSignalKey({
-            scope: "task",
-            taskId: envelope.taskId,
-            roleName: envelope.roleName
-        })
-    }, { timeoutMs: 100 }).catch(() => { });
-}
-/**
- * Parses a Claude hook payload by hook_event_name into the exact fenced
- * envelope. Every event requires the managed launch envelope (task/role/agent/
- * launch/run) and the payload session id must match YUI_NATIVE_SESSION_ID, so a
- * mismatched generation fails closed before any inbox write.
- */
-export function parseClaudeHookEnvelope(stdinJson, environment) {
-    const payload = parseObject(stdinJson);
-    if (payload.hook_event_name !== "SessionStart"
-        && payload.hook_event_name !== "UserPromptSubmit"
-        && payload.hook_event_name !== "PostToolUse"
-        && payload.hook_event_name !== "StopFailure") {
-        throw new Error("Managed Claude lifecycle ingestion received an unsupported hook event.");
-    }
-    const sessionSource = payload.hook_event_name === "SessionStart"
-        ? requireIdentity(payload.source, "Claude SessionStart source")
-        : undefined;
-    const base = parseClaudeEnvelope(payload, environment, {
-        allowPreallocatedClaudeStartup: sessionSource === "startup"
-    });
-    switch (payload.hook_event_name) {
-        case "SessionStart":
-            return {
-                ...base,
-                kind: "session-start",
-                sessionSource: sessionSource
-            };
-        case "UserPromptSubmit":
-            return {
-                ...base,
-                kind: "prompt-submit",
-                receiptId: requireIdentity(base.receiptId, "Claude transport receipt id")
-            };
-        case "PostToolUse":
-            return {
-                ...base,
-                kind: "turn-progress",
-                progressId: requireIdentity(payload.tool_use_id, "Claude PostToolUse id")
-            };
-        case "StopFailure":
-            return {
-                ...base,
-                kind: "stop-failure",
-                error: requireResult(payload.error, "Claude StopFailure error"),
-                ...(payload.error_details === undefined
-                    ? {}
-                    : { errorDetails: requireResult(payload.error_details, "Claude StopFailure error_details") }),
-                ...(payload.last_assistant_message === undefined
-                    ? {}
-                    : {
-                        lastAssistantMessage: requireResult(payload.last_assistant_message, "Claude StopFailure last_assistant_message")
-                    })
-            };
-        default:
-            throw new Error("Managed Claude lifecycle ingestion received an unsupported hook event.");
-    }
-}
-function parseClaudeEnvelope(payload, environment, options) {
-    const nativeSessionId = requireIdentity(payload.session_id, "Claude session id");
-    return {
-        ...resolveProviderHookRunFence(environment, "claude", nativeSessionId, options),
-        adapterId: "claude"
-    };
-}
-export function parseClaudeStopFailureHookNotification(stdinJson, environment) {
-    const envelope = parseClaudeHookEnvelope(stdinJson, environment);
-    if (envelope.kind !== "stop-failure") {
-        throw new Error("Managed Claude lifecycle ingestion accepts only StopFailure.");
-    }
-    return {
-        taskId: envelope.taskId,
-        roleName: envelope.roleName,
-        agentId: envelope.agentId,
-        adapterId: "claude",
-        launchId: envelope.launchId,
-        runId: envelope.runId,
-        nativeSessionId: envelope.nativeSessionId,
-        type: "StopFailure",
-        error: envelope.error,
-        ...(envelope.errorDetails === undefined ? {} : { errorDetails: envelope.errorDetails }),
-        ...(envelope.lastAssistantMessage === undefined
-            ? {}
-            : { lastAssistantMessage: envelope.lastAssistantMessage })
-    };
-}
-function parseObject(value) {
-    if (value === undefined
-        || Buffer.byteLength(value, "utf8") > MAX_RUNTIME_EVENT_FILE_BYTES) {
-        throw new Error("Claude lifecycle hook stdin JSON is invalid.");
-    }
-    try {
-        const parsed = JSON.parse(value);
-        if (!isObject(parsed))
-            throw new Error("shape");
-        return parsed;
-    }
-    catch {
-        throw new Error("Claude lifecycle hook stdin JSON is invalid.");
-    }
-}
-function requireIdentity(value, label) {
-    if (typeof value !== "string" || value.includes("\0")) {
-        throw new Error(`${label} is required.`);
-    }
-    const normalized = value.trim();
-    if (normalized.length === 0 || normalized.length > 1_024) {
-        throw new Error(`${label} is invalid.`);
-    }
-    return normalized;
-}
-function requireResult(value, label) {
-    if (typeof value !== "string" || value.includes("\0") || value.trim().length === 0) {
-        throw new Error(`${label} is required.`);
-    }
-    return value;
-}
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/dist/controller/codexLifecycleHook.js

@@ -1,108 +0,0 @@
-import { callController } from "../core/controllerClient.js";
-import { runtimeLifecycleSignalKey } from "../runtime/lifecycleReservation.js";
-import { FileRuntimeEventInbox, MAX_RUNTIME_EVENT_FILE_BYTES } from "./runtimeEventInbox.js";
-import { resolveProviderHookRunFence } from "./providerHookRunFence.js";
-/**
- * Hidden CLI entrypoint used by the managed Codex lifecycle hooks. Codex 0.145
- * fires SessionStart and UserPromptSubmit inside run_turn(input); this parses
- * by hook_event_name and writes one immutable runtime-inbox event per fact.
- * SessionStart maps (via the adapter) to provider-session-started only — never
- * pre-input readiness; UserPromptSubmit is the exact provider-accepted fence.
- * The durable write is authoritative; the socket call is only a wake-up hint.
- */
-export async function runCodexLifecycleHookCommand(stdinJson, environment = process.env, call = callController) {
-    const home = requireIdentity(environment.YUI_HOME, "YUI_HOME");
-    const inbox = new FileRuntimeEventInbox(home);
-    const envelope = parseCodexHookEnvelope(stdinJson, environment);
-    if (envelope.kind === "session-start") {
-        inbox.enqueueSessionLifecycle({
-            scope: "task",
-            taskId: envelope.taskId,
-            roleName: envelope.roleName,
-            agentId: envelope.agentId,
-            adapterId: "codex",
-            launchId: envelope.launchId,
-            nativeSessionId: envelope.nativeSessionId,
-            runId: envelope.runId
-            // Codex SessionStart arrives within the first turn, not before input.
-        });
-    }
-    else {
-        inbox.enqueuePromptAccepted({
-            scope: "task",
-            taskId: envelope.taskId,
-            roleName: envelope.roleName,
-            agentId: envelope.agentId,
-            adapterId: "codex",
-            launchId: envelope.launchId,
-            nativeSessionId: envelope.nativeSessionId,
-            runId: envelope.runId,
-            receiptId: envelope.receiptId
-        });
-    }
-    await call(home, "scheduler.signal", {
-        key: runtimeLifecycleSignalKey({
-            scope: "task",
-            taskId: envelope.taskId,
-            roleName: envelope.roleName
-        })
-    }, { timeoutMs: 100 }).catch(() => { });
-}
-/**
- * Parses a Codex hook payload by hook_event_name into the exact fenced envelope.
- * Every event requires the managed launch envelope, and the payload session id
- * must match YUI_NATIVE_SESSION_ID, so a mismatched generation fails closed
- * before any inbox write.
- */
-export function parseCodexHookEnvelope(stdinJson, environment) {
-    const payload = parseObject(stdinJson);
-    if (payload.hook_event_name !== "SessionStart"
-        && payload.hook_event_name !== "UserPromptSubmit") {
-        throw new Error("Managed Codex lifecycle ingestion received an unsupported hook event.");
-    }
-    const base = parseCodexEnvelope(payload, environment);
-    switch (payload.hook_event_name) {
-        case "SessionStart":
-            return { ...base, kind: "session-start" };
-        case "UserPromptSubmit":
-            return {
-                ...base,
-                kind: "prompt-submit",
-                receiptId: requireIdentity(base.receiptId, "Codex transport receipt id")
-            };
-        default:
-            throw new Error("Managed Codex lifecycle ingestion received an unsupported hook event.");
-    }
-}
-function parseCodexEnvelope(payload, environment) {
-    const nativeSessionId = requireIdentity(payload.session_id, "Codex session id");
-    return resolveProviderHookRunFence(environment, "codex", nativeSessionId);
-}
-function parseObject(value) {
-    if (value === undefined
-        || Buffer.byteLength(value, "utf8") > MAX_RUNTIME_EVENT_FILE_BYTES) {
-        throw new Error("Codex lifecycle hook stdin JSON is invalid.");
-    }
-    try {
-        const parsed = JSON.parse(value);
-        if (!isObject(parsed))
-            throw new Error("shape");
-        return parsed;
-    }
-    catch {
-        throw new Error("Codex lifecycle hook stdin JSON is invalid.");
-    }
-}
-function requireIdentity(value, label) {
-    if (typeof value !== "string" || value.includes("\0")) {
-        throw new Error(`${label} is required.`);
-    }
-    const normalized = value.trim();
-    if (normalized.length === 0 || normalized.length > 1_024) {
-        throw new Error(`${label} is invalid.`);
-    }
-    return normalized;
-}
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/dist/controller/providerHookRunFence.js

@@ -1,156 +0,0 @@
-import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
-import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
-import { YUI_CONTROL_PLANE_DESCRIPTOR, YUI_TASK_RUNTIME_DESCRIPTOR, assertExactTaskRuntimeEnvironment, exactControlPlaneDigest, parseExactControlPlaneDescriptor, refreshReusedTaskRuntimeDescriptorSource } from "../runtime/exactControlPlane.js";
-import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
-/**
- * Resolves turn identity from the current durable in-flight fence. The one
- * exception is Claude SessionStart(startup), which can arrive synchronously
- * before Session projection and is fenced by the exact Run-bound launch
- * reservation plus deterministic native identity. The immutable hook event is
- * revalidated by the normal inbox fold before changing any state.
- */
-export function resolveProviderHookRunFence(environment, adapterId, payloadNativeSessionId, options = {}) {
-    if (environment.YUI_SESSION_SCOPE !== "task") {
-        throw new Error("Provider lifecycle hook requires a Task session scope.");
-    }
-    if (environment.YUI_ADAPTER_ID !== adapterId) {
-        throw new Error(`Provider lifecycle hook requires the ${adapterId} adapter.`);
-    }
-    const home = requireIdentity(environment.YUI_HOME, "YUI_HOME");
-    const taskId = requireIdentity(environment.YUI_TASK_ID, "Task id");
-    const roleName = requireIdentity(environment.YUI_ROLE, "Role name");
-    const agentId = requireIdentity(environment.YUI_AGENT_ID, "Agent id");
-    const workspace = requireIdentity(environment.YUI_WORKSPACE, "YUI workspace");
-    const runtimeSource = environment[YUI_TASK_RUNTIME_DESCRIPTOR];
-    const runtime = runtimeSource === undefined
-        ? undefined
-        : assertExactTaskRuntimeEnvironment(runtimeSource, environment, exactControlPlaneDigest(parseExactControlPlaneDescriptor(requireIdentity(environment[YUI_CONTROL_PLANE_DESCRIPTOR], "Exact control-plane descriptor"))), home);
-    const launchId = requireIdentity(runtime?.launchId ?? environment.YUI_LAUNCH_ID, "Launch id");
-    const nativeSessionId = requireIdentity(payloadNativeSessionId, "Provider session id");
-    const expectedNativeSessionId = runtime?.nativeSessionId ?? environment.YUI_NATIVE_SESSION_ID;
-    if (expectedNativeSessionId !== undefined
-        && nativeSessionId !== requireIdentity(expectedNativeSessionId, "YUI native session id")) {
-        throw new Error("Provider lifecycle hook native session does not match its launch envelope.");
-    }
-    const store = openCompatibleFileTaskStore(home);
-    const task = store.getTask(taskId);
-    if (task === null || task.status !== "active") {
-        throw new Error("Provider lifecycle hook Task is not current and active.");
-    }
-    const role = store.getRole(taskId, roleName);
-    if (role === null || role.activeAgentId !== agentId) {
-        throw new Error("Provider lifecycle hook Role or Agent is not current.");
-    }
-    const sessions = store.getTaskRoleSessionSet(taskId, roleName);
-    if (sessions !== null && sessions.activeAgentId !== agentId) {
-        throw new Error("Provider lifecycle hook Session Agent is not current.");
-    }
-    const inFlight = sessions?.inFlight;
-    const session = sessions?.sessions[agentId];
-    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget({
-        scope: "task",
-        taskId,
-        roleName
-    }));
-    const exactReservation = isRuntimeLaunchReservation(mailbox?.processing, launchId)
-        && !hasRuntimeCleanupObligation(mailbox);
-    const executionRef = mailbox?.processing?.executionRef;
-    const startupRunId = options.allowPreallocatedClaudeStartup === true
-        ? requireIdentity(runtime?.runId ?? environment.YUI_RUN_ID, "Run id")
-        : undefined;
-    const deterministicClaudeStartup = adapterId === "claude"
-        && options.allowPreallocatedClaudeStartup === true
-        && expectedNativeSessionId !== undefined
-        && session === undefined
-        && exactReservation
-        && executionRef?.type === "run"
-        && executionRef.taskId === taskId
-        && executionRef.id === startupRunId
-        && nativeSessionId === nativeSessionIdForLaunch(home, launchId, agentId, adapterId);
-    if ((inFlight === null || inFlight === undefined) && !deterministicClaudeStartup) {
-        throw new Error("Provider lifecycle hook has no matching durable in-flight Run.");
-    }
-    if (inFlight !== null && inFlight !== undefined && inFlight.agentId !== agentId) {
-        throw new Error("Provider lifecycle hook has no matching durable in-flight Run.");
-    }
-    if (deterministicClaudeStartup
-        && inFlight !== null
-        && inFlight !== undefined
-        && (inFlight.runId !== startupRunId
-            || inFlight.receiptId !== formatAgentRunReceiptId(taskId, startupRunId))) {
-        throw new Error("Provider lifecycle hook has no matching durable in-flight Run.");
-    }
-    const runId = inFlight?.runId ?? startupRunId;
-    let effectiveRuntime = runtime;
-    let effectiveLaunchId = launchId;
-    const sessionLaunchId = session?.launchId;
-    if (runtime !== undefined
-        && session !== undefined
-        && sessionLaunchId !== undefined
-        && typeof runtimeSource === "string"
-        && !runtimeSource.trimStart().startsWith("{")
-        && (runtime.runId !== runId
-            || runtime.launchId !== sessionLaunchId
-            || runtime.nativeSessionId !== session.nativeSessionId)) {
-        // A reused native pane keeps its original descriptor source. Advance only
-        // that Hook-owned source to the current durable generation before the
-        // volatile fence; the Controller no longer scans history to keep it fresh.
-        effectiveRuntime = refreshReusedTaskRuntimeDescriptorSource(runtimeSource, home, store, {
-            runId,
-            launchId: sessionLaunchId,
-            nativeSessionId: session.nativeSessionId
-        });
-        effectiveLaunchId = effectiveRuntime.launchId;
-    }
-    if (effectiveRuntime?.runId !== undefined && effectiveRuntime.runId !== runId) {
-        throw new Error("Provider lifecycle hook Run does not match its current descriptor.");
-    }
-    const run = store.getActiveAgentRun(taskId, roleName);
-    if (run === null
-        || run.id !== runId
-        || run.status !== "active"
-        || run.effective.agentId !== agentId
-        || run.effective.adapterId !== adapterId) {
-        throw new Error("Provider lifecycle hook Run does not match durable active state.");
-    }
-    if (run.effective.workspace.root !== workspace) {
-        throw new Error("Provider lifecycle hook workspace does not match the durable Run snapshot.");
-    }
-    if (session !== undefined) {
-        if (session.adapterId !== adapterId
-            || session.launchId !== effectiveLaunchId
-            || session.nativeSessionId !== nativeSessionId
-            || session.effective.workspace.root !== workspace) {
-            throw new Error("Provider lifecycle hook Session does not match its durable generation.");
-        }
-    }
-    else {
-        const runtimeDiscoveredCodex = adapterId === "codex"
-            && expectedNativeSessionId === undefined
-            && exactReservation;
-        if (!runtimeDiscoveredCodex && !deterministicClaudeStartup) {
-            throw new Error("Provider lifecycle hook launch is not durably reserved.");
-        }
-    }
-    return {
-        taskId,
-        roleName,
-        agentId,
-        launchId: effectiveLaunchId,
-        runId,
-        ...(inFlight?.receiptId === undefined ? {} : { receiptId: inFlight.receiptId }),
-        nativeSessionId,
-        workspace
-    };
-}
-function requireIdentity(value, label) {
-    if (typeof value !== "string" || value.includes("\0")) {
-        throw new Error(`${label} is required.`);
-    }
-    const normalized = value.trim();
-    if (normalized.length === 0 || normalized.length > 1_024) {
-        throw new Error(`${label} is invalid.`);
-    }
-    return normalized;
-}

package/dist/lifecycle/providerLifecycleMapping.js

@@ -1,190 +0,0 @@
-import { createCanonicalLifecycleEvent, CanonicalLifecycleError } from "./canonicalLifecycleEvent.js";
-/**
- * Claude, mapped from its observed SessionStart / UserPromptSubmit / StopFailure
- * contract (claude 2.1.x). SessionStart with source=startup fires at process
- * startup, *before* the first prompt, so only that exact variant proves pre-input
- * readiness. A resume/clear/compact SessionStart occurs within an existing
- * session and is downgraded to provider-session-started (never pre-input-ready).
- * A single prompt push precedes the only acceptance fence, an identity-matched
- * UserPromptSubmit.
- */
-const CLAUDE_PRE_INPUT_SESSION_SOURCE = "startup";
-const CLAUDE_LIFECYCLE_MAPPING = {
-    adapterId: "claude",
-    preInputReadiness: {
-        status: "supported",
-        nativeEvent: "SessionStart(source=startup)",
-        note: "Claude fires SessionStart at process startup before the first prompt, so "
-            + "readiness is proven pre-input by a native durable event. Only the "
-            + "startup variant qualifies; resume/clear/compact are session-started only."
-    },
-    supportedSignals: [
-        "native-session-start",
-        "native-prompt-submit",
-        "native-turn-progress",
-        "native-turn-complete",
-        "native-stop-failure"
-    ],
-    map(signal) {
-        switch (signal.kind) {
-            case "native-session-start": {
-                // The SessionStart source discriminator is required for Claude: readiness
-                // safety depends on distinguishing startup from later in-session variants.
-                if (signal.sessionSource === undefined) {
-                    throw new CanonicalLifecycleError("Claude native-session-start requires the SessionStart source variant.");
-                }
-                if (signal.sessionSource !== CLAUDE_PRE_INPUT_SESSION_SOURCE) {
-                    // A non-startup SessionStart (resume/clear/compact) fires inside an
-                    // existing session and cannot prove pre-input readiness; downgrade it.
-                    return createCanonicalLifecycleEvent({
-                        phase: "provider-session-started",
-                        source: "provider-native",
-                        evidence: "provider-native-durable",
-                        fence: signal.fence
-                    });
-                }
-                // SessionStart(startup) proves readiness before any input for Claude.
-                return createCanonicalLifecycleEvent({
-                    phase: "provider-ready",
-                    source: "provider-native",
-                    evidence: "provider-native-durable",
-                    preInputReady: true,
-                    readinessVariant: `SessionStart(source=${signal.sessionSource})`,
-                    fence: signal.fence
-                });
-            }
-            case "native-prompt-submit":
-                return createCanonicalLifecycleEvent({
-                    phase: "provider-accepted",
-                    source: "provider-native",
-                    evidence: "provider-native-durable",
-                    fence: signal.fence
-                });
-            case "native-turn-progress":
-                return createCanonicalLifecycleEvent({
-                    phase: "turn-progress",
-                    source: "provider-native",
-                    evidence: "provider-native-durable",
-                    ...(signal.sequence === undefined ? {} : { sequence: signal.sequence }),
-                    fence: signal.fence
-                });
-            case "native-turn-complete":
-                return createCanonicalLifecycleEvent({
-                    phase: "turn-terminal",
-                    source: "provider-native",
-                    evidence: "provider-native-durable",
-                    summary: signal.summary,
-                    fence: signal.fence
-                });
-            case "native-stop-failure":
-                return createCanonicalLifecycleEvent({
-                    phase: "turn-terminal",
-                    source: "provider-native",
-                    evidence: "provider-native-durable",
-                    summary: signal.summary,
-                    fence: signal.fence
-                });
-            default:
-                throw unsupportedSignal("claude", signal);
-        }
-    }
-};
-/**
- * Codex 0.145, mapped from its observed run_turn(input) -> SessionStart ->
- * UserPromptSubmit ordering. SessionStart fires *inside* run_turn — after the
- * first input — so it can only prove that the session/thread now exists, never
- * pre-input readiness. UserPromptSubmit is the acceptance fence; the notify
- * agent-turn-complete is the terminal fact. Codex emits no StopFailure hook.
- */
-const CODEX_LIFECYCLE_MAPPING = {
-    adapterId: "codex",
-    preInputReadiness: {
-        status: "unsupported",
-        reason: "not-available",
-        note: "Codex 0.145 SessionStart fires within run_turn(input), i.e. after the "
-            + "first input; no native event precedes the first prompt, so pre-input "
-            + "readiness is not available and fails closed."
-    },
-    supportedSignals: [
-        "native-session-start",
-        "native-prompt-submit",
-        "native-turn-progress",
-        "native-turn-complete"
-    ],
-    map(signal) {
-        switch (signal.kind) {
-            case "native-session-start":
-                // SessionStart proves the thread exists but arrives after the first
-                // input, so it maps to session-started only — never ready, never pre-input.
-                return createCanonicalLifecycleEvent({
-                    phase: "provider-session-started",
-                    source: "provider-native",
-                    evidence: "provider-native-durable",
-                    fence: signal.fence
-                });
-            case "native-prompt-submit":
-                return createCanonicalLifecycleEvent({
-                    phase: "provider-accepted",
-                    source: "provider-native",
-                    evidence: "provider-native-durable",
-                    fence: signal.fence
-                });
-            case "native-turn-progress":
-                return createCanonicalLifecycleEvent({
-                    phase: "turn-progress",
-                    source: "provider-native",
-                    evidence: "provider-native-durable",
-                    ...(signal.sequence === undefined ? {} : { sequence: signal.sequence }),
-                    fence: signal.fence
-                });
-            case "native-turn-complete":
-                return createCanonicalLifecycleEvent({
-                    phase: "turn-terminal",
-                    source: "provider-native",
-                    evidence: "provider-native-durable",
-                    summary: signal.summary,
-                    fence: signal.fence
-                });
-            case "native-stop-failure":
-                // Codex 0.145 has no StopFailure hook; refuse rather than invent one.
-                throw unsupportedSignal("codex", signal);
-            default:
-                throw unsupportedSignal("codex", signal);
-        }
-    }
-};
-const PROVIDER_LIFECYCLE_MAPPINGS = Object.freeze({
-    claude: CLAUDE_LIFECYCLE_MAPPING,
-    codex: CODEX_LIFECYCLE_MAPPING
-});
-/**
- * Registry lookup: returns the mapping for an adapter without the caller
- * branching on the provider name. Unknown adapters fail closed.
- */
-export function providerLifecycleMapping(adapterId) {
-    const mapping = findProviderLifecycleMapping(adapterId);
-    if (mapping === null) {
-        throw new CanonicalLifecycleError(`No lifecycle mapping for adapter: ${adapterId}.`);
-    }
-    return mapping;
-}
-export function findProviderLifecycleMapping(adapterId) {
-    return adapterId === "codex" || adapterId === "claude"
-        ? PROVIDER_LIFECYCLE_MAPPINGS[adapterId]
-        : null;
-}
-/** Neutral capability lookup for consumers that need only the readiness fact. */
-export function preInputReadinessCapability(adapterId) {
-    return providerLifecycleMapping(adapterId).preInputReadiness;
-}
-/**
- * Maps a native signal through the adapter selected by its fence. The fence's
- * adapterId chooses the mapping, so a Codex signal can never be mapped by
- * Claude's rules or vice versa.
- */
-export function mapNativeLifecycleSignal(signal) {
-    return providerLifecycleMapping(signal.fence.adapterId).map(signal);
-}
-function unsupportedSignal(adapterId, signal) {
-    return new CanonicalLifecycleError(`Adapter ${adapterId} does not emit native signal: ${signal.kind}.`);
-}