@h-rig/linear-plugin 0.0.6-alpha.65

package/README.md

@@ -0,0 +1,227 @@
+# @rig/linear-plugin
+
+Linear as a Rig task source — and the canonical example of a plugin that
+adapts an **external HTTP API** into Rig's task-source contract.
+
+The two first-party adapters in `@rig/standard-plugin` cover a CLI wrapper
+(`github-issues` shells out to `gh`) and the local filesystem (`files`). This
+package covers the third shape you'll actually build most often: a remote
+API spoken over HTTP, with credentials, pagination, write-back mutations, and
+tests that never touch the network. If you are writing a Jira/Asana/Shortcut/
+internal-queue adapter, copy this package.
+
+```
+packages/linear-plugin/
+├── package.json                       ← workspace package, mirrors standard-plugin
+├── tsconfig.json
+└── src/
+    ├── index.ts                       ← definePlugin wiring (metadata + runtime channels)
+    ├── linear-issues-source.ts        ← the adapter: GraphQL client, mapping, write-back
+    ├── fixture-transport.ts           ← fixture-driven fake transport for tests
+    ├── fixtures.ts                    ← canned Linear GraphQL payloads
+    ├── contract.test.ts               ← @rig/plugin-testkit contract suite + factory wiring
+    └── linear-issues-source.test.ts   ← mapping, lifecycle, pagination, error surfaces
+```
+
+## Using it
+
+```typescript
+// rig.config.ts
+import { defineConfig } from "@rig/core";
+import linear from "@rig/linear-plugin";
+
+export default defineConfig({
+  plugins: [linear()],
+  taskSource: {
+    kind: "linear",
+    options: {
+      teamKey: "ENG",                 // required — the "ENG" in ENG-123
+      states: ["Todo", "In Progress"], // optional: workflow state names
+      assignee: "alex@example.com",    // optional: email or display name
+      labels: ["rig"],                 // optional: issue must carry ALL listed labels
+      // pageSize: 50,                 // optional: issues per GraphQL page (max 250)
+      // listLimit: 1000,              // optional: fail-loud ceiling, no silent truncation
+    },
+  },
+  // ... workspace, runtime, etc.
+});
+```
+
+Authentication comes from the environment, never from the committed config:
+
+```bash
+export LINEAR_API_KEY=lin_api_...   # personal API key (Settings → API)
+```
+
+Personal API keys (`lin_api_…`) are sent raw in the `Authorization` header;
+OAuth access tokens (`lin_oauth_…`) are automatically sent as `Bearer <token>`.
+You can also pass the key programmatically: `linear({ apiKey })`.
+
+## Anatomy of an external-API task source
+
+### 1. Two channels, one `definePlugin` call
+
+Rig plugins declare *what they contribute* as Effect-Schema-validated metadata
+and ship *executable code* on a sibling runtime channel — schemas can't carry
+functions. `src/index.ts`:
+
+```typescript
+export default function linearPlugin(opts: LinearPluginOptions = {}) {
+  return definePlugin(
+    // Channel 1: metadata. Validated against the RigPlugin schema at load time.
+    {
+      name: "rig-linear",
+      version: "0.1.0",
+      contributes: {
+        taskSources: [{ id: "linear:issues", kind: "linear", description: "…" }],
+      },
+    },
+    // Channel 2: runtime. The factory turns a TaskSourceConfig into a live source.
+    {
+      taskSources: [{ id: "linear:issues", kind: "linear", factory(config) { … } }],
+    },
+  );
+}
+```
+
+`definePlugin` enforces referential integrity: every factory must match a
+metadata entry by `id` with the same `kind`, and (once a plugin opts into the
+runtime channel) every metadata entry must be backed by a factory. Drift
+throws at config-load time, not at dispatch time.
+
+At boot, `buildTaskSourceRegistry(config, pluginHost)` in `@rig/runtime` reads
+`config.taskSource.kind` (`"linear"`), resolves the factory through the plugin
+host (which also rejects duplicate kinds across plugins), and instantiates the
+source.
+
+### 2. Plugin-specific config rides in `options`
+
+`TaskSourceConfig`'s top-level fields (`path`, `owner`, `repo`, …) are
+reserved for the built-in adapters. Everything Linear-specific lives in the
+documented `options` extension bag — the factory pulls its own fields out and
+validates them with actionable errors:
+
+```typescript
+const teamKey = optionString(config, "teamKey");
+if (!teamKey) {
+  throw new Error('task source linear: options.teamKey is required — …');
+}
+```
+
+Process-level concerns (API key, endpoint override, transport injection)
+arrive through the plugin function's own options instead, because they belong
+to the environment, not to the committed project config.
+
+### 3. An injectable transport is the whole testing story
+
+The adapter never calls `fetch` directly. It calls a fetch-*shaped* function
+it was constructed with:
+
+```typescript
+export type LinearTransport = (
+  url: string,
+  init: { method: "POST"; headers: Record<string, string>; body: string },
+) => Promise<{ ok: boolean; status: number; text(): Promise<string> }>;
+
+const transport: LinearTransport = opts.transport ?? fetch; // global fetch satisfies it
+```
+
+That one seam is why this package's test suite makes **zero live API calls**.
+`fixture-transport.ts` exports `createFixtureTransport(routes)`, which routes
+requests by GraphQL *operation name* (every query/mutation in the adapter is
+deliberately named: `RigListIssues`, `RigTeamStates`, `RigIssueUpdate`, …),
+records every call for payload assertions, and fails loudly on any operation
+a test didn't explicitly allow:
+
+```typescript
+const fixture = createFixtureTransport({
+  RigListIssues: () => listIssuesPage(issueFixtures),
+  RigIssueUpdate: () => ({ issueUpdate: { success: true } }),
+});
+const source = createLinearIssuesTaskSource({
+  teamKey: "ENG",
+  apiKey: "lin_api_test",
+  transport: fixture.transport,
+});
+// …act…
+expect(fixture.callsFor("RigIssueUpdate")[0].variables.input).toEqual({ stateId: … });
+```
+
+`graphqlErrors([...])` and `httpFailure(status, body)` simulate the two
+failure layers a GraphQL API has (200-with-errors vs. non-200 HTTP).
+
+### 4. Mapping external records to `TaskRecord`
+
+`TaskRecord` requires `id`, `deps`, `status` and is open-ended beyond that.
+The mapping decisions here:
+
+| TaskRecord field | Source |
+|---|---|
+| `id` | Linear identifier (`ENG-123`) — human-facing, like GitHub issue numbers |
+| `status` | Linear workflow-state **type** (see table below) |
+| `title`, `body`/`description` | issue title/description (`body` is Rig convention; `description` mirrors Linear) |
+| `priority`, `priorityLabel` | Linear priority (0–4) and its label |
+| `labels` | label names; `scope:`/`role:`/`validator:` prefixes get the same treatment as the GitHub adapter |
+| `externalRef` | `linear:<identifier>` |
+| `sourceIssueId` | the identifier |
+| `linearIssueId` | Linear's internal UUID — kept so mutations can skip a lookup |
+| `url`, `raw` | issue URL, full raw node |
+
+Status mapping is keyed off Linear's fixed state-type taxonomy, not the
+user-renamable state names:
+
+| Linear state type | Rig status |
+|---|---|
+| `triage`, `backlog`, `unstarted` | `ready` |
+| `started` | `in_progress` |
+| `completed` | `completed` |
+| `canceled` | `cancelled` |
+| anything unknown | `open` (fail-soft) |
+
+### 5. Lifecycle write-back
+
+Rig drives the source through `updateStatus(id, status)` and
+`updateTask(id, update)` (status/title/body/comment/metadata). The Linear
+implementation mirrors the GitHub adapter's responsibilities with GraphQL
+mutations:
+
+- **Status** → resolve the team's workflow states (`RigTeamStates`, cached per
+  source instance), pick the lowest-`position` state whose `type` matches the
+  Rig status (`in_progress` → `started`, `closed`/`completed` → `completed`,
+  `cancelled` → `canceled`, `ready` → `unstarted`), then `issueUpdate` with
+  `stateId`. Statuses Linear has no workflow concept for (`blocked`,
+  `failed`, `needs_attention`) deliberately leave the state untouched — they
+  surface through comments instead of mangling the board.
+- **Title / body / metadata** → folded into the same single `issueUpdate`
+  call. `update.metadata` is rendered into the Rig-owned
+  `<!-- rig:metadata:start/end -->` block (same markers as the GitHub
+  adapter, so operator surfaces parse both identically), replacing a previous
+  block in the existing description when present.
+- **Comment** → `commentCreate` after the update.
+- Task ids are accepted as either the identifier (`ENG-123`) or Linear's UUID;
+  identifiers are resolved with one extra `issue(id:)` query.
+
+Every write fires the optional `onTaskChanged` callback so the host can
+refresh snapshots — same pattern as the GitHub adapter.
+
+### 6. Error surfaces are part of the contract
+
+- No key configured → `"Linear task source: no API key configured. Pass apiKey in plugin options or set the LINEAR_API_KEY environment variable."` — thrown before any request.
+- Bad token (HTTP 401 or a GraphQL `AUTHENTICATION_ERROR`) → `"Linear API authentication failed (…). Check that the configured API key (options.apiKey / LINEAR_API_KEY) is a valid Linear key…"`.
+- Other GraphQL errors → surfaced with the server's message.
+- Non-200 HTTP → status + body excerpt.
+- More matching issues than `listLimit` → a loud refusal to truncate, telling
+  you exactly which knob to turn — never a silently short task list.
+
+## Running the tests
+
+```bash
+cd packages/linear-plugin
+bun test            # 39 tests, no network
+bunx tsc --noEmit   # typecheck
+```
+
+`contract.test.ts` runs `pluginContractTests` from `@rig/plugin-testkit`
+(schema validity, namespaced ids, duplicate-id detection) plus factory-wiring
+assertions; `linear-issues-source.test.ts` covers mapping, filters,
+pagination, lifecycle mutation payloads, and every error surface above.

package/dist/src/fixture-transport.js

@@ -0,0 +1,56 @@
+// @bun
+// packages/linear-plugin/src/fixture-transport.ts
+var HTTP_FAILURE = Symbol("linear-fixture-http-failure");
+var GRAPHQL_ERRORS = Symbol("linear-fixture-graphql-errors");
+function httpFailure(status, body) {
+  return { [HTTP_FAILURE]: true, status, body };
+}
+function graphqlErrors(errors) {
+  return { [GRAPHQL_ERRORS]: true, errors };
+}
+function isHttpFailure(value) {
+  return typeof value === "object" && value !== null && HTTP_FAILURE in value;
+}
+function isGraphQLErrors(value) {
+  return typeof value === "object" && value !== null && GRAPHQL_ERRORS in value;
+}
+function jsonResponse(status, body) {
+  return { ok: status >= 200 && status < 300, status, text: async () => body };
+}
+function createFixtureTransport(routes) {
+  const calls = [];
+  const transport = async (url, init) => {
+    const body = JSON.parse(init.body);
+    const operation = /(?:query|mutation)\s+([A-Za-z0-9_]+)/.exec(body.query)?.[1] ?? "<anonymous>";
+    const call = {
+      url,
+      authorization: init.headers["Authorization"],
+      operation,
+      query: body.query,
+      variables: body.variables ?? {}
+    };
+    calls.push(call);
+    const route = routes[operation];
+    if (!route) {
+      throw new Error(`createFixtureTransport: no fixture route for operation "${operation}"`);
+    }
+    const result = route(call.variables, call);
+    if (isHttpFailure(result)) {
+      return jsonResponse(result.status, result.body);
+    }
+    if (isGraphQLErrors(result)) {
+      return jsonResponse(200, JSON.stringify({ errors: result.errors }));
+    }
+    return jsonResponse(200, JSON.stringify({ data: result }));
+  };
+  return {
+    transport,
+    calls,
+    callsFor: (operation) => calls.filter((c) => c.operation === operation)
+  };
+}
+export {
+  httpFailure,
+  graphqlErrors,
+  createFixtureTransport
+};

package/dist/src/fixtures.js

@@ -0,0 +1,155 @@
+// @bun
+// packages/linear-plugin/src/fixtures.ts
+var TEAM_KEY = "ENG";
+var STATE_IDS = {
+  triage: "11111111-1111-4111-8111-111111111101",
+  backlog: "11111111-1111-4111-8111-111111111102",
+  todo: "11111111-1111-4111-8111-111111111103",
+  inProgress: "11111111-1111-4111-8111-111111111104",
+  inReview: "11111111-1111-4111-8111-111111111105",
+  done: "11111111-1111-4111-8111-111111111106",
+  canceled: "11111111-1111-4111-8111-111111111107"
+};
+var teamStatesFixture = {
+  teams: {
+    nodes: [
+      {
+        id: "22222222-2222-4222-8222-222222222201",
+        key: TEAM_KEY,
+        states: {
+          nodes: [
+            { id: STATE_IDS.triage, name: "Triage", type: "triage", position: 0 },
+            { id: STATE_IDS.backlog, name: "Backlog", type: "backlog", position: 1 },
+            { id: STATE_IDS.todo, name: "Todo", type: "unstarted", position: 2 },
+            { id: STATE_IDS.inReview, name: "In Review", type: "started", position: 4 },
+            { id: STATE_IDS.inProgress, name: "In Progress", type: "started", position: 3 },
+            { id: STATE_IDS.done, name: "Done", type: "completed", position: 5 },
+            { id: STATE_IDS.canceled, name: "Canceled", type: "canceled", position: 6 }
+          ]
+        }
+      }
+    ]
+  }
+};
+var ISSUE_UUIDS = {
+  eng1: "33333333-3333-4333-8333-333333333301",
+  eng2: "33333333-3333-4333-8333-333333333302",
+  eng3: "33333333-3333-4333-8333-333333333303",
+  eng4: "33333333-3333-4333-8333-333333333304",
+  eng5: "33333333-3333-4333-8333-333333333305",
+  eng6: "33333333-3333-4333-8333-333333333306",
+  eng7: "33333333-3333-4333-8333-333333333307"
+};
+var issueFixtures = [
+  {
+    id: ISSUE_UUIDS.eng1,
+    identifier: "ENG-1",
+    title: "Untriaged crash report",
+    description: null,
+    priority: 0,
+    priorityLabel: "No priority",
+    url: "https://linear.app/acme/issue/ENG-1",
+    state: { id: STATE_IDS.triage, name: "Triage", type: "triage" },
+    labels: { nodes: [] },
+    assignee: null
+  },
+  {
+    id: ISSUE_UUIDS.eng2,
+    identifier: "ENG-2",
+    title: "Someday refactor",
+    description: "Park it in the backlog.",
+    priority: 4,
+    priorityLabel: "Low",
+    url: "https://linear.app/acme/issue/ENG-2",
+    state: { id: STATE_IDS.backlog, name: "Backlog", type: "backlog" },
+    labels: { nodes: [{ name: "tech-debt" }] },
+    assignee: null
+  },
+  {
+    id: ISSUE_UUIDS.eng3,
+    identifier: "ENG-3",
+    title: "Add retry to webhook dispatcher",
+    description: `Retries with backoff.
+
+See the incident doc.`,
+    priority: 2,
+    priorityLabel: "High",
+    url: "https://linear.app/acme/issue/ENG-3",
+    state: { id: STATE_IDS.todo, name: "Todo", type: "unstarted" },
+    labels: {
+      nodes: [
+        { name: "rig" },
+        { name: "scope:packages/server/**" },
+        { name: "role:builder" },
+        { name: "validator:typecheck" }
+      ]
+    },
+    assignee: { name: "Alex", email: "alex@example.com" }
+  },
+  {
+    id: ISSUE_UUIDS.eng4,
+    identifier: "ENG-4",
+    title: "Migrate auth tokens",
+    description: "In flight.",
+    priority: 1,
+    priorityLabel: "Urgent",
+    url: "https://linear.app/acme/issue/ENG-4",
+    state: { id: STATE_IDS.inProgress, name: "In Progress", type: "started" },
+    labels: { nodes: [{ name: "rig" }] },
+    assignee: { name: "Alex", email: "alex@example.com" }
+  },
+  {
+    id: ISSUE_UUIDS.eng5,
+    identifier: "ENG-5",
+    title: "Ship the dashboard",
+    description: "Done last sprint.",
+    priority: 3,
+    priorityLabel: "Medium",
+    url: "https://linear.app/acme/issue/ENG-5",
+    state: { id: STATE_IDS.done, name: "Done", type: "completed" },
+    labels: { nodes: [] },
+    assignee: null
+  },
+  {
+    id: ISSUE_UUIDS.eng6,
+    identifier: "ENG-6",
+    title: "Dead-end spike",
+    description: null,
+    priority: null,
+    priorityLabel: null,
+    url: "https://linear.app/acme/issue/ENG-6",
+    state: { id: STATE_IDS.canceled, name: "Canceled", type: "canceled" },
+    labels: { nodes: [] },
+    assignee: null
+  },
+  {
+    id: ISSUE_UUIDS.eng7,
+    identifier: "ENG-7",
+    title: "Issue in a state type this adapter has never heard of",
+    description: null,
+    priority: null,
+    priorityLabel: null,
+    url: "https://linear.app/acme/issue/ENG-7",
+    state: { id: "11111111-1111-4111-8111-111111111199", name: "Weird", type: "someday-new-type" },
+    labels: { nodes: [] },
+    assignee: null
+  }
+];
+function listIssuesPage(issues, pageInfo = { hasNextPage: false, endCursor: null }) {
+  return { issues: { pageInfo, nodes: issues } };
+}
+function issueByIdentifier(identifier) {
+  const issue = issueFixtures.find((i) => i.identifier === identifier);
+  if (!issue)
+    throw new Error(`fixture issue not found: ${identifier}`);
+  return issue;
+}
+export {
+  teamStatesFixture,
+  listIssuesPage,
+  issueFixtures,
+  issueByIdentifier,
+  TEAM_KEY,
+  STATE_IDS,
+  ISSUE_UUIDS
+};

package/dist/src/index.js

@@ -0,0 +1,492 @@
+// @bun
+// packages/linear-plugin/src/index.ts
+import { definePlugin } from "@rig/core";
+
+// packages/linear-plugin/src/linear-issues-source.ts
+var ISSUE_FIELDS = `
+      id
+      identifier
+      title
+      description
+      priority
+      priorityLabel
+      url
+      state { id name type }
+      labels { nodes { name } }
+      assignee { name email }`;
+var LIST_ISSUES_QUERY = `query RigListIssues($filter: IssueFilter, $first: Int!, $after: String) {
+  issues(filter: $filter, first: $first, after: $after) {
+    pageInfo { hasNextPage endCursor }
+    nodes {${ISSUE_FIELDS}
+    }
+  }
+}`;
+var GET_ISSUE_QUERY = `query RigGetIssue($id: String!) {
+  issue(id: $id) {${ISSUE_FIELDS}
+  }
+}`;
+var RESOLVE_ISSUE_QUERY = `query RigResolveIssue($id: String!) {
+  issue(id: $id) { id }
+}`;
+var ISSUE_DESCRIPTION_QUERY = `query RigIssueDescription($id: String!) {
+  issue(id: $id) { description }
+}`;
+var TEAM_STATES_QUERY = `query RigTeamStates($teamKey: String!) {
+  teams(filter: { key: { eq: $teamKey } }, first: 1) {
+    nodes {
+      id
+      key
+      states { nodes { id name type position } }
+    }
+  }
+}`;
+var ISSUE_UPDATE_MUTATION = `mutation RigIssueUpdate($id: String!, $input: IssueUpdateInput!) {
+  issueUpdate(id: $id, input: $input) { success }
+}`;
+var COMMENT_CREATE_MUTATION = `mutation RigCommentCreate($input: CommentCreateInput!) {
+  commentCreate(input: $input) { success }
+}`;
+function rigStatusForLinearStateType(stateType) {
+  switch (stateType) {
+    case "triage":
+    case "backlog":
+    case "unstarted":
+      return "ready";
+    case "started":
+      return "in_progress";
+    case "completed":
+      return "completed";
+    case "canceled":
+      return "cancelled";
+    default:
+      return "open";
+  }
+}
+function linearStateTypeForRigStatus(status) {
+  switch (status) {
+    case "ready":
+      return "unstarted";
+    case "in_progress":
+    case "under_review":
+    case "ci_fixing":
+    case "merging":
+      return "started";
+    case "closed":
+    case "completed":
+      return "completed";
+    case "cancelled":
+      return "canceled";
+    case "blocked":
+    case "failed":
+    case "needs_attention":
+    case "open":
+      return null;
+    default:
+      return null;
+  }
+}
+var RIG_METADATA_START = "<!-- rig:metadata:start -->";
+var RIG_METADATA_END = "<!-- rig:metadata:end -->";
+function yamlScalar(value) {
+  if (Array.isArray(value)) {
+    return value.length === 0 ? "[]" : `
+${value.map((entry) => `  - ${String(entry)}`).join(`
+`)}`;
+  }
+  if (value && typeof value === "object")
+    return JSON.stringify(value);
+  return String(value);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function updateRigOwnedMetadataBlock(body, metadata) {
+  const rendered = [
+    RIG_METADATA_START,
+    ...Object.entries(metadata).map(([key, value]) => Array.isArray(value) ? `${key}:${yamlScalar(value)}` : `${key}: ${yamlScalar(value)}`),
+    RIG_METADATA_END
+  ].join(`
+`);
+  const pattern = new RegExp(`${escapeRegExp(RIG_METADATA_START)}\\s*[\\s\\S]*?\\s*${escapeRegExp(RIG_METADATA_END)}`);
+  if (pattern.test(body))
+    return body.replace(pattern, rendered);
+  return body.trim().length > 0 ? `${body.trimEnd()}
+
+${rendered}
+` : `${rendered}
+`;
+}
+function labelNamesFor(issue) {
+  return (issue.labels?.nodes ?? []).map((label) => label.name);
+}
+function issueToTask(issue) {
+  const labelNames = labelNamesFor(issue);
+  const scope = labelNames.filter((l) => l.startsWith("scope:")).map((l) => l.slice("scope:".length));
+  const roleLabel = labelNames.find((l) => l.startsWith("role:"));
+  const validators = labelNames.filter((l) => l.startsWith("validator:")).map((l) => l.slice("validator:".length));
+  const description = issue.description ?? "";
+  return {
+    id: issue.identifier,
+    deps: [],
+    status: rigStatusForLinearStateType(issue.state?.type),
+    title: issue.title,
+    body: description,
+    description,
+    ...scope.length > 0 ? { scope } : {},
+    ...roleLabel ? { role: roleLabel.slice("role:".length) } : {},
+    ...validators.length > 0 ? { validators } : {},
+    ...issue.priority !== null && issue.priority !== undefined ? { priority: issue.priority } : {},
+    ...issue.priorityLabel ? { priorityLabel: issue.priorityLabel } : {},
+    ...issue.url ? { url: issue.url } : {},
+    labels: labelNames,
+    externalRef: `linear:${issue.identifier}`,
+    sourceIssueId: issue.identifier,
+    linearIssueId: issue.id,
+    ...issue.state ? { stateName: issue.state.name, stateType: issue.state.type } : {},
+    raw: issue
+  };
+}
+function buildIssueFilter(opts) {
+  const filter = { team: { key: { eq: opts.teamKey } } };
+  if (opts.states && opts.states.length > 0) {
+    filter.state = { name: { in: [...opts.states] } };
+  }
+  const assignee = opts.assignee?.trim();
+  if (assignee) {
+    filter.assignee = assignee.includes("@") ? { email: { eq: assignee } } : { displayName: { eq: assignee } };
+  }
+  if (opts.labels && opts.labels.length > 0) {
+    filter.and = opts.labels.map((name) => ({ labels: { some: { name: { eq: name } } } }));
+  }
+  return filter;
+}
+var DEFAULT_ENDPOINT = "https://api.linear.app/graphql";
+var DEFAULT_PAGE_SIZE = 50;
+var DEFAULT_LIST_LIMIT = 1000;
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function truncateForError(text) {
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length > 300 ? `${clean.slice(0, 300)}\u2026` : clean;
+}
+function isAuthErrorPayload(status, errors) {
+  if (status === 401)
+    return "HTTP 401";
+  for (const error of errors ?? []) {
+    const code = error.extensions?.code ?? "";
+    if (code === "AUTHENTICATION_ERROR" || /authentication/i.test(error.message ?? "")) {
+      return error.message ?? code;
+    }
+  }
+  return null;
+}
+function createGraphQLClient(opts) {
+  const endpoint = opts.endpoint ?? DEFAULT_ENDPOINT;
+  const transport = opts.transport ?? fetch;
+  return {
+    async request(query, variables) {
+      const apiKey = (opts.apiKey ?? process.env.LINEAR_API_KEY)?.trim();
+      if (!apiKey) {
+        throw new Error("Linear task source: no API key configured. Pass apiKey in plugin options or set the LINEAR_API_KEY environment variable.");
+      }
+      const authorization = apiKey.startsWith("lin_oauth_") ? `Bearer ${apiKey}` : apiKey;
+      let response;
+      try {
+        response = await transport(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: authorization
+          },
+          body: JSON.stringify({ query, variables })
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Linear API request failed (network error): ${message}`, { cause: error });
+      }
+      const text = await response.text();
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = undefined;
+      }
+      const authError = isAuthErrorPayload(response.status, parsed?.errors);
+      if (authError) {
+        throw new Error(`Linear API authentication failed (${authError}). Check that the configured API key (options.apiKey / LINEAR_API_KEY) is a valid Linear key with access to team "${opts.teamKey}".`);
+      }
+      if (!response.ok) {
+        throw new Error(`Linear API request failed (HTTP ${response.status}): ${truncateForError(text)}`);
+      }
+      if (parsed?.errors && parsed.errors.length > 0) {
+        const messages = parsed.errors.map((e) => e.message ?? "unknown error").join("; ");
+        throw new Error(`Linear GraphQL error: ${messages}`);
+      }
+      if (!parsed || parsed.data === undefined || parsed.data === null) {
+        throw new Error(`Linear API returned no data: ${truncateForError(text)}`);
+      }
+      return parsed.data;
+    }
+  };
+}
+function createLinearIssuesTaskSource(opts) {
+  if (!opts.teamKey?.trim()) {
+    throw new Error("createLinearIssuesTaskSource: teamKey is required");
+  }
+  const teamKey = opts.teamKey.trim();
+  const client = createGraphQLClient(opts);
+  const pageSize = Math.min(250, Math.max(1, Math.trunc(opts.pageSize ?? DEFAULT_PAGE_SIZE)));
+  const listLimit = Math.max(1, Math.trunc(opts.listLimit ?? DEFAULT_LIST_LIMIT));
+  let cachedStates = null;
+  const fetchTeamStates = async () => {
+    if (cachedStates)
+      return cachedStates;
+    const data = await client.request(TEAM_STATES_QUERY, { teamKey });
+    const team = data.teams.nodes[0];
+    if (!team) {
+      throw new Error(`Linear team not found for key "${teamKey}" \u2014 check taskSource.options.teamKey.`);
+    }
+    cachedStates = team.states.nodes;
+    return cachedStates;
+  };
+  const resolveStateId = async (stateType) => {
+    const states = await fetchTeamStates();
+    const candidates = states.filter((s) => s.type === stateType).toSorted((a, b) => (a.position ?? 0) - (b.position ?? 0));
+    const target = candidates[0];
+    if (!target) {
+      throw new Error(`Linear team "${teamKey}" has no workflow state of type "${stateType}" \u2014 cannot map this Rig status to a Linear state.`);
+    }
+    return target.id;
+  };
+  const resolveIssueUuid = async (taskId) => {
+    if (UUID_PATTERN.test(taskId))
+      return taskId;
+    const data = await client.request(RESOLVE_ISSUE_QUERY, { id: taskId });
+    if (!data.issue) {
+      throw new Error(`Linear issue not found: ${taskId}`);
+    }
+    return data.issue.id;
+  };
+  const fetchDescription = async (issueUuid) => {
+    const data = await client.request(ISSUE_DESCRIPTION_QUERY, { id: issueUuid });
+    return data.issue?.description ?? "";
+  };
+  const applyIssueUpdate = async (taskId, update) => {
+    const issueUuid = await resolveIssueUuid(taskId);
+    const input = {};
+    if (update.status) {
+      const stateType = linearStateTypeForRigStatus(update.status);
+      if (stateType)
+        input.stateId = await resolveStateId(stateType);
+    }
+    if (update.title?.trim())
+      input.title = update.title.trim();
+    const nextBody = update.metadata ? updateRigOwnedMetadataBlock(update.body ?? await fetchDescription(issueUuid), update.metadata) : update.body;
+    if (nextBody !== undefined)
+      input.description = nextBody;
+    if (Object.keys(input).length > 0) {
+      await client.request(ISSUE_UPDATE_MUTATION, {
+        id: issueUuid,
+        input
+      });
+    }
+    if (update.comment?.trim()) {
+      await client.request(COMMENT_CREATE_MUTATION, {
+        input: { issueId: issueUuid, body: update.comment }
+      });
+    }
+  };
+  const notifyTaskChanged = (id, status) => {
+    opts.onTaskChanged?.({ teamKey, id, ...status ? { status } : {}, reason: "linear-issue-updated" });
+  };
+  return {
+    id: "linear:issues",
+    kind: "linear",
+    async list() {
+      const filter = buildIssueFilter({ ...opts, teamKey });
+      const out = [];
+      let after = null;
+      for (;; ) {
+        const data = await client.request(LIST_ISSUES_QUERY, {
+          filter,
+          first: pageSize,
+          after
+        });
+        out.push(...data.issues.nodes.map(issueToTask));
+        if (out.length > listLimit) {
+          throw new Error(`Linear issue list for team ${teamKey} exceeded the configured limit (${listLimit}); refusing to silently truncate matching issues. Increase taskSource.options.listLimit or narrow states/labels/assignee.`);
+        }
+        if (!data.issues.pageInfo.hasNextPage)
+          break;
+        after = data.issues.pageInfo.endCursor ?? null;
+        if (!after)
+          break;
+      }
+      return out;
+    },
+    async get(id) {
+      try {
+        const data = await client.request(GET_ISSUE_QUERY, { id });
+        return data.issue ? issueToTask(data.issue) : undefined;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/authentication|API key/i.test(message))
+          throw error;
+        if (/not found|entity not found/i.test(message))
+          return;
+        throw error;
+      }
+    },
+    async updateStatus(id, status) {
+      const stateType = linearStateTypeForRigStatus(status);
+      if (stateType) {
+        const issueUuid = await resolveIssueUuid(id);
+        const stateId = await resolveStateId(stateType);
+        await client.request(ISSUE_UPDATE_MUTATION, {
+          id: issueUuid,
+          input: { stateId }
+        });
+      }
+      notifyTaskChanged(id, status);
+    },
+    async updateTask(id, update) {
+      await applyIssueUpdate(id, update);
+      notifyTaskChanged(id, update.status);
+    }
+  };
+}
+// packages/linear-plugin/src/fixture-transport.ts
+var HTTP_FAILURE = Symbol("linear-fixture-http-failure");
+var GRAPHQL_ERRORS = Symbol("linear-fixture-graphql-errors");
+function httpFailure(status, body) {
+  return { [HTTP_FAILURE]: true, status, body };
+}
+function graphqlErrors(errors) {
+  return { [GRAPHQL_ERRORS]: true, errors };
+}
+function isHttpFailure(value) {
+  return typeof value === "object" && value !== null && HTTP_FAILURE in value;
+}
+function isGraphQLErrors(value) {
+  return typeof value === "object" && value !== null && GRAPHQL_ERRORS in value;
+}
+function jsonResponse(status, body) {
+  return { ok: status >= 200 && status < 300, status, text: async () => body };
+}
+function createFixtureTransport(routes) {
+  const calls = [];
+  const transport = async (url, init) => {
+    const body = JSON.parse(init.body);
+    const operation = /(?:query|mutation)\s+([A-Za-z0-9_]+)/.exec(body.query)?.[1] ?? "<anonymous>";
+    const call = {
+      url,
+      authorization: init.headers["Authorization"],
+      operation,
+      query: body.query,
+      variables: body.variables ?? {}
+    };
+    calls.push(call);
+    const route = routes[operation];
+    if (!route) {
+      throw new Error(`createFixtureTransport: no fixture route for operation "${operation}"`);
+    }
+    const result = route(call.variables, call);
+    if (isHttpFailure(result)) {
+      return jsonResponse(result.status, result.body);
+    }
+    if (isGraphQLErrors(result)) {
+      return jsonResponse(200, JSON.stringify({ errors: result.errors }));
+    }
+    return jsonResponse(200, JSON.stringify({ data: result }));
+  };
+  return {
+    transport,
+    calls,
+    callsFor: (operation) => calls.filter((c) => c.operation === operation)
+  };
+}
+
+// packages/linear-plugin/src/index.ts
+var TASK_SOURCE_ID = "linear:issues";
+var TASK_SOURCE_KIND = "linear";
+var TASK_SOURCE_DESCRIPTION = "Linear issues via the Linear GraphQL API";
+function optionString(config, field) {
+  const value = config.options?.[field];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function optionStringArray(config, field) {
+  const value = config.options?.[field];
+  if (!Array.isArray(value))
+    return;
+  const strings = value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+  return strings.length > 0 ? strings : undefined;
+}
+function optionNumber(config, field) {
+  const value = config.options?.[field];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function linearPlugin(opts = {}) {
+  return definePlugin({
+    name: "rig-linear",
+    version: "0.1.0",
+    contributes: {
+      taskSources: [
+        {
+          id: TASK_SOURCE_ID,
+          kind: TASK_SOURCE_KIND,
+          description: TASK_SOURCE_DESCRIPTION
+        }
+      ]
+    }
+  }, {
+    taskSources: [
+      {
+        id: TASK_SOURCE_ID,
+        kind: TASK_SOURCE_KIND,
+        description: TASK_SOURCE_DESCRIPTION,
+        factory(config) {
+          const teamKey = optionString(config, "teamKey");
+          if (!teamKey) {
+            throw new Error('task source linear: options.teamKey is required \u2014 e.g. taskSource: { kind: "linear", options: { teamKey: "ENG" } }');
+          }
+          const options = { teamKey };
+          if (opts.apiKey)
+            options.apiKey = opts.apiKey;
+          if (opts.endpoint)
+            options.endpoint = opts.endpoint;
+          if (opts.transport)
+            options.transport = opts.transport;
+          if (opts.onTaskChanged)
+            options.onTaskChanged = opts.onTaskChanged;
+          const states = optionStringArray(config, "states");
+          if (states)
+            options.states = states;
+          const assignee = optionString(config, "assignee");
+          if (assignee)
+            options.assignee = assignee;
+          const labels = optionStringArray(config, "labels") ?? (config.labels && config.labels.length > 0 ? [...config.labels] : undefined);
+          if (labels)
+            options.labels = labels;
+          const pageSize = optionNumber(config, "pageSize");
+          if (pageSize !== undefined)
+            options.pageSize = pageSize;
+          const listLimit = optionNumber(config, "listLimit");
+          if (listLimit !== undefined)
+            options.listLimit = listLimit;
+          return createLinearIssuesTaskSource(options);
+        }
+      }
+    ]
+  });
+}
+export {
+  updateRigOwnedMetadataBlock,
+  rigStatusForLinearStateType,
+  linearStateTypeForRigStatus,
+  httpFailure,
+  graphqlErrors,
+  linearPlugin as default,
+  createLinearIssuesTaskSource,
+  createFixtureTransport,
+  RIG_METADATA_START,
+  RIG_METADATA_END
+};

package/dist/src/linear-issues-source.js

@@ -0,0 +1,361 @@
+// @bun
+// packages/linear-plugin/src/linear-issues-source.ts
+var ISSUE_FIELDS = `
+      id
+      identifier
+      title
+      description
+      priority
+      priorityLabel
+      url
+      state { id name type }
+      labels { nodes { name } }
+      assignee { name email }`;
+var LIST_ISSUES_QUERY = `query RigListIssues($filter: IssueFilter, $first: Int!, $after: String) {
+  issues(filter: $filter, first: $first, after: $after) {
+    pageInfo { hasNextPage endCursor }
+    nodes {${ISSUE_FIELDS}
+    }
+  }
+}`;
+var GET_ISSUE_QUERY = `query RigGetIssue($id: String!) {
+  issue(id: $id) {${ISSUE_FIELDS}
+  }
+}`;
+var RESOLVE_ISSUE_QUERY = `query RigResolveIssue($id: String!) {
+  issue(id: $id) { id }
+}`;
+var ISSUE_DESCRIPTION_QUERY = `query RigIssueDescription($id: String!) {
+  issue(id: $id) { description }
+}`;
+var TEAM_STATES_QUERY = `query RigTeamStates($teamKey: String!) {
+  teams(filter: { key: { eq: $teamKey } }, first: 1) {
+    nodes {
+      id
+      key
+      states { nodes { id name type position } }
+    }
+  }
+}`;
+var ISSUE_UPDATE_MUTATION = `mutation RigIssueUpdate($id: String!, $input: IssueUpdateInput!) {
+  issueUpdate(id: $id, input: $input) { success }
+}`;
+var COMMENT_CREATE_MUTATION = `mutation RigCommentCreate($input: CommentCreateInput!) {
+  commentCreate(input: $input) { success }
+}`;
+function rigStatusForLinearStateType(stateType) {
+  switch (stateType) {
+    case "triage":
+    case "backlog":
+    case "unstarted":
+      return "ready";
+    case "started":
+      return "in_progress";
+    case "completed":
+      return "completed";
+    case "canceled":
+      return "cancelled";
+    default:
+      return "open";
+  }
+}
+function linearStateTypeForRigStatus(status) {
+  switch (status) {
+    case "ready":
+      return "unstarted";
+    case "in_progress":
+    case "under_review":
+    case "ci_fixing":
+    case "merging":
+      return "started";
+    case "closed":
+    case "completed":
+      return "completed";
+    case "cancelled":
+      return "canceled";
+    case "blocked":
+    case "failed":
+    case "needs_attention":
+    case "open":
+      return null;
+    default:
+      return null;
+  }
+}
+var RIG_METADATA_START = "<!-- rig:metadata:start -->";
+var RIG_METADATA_END = "<!-- rig:metadata:end -->";
+function yamlScalar(value) {
+  if (Array.isArray(value)) {
+    return value.length === 0 ? "[]" : `
+${value.map((entry) => `  - ${String(entry)}`).join(`
+`)}`;
+  }
+  if (value && typeof value === "object")
+    return JSON.stringify(value);
+  return String(value);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function updateRigOwnedMetadataBlock(body, metadata) {
+  const rendered = [
+    RIG_METADATA_START,
+    ...Object.entries(metadata).map(([key, value]) => Array.isArray(value) ? `${key}:${yamlScalar(value)}` : `${key}: ${yamlScalar(value)}`),
+    RIG_METADATA_END
+  ].join(`
+`);
+  const pattern = new RegExp(`${escapeRegExp(RIG_METADATA_START)}\\s*[\\s\\S]*?\\s*${escapeRegExp(RIG_METADATA_END)}`);
+  if (pattern.test(body))
+    return body.replace(pattern, rendered);
+  return body.trim().length > 0 ? `${body.trimEnd()}
+
+${rendered}
+` : `${rendered}
+`;
+}
+function labelNamesFor(issue) {
+  return (issue.labels?.nodes ?? []).map((label) => label.name);
+}
+function issueToTask(issue) {
+  const labelNames = labelNamesFor(issue);
+  const scope = labelNames.filter((l) => l.startsWith("scope:")).map((l) => l.slice("scope:".length));
+  const roleLabel = labelNames.find((l) => l.startsWith("role:"));
+  const validators = labelNames.filter((l) => l.startsWith("validator:")).map((l) => l.slice("validator:".length));
+  const description = issue.description ?? "";
+  return {
+    id: issue.identifier,
+    deps: [],
+    status: rigStatusForLinearStateType(issue.state?.type),
+    title: issue.title,
+    body: description,
+    description,
+    ...scope.length > 0 ? { scope } : {},
+    ...roleLabel ? { role: roleLabel.slice("role:".length) } : {},
+    ...validators.length > 0 ? { validators } : {},
+    ...issue.priority !== null && issue.priority !== undefined ? { priority: issue.priority } : {},
+    ...issue.priorityLabel ? { priorityLabel: issue.priorityLabel } : {},
+    ...issue.url ? { url: issue.url } : {},
+    labels: labelNames,
+    externalRef: `linear:${issue.identifier}`,
+    sourceIssueId: issue.identifier,
+    linearIssueId: issue.id,
+    ...issue.state ? { stateName: issue.state.name, stateType: issue.state.type } : {},
+    raw: issue
+  };
+}
+function buildIssueFilter(opts) {
+  const filter = { team: { key: { eq: opts.teamKey } } };
+  if (opts.states && opts.states.length > 0) {
+    filter.state = { name: { in: [...opts.states] } };
+  }
+  const assignee = opts.assignee?.trim();
+  if (assignee) {
+    filter.assignee = assignee.includes("@") ? { email: { eq: assignee } } : { displayName: { eq: assignee } };
+  }
+  if (opts.labels && opts.labels.length > 0) {
+    filter.and = opts.labels.map((name) => ({ labels: { some: { name: { eq: name } } } }));
+  }
+  return filter;
+}
+var DEFAULT_ENDPOINT = "https://api.linear.app/graphql";
+var DEFAULT_PAGE_SIZE = 50;
+var DEFAULT_LIST_LIMIT = 1000;
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function truncateForError(text) {
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length > 300 ? `${clean.slice(0, 300)}\u2026` : clean;
+}
+function isAuthErrorPayload(status, errors) {
+  if (status === 401)
+    return "HTTP 401";
+  for (const error of errors ?? []) {
+    const code = error.extensions?.code ?? "";
+    if (code === "AUTHENTICATION_ERROR" || /authentication/i.test(error.message ?? "")) {
+      return error.message ?? code;
+    }
+  }
+  return null;
+}
+function createGraphQLClient(opts) {
+  const endpoint = opts.endpoint ?? DEFAULT_ENDPOINT;
+  const transport = opts.transport ?? fetch;
+  return {
+    async request(query, variables) {
+      const apiKey = (opts.apiKey ?? process.env.LINEAR_API_KEY)?.trim();
+      if (!apiKey) {
+        throw new Error("Linear task source: no API key configured. Pass apiKey in plugin options or set the LINEAR_API_KEY environment variable.");
+      }
+      const authorization = apiKey.startsWith("lin_oauth_") ? `Bearer ${apiKey}` : apiKey;
+      let response;
+      try {
+        response = await transport(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: authorization
+          },
+          body: JSON.stringify({ query, variables })
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Linear API request failed (network error): ${message}`, { cause: error });
+      }
+      const text = await response.text();
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = undefined;
+      }
+      const authError = isAuthErrorPayload(response.status, parsed?.errors);
+      if (authError) {
+        throw new Error(`Linear API authentication failed (${authError}). Check that the configured API key (options.apiKey / LINEAR_API_KEY) is a valid Linear key with access to team "${opts.teamKey}".`);
+      }
+      if (!response.ok) {
+        throw new Error(`Linear API request failed (HTTP ${response.status}): ${truncateForError(text)}`);
+      }
+      if (parsed?.errors && parsed.errors.length > 0) {
+        const messages = parsed.errors.map((e) => e.message ?? "unknown error").join("; ");
+        throw new Error(`Linear GraphQL error: ${messages}`);
+      }
+      if (!parsed || parsed.data === undefined || parsed.data === null) {
+        throw new Error(`Linear API returned no data: ${truncateForError(text)}`);
+      }
+      return parsed.data;
+    }
+  };
+}
+function createLinearIssuesTaskSource(opts) {
+  if (!opts.teamKey?.trim()) {
+    throw new Error("createLinearIssuesTaskSource: teamKey is required");
+  }
+  const teamKey = opts.teamKey.trim();
+  const client = createGraphQLClient(opts);
+  const pageSize = Math.min(250, Math.max(1, Math.trunc(opts.pageSize ?? DEFAULT_PAGE_SIZE)));
+  const listLimit = Math.max(1, Math.trunc(opts.listLimit ?? DEFAULT_LIST_LIMIT));
+  let cachedStates = null;
+  const fetchTeamStates = async () => {
+    if (cachedStates)
+      return cachedStates;
+    const data = await client.request(TEAM_STATES_QUERY, { teamKey });
+    const team = data.teams.nodes[0];
+    if (!team) {
+      throw new Error(`Linear team not found for key "${teamKey}" \u2014 check taskSource.options.teamKey.`);
+    }
+    cachedStates = team.states.nodes;
+    return cachedStates;
+  };
+  const resolveStateId = async (stateType) => {
+    const states = await fetchTeamStates();
+    const candidates = states.filter((s) => s.type === stateType).toSorted((a, b) => (a.position ?? 0) - (b.position ?? 0));
+    const target = candidates[0];
+    if (!target) {
+      throw new Error(`Linear team "${teamKey}" has no workflow state of type "${stateType}" \u2014 cannot map this Rig status to a Linear state.`);
+    }
+    return target.id;
+  };
+  const resolveIssueUuid = async (taskId) => {
+    if (UUID_PATTERN.test(taskId))
+      return taskId;
+    const data = await client.request(RESOLVE_ISSUE_QUERY, { id: taskId });
+    if (!data.issue) {
+      throw new Error(`Linear issue not found: ${taskId}`);
+    }
+    return data.issue.id;
+  };
+  const fetchDescription = async (issueUuid) => {
+    const data = await client.request(ISSUE_DESCRIPTION_QUERY, { id: issueUuid });
+    return data.issue?.description ?? "";
+  };
+  const applyIssueUpdate = async (taskId, update) => {
+    const issueUuid = await resolveIssueUuid(taskId);
+    const input = {};
+    if (update.status) {
+      const stateType = linearStateTypeForRigStatus(update.status);
+      if (stateType)
+        input.stateId = await resolveStateId(stateType);
+    }
+    if (update.title?.trim())
+      input.title = update.title.trim();
+    const nextBody = update.metadata ? updateRigOwnedMetadataBlock(update.body ?? await fetchDescription(issueUuid), update.metadata) : update.body;
+    if (nextBody !== undefined)
+      input.description = nextBody;
+    if (Object.keys(input).length > 0) {
+      await client.request(ISSUE_UPDATE_MUTATION, {
+        id: issueUuid,
+        input
+      });
+    }
+    if (update.comment?.trim()) {
+      await client.request(COMMENT_CREATE_MUTATION, {
+        input: { issueId: issueUuid, body: update.comment }
+      });
+    }
+  };
+  const notifyTaskChanged = (id, status) => {
+    opts.onTaskChanged?.({ teamKey, id, ...status ? { status } : {}, reason: "linear-issue-updated" });
+  };
+  return {
+    id: "linear:issues",
+    kind: "linear",
+    async list() {
+      const filter = buildIssueFilter({ ...opts, teamKey });
+      const out = [];
+      let after = null;
+      for (;; ) {
+        const data = await client.request(LIST_ISSUES_QUERY, {
+          filter,
+          first: pageSize,
+          after
+        });
+        out.push(...data.issues.nodes.map(issueToTask));
+        if (out.length > listLimit) {
+          throw new Error(`Linear issue list for team ${teamKey} exceeded the configured limit (${listLimit}); refusing to silently truncate matching issues. Increase taskSource.options.listLimit or narrow states/labels/assignee.`);
+        }
+        if (!data.issues.pageInfo.hasNextPage)
+          break;
+        after = data.issues.pageInfo.endCursor ?? null;
+        if (!after)
+          break;
+      }
+      return out;
+    },
+    async get(id) {
+      try {
+        const data = await client.request(GET_ISSUE_QUERY, { id });
+        return data.issue ? issueToTask(data.issue) : undefined;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/authentication|API key/i.test(message))
+          throw error;
+        if (/not found|entity not found/i.test(message))
+          return;
+        throw error;
+      }
+    },
+    async updateStatus(id, status) {
+      const stateType = linearStateTypeForRigStatus(status);
+      if (stateType) {
+        const issueUuid = await resolveIssueUuid(id);
+        const stateId = await resolveStateId(stateType);
+        await client.request(ISSUE_UPDATE_MUTATION, {
+          id: issueUuid,
+          input: { stateId }
+        });
+      }
+      notifyTaskChanged(id, status);
+    },
+    async updateTask(id, update) {
+      await applyIssueUpdate(id, update);
+      notifyTaskChanged(id, update.status);
+    }
+  };
+}
+export {
+  updateRigOwnedMetadataBlock,
+  rigStatusForLinearStateType,
+  linearStateTypeForRigStatus,
+  createLinearIssuesTaskSource,
+  RIG_METADATA_START,
+  RIG_METADATA_END
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@h-rig/linear-plugin",
+  "version": "0.0.6-alpha.65",
+  "type": "module",
+  "description": "Rig package",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/src/index.js"
+    }
+  },
+  "engines": {
+    "bun": ">=1.3.11"
+  },
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "dependencies": {
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.65",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.65",
+    "effect": "4.0.0-beta.78"
+  }
+}