patchrelay 0.8.9 → 0.9.1

package/dist/service-webhook-processor.js

@@ -1,411 +0,0 @@
-import { resolveProject, trustedActorAllowed } from "./project-resolution.js";
-import { StageAgentActivityPublisher } from "./stage-agent-activity-publisher.js";
-import { StageTurnInputDispatcher } from "./stage-turn-input-dispatcher.js";
-import { safeJsonParse, sanitizeDiagnosticText } from "./utils.js";
-import { AgentSessionWebhookHandler } from "./webhook-agent-session-handler.js";
-import { CommentWebhookHandler } from "./webhook-comment-handler.js";
-import { WebhookDesiredStageRecorder } from "./webhook-desired-stage-recorder.js";
-import { InstallationWebhookHandler } from "./webhook-installation-handler.js";
-import { normalizeWebhook } from "./webhooks.js";
-export class ServiceWebhookProcessor {
-    config;
-    stores;
-    linearProvider;
-    enqueueIssue;
-    logger;
-    feed;
-    desiredStageRecorder;
-    agentSessionHandler;
-    commentHandler;
-    installationHandler;
-    constructor(config, stores, linearProvider, codex, enqueueIssue, logger, feed) {
-        this.config = config;
-        this.stores = stores;
-        this.linearProvider = linearProvider;
-        this.enqueueIssue = enqueueIssue;
-        this.logger = logger;
-        this.feed = feed;
-        const turnInputDispatcher = new StageTurnInputDispatcher(stores, codex, logger);
-        const agentActivity = new StageAgentActivityPublisher(config, linearProvider, logger);
-        this.desiredStageRecorder = new WebhookDesiredStageRecorder(stores);
-        this.agentSessionHandler = new AgentSessionWebhookHandler(stores, turnInputDispatcher, agentActivity, feed);
-        this.commentHandler = new CommentWebhookHandler(stores, turnInputDispatcher, feed);
-        this.installationHandler = new InstallationWebhookHandler(config, stores, logger);
-    }
-    async processWebhookEvent(webhookEventId) {
-        const event = this.stores.webhookEvents.getWebhookEvent(webhookEventId);
-        if (!event) {
-            this.logger.warn({ webhookEventId }, "Webhook event was not found during processing");
-            return;
-        }
-        try {
-            const payload = safeJsonParse(event.payloadJson);
-            if (!payload) {
-                this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "failed");
-                this.markEventReceiptProcessed(event.webhookId, "failed");
-                throw new Error(`Stored webhook payload is invalid JSON: event ${webhookEventId}`);
-            }
-            let normalized = normalizeWebhook({
-                webhookId: event.webhookId,
-                payload,
-            });
-            this.logger.info({
-                webhookEventId,
-                webhookId: event.webhookId,
-                eventType: normalized.eventType,
-                triggerEvent: normalized.triggerEvent,
-                issueKey: normalized.issue?.identifier,
-                issueId: normalized.issue?.id,
-            }, "Processing stored webhook event");
-            if (!normalized.issue) {
-                this.feed?.publish({
-                    level: "info",
-                    kind: "webhook",
-                    status: normalized.triggerEvent,
-                    summary: `Received ${normalized.triggerEvent} webhook`,
-                });
-                this.installationHandler.handle(normalized);
-                this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "processed");
-                this.markEventReceiptProcessed(event.webhookId, "processed");
-                return;
-            }
-            let project = resolveProject(this.config, normalized.issue);
-            if (!project) {
-                const routed = await this.tryHydrateProjectRoute(normalized);
-                if (routed) {
-                    normalized = routed.normalized;
-                    project = routed.project;
-                }
-            }
-            if (!project) {
-                const unresolvedIssue = normalized.issue;
-                if (!unresolvedIssue) {
-                    this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "failed");
-                    this.markEventReceiptProcessed(event.webhookId, "failed");
-                    throw new Error(`Normalized issue context disappeared before routing webhook ${event.webhookId}`);
-                }
-                this.feed?.publish({
-                    level: "warn",
-                    kind: "webhook",
-                    issueKey: unresolvedIssue.identifier,
-                    status: "ignored",
-                    summary: "Ignored webhook with no matching project route",
-                    detail: normalized.triggerEvent,
-                });
-                this.logger.info({
-                    webhookEventId,
-                    webhookId: event.webhookId,
-                    issueKey: unresolvedIssue.identifier,
-                    issueId: unresolvedIssue.id,
-                    teamId: unresolvedIssue.teamId,
-                    teamKey: unresolvedIssue.teamKey,
-                    triggerEvent: normalized.triggerEvent,
-                }, "Ignoring webhook because no project route matched the Linear issue");
-                this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "processed");
-                this.markEventReceiptProcessed(event.webhookId, "processed");
-                return;
-            }
-            const routedIssue = normalized.issue;
-            if (!routedIssue) {
-                this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "failed");
-                this.markEventReceiptProcessed(event.webhookId, "failed");
-                throw new Error(`Normalized issue context disappeared while routing webhook ${event.webhookId}`);
-            }
-            if (!trustedActorAllowed(project, normalized.actor)) {
-                this.feed?.publish({
-                    level: "warn",
-                    kind: "webhook",
-                    issueKey: routedIssue.identifier,
-                    projectId: project.id,
-                    status: "ignored",
-                    summary: "Ignored webhook from an untrusted actor",
-                    detail: normalized.actor?.name ?? normalized.actor?.email ?? normalized.triggerEvent,
-                });
-                this.logger.info({
-                    webhookId: normalized.webhookId,
-                    projectId: project.id,
-                    triggerEvent: normalized.triggerEvent,
-                    actorId: normalized.actor?.id,
-                    actorName: normalized.actor?.name,
-                    actorEmail: normalized.actor?.email,
-                }, "Ignoring webhook from untrusted Linear actor");
-                this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "processed");
-                this.assignEventReceiptContext(event.webhookId, project.id, routedIssue.id);
-                this.markEventReceiptProcessed(event.webhookId, "processed");
-                return;
-            }
-            this.stores.webhookEvents.assignWebhookProject(webhookEventId, project.id);
-            const receipt = this.ensureEventReceipt(event, project.id, routedIssue.id);
-            const hydrated = await this.hydrateIssueContext(project.id, normalized);
-            const hydratedIssue = hydrated.issue ?? routedIssue;
-            const priorIssue = this.stores.issueWorkflows.getTrackedIssue(project.id, hydratedIssue.id);
-            const issueState = this.desiredStageRecorder.record(project, hydrated, receipt ? { eventReceiptId: receipt.id } : undefined);
-            const observation = describeWebhookObservation(hydrated, issueState.delegatedToPatchRelay);
-            if (observation) {
-                this.feed?.publish({
-                    level: "info",
-                    kind: observation.kind,
-                    issueKey: hydratedIssue.identifier,
-                    projectId: project.id,
-                    ...(issueState.issue?.selectedWorkflowId ? { workflowId: issueState.issue.selectedWorkflowId } : {}),
-                    ...(observation.status ? { status: observation.status } : {}),
-                    summary: observation.summary,
-                    ...(observation.detail ? { detail: observation.detail } : {}),
-                });
-            }
-            if (issueState.issue?.selectedWorkflowId &&
-                issueState.issue.selectedWorkflowId !== priorIssue?.selectedWorkflowId) {
-                this.feed?.publish({
-                    level: "info",
-                    kind: "workflow",
-                    issueKey: hydratedIssue.identifier,
-                    projectId: project.id,
-                    workflowId: issueState.issue.selectedWorkflowId,
-                    ...(issueState.desiredStage ? { nextStage: issueState.desiredStage } : {}),
-                    status: "selected",
-                    summary: `Selected ${issueState.issue.selectedWorkflowId} workflow`,
-                    detail: issueState.desiredStage
-                        ? `PatchRelay will start with ${issueState.desiredStage} from ${hydratedIssue.stateName ?? "the current Linear state"}.`
-                        : undefined,
-                });
-            }
-            await this.agentSessionHandler.handle({
-                normalized: hydrated,
-                project,
-                issue: issueState.issue,
-                desiredStage: issueState.desiredStage,
-                delegatedToPatchRelay: issueState.delegatedToPatchRelay,
-            });
-            await this.commentHandler.handle(hydrated, project);
-            this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "processed");
-            this.markEventReceiptProcessed(event.webhookId, "processed");
-            if (issueState.desiredStage) {
-                this.feed?.publish({
-                    level: "info",
-                    kind: "stage",
-                    issueKey: hydratedIssue.identifier,
-                    projectId: project.id,
-                    stage: issueState.desiredStage,
-                    ...(issueState.issue?.selectedWorkflowId ? { workflowId: issueState.issue.selectedWorkflowId } : {}),
-                    status: "queued",
-                    summary: `Queued ${issueState.desiredStage} workflow`,
-                    detail: `Triggered by ${hydrated.triggerEvent}${hydratedIssue.stateName ? ` from ${hydratedIssue.stateName}` : ""}.`,
-                });
-                this.logger.info({
-                    webhookEventId,
-                    webhookId: event.webhookId,
-                    projectId: project.id,
-                    issueKey: hydratedIssue.identifier,
-                    issueId: hydratedIssue.id,
-                    desiredStage: issueState.desiredStage,
-                    delegatedToPatchRelay: issueState.delegatedToPatchRelay,
-                }, "Recorded desired stage from webhook and enqueued issue execution");
-                this.enqueueIssue(project.id, hydratedIssue.id);
-                return;
-            }
-            this.logger.info({
-                webhookEventId,
-                webhookId: event.webhookId,
-                projectId: project.id,
-                issueKey: hydratedIssue.identifier,
-                issueId: hydratedIssue.id,
-                triggerEvent: hydrated.triggerEvent,
-                delegatedToPatchRelay: issueState.delegatedToPatchRelay,
-            }, "Processed webhook without enqueuing a new stage run");
-        }
-        catch (error) {
-            this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "failed");
-            this.markEventReceiptProcessed(event.webhookId, "failed");
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.feed?.publish({
-                level: "error",
-                kind: "webhook",
-                projectId: event.projectId ?? undefined,
-                status: "failed",
-                summary: "Failed to process webhook",
-                detail: sanitizeDiagnosticText(err.message),
-            });
-            this.logger.error({
-                webhookEventId,
-                webhookId: event.webhookId,
-                issueId: event.issueId,
-                projectId: event.projectId,
-                error: sanitizeDiagnosticText(err.message),
-                stack: err.stack,
-            }, "Failed to process Linear webhook event");
-            throw err;
-        }
-    }
-    async hydrateIssueContext(projectId, normalized) {
-        if (!normalized.issue) {
-            return normalized;
-        }
-        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted") {
-            return normalized;
-        }
-        if (hasCompleteIssueContext(normalized.issue)) {
-            return normalized;
-        }
-        const linear = await this.linearProvider.forProject(projectId);
-        if (!linear) {
-            return normalized;
-        }
-        try {
-            const liveIssue = await linear.getIssue(normalized.issue.id);
-            return {
-                ...normalized,
-                issue: mergeIssueMetadata(normalized.issue, liveIssue),
-            };
-        }
-        catch (error) {
-            this.logger.warn({
-                projectId,
-                issueId: normalized.issue.id,
-                triggerEvent: normalized.triggerEvent,
-                error: sanitizeDiagnosticText(error instanceof Error ? error.message : String(error)),
-            }, "Failed to hydrate sparse Linear issue context for agent session webhook");
-            return normalized;
-        }
-    }
-    async tryHydrateProjectRoute(normalized) {
-        if (!normalized.issue) {
-            return undefined;
-        }
-        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted") {
-            return undefined;
-        }
-        for (const candidate of this.config.projects) {
-            const linear = await this.linearProvider.forProject(candidate.id);
-            if (!linear) {
-                continue;
-            }
-            try {
-                const liveIssue = await linear.getIssue(normalized.issue.id);
-                const hydrated = {
-                    ...normalized,
-                    issue: mergeIssueMetadata(normalized.issue, liveIssue),
-                };
-                const resolved = resolveProject(this.config, hydrated.issue);
-                if (resolved) {
-                    return {
-                        project: resolved,
-                        normalized: hydrated,
-                    };
-                }
-            }
-            catch (error) {
-                this.logger.debug({
-                    candidateProjectId: candidate.id,
-                    issueId: normalized.issue.id,
-                    triggerEvent: normalized.triggerEvent,
-                    error: sanitizeDiagnosticText(error instanceof Error ? error.message : String(error)),
-                }, "Failed to hydrate Linear issue context while resolving project route");
-            }
-        }
-        return undefined;
-    }
-    assignEventReceiptContext(webhookId, projectId, linearIssueId) {
-        const receipt = this.lookupEventReceipt(webhookId);
-        if (!receipt) {
-            return;
-        }
-        this.stores.eventReceipts.assignEventReceiptContext(receipt.id, {
-            ...(projectId ? { projectId } : {}),
-            ...(linearIssueId ? { linearIssueId } : {}),
-        });
-    }
-    markEventReceiptProcessed(webhookId, status) {
-        const receipt = this.lookupEventReceipt(webhookId);
-        if (!receipt) {
-            return;
-        }
-        this.stores.eventReceipts.markEventReceiptProcessed(receipt.id, status);
-    }
-    lookupEventReceipt(webhookId) {
-        return this.stores.eventReceipts.getEventReceiptBySourceExternalId("linear-webhook", webhookId);
-    }
-    ensureEventReceipt(event, projectId, linearIssueId) {
-        const existing = this.lookupEventReceipt(event.webhookId);
-        if (existing) {
-            this.assignEventReceiptContext(event.webhookId, projectId, linearIssueId);
-            return existing;
-        }
-        const inserted = this.stores.eventReceipts.insertEventReceipt({
-            source: "linear-webhook",
-            externalId: event.webhookId,
-            eventType: event.eventType,
-            receivedAt: event.receivedAt,
-            acceptanceStatus: "accepted",
-            ...(projectId ? { projectId } : {}),
-            ...(linearIssueId ? { linearIssueId } : {}),
-            headersJson: event.headersJson,
-            payloadJson: event.payloadJson,
-        });
-        return this.stores.eventReceipts.getEventReceipt(inserted.id);
-    }
-}
-function hasCompleteIssueContext(issue) {
-    return Boolean(issue.stateName && issue.delegateId && issue.teamId && issue.teamKey);
-}
-function mergeIssueMetadata(issue, liveIssue) {
-    return {
-        ...issue,
-        ...(issue.identifier ? {} : liveIssue.identifier ? { identifier: liveIssue.identifier } : {}),
-        ...(issue.title ? {} : liveIssue.title ? { title: liveIssue.title } : {}),
-        ...(issue.url ? {} : liveIssue.url ? { url: liveIssue.url } : {}),
-        ...(issue.teamId ? {} : liveIssue.teamId ? { teamId: liveIssue.teamId } : {}),
-        ...(issue.teamKey ? {} : liveIssue.teamKey ? { teamKey: liveIssue.teamKey } : {}),
-        ...(issue.stateId ? {} : liveIssue.stateId ? { stateId: liveIssue.stateId } : {}),
-        ...(issue.stateName ? {} : liveIssue.stateName ? { stateName: liveIssue.stateName } : {}),
-        ...(issue.delegateId ? {} : liveIssue.delegateId ? { delegateId: liveIssue.delegateId } : {}),
-        ...(issue.delegateName ? {} : liveIssue.delegateName ? { delegateName: liveIssue.delegateName } : {}),
-        labelNames: issue.labelNames.length > 0 ? issue.labelNames : (liveIssue.labels ?? []).map((label) => label.name),
-    };
-}
-function describeWebhookObservation(normalized, delegatedToPatchRelay) {
-    switch (normalized.triggerEvent) {
-        case "delegateChanged":
-            return delegatedToPatchRelay
-                ? {
-                    kind: "agent",
-                    status: "delegated",
-                    summary: "Delegated to PatchRelay",
-                    detail: normalized.issue?.stateName ? `Current Linear state: ${normalized.issue.stateName}.` : undefined,
-                }
-                : {
-                    kind: "agent",
-                    status: "undelegated",
-                    summary: "Delegation moved away from PatchRelay",
-                };
-        case "agentSessionCreated":
-            return {
-                kind: "agent",
-                status: delegatedToPatchRelay ? "session" : "mention",
-                summary: delegatedToPatchRelay ? "Opened a delegated agent session" : "Mentioned PatchRelay in Linear",
-                detail: normalized.agentSession?.promptBody ?? normalized.agentSession?.promptContext,
-            };
-        case "agentPrompted":
-            return {
-                kind: "agent",
-                status: "prompted",
-                summary: "Received follow-up agent instructions",
-                detail: normalized.agentSession?.promptBody ?? normalized.agentSession?.promptContext,
-            };
-        case "commentCreated":
-        case "commentUpdated":
-            return {
-                kind: "comment",
-                status: "received",
-                summary: "Received a Linear comment",
-                detail: normalized.comment?.userName ?? normalized.comment?.body,
-            };
-        case "statusChanged":
-            return {
-                kind: "webhook",
-                status: "status_changed",
-                summary: normalized.issue?.stateName ? `Linear state changed to ${normalized.issue.stateName}` : "Linear state changed",
-            };
-        default:
-            return undefined;
-    }
-}

package/dist/stage-agent-activity-publisher.js

@@ -1,59 +0,0 @@
-import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
-export class StageAgentActivityPublisher {
-    config;
-    linearProvider;
-    logger;
-    constructor(config, linearProvider, logger) {
-        this.config = config;
-        this.linearProvider = linearProvider;
-        this.logger = logger;
-    }
-    async publishForSession(projectId, agentSessionId, content, options) {
-        const linear = await this.linearProvider.forProject(projectId);
-        if (!linear) {
-            return;
-        }
-        try {
-            await linear.createAgentActivity({
-                agentSessionId,
-                content,
-                ephemeral: options?.ephemeral ?? (content.type === "thought" || content.type === "action"),
-            });
-        }
-        catch (error) {
-            this.logger.warn({
-                agentSessionId,
-                error: error instanceof Error ? error.message : String(error),
-            }, "Failed to publish Linear agent activity");
-        }
-    }
-    async publishForIssue(issue, content, options) {
-        if (!issue.activeAgentSessionId) {
-            return;
-        }
-        await this.publishForSession(issue.projectId, issue.activeAgentSessionId, content, options);
-    }
-    async updateSession(params) {
-        const linear = await this.linearProvider.forProject(params.projectId);
-        if (!linear?.updateAgentSession) {
-            return;
-        }
-        const externalUrls = buildAgentSessionExternalUrls(this.config, params.issueKey);
-        if (!externalUrls && !params.plan) {
-            return;
-        }
-        try {
-            await linear.updateAgentSession({
-                agentSessionId: params.agentSessionId,
-                ...(externalUrls ? { externalUrls } : {}),
-                ...(params.plan ? { plan: params.plan } : {}),
-            });
-        }
-        catch (error) {
-            this.logger.warn({
-                agentSessionId: params.agentSessionId,
-                error: error instanceof Error ? error.message : String(error),
-            }, "Failed to update Linear agent session");
-        }
-    }
-}

package/dist/stage-event-ports.js

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

package/dist/stage-failure.js

@@ -1,92 +0,0 @@
-import { buildFailedSessionPlan } from "./agent-session-plan.js";
-import { buildStageFailedComment, resolveActiveLinearState, resolveFallbackLinearState, resolveWorkflowLabelCleanup, } from "./linear-workflow.js";
-function normalizeStateName(value) {
-    const trimmed = value?.trim();
-    return trimmed ? trimmed.toLowerCase() : undefined;
-}
-export async function syncFailedStageToLinear(params) {
-    const linear = await params.linearProvider.forProject(params.stageRun.projectId);
-    if (!linear) {
-        return;
-    }
-    const fallbackState = resolveFallbackLinearState(params.project, params.stageRun.stage, params.issue.selectedWorkflowId);
-    let shouldWriteFailureState = true;
-    if (params.requireActiveLinearStateMatch) {
-        const activeState = resolveActiveLinearState(params.project, params.stageRun.stage, params.issue.selectedWorkflowId);
-        if (!activeState) {
-            shouldWriteFailureState = false;
-        }
-        else {
-            try {
-                const linearIssue = await linear.getIssue(params.stageRun.linearIssueId);
-                shouldWriteFailureState = normalizeStateName(linearIssue.stateName) === normalizeStateName(activeState);
-            }
-            catch {
-                shouldWriteFailureState = false;
-            }
-        }
-    }
-    const cleanup = resolveWorkflowLabelCleanup(params.project);
-    if (cleanup.remove.length > 0) {
-        await linear
-            .updateIssueLabels({
-            issueId: params.stageRun.linearIssueId,
-            removeNames: cleanup.remove,
-        })
-            .catch(() => undefined);
-    }
-    if (!shouldWriteFailureState) {
-        return;
-    }
-    if (fallbackState) {
-        await linear.setIssueState(params.stageRun.linearIssueId, fallbackState).catch(() => undefined);
-        params.stores.workflowCoordinator.upsertTrackedIssue({
-            projectId: params.stageRun.projectId,
-            linearIssueId: params.stageRun.linearIssueId,
-            currentLinearState: fallbackState,
-            statusCommentId: params.issue.statusCommentId ?? null,
-            activeAgentSessionId: params.issue.activeAgentSessionId ?? null,
-            lifecycleStatus: "failed",
-        });
-    }
-    let deliveredToSession = false;
-    if (params.issue.activeAgentSessionId) {
-        deliveredToSession =
-            (await linear
-                .updateAgentSession?.({
-                agentSessionId: params.issue.activeAgentSessionId,
-                plan: buildFailedSessionPlan(params.stageRun.stage, params.stageRun),
-            })
-                .then(() => true)
-                .catch(() => false)) ?? false;
-        deliveredToSession =
-            (await linear
-                .createAgentActivity({
-                agentSessionId: params.issue.activeAgentSessionId,
-                content: {
-                    type: "error",
-                    body: `PatchRelay could not complete the ${params.stageRun.stage} workflow: ${params.message}`,
-                },
-            })
-                .then(() => true)
-                .catch(() => false)) || deliveredToSession;
-    }
-    if (!deliveredToSession && !params.issue.activeAgentSessionId) {
-        const result = await linear
-            .upsertIssueComment({
-            issueId: params.stageRun.linearIssueId,
-            ...(params.issue.statusCommentId ? { commentId: params.issue.statusCommentId } : {}),
-            body: buildStageFailedComment({
-                issue: params.issue,
-                stageRun: params.stageRun,
-                message: params.message,
-                ...(fallbackState ? { fallbackState } : {}),
-                ...(params.mode ? { mode: params.mode } : {}),
-            }),
-        })
-            .catch(() => undefined);
-        if (result) {
-            params.stores.workflowCoordinator.setIssueStatusComment(params.stageRun.projectId, params.stageRun.linearIssueId, result.id);
-        }
-    }
-}

package/dist/stage-handoff.js

@@ -1,107 +0,0 @@
-import { safeJsonParse } from "./utils.js";
-import { listAllowedTransitionTargets, listWorkflowStageIds, resolveWorkflowStageCandidate } from "./workflow-policy.js";
-function normalize(value) {
-    const trimmed = value?.trim();
-    return trimmed ? trimmed.toLowerCase() : undefined;
-}
-function stripListPrefix(value) {
-    return value.replace(/^[-*•]\s+/, "").replace(/^\d+\.\s+/, "").trim();
-}
-function resolveTerminalTarget(value) {
-    const normalized = normalize(value)?.replace(/[\s_-]+/g, "");
-    if (!normalized) {
-        return undefined;
-    }
-    if (["done", "complete", "completed", "shipped", "ship"].includes(normalized)) {
-        return "done";
-    }
-    if (["humanneeded", "humaninput", "needsinput", "unclear", "unknown", "blocked", "ambiguous"].includes(normalized)) {
-        return "human_needed";
-    }
-    return undefined;
-}
-export function resolveWorkflowTarget(project, value) {
-    return resolveWorkflowTargetForDefinition(project, value);
-}
-export function resolveWorkflowTargetForDefinition(project, value, workflowDefinitionId) {
-    return resolveWorkflowStageCandidate(project, value, workflowDefinitionId) ?? resolveTerminalTarget(value);
-}
-function summarizeSignalsHumanNeeded(lines) {
-    const joined = normalize(lines.join(" "));
-    if (!joined) {
-        return false;
-    }
-    return ["blocked", "unclear", "ambiguous", "human input", "human needed", "need human", "cannot determine"].some((token) => joined.includes(token));
-}
-export function parseStageHandoff(project, assistantMessages, workflowDefinitionId) {
-    const latestMessage = [...assistantMessages].reverse().find((message) => typeof message === "string" && message.trim().length > 0);
-    if (!latestMessage) {
-        return undefined;
-    }
-    const lines = latestMessage
-        .split(/\r?\n/)
-        .map((line) => line.trimEnd());
-    const markerIndex = lines.findIndex((line) => /^stage result\s*:?\s*$/i.test(line.trim()));
-    const relevantLines = (markerIndex >= 0 ? lines.slice(markerIndex + 1) : lines)
-        .map((line) => stripListPrefix(line.trim()))
-        .filter(Boolean);
-    if (relevantLines.length === 0) {
-        return undefined;
-    }
-    const summaryLines = [];
-    let nextLikelyStageText;
-    let nextAttention;
-    for (const line of relevantLines) {
-        const nextStageMatch = line.match(/^next likely stage\s*:\s*(.+)$/i);
-        if (nextStageMatch) {
-            nextLikelyStageText = nextStageMatch[1]?.trim();
-            continue;
-        }
-        const attentionMatch = line.match(/^(next attention|what to watch|watch carefully|pay attention|human attention)\s*:\s*(.+)$/i);
-        if (attentionMatch) {
-            nextAttention = attentionMatch[2]?.trim();
-            continue;
-        }
-        summaryLines.push(line);
-    }
-    const resolvedNextStage = resolveWorkflowTargetForDefinition(project, nextLikelyStageText, workflowDefinitionId);
-    return {
-        sourceText: latestMessage,
-        summaryLines,
-        ...(nextLikelyStageText ? { nextLikelyStageText } : {}),
-        ...(nextAttention ? { nextAttention } : {}),
-        suggestsHumanNeeded: summarizeSignalsHumanNeeded(summaryLines),
-        ...(resolvedNextStage ? { resolvedNextStage } : {}),
-    };
-}
-export function extractPriorStageHandoff(project, stageRun, workflowDefinitionId) {
-    if (!stageRun?.reportJson) {
-        return undefined;
-    }
-    const report = safeJsonParse(stageRun.reportJson);
-    return report ? parseStageHandoff(project, report.assistantMessages, workflowDefinitionId) : undefined;
-}
-export function buildCarryForwardPrompt(params) {
-    const availableStages = listWorkflowStageIds(params.project, params.workflowDefinitionId);
-    const attemptNumber = params.stageHistory.filter((stageRun) => stageRun.stage === params.currentStage).length + 1;
-    const recentHistory = params.stageHistory.slice(-4).map((stageRun) => stageRun.stage);
-    const previousHandoff = extractPriorStageHandoff(params.project, params.previousStageRun, params.workflowDefinitionId);
-    const lines = [
-        `Workflow stage ids: ${availableStages.join(", ")}`,
-        `Allowed next targets from ${params.currentStage}: ${listAllowedTransitionTargets(params.project, params.currentStage, params.workflowDefinitionId).join(", ")}`,
-        `This is attempt ${attemptNumber} for the ${params.currentStage} stage.`,
-        recentHistory.length > 0 ? `Recent workflow history: ${recentHistory.join(" -> ")}` : undefined,
-        params.workspace?.branchName ? `Branch: ${params.workspace.branchName}` : undefined,
-        params.workspace?.worktreePath ? `Worktree: ${params.workspace.worktreePath}` : undefined,
-        params.previousStageRun ? "" : undefined,
-        params.previousStageRun ? "Carry-forward from the previous stage:" : undefined,
-        params.previousStageRun ? `- Prior stage: ${params.previousStageRun.stage}` : undefined,
-        previousHandoff?.summaryLines[0] ? `- Outcome: ${previousHandoff.summaryLines[0]}` : undefined,
-        previousHandoff && previousHandoff.summaryLines.length > 1
-            ? `- Key facts: ${previousHandoff.summaryLines.slice(1, 3).join(" ")}`
-            : undefined,
-        previousHandoff?.nextAttention ? `- Watch next: ${previousHandoff.nextAttention}` : undefined,
-        params.previousStageRun?.threadId ? `- Prior thread: ${params.previousStageRun.threadId}` : undefined,
-    ].filter((value) => Boolean(value));
-    return lines.length > 0 ? lines.join("\n") : undefined;
-}