patchrelay 0.8.8 → 0.9.0

package/dist/reconciliation-action-applier.js

@@ -1,68 +0,0 @@
-export class ReconciliationActionApplier {
-    callbacks;
-    constructor(callbacks) {
-        this.callbacks = callbacks;
-    }
-    async apply(params) {
-        const { snapshot, decision } = params;
-        const threadId = snapshot.runLease.threadId;
-        const turnId = snapshot.runLease.turnId;
-        const obligationTargetAction = decision.actions.find((action) => action.type === "deliver_obligation" || action.type === "route_obligation");
-        const targetThreadId = obligationTargetAction?.type === "deliver_obligation" || obligationTargetAction?.type === "route_obligation"
-            ? obligationTargetAction.threadId
-            : threadId;
-        const targetTurnId = obligationTargetAction?.type === "deliver_obligation" || obligationTargetAction?.type === "route_obligation"
-            ? obligationTargetAction.turnId
-            : turnId;
-        const clearAction = decision.actions.find((action) => action.type === "clear_active_run" || action.type === "release_issue_ownership");
-        const nextLifecycleStatus = clearAction?.type === "clear_active_run" || clearAction?.type === "release_issue_ownership"
-            ? clearAction.nextLifecycleStatus
-            : undefined;
-        if (decision.outcome === "launch") {
-            this.callbacks.enqueueIssue(snapshot.runLease.projectId, snapshot.runLease.linearIssueId);
-            return;
-        }
-        if (decision.outcome === "continue") {
-            if (targetThreadId) {
-                await this.callbacks.deliverPendingObligations(snapshot.runLease.projectId, snapshot.runLease.linearIssueId, targetThreadId, targetTurnId);
-            }
-            return;
-        }
-        const completedAction = decision.actions.find((action) => action.type === "mark_run_completed");
-        if (decision.outcome === "complete" || (decision.outcome === "release" && completedAction?.type === "mark_run_completed")) {
-            const liveThread = snapshot.input.live?.codex?.status === "found" ? snapshot.input.live.codex.thread : undefined;
-            if (!liveThread) {
-                return;
-            }
-            const latestTurn = liveThread.turns.at(-1);
-            this.callbacks.completeRun(snapshot.runLease.projectId, snapshot.runLease.linearIssueId, liveThread, {
-                threadId: liveThread.id,
-                ...(latestTurn?.id ? { turnId: latestTurn.id } : {}),
-                ...(nextLifecycleStatus ? { nextLifecycleStatus } : {}),
-            });
-            return;
-        }
-        if (decision.outcome === "fail" || decision.outcome === "release") {
-            const failedAction = decision.actions.find((action) => action.type === "mark_run_failed");
-            if (decision.outcome === "release" && failedAction?.type !== "mark_run_failed") {
-                const releasedAction = decision.actions.find((action) => action.type === "release_issue_ownership");
-                if (releasedAction?.type !== "release_issue_ownership") {
-                    return;
-                }
-                await this.callbacks.releaseRunDuringReconciliation(snapshot.runLease.projectId, snapshot.runLease.linearIssueId, {
-                    runId: snapshot.runLease.id,
-                    ...(threadId ? { threadId } : {}),
-                    ...(turnId ? { turnId } : {}),
-                    ...(nextLifecycleStatus ? { nextLifecycleStatus } : {}),
-                    ...(snapshot.input.live?.linear?.status === "known" && snapshot.input.live.linear.issue?.stateName
-                        ? { currentLinearState: snapshot.input.live.linear.issue.stateName }
-                        : {}),
-                });
-                return;
-            }
-            await this.callbacks.failRunDuringReconciliation(snapshot.runLease.projectId, snapshot.runLease.linearIssueId, failedAction?.type === "mark_run_failed" && failedAction.threadId
-                ? failedAction.threadId
-                : threadId ?? `missing-thread-${snapshot.runLease.id}`, decision.reasons[0] ?? "Thread was not found during startup reconciliation", ...(failedAction?.type === "mark_run_failed" && failedAction.turnId ? [{ turnId: failedAction.turnId }] : []));
-        }
-    }
-}

package/dist/reconciliation-actions.js

@@ -1 +0,0 @@
-export {};

package/dist/reconciliation-engine.js

@@ -1,350 +0,0 @@
-export class ReconciliationEngine {
-    reconcile(input) {
-        const actions = [];
-        const issue = input.issue;
-        const policy = input.policy ?? {};
-        const liveLinear = input.live?.linear ?? { status: "unknown" };
-        const liveCodex = input.live?.codex ?? { status: "unknown" };
-        const obligations = relevantObligations(issue, input.obligations ?? []);
-        if (!issue.activeRun) {
-            if (!issue.desiredStage) {
-                return {
-                    outcome: "noop",
-                    reasons: ["issue has no active run and no desired stage"],
-                    actions,
-                };
-            }
-            return {
-                outcome: "launch",
-                reasons: [`desired stage ${issue.desiredStage} is ready to launch`],
-                actions: [
-                    {
-                        type: "launch_desired_stage",
-                        projectId: issue.projectId,
-                        linearIssueId: issue.linearIssueId,
-                        stage: issue.desiredStage,
-                        reason: "desired stage exists without an active run",
-                    },
-                ],
-            };
-        }
-        if (needsLinearState(issue, policy, liveLinear)) {
-            actions.push({
-                type: "read_linear_issue",
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                reason: "active reconciliation needs the live Linear state",
-            });
-        }
-        if (needsCodexState(issue.activeRun, liveCodex)) {
-            actions.push({
-                type: "read_codex_thread",
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                runId: issue.activeRun.id,
-                threadId: issue.activeRun.threadId,
-                reason: "active reconciliation needs the live Codex thread",
-            });
-        }
-        if (actions.length > 0) {
-            return {
-                outcome: "hydrate_live_state",
-                reasons: ["reconciliation needs fresh live state before deciding"],
-                actions,
-            };
-        }
-        return reconcileActiveRun({
-            issue,
-            liveLinear,
-            liveCodex,
-            obligations,
-            policy,
-        });
-    }
-}
-export function reconcileIssue(input) {
-    return new ReconciliationEngine().reconcile(input);
-}
-function reconcileActiveRun(params) {
-    const { issue, liveLinear, liveCodex, obligations, policy } = params;
-    const run = issue.activeRun;
-    const authoritativeStopState = resolveAuthoritativeStopState(liveLinear);
-    if (authoritativeStopState) {
-        return {
-            outcome: "release",
-            reasons: [`live Linear state is already ${authoritativeStopState.stateName}`],
-            actions: [
-                {
-                    type: "release_issue_ownership",
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    runId: run.id,
-                    nextLifecycleStatus: authoritativeStopState.lifecycleStatus,
-                    reason: `live Linear state is already ${authoritativeStopState.stateName}`,
-                },
-            ],
-        };
-    }
-    if (run.status === "queued") {
-        return {
-            outcome: "launch",
-            reasons: ["queued run has not been materialized yet"],
-            actions: [
-                {
-                    type: "launch_desired_stage",
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    stage: run.stage,
-                    runId: run.id,
-                    reason: "active run is queued and should be launched",
-                },
-            ],
-        };
-    }
-    if (!run.threadId) {
-        return failRun(issue, run, liveLinear, policy, "active run is missing a persisted thread id");
-    }
-    if (liveCodex.status === "error") {
-        return {
-            outcome: "continue",
-            reasons: [liveCodex.errorMessage ?? "codex thread lookup failed"],
-            actions: [
-                {
-                    type: "await_codex_retry",
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    runId: run.id,
-                    reason: liveCodex.errorMessage ?? "codex thread lookup failed",
-                },
-            ],
-        };
-    }
-    if (liveCodex.status === "missing" || !liveCodex.thread) {
-        return failRun(issue, run, liveLinear, policy, "thread was not found during reconciliation");
-    }
-    const latestTurn = latestThreadTurn(liveCodex.thread);
-    const targetTurnId = latestTurn?.id ?? run.turnId;
-    if (!latestTurn || latestTurn.status === "inProgress") {
-        const actions = routePendingObligations(issue, run, obligations, liveCodex.thread.id, targetTurnId);
-        actions.push({
-            type: "keep_run_active",
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            runId: run.id,
-            reason: !latestTurn ? "thread has not produced a turn yet" : "latest turn is still in progress",
-        });
-        return {
-            outcome: "continue",
-            reasons: [!latestTurn ? "thread has no completed turns yet" : "latest turn is still in progress"],
-            actions,
-        };
-    }
-    if (latestTurn.status !== "completed") {
-        return failRun(issue, run, liveLinear, policy, "thread completed reconciliation in a failed state", latestTurn.id);
-    }
-    const actions = [
-        {
-            type: "mark_run_completed",
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            runId: run.id,
-            threadId: liveCodex.thread.id,
-            ...(latestTurn.id ? { turnId: latestTurn.id } : {}),
-            reason: "latest turn completed successfully during reconciliation",
-        },
-    ];
-    if (shouldAwaitHandoff(liveLinear, policy)) {
-        actions.push({
-            type: "clear_active_run",
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            runId: run.id,
-            nextLifecycleStatus: "paused",
-            reason: "stage completed while the issue still matches the service-owned active Linear state",
-        }, {
-            type: "refresh_status_comment",
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            runId: run.id,
-            ...(issue.statusCommentId ? { commentId: issue.statusCommentId } : {}),
-            mode: "awaiting_handoff",
-            reason: "stage completed and should publish an awaiting handoff status",
-        });
-        return {
-            outcome: "complete",
-            reasons: ["stage completed and should pause for human handoff"],
-            actions,
-        };
-    }
-    actions.push({
-        type: "release_issue_ownership",
-        projectId: issue.projectId,
-        linearIssueId: issue.linearIssueId,
-        runId: run.id,
-        nextLifecycleStatus: "completed",
-        reason: "stage completed after the live Linear state moved on",
-    });
-    return {
-        outcome: "release",
-        reasons: ["stage completed and the live Linear state already moved on"],
-        actions,
-    };
-}
-function failRun(issue, run, liveLinear, policy, message, turnId) {
-    const actions = [
-        {
-            type: "mark_run_failed",
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            runId: run.id,
-            ...(run.threadId ? { threadId: run.threadId } : {}),
-            ...(turnId ? { turnId } : run.turnId ? { turnId: run.turnId } : {}),
-            reason: message,
-        },
-    ];
-    if (shouldFailBack(liveLinear, policy)) {
-        actions.push({
-            type: "sync_linear_failure",
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            runId: run.id,
-            ...(policy.activeLinearStateName ? { expectedStateName: policy.activeLinearStateName } : {}),
-            ...(policy.fallbackLinearStateName ? { fallbackStateName: policy.fallbackLinearStateName } : {}),
-            message,
-        }, {
-            type: "clear_active_run",
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            runId: run.id,
-            nextLifecycleStatus: "failed",
-            reason: "run failed while PatchRelay still owned the expected active Linear state",
-        });
-        if (issue.statusCommentId) {
-            actions.push({
-                type: "refresh_status_comment",
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                runId: run.id,
-                commentId: issue.statusCommentId,
-                mode: "failed",
-                reason: "run failed and should refresh the service-owned status comment",
-            });
-        }
-        return {
-            outcome: "fail",
-            reasons: [message],
-            actions,
-        };
-    }
-    actions.push({
-        type: "release_issue_ownership",
-        projectId: issue.projectId,
-        linearIssueId: issue.linearIssueId,
-        runId: run.id,
-        nextLifecycleStatus: "failed",
-        reason: "run failed after the live Linear state moved on",
-    });
-    return {
-        outcome: "release",
-        reasons: [message, "live Linear state no longer matches the expected service-owned active state"],
-        actions,
-    };
-}
-function routePendingObligations(issue, run, obligations, threadId, turnId) {
-    if (!turnId) {
-        return [];
-    }
-    const actions = [];
-    for (const obligation of obligations) {
-        const needsRouting = obligation.threadId !== threadId || obligation.turnId !== turnId;
-        if (needsRouting) {
-            actions.push({
-                type: "route_obligation",
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                obligationId: obligation.id,
-                runId: run.id,
-                threadId,
-                turnId,
-                reason: "pending obligation should target the latest live turn",
-            });
-        }
-        actions.push({
-            type: "deliver_obligation",
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            obligationId: obligation.id,
-            runId: run.id,
-            threadId,
-            turnId,
-            reason: "pending obligation can be delivered to the active turn",
-        });
-    }
-    return actions;
-}
-function needsLinearState(issue, policy, liveLinear) {
-    if (!issue.activeRun) {
-        return false;
-    }
-    if (!policy.activeLinearStateName && !policy.fallbackLinearStateName) {
-        return false;
-    }
-    return liveLinear.status === "unknown";
-}
-function needsCodexState(run, liveCodex) {
-    if (!run.threadId) {
-        return false;
-    }
-    return liveCodex.status === "unknown";
-}
-function shouldFailBack(liveLinear, policy) {
-    return matchesActiveLinearOwnership(liveLinear, policy);
-}
-function shouldAwaitHandoff(liveLinear, policy) {
-    return matchesActiveLinearOwnership(liveLinear, policy);
-}
-function matchesActiveLinearOwnership(liveLinear, policy) {
-    if (!policy.activeLinearStateName) {
-        return true;
-    }
-    if (liveLinear.status !== "known") {
-        return false;
-    }
-    return liveLinear.issue?.stateName === policy.activeLinearStateName;
-}
-function resolveAuthoritativeStopState(liveLinear) {
-    if (liveLinear.status !== "known" || !liveLinear.issue?.stateName) {
-        return undefined;
-    }
-    const stateName = liveLinear.issue.stateName.trim();
-    const normalizedName = stateName.toLowerCase();
-    const normalizedType = liveLinear.issue.stateType?.trim().toLowerCase();
-    if (normalizedType === "completed" || normalizedName === "done" || normalizedName === "completed" || normalizedName === "complete") {
-        return {
-            stateName,
-            lifecycleStatus: "completed",
-        };
-    }
-    if (normalizedName === "human needed") {
-        return {
-            stateName,
-            lifecycleStatus: "paused",
-        };
-    }
-    return undefined;
-}
-function relevantObligations(issue, obligations) {
-    const activeRunId = issue.activeRun?.id;
-    return obligations.filter((obligation) => {
-        if (obligation.status === "completed" || obligation.status === "cancelled") {
-            return false;
-        }
-        if (activeRunId === undefined) {
-            return false;
-        }
-        return obligation.runId === undefined || obligation.runId === activeRunId;
-    });
-}
-function latestThreadTurn(thread) {
-    return thread.turns.at(-1);
-}

package/dist/reconciliation-snapshot-builder.js

@@ -1,135 +0,0 @@
-import { resolveWorkflowStageConfig } from "./workflow-policy.js";
-import { safeJsonParse } from "./utils.js";
-export async function buildReconciliationSnapshot(params) {
-    const runLease = params.stores.runLeases.getRunLease(params.runLeaseId);
-    if (!runLease) {
-        return undefined;
-    }
-    const issueControl = params.stores.issueControl.getIssueControl(runLease.projectId, runLease.linearIssueId);
-    if (!issueControl) {
-        return undefined;
-    }
-    const workspaceOwnership = params.stores.workspaceOwnership.getWorkspaceOwnership(runLease.workspaceOwnershipId);
-    const project = params.config.projects.find((candidate) => candidate.id === runLease.projectId);
-    const workflowConfig = project ? resolveWorkflowStageConfig(project, runLease.stage, issueControl.selectedWorkflowId) : undefined;
-    const liveLinear = project
-        ? await params.linearProvider
-            .forProject(runLease.projectId)
-            .then((linear) => linear
-            ? linear.getIssue(runLease.linearIssueId).then((issue) => issue.stateName
-                ? {
-                    status: "known",
-                    issue: {
-                        id: issue.id,
-                        stateName: issue.stateName,
-                        ...(() => {
-                            const currentState = issue.workflowStates?.find((state) => state.name === issue.stateName);
-                            return currentState?.type ? { stateType: currentState.type } : {};
-                        })(),
-                    },
-                }
-                : ({ status: "unknown" }))
-            : ({ status: "unknown" }))
-            .catch(() => ({ status: "unknown" }))
-        : ({ status: "unknown" });
-    const liveCodex = runLease.threadId
-        ? await hydrateLiveCodexState({
-            codex: params.codex,
-            threadId: runLease.threadId,
-            ...(workspaceOwnership?.worktreePath ? { cwd: workspaceOwnership.worktreePath } : {}),
-        })
-        : ({ status: "unknown" });
-    const obligations = params.stores.obligations
-        .listPendingObligations({ runLeaseId: runLease.id, includeInProgress: true })
-        .map((obligation) => {
-        const payload = safeJsonParse(obligation.payloadJson);
-        return {
-            id: obligation.id,
-            kind: obligation.kind,
-            status: obligation.status,
-            ...(obligation.runLeaseId !== undefined ? { runId: obligation.runLeaseId } : {}),
-            ...(obligation.threadId ? { threadId: obligation.threadId } : {}),
-            ...(obligation.turnId ? { turnId: obligation.turnId } : {}),
-            ...(payload !== undefined ? { payload } : {}),
-        };
-    });
-    return {
-        issueControl,
-        runLease,
-        ...(workspaceOwnership ? { workspaceOwnership } : {}),
-        input: {
-            issue: {
-                projectId: runLease.projectId,
-                linearIssueId: runLease.linearIssueId,
-                ...(issueControl.desiredStage ? { desiredStage: issueControl.desiredStage } : {}),
-                lifecycleStatus: issueControl.lifecycleStatus,
-                ...(issueControl.serviceOwnedCommentId ? { statusCommentId: issueControl.serviceOwnedCommentId } : {}),
-                activeRun: {
-                    id: runLease.id,
-                    stage: runLease.stage,
-                    status: runLease.status,
-                    ...(runLease.threadId ? { threadId: runLease.threadId } : {}),
-                    ...(runLease.turnId ? { turnId: runLease.turnId } : {}),
-                    ...(runLease.parentThreadId ? { parentThreadId: runLease.parentThreadId } : {}),
-                },
-            },
-            ...(obligations.length > 0 ? { obligations } : {}),
-            ...(workflowConfig
-                ? {
-                    policy: {
-                        ...(workflowConfig.activeState ? { activeLinearStateName: workflowConfig.activeState } : {}),
-                        ...(workflowConfig.fallbackState ? { fallbackLinearStateName: workflowConfig.fallbackState } : {}),
-                    },
-                }
-                : {}),
-            live: {
-                linear: liveLinear,
-                codex: liveCodex,
-            },
-        },
-    };
-}
-async function hydrateLiveCodexState(params) {
-    try {
-        const thread = await params.codex.readThread(params.threadId, true);
-        if (latestThreadTurn(thread)?.status === "interrupted" && params.cwd) {
-            const resumedThread = await tryResumeThread(params.codex, params.threadId, params.cwd);
-            if (resumedThread) {
-                return { status: "found", thread: resumedThread };
-            }
-        }
-        return { status: "found", thread };
-    }
-    catch (error) {
-        const mapped = mapCodexReadFailure(error);
-        if (mapped.status === "missing" && params.cwd) {
-            const resumedThread = await tryResumeThread(params.codex, params.threadId, params.cwd);
-            if (resumedThread) {
-                return { status: "found", thread: resumedThread };
-            }
-        }
-        return mapped;
-    }
-}
-async function tryResumeThread(codex, threadId, cwd) {
-    try {
-        return await codex.resumeThread(threadId, cwd);
-    }
-    catch {
-        return undefined;
-    }
-}
-function latestThreadTurn(thread) {
-    return thread.turns.at(-1);
-}
-function mapCodexReadFailure(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const normalized = message.trim().toLowerCase();
-    if (normalized.includes("not found") || normalized.includes("missing")) {
-        return { status: "missing" };
-    }
-    return {
-        status: "error",
-        errorMessage: message,
-    };
-}

package/dist/reconciliation-types.js

@@ -1 +0,0 @@
-export {};