@valescoagency/runway 0.3.0 → 0.5.0

package/dist/git.js

@@ -1,4 +1,15 @@
-import { execa } from "execa";
+import { Data, Effect } from "effect";
+import { runExecaScoped } from "./subprocess.js";
+/**
+ * VA-358: thin typed error for `detectBaseBranch`. We don't model
+ * every git failure mode — the orchestrator just wants to know "did
+ * we get a branch name back?" If not, surface a single error so the
+ * caller can fail fast with a helpful message. As a `Data.TaggedError`
+ * it's an Error instance, so vitest's `.rejects.toThrow(/regex/)`
+ * works the same as before this refactor.
+ */
+export class BaseBranchDetectionFailed extends Data.TaggedError("BaseBranchDetectionFailed") {
+}
 /**
  * Resolve the default branch name of the cwd repo. Tries
  * `git symbolic-ref` against `origin/HEAD` first (fast, works on any
@@ -6,36 +17,39 @@ import { execa } from "execa";
  * `git remote show origin` (slower, hits the network but works on
  * fresh clones that never had `origin/HEAD` set locally).
  *
- * Throws if neither path resolves a branch name — better to fail
- * fast at orchestrator startup than to crash mid-diff with a stale
- * "ambiguous argument" git error.
+ * VA-358: now an Effect so the orchestrator program can stay in
+ * Effect-land end-to-end. Subprocess kills propagate via
+ * `runExecaScoped` if the orchestrator fiber is interrupted.
  */
-export async function detectBaseBranch(repoPath) {
-    // Fast path: local symbolic ref. Returns e.g. `origin/main` or `origin/master`.
-    try {
-        const { stdout, exitCode } = await execa("git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], { cwd: repoPath, reject: false });
-        if (exitCode === 0) {
-            const name = stdout.trim().replace(/^origin\//, "");
-            if (name)
-                return name;
-        }
+export const detectBaseBranch = (repoPath) => Effect.gen(function* () {
+    // Fast path: local symbolic ref. Returns e.g. `origin/main`.
+    const symbolic = yield* runExecaScoped("git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], { cwd: repoPath, reject: false }, (err) => new BaseBranchDetectionFailed({
+        message: err instanceof Error ? err.message : String(err),
+    })).pipe(Effect.either);
+    if (symbolic._tag === "Right" && symbolic.right.exitCode === 0) {
+        // execa's `stdout` type is a union (encoding-dependent). We don't
+        // change `encoding`, so it's `string` at runtime — narrow here
+        // rather than fighting the generic types upstream.
+        const raw = symbolic.right.stdout;
+        const out = typeof raw === "string" ? raw : "";
+        const name = out.trim().replace(/^origin\//, "");
+        if (name)
+            return name;
     }
-    catch {
-        // fall through to remote-show fallback
-    }
-    // Slow path: ask the remote. Output line looks like `  HEAD branch: master`.
-    try {
-        const { stdout } = await execa("git", ["remote", "show", "origin"], {
-            cwd: repoPath,
-        });
-        const match = stdout.match(/^\s*HEAD branch:\s*(\S+)\s*$/m);
+    // Slow path: ask the remote. Output line: `  HEAD branch: master`.
+    const remoteShow = yield* runExecaScoped("git", ["remote", "show", "origin"], { cwd: repoPath }, (err) => new BaseBranchDetectionFailed({
+        message: err instanceof Error ? err.message : String(err),
+    })).pipe(Effect.either);
+    if (remoteShow._tag === "Right") {
+        const raw = remoteShow.right.stdout;
+        const out = typeof raw === "string" ? raw : "";
+        const match = out.match(/^\s*HEAD branch:\s*(\S+)\s*$/m);
         if (match?.[1])
             return match[1];
     }
-    catch {
-        // fall through to error
-    }
-    throw new Error(`Could not detect the default branch of ${repoPath}. ` +
-        `Set RUNWAY_BASE_BRANCH explicitly, or run ` +
-        `\`git remote set-head origin --auto\` to populate origin/HEAD.`);
-}
+    return yield* Effect.fail(new BaseBranchDetectionFailed({
+        message: `Could not detect the default branch of ${repoPath}. ` +
+            `Set RUNWAY_BASE_BRANCH explicitly, or run ` +
+            `\`git remote set-head origin --auto\` to populate origin/HEAD.`,
+    }));
+});

package/dist/github.js

@@ -1,4 +1,70 @@
+import { Data, Effect, Schedule } from "effect";
 import { execa } from "execa";
+// VA-356: typed error ADT for the GitHub gateway. `GhCliMissing` is
+// its own branch so the orchestrator (and `runway doctor`) can show
+// an install hint instead of an opaque ENOENT. Push and PR failures
+// are split because retry semantics differ — re-pushing the same
+// branch is idempotent, re-running `gh pr create` after a partial
+// failure can create duplicate PRs.
+export class GhCliMissing extends Data.TaggedError("GhCliMissing") {
+}
+export class PushFailed extends Data.TaggedError("PushFailed") {
+}
+export class PrCreateFailed extends Data.TaggedError("PrCreateFailed") {
+}
+// VA-357: a hung `gh` or `git` subprocess becomes a typed timeout.
+// Step 3 (VA-358) is where we add scoped subprocess cleanup; here the
+// Effect's fiber gets interrupted but the underlying child may still
+// be running. We accept that limitation for Step 2.
+export class GithubTimeout extends Data.TaggedError("GithubTimeout") {
+}
+// VA-357: same jittered exponential shape as the Linear policy.
+export const githubRetrySchedule = Schedule.exponential("1 second").pipe(Schedule.compose(Schedule.recurs(5)), Schedule.jittered);
+/**
+ * VA-357: timeout + optional retry policy for a GitHub call. Unlike
+ * Linear (where all methods are idempotent reads or idempotent
+ * updates), GitHub differs by method:
+ *
+ * - `push` is idempotent (re-pushing the same SHA is a no-op) ⇒ retry
+ *   on timeout.
+ * - `gh pr create` is NOT idempotent — a retry after a partial failure
+ *   can create a duplicate PR. Just bound it with a timeout, no
+ *   retries.
+ *
+ * The caller picks the policy by passing a `retryOn` predicate (or
+ * omitting it for timeout-only).
+ */
+export const applyGithubPolicy = (effect, opts) => {
+    const withTimeout = effect.pipe(Effect.timeoutFail({
+        duration: `${opts.timeoutMs} millis`,
+        onTimeout: () => new GithubTimeout({
+            call: opts.call,
+            afterMs: opts.timeoutMs,
+            message: `${opts.call} timed out after ${opts.timeoutMs}ms`,
+        }),
+    }));
+    if (!opts.retryOn)
+        return withTimeout;
+    return withTimeout.pipe(Effect.retry({
+        schedule: githubRetrySchedule,
+        while: opts.retryOn,
+    }));
+};
+function isCommandMissing(err) {
+    if (!(err instanceof Error))
+        return false;
+    const e = err;
+    if (e.code === "ENOENT")
+        return true;
+    return /\bcommand not found\b|: not found/i.test(e.message);
+}
+function execaStderr(err) {
+    if (err && typeof err === "object" && "stderr" in err) {
+        const s = err.stderr;
+        return typeof s === "string" ? s : "";
+    }
+    return "";
+}
 /**
  * `gh` CLI-backed gateway. Runway runs on a host with `gh` authenticated
  * (via `GH_TOKEN` or the user's keychain login); we don't reimplement
@@ -6,29 +72,78 @@ import { execa } from "execa";
  */
 export function createGithubGateway() {
     return {
-        async pushBranch(repoPath, branch) {
-            await execa("git", ["push", "-u", "origin", branch], {
-                cwd: repoPath,
-                stdio: "inherit",
+        pushBranch(repoPath, branch) {
+            return applyGithubPolicy(Effect.tryPromise({
+                try: async () => {
+                    await execa("git", ["push", "-u", "origin", branch], {
+                        cwd: repoPath,
+                        stdio: "inherit",
+                    });
+                },
+                catch: (err) => {
+                    if (isCommandMissing(err)) {
+                        return new GhCliMissing({
+                            message: `git not found on PATH: ${err instanceof Error ? err.message : String(err)}`,
+                        });
+                    }
+                    return new PushFailed({
+                        branch,
+                        stderr: execaStderr(err),
+                        message: err instanceof Error
+                            ? err.message
+                            : `push failed: ${String(err)}`,
+                    });
+                },
+            }), {
+                call: `pushBranch(${branch})`,
+                // `git push` can be slow for large branches on slow networks.
+                timeoutMs: 60_000,
+                // Push is idempotent; retry on timeout only. We don't retry
+                // PushFailed because a real failure (auth, conflict) won't
+                // resolve itself.
+                retryOn: (err) => err._tag === "GithubTimeout",
             });
         },
-        async openPullRequest({ repoPath, branch, base, issue, body }) {
-            const title = `${issue.identifier}: ${issue.title}`;
-            const { stdout } = await execa("gh", [
-                "pr",
-                "create",
-                "--base",
-                base,
-                "--head",
-                branch,
-                "--title",
-                title,
-                "--body",
-                body,
-            ], { cwd: repoPath });
-            // `gh pr create` prints the URL on the last line.
-            const url = stdout.trim().split("\n").at(-1) ?? "";
-            return url;
+        openPullRequest({ repoPath, branch, base, issue, body }) {
+            return applyGithubPolicy(Effect.tryPromise({
+                try: async () => {
+                    const title = `${issue.identifier}: ${issue.title}`;
+                    const { stdout } = await execa("gh", [
+                        "pr",
+                        "create",
+                        "--base",
+                        base,
+                        "--head",
+                        branch,
+                        "--title",
+                        title,
+                        "--body",
+                        body,
+                    ], { cwd: repoPath });
+                    // `gh pr create` prints the URL on the last line.
+                    return stdout.trim().split("\n").at(-1) ?? "";
+                },
+                catch: (err) => {
+                    if (isCommandMissing(err)) {
+                        return new GhCliMissing({
+                            message: `gh CLI not found on PATH — install https://cli.github.com (${err instanceof Error ? err.message : String(err)})`,
+                        });
+                    }
+                    return new PrCreateFailed({
+                        branch,
+                        stderr: execaStderr(err),
+                        message: err instanceof Error
+                            ? err.message
+                            : `gh pr create failed: ${String(err)}`,
+                    });
+                },
+            }), {
+                call: `openPullRequest(${branch})`,
+                timeoutMs: 30_000,
+                // No retry: gh pr create is NOT idempotent — a partial
+                // success on the previous attempt could leave a PR behind,
+                // and a retry would create a duplicate.
+            });
         },
     };
 }

package/dist/linear.js

@@ -1,29 +1,177 @@
 import { LinearClient } from "@linear/sdk";
+import { Data, Effect, ParseResult, Redacted, Schedule, Schema, } from "effect";
+// VA-360: schemas covering only the fields runway actually reads
+// off the Linear SDK. Validation runs at the gateway boundary so an
+// upstream API drift (renamed field, removed field, type change)
+// surfaces as a typed `LinearSchemaError` rather than a `Cannot read
+// property 'nodes' of undefined` deep in the call stack.
+const IssueNodeSchema = Schema.Struct({
+    id: Schema.String,
+    identifier: Schema.String,
+    title: Schema.String,
+    description: Schema.NullOr(Schema.String),
+});
+const WorkflowStateNodeSchema = Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+});
+const TeamNodeSchema = Schema.Struct({
+    id: Schema.String,
+    key: Schema.String,
+});
+const IssueLabelNodeSchema = Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+});
+const ProjectNodeSchema = Schema.Struct({
+    id: Schema.String,
+});
+const decodeIssueNode = Schema.decodeUnknownSync(IssueNodeSchema);
+const decodeWorkflowStateNode = Schema.decodeUnknownSync(WorkflowStateNodeSchema);
+const decodeTeamNode = Schema.decodeUnknownSync(TeamNodeSchema);
+const decodeIssueLabelNode = Schema.decodeUnknownSync(IssueLabelNodeSchema);
+const decodeProjectNode = Schema.decodeUnknownSync(ProjectNodeSchema);
+export class LinearNotFound extends Data.TaggedError("LinearNotFound") {
+}
+export class LinearUnauthorized extends Data.TaggedError("LinearUnauthorized") {
+}
+export class LinearRateLimited extends Data.TaggedError("LinearRateLimited") {
+}
+export class LinearNetworkError extends Data.TaggedError("LinearNetworkError") {
+}
+// VA-357: a stalled HTTP request becomes a typed timeout (rather than
+// a stuck process). Retryable just like NetworkError — the next attempt
+// may succeed.
+export class LinearTimeout extends Data.TaggedError("LinearTimeout") {
+}
+// VA-360: SDK response failed schema validation — Linear's GraphQL
+// schema drifted, an expected field went missing, or a type changed.
+// NOT retryable: re-running the same call will produce the same
+// drift. The operator needs to update runway's schemas (or pin the
+// SDK version) before this gets better.
+export class LinearSchemaError extends Data.TaggedError("LinearSchemaError") {
+}
+// VA-357: which typed errors a retry policy will re-attempt. Hard
+// failures (NotFound, Unauthorized) bypass the retry loop and surface
+// immediately — they are operator-fix problems, not transient blips.
+const RETRYABLE_LINEAR_TAGS = new Set([
+    "LinearNetworkError",
+    "LinearRateLimited",
+    "LinearTimeout",
+]);
+const isRetryableLinearError = (err) => RETRYABLE_LINEAR_TAGS.has(err._tag);
+/**
+ * VA-357: timeout + jittered-exponential retry policy for one Linear
+ * call. 5 retries from a 1s base ⇒ delays jittered around 1/2/4/8/16s
+ * ⇒ ~31s worst-case wall time before bubbling out. `while` gates the
+ * retry on the typed error tag so an `Unauthorized` or `NotFound` is
+ * not retried (no point: it's an operator/config problem).
+ *
+ * Exported so unit tests can apply it to a hand-built Effect and
+ * verify retry behavior under `TestClock`.
+ */
+export const linearRetrySchedule = Schedule.exponential("1 second").pipe(Schedule.compose(Schedule.recurs(5)), Schedule.jittered);
+export const applyLinearPolicy = (effect, opts) => {
+    const timeoutMs = opts.timeoutMs ?? 30_000;
+    return effect.pipe(Effect.timeoutFail({
+        duration: `${timeoutMs} millis`,
+        onTimeout: () => new LinearTimeout({
+            call: opts.call,
+            afterMs: timeoutMs,
+            message: `Linear ${opts.call} timed out after ${timeoutMs}ms`,
+        }),
+    }), Effect.retry({
+        schedule: linearRetrySchedule,
+        while: isRetryableLinearError,
+    }));
+};
+/**
+ * Best-effort classification of an unknown thrown value into the
+ * gateway's typed error ADT. `LinearNotFound`s we threw ourselves
+ * (from the find* helpers) pass through unchanged; SDK / network
+ * exceptions are bucketed by message-shape. Step 2 (VA-357) is where
+ * the retry policy actually leans on these tags — for now, the value
+ * is mostly that the orchestrator's `catch (err: unknown)` becomes
+ * `catch (err: LinearError)`.
+ */
+function classifyLinearError(err, context) {
+    if (err instanceof LinearNotFound ||
+        err instanceof LinearUnauthorized ||
+        err instanceof LinearRateLimited ||
+        err instanceof LinearNetworkError ||
+        err instanceof LinearTimeout ||
+        err instanceof LinearSchemaError) {
+        return err;
+    }
+    // VA-360: a schema validation throw (Linear API drift) should
+    // surface as `LinearSchemaError`, not get bucketed as a transient
+    // NetworkError — retrying won't fix a drifted field.
+    if (ParseResult.isParseError(err)) {
+        return new LinearSchemaError({
+            call: context,
+            message: `${context}: SDK response failed schema validation — ${err.message}`,
+        });
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/\b(401|403)\b|unauthorized|invalid api key|forbidden/i.test(msg)) {
+        return new LinearUnauthorized({ message: msg });
+    }
+    if (/\b429\b|rate.?limit/i.test(msg)) {
+        return new LinearRateLimited({ message: msg });
+    }
+    return new LinearNetworkError({
+        cause: err,
+        message: `${context}: ${msg}`,
+    });
+}
 /**
  * Concrete @linear/sdk-backed implementation. Tests inject their own
  * gateway; never reach for the SDK directly outside this file.
+ *
+ * The internal `find*` helpers stay plain `async` and throw typed
+ * `LinearNotFound` directly. Only the public `LinearGateway` methods
+ * wrap into `Effect.tryPromise` — that's the boundary the orchestrator
+ * sees.
+ *
+ * VA-358: optional `limiter` wraps every method's Effect so the queue
+ * drain respects Linear's API rate limit (~1500 req/hr). When `null`
+ * (the default — tests don't need it), calls go through unrestricted.
+ * Production: `commands/run.ts` builds a limiter inside `Effect.scoped`
+ * and passes it here.
  */
-export function createLinearGateway(config) {
-    const client = new LinearClient({ apiKey: config.linearApiKey });
+export function createLinearGateway(config, limiter = null) {
+    const client = new LinearClient({ apiKey: Redacted.value(config.linearApiKey) });
+    const gate = (eff) => (limiter ? limiter(eff) : eff);
     async function findStateId(teamId, name) {
         const states = await client.workflowStates({
             filter: { team: { id: { eq: teamId } }, name: { eq: name } },
         });
-        const state = states.nodes[0];
-        if (!state) {
-            throw new Error(`Linear workflow state "${name}" not found on team ${teamId}`);
+        const rawState = states.nodes[0];
+        if (!rawState) {
+            throw new LinearNotFound({
+                resource: "state",
+                identifier: name,
+                message: `Linear workflow state "${name}" not found on team ${teamId}`,
+            });
         }
-        return state.id;
+        // VA-360: validate the SDK shape. `decodeWorkflowStateNode` throws
+        // `ParseError` on drift, which `classifyLinearError` maps to
+        // `LinearSchemaError` (non-retryable).
+        return decodeWorkflowStateNode(rawState).id;
     }
     async function findTeamId() {
         const teams = await client.teams({
             filter: { key: { eq: config.linearTeam } },
         });
-        const team = teams.nodes[0];
-        if (!team) {
-            throw new Error(`Linear team "${config.linearTeam}" not found`);
+        const rawTeam = teams.nodes[0];
+        if (!rawTeam) {
+            throw new LinearNotFound({
+                resource: "team",
+                identifier: config.linearTeam,
+                message: `Linear team "${config.linearTeam}" not found`,
+            });
         }
-        return team.id;
+        return decodeTeamNode(rawTeam).id;
     }
     /**
      * Resolve a project identifier (UUID, slug, or name) to its Linear
@@ -40,67 +188,151 @@ export function createLinearGateway(config) {
                 ],
             },
         });
-        const project = projects.nodes[0];
-        if (!project) {
-            throw new Error(`Linear project "${identifier}" not found`);
+        const rawProject = projects.nodes[0];
+        if (!rawProject) {
+            throw new LinearNotFound({
+                resource: "project",
+                identifier,
+                message: `Linear project "${identifier}" not found`,
+            });
         }
-        return project.id;
+        return decodeProjectNode(rawProject).id;
     }
     return {
-        async fetchReady() {
-            const teamId = await findTeamId();
-            const readyStateId = await findStateId(teamId, config.readyStatus);
-            const projectId = config.linearProject
-                ? await findProjectId(config.linearProject)
-                : null;
-            const issues = await client.issues({
-                filter: {
-                    team: { id: { eq: teamId } },
-                    state: { id: { eq: readyStateId } },
-                    ...(projectId ? { project: { id: { eq: projectId } } } : {}),
+        fetchReady() {
+            return gate(applyLinearPolicy(Effect.tryPromise({
+                try: async () => {
+                    const teamId = await findTeamId();
+                    const readyStateId = await findStateId(teamId, config.readyStatus);
+                    const projectId = config.linearProject
+                        ? await findProjectId(config.linearProject)
+                        : null;
+                    const issues = await client.issues({
+                        filter: {
+                            team: { id: { eq: teamId } },
+                            state: { id: { eq: readyStateId } },
+                            ...(projectId ? { project: { id: { eq: projectId } } } : {}),
+                        },
+                        // Stable order: oldest first so the queue drains FIFO.
+                        orderBy: "createdAt",
+                    });
+                    // VA-360: validate every issue node through the schema —
+                    // a single drifted issue surfaces as `LinearSchemaError`
+                    // instead of a downstream `cannot read property X`.
+                    return issues.nodes.map((raw) => {
+                        const i = decodeIssueNode(raw);
+                        return {
+                            id: i.id,
+                            identifier: i.identifier,
+                            title: i.title,
+                            description: i.description ?? "",
+                        };
+                    });
                 },
-                // Stable order: oldest first so the queue drains FIFO.
-                orderBy: "createdAt",
-            });
-            return issues.nodes.map((i) => ({
-                id: i.id,
-                identifier: i.identifier,
-                title: i.title,
-                description: i.description ?? "",
-            }));
+                catch: (err) => classifyLinearError(err, "fetchReady"),
+            }), { call: "fetchReady" }));
         },
-        async transition(issueId, statusName) {
-            const issue = await client.issue(issueId);
-            const team = await issue.team;
-            if (!team)
-                throw new Error(`Issue ${issueId} has no team`);
-            const stateId = await findStateId(team.id, statusName);
-            await client.updateIssue(issueId, { stateId });
+        transition(issueId, statusName) {
+            return gate(applyLinearPolicy(Effect.tryPromise({
+                try: async () => {
+                    const issue = await client.issue(issueId);
+                    const team = await issue.team;
+                    if (!team) {
+                        throw new LinearNotFound({
+                            resource: "issue",
+                            identifier: issueId,
+                            message: `Issue ${issueId} has no team`,
+                        });
+                    }
+                    const stateId = await findStateId(team.id, statusName);
+                    await client.updateIssue(issueId, { stateId });
+                },
+                catch: (err) => classifyLinearError(err, `transition(${statusName})`),
+            }), { call: `transition(${statusName})` }));
         },
-        async applyLabel(issueId, labelName) {
-            const issue = await client.issue(issueId);
-            const team = await issue.team;
-            if (!team)
-                throw new Error(`Issue ${issueId} has no team`);
-            const labels = await client.issueLabels({
-                filter: {
-                    team: { id: { eq: team.id } },
-                    name: { eq: labelName },
+        applyLabel(issueId, labelName) {
+            return gate(applyLinearPolicy(Effect.tryPromise({
+                try: async () => {
+                    const issue = await client.issue(issueId);
+                    const team = await issue.team;
+                    if (!team) {
+                        throw new LinearNotFound({
+                            resource: "issue",
+                            identifier: issueId,
+                            message: `Issue ${issueId} has no team`,
+                        });
+                    }
+                    const labels = await client.issueLabels({
+                        filter: {
+                            team: { id: { eq: team.id } },
+                            name: { eq: labelName },
+                        },
+                    });
+                    const rawLabel = labels.nodes[0];
+                    if (!rawLabel) {
+                        throw new LinearNotFound({
+                            resource: "label",
+                            identifier: labelName,
+                            message: `Linear label "${labelName}" not found on team ${team.id}`,
+                        });
+                    }
+                    const label = decodeIssueLabelNode(rawLabel);
+                    const existing = await issue.labels();
+                    const existingIds = existing.nodes.map((l) => decodeIssueLabelNode(l).id);
+                    const labelIds = [...existingIds, label.id];
+                    await client.updateIssue(issueId, { labelIds });
                 },
-            });
-            const label = labels.nodes[0];
-            if (!label) {
-                throw new Error(`Linear label "${labelName}" not found on team ${team.id}`);
-            }
-            const existing = await issue.labels();
-            const labelIds = [
-                ...existing.nodes.map((l) => l.id),
-                label.id,
-            ];
-            await client.updateIssue(issueId, { labelIds });
+                catch: (err) => classifyLinearError(err, `applyLabel(${labelName})`),
+            }), { call: `applyLabel(${labelName})` }));
         },
-        async comment(issueId, body) {
-            await client.createComment({ issueId, body });
+        comment(issueId, body) {
+            return gate(applyLinearPolicy(Effect.tryPromise({
+                try: async () => {
+                    await client.createComment({ issueId, body });
+                },
+                catch: (err) => classifyLinearError(err, "comment"),
+            }), { call: "comment" }));
         },
     };
 }
+export async function validateLinearConfig(config) {
+    const client = new LinearClient({ apiKey: Redacted.value(config.linearApiKey) });
+    const teams = await client.teams({
+        filter: { key: { eq: config.linearTeam } },
+    });
+    const team = teams.nodes[0];
+    if (!team) {
+        return {
+            team: { kind: "missing", key: config.linearTeam },
+            readyStatus: { kind: "skipped", reason: "team missing" },
+            inProgressStatus: { kind: "skipped", reason: "team missing" },
+            inReviewStatus: { kind: "skipped", reason: "team missing" },
+            hitlLabel: { kind: "skipped", reason: "team missing" },
+        };
+    }
+    const states = await client.workflowStates({
+        filter: { team: { id: { eq: team.id } } },
+    });
+    const stateNames = states.nodes.map((s) => s.name);
+    const checkState = (want) => stateNames.includes(want)
+        ? { kind: "ok", name: want }
+        : { kind: "missing", name: want, available: stateNames };
+    const labels = await client.issueLabels({
+        filter: { team: { id: { eq: team.id } } },
+    });
+    const labelNames = labels.nodes.map((l) => l.name);
+    const hitlLabel = labelNames.includes(config.hitlLabel)
+        ? { kind: "ok", name: config.hitlLabel }
+        : {
+            kind: "missing",
+            name: config.hitlLabel,
+            available: labelNames.slice(0, 50),
+        };
+    return {
+        team: { kind: "ok", id: team.id },
+        readyStatus: checkState(config.readyStatus),
+        inProgressStatus: checkState(config.inProgressStatus),
+        inReviewStatus: checkState(config.inReviewStatus),
+        hitlLabel,
+    };
+}