@smwb/onreel-git-mcp 0.4.0 → 0.6.0

package/dist/tracker/index.js

@@ -1,7 +1,8 @@
 import {
+  REDACTED,
   defaultSecretSink,
   redactSecretText
-} from "../chunk-L7CPE2SO.js";
+} from "../chunk-AGGJK2XZ.js";
 import {
   issueLinkSchema,
   timestampSchema
@@ -20,6 +21,12 @@ var LEGACY_ISSUE_CAPABILITIES = {
   list: { filters: ["status"], clientSide: ["status"], sorts: [] },
   comments: { filters: [], clientSide: [], order: ["asc"] }
 };
+var CI_LOG_DEFAULT_BYTES = 16 * 1024;
+var CI_LOG_MAX_BYTES = 1024 * 1024;
+var CI_LOG_READ_MAX_BYTES = 64 * 1024 * 1024;
+var CI_LOG_TIMEOUT_MS = 6e4;
+var CI_LOG_PAGES_MAX = 50;
+var CI_FINISHED_STATUSES = ["success", "failed", "canceled", "skipped"];
 
 // src/tracker/tracker.lib.ts
 var TrackerError = class extends Error {
@@ -230,6 +237,84 @@ var SOURCECRAFT_PULL_STATUSES = {
   merged: "merged",
   discarded: "closed"
 };
+var GITHUB_RUN_STATUSES = {
+  queued: "queued",
+  requested: "queued",
+  pending: "queued",
+  waiting: "waiting",
+  in_progress: "running"
+};
+var GITHUB_RUN_CONCLUSIONS = {
+  success: "success",
+  neutral: "success",
+  failure: "failed",
+  timed_out: "failed",
+  startup_failure: "failed",
+  cancelled: "canceled",
+  stale: "canceled",
+  skipped: "skipped",
+  action_required: "waiting"
+};
+var GITHUB_RUN_EVENTS = {
+  push: "push",
+  pull_request: "pull_request",
+  pull_request_target: "pull_request",
+  merge_group: "pull_request",
+  workflow_dispatch: "manual",
+  schedule: "schedule",
+  repository_dispatch: "trigger",
+  workflow_run: "trigger",
+  workflow_call: "trigger"
+};
+var GITLAB_CI_STATUSES = {
+  created: "queued",
+  waiting_for_resource: "queued",
+  preparing: "queued",
+  pending: "queued",
+  running: "running",
+  canceling: "running",
+  waiting_for_callback: "waiting",
+  manual: "waiting",
+  scheduled: "waiting",
+  success: "success",
+  failed: "failed",
+  canceled: "canceled",
+  skipped: "skipped"
+};
+var GITLAB_PIPELINE_SOURCES = {
+  push: "push",
+  merge_request_event: "pull_request",
+  external_pull_request_event: "pull_request",
+  web: "manual",
+  api: "manual",
+  chat: "manual",
+  webide: "manual",
+  schedule: "schedule",
+  pipeline_execution_policy_schedule: "schedule",
+  trigger: "trigger",
+  pipeline: "trigger",
+  parent_pipeline: "trigger"
+};
+var SOURCECRAFT_CI_STATUSES = {
+  created: "queued",
+  prepared: "queued",
+  processing: "running",
+  awaiting_approval: "waiting",
+  success: "success",
+  failed: "failed",
+  timeout: "failed",
+  canceled: "canceled",
+  rejected: "canceled",
+  skipped: "skipped"
+};
+var SOURCECRAFT_RUN_EVENTS = {
+  push: "push",
+  pr_update: "pull_request",
+  manual: "manual",
+  restart: "retry",
+  schedule: "schedule",
+  repository_event: "trigger"
+};
 
 // src/tracker/http.lib.ts
 async function requestJson(url, request) {
@@ -242,7 +327,7 @@ async function requestJson(url, request) {
       signal: AbortSignal.timeout(TRACKER_TIMEOUT_MS)
     });
   } catch (error) {
-    throw new TrackerError("failed", redactSecretText(`\u0422\u0440\u0435\u043A\u0435\u0440 \u043D\u0435 \u043E\u0442\u0432\u0435\u0442\u0438\u043B (${hostOf(url)}): ${error instanceof Error ? error.message : String(error)}`));
+    throw notAnswered(url, error);
   }
   const raw = await response.text();
   if (!response.ok) throw failureOf(url, response, raw, request);
@@ -253,6 +338,131 @@ async function requestJson(url, request) {
     throw new TrackerError("failed", `\u0422\u0440\u0435\u043A\u0435\u0440 ${hostOf(url)} \u0432\u0435\u0440\u043D\u0443\u043B \u043D\u0435 JSON.`);
   }
 }
+var ERROR_BODY_READ_MAX = 16 * 1024;
+async function requestText(url, request) {
+  const skip = request.skip ?? 0;
+  const { bytes, from } = request.keep;
+  const readMax = request.readMax ?? CI_LOG_READ_MAX_BYTES;
+  if (![skip, bytes, readMax].every((value) => Number.isSafeInteger(value) && value >= 0)) {
+    throw new TrackerError("invalid_request", "\u041E\u043A\u043D\u043E \u0447\u0442\u0435\u043D\u0438\u044F \u0442\u0435\u043A\u0441\u0442\u0430 \u2014 \u0446\u0435\u043B\u044B\u0435 \u0447\u0438\u0441\u043B\u0430 \u0431\u0430\u0439\u0442 \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 0.");
+  }
+  let response;
+  try {
+    response = await request.fetch(url, {
+      method: "GET",
+      headers: { accept: request.accept ?? "text/plain", ...request.headers },
+      signal: AbortSignal.timeout(request.timeoutMs ?? CI_LOG_TIMEOUT_MS)
+    });
+  } catch (error) {
+    throw notAnswered(url, error);
+  }
+  if (!response.ok) {
+    const head = await readBody(url, response, { skip: 0, bytes: ERROR_BODY_READ_MAX, from: "head", readMax: ERROR_BODY_READ_MAX });
+    throw failureOf(url, response, decodeUtf8(head.window), request);
+  }
+  const body = await readBody(url, response, { skip, bytes, from, readMax });
+  let start = Math.min(body.start, body.end);
+  let end = body.end;
+  let window = body.window;
+  const lead = start > 0 ? leadingContinuation(window) : 0;
+  const tail = trailingPartial(window.subarray(lead));
+  if (lead > 0 || tail > 0) {
+    window = window.subarray(lead, window.length - tail);
+    start += lead;
+    end -= tail;
+  }
+  return { text: decodeUtf8(window), start, end, read: body.read, whole: body.whole, headers: response.headers };
+}
+async function readBody(url, response, window) {
+  const { skip, bytes, from, readMax } = window;
+  const reader = response.body?.getReader();
+  const kept = from === "head" ? headBuffer(bytes) : ringBuffer(bytes);
+  let read = 0;
+  let whole = true;
+  if (reader !== void 0) {
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = value.subarray(0, Math.max(0, readMax - read));
+        const cut = chunk.length < value.length;
+        const offset = Math.max(0, skip - read);
+        if (offset < chunk.length) kept.push(chunk.subarray(offset));
+        read += chunk.length;
+        if (cut || kept.full()) {
+          whole = false;
+          await reader.cancel().catch(() => void 0);
+          break;
+        }
+      }
+    } catch (error) {
+      await reader.cancel().catch(() => void 0);
+      throw notAnswered(url, error);
+    }
+  }
+  const data = kept.bytes();
+  const start = from === "head" ? skip : Math.max(skip, read - data.length);
+  return { window: data, start, end: from === "head" ? skip + data.length : read, read, whole };
+}
+function headBuffer(capacity) {
+  const buffer = new Uint8Array(capacity);
+  let length = 0;
+  let overflow = false;
+  return {
+    push(chunk) {
+      const room = capacity - length;
+      buffer.set(chunk.subarray(0, room), length);
+      length += Math.min(room, chunk.length);
+      if (chunk.length > room) overflow = true;
+    },
+    full: () => overflow,
+    bytes: () => buffer.subarray(0, length)
+  };
+}
+function ringBuffer(capacity) {
+  const buffer = new Uint8Array(capacity);
+  let next = 0;
+  let length = 0;
+  return {
+    push(chunk) {
+      if (capacity === 0) return;
+      const part = chunk.subarray(Math.max(0, chunk.length - capacity));
+      const first = Math.min(part.length, capacity - next);
+      buffer.set(part.subarray(0, first), next);
+      buffer.set(part.subarray(first), 0);
+      next = (next + part.length) % capacity;
+      length = Math.min(capacity, length + part.length);
+    },
+    full: () => false,
+    bytes() {
+      if (length < capacity) return buffer.subarray(0, length);
+      const ordered = new Uint8Array(capacity);
+      ordered.set(buffer.subarray(next), 0);
+      ordered.set(buffer.subarray(0, next), capacity - next);
+      return ordered;
+    }
+  };
+}
+function leadingContinuation(window) {
+  let count = 0;
+  while (count < 3 && count < window.length && ((window[count] ?? 0) & 192) === 128) count += 1;
+  return count;
+}
+function trailingPartial(window) {
+  for (let back = 1; back <= Math.min(4, window.length); back += 1) {
+    const byte = window[window.length - back] ?? 0;
+    if ((byte & 192) === 128) continue;
+    const length = byte >= 240 ? 4 : byte >= 224 ? 3 : byte >= 192 ? 2 : 1;
+    return length > back ? back : 0;
+  }
+  return 0;
+}
+function decodeUtf8(bytes) {
+  return new TextDecoder("utf-8").decode(bytes);
+}
+function notAnswered(url, error) {
+  return new TrackerError("failed", redactSecretText(`\u0422\u0440\u0435\u043A\u0435\u0440 \u043D\u0435 \u043E\u0442\u0432\u0435\u0442\u0438\u043B (${hostOf(url)}): ${error instanceof Error ? error.message : String(error)}`));
+}
 function failureOf(url, response, raw, request) {
   const status = response.status;
   if (status === 404 && request.missing !== void 0) return new TrackerError(request.missing.failure, request.missing.message);
@@ -304,6 +514,1000 @@ function baseUrl(value, fallback) {
   return raw;
 }
 
+// src/tracker/ci.schema.ts
+import { z } from "zod";
+var ciStatusCategorySchema = z.enum(["queued", "running", "waiting", "success", "failed", "canceled", "skipped"]);
+var ciEventCategorySchema = z.enum(["push", "pull_request", "manual", "schedule", "retry", "trigger", "other"]);
+var ciRunFilterSchema = z.enum(["status", "ref", "sha", "event", "workflow", "actor", "pullRequest", "createdAfter", "createdBefore", "updatedAfter", "updatedBefore"]);
+var ciRunSortFieldSchema = z.enum(["created", "updated"]);
+var ciJobFilterSchema = z.enum(["status", "allAttempts"]);
+var ciStatusSchema = z.object({ category: ciStatusCategorySchema, name: z.string().min(1).max(100) });
+var ciWorkflowSchema = z.object({
+  /** Ключ workflow: GitHub — id строкой; подходит в trigger.workflows и фильтр workflow. */
+  key: z.string().min(1).max(200),
+  name: z.string().min(1).max(500),
+  path: z.string().min(1).max(1e3).optional(),
+  enabled: z.boolean()
+});
+var ciRunSchema = z.object({
+  /** Ключ прогона: GitHub run id, GitLab pipeline id, SourceCraft slug-счётчик; непрозрачная строка. */
+  key: z.string().min(1).max(200),
+  /** Номер для людей: GitHub run_number, GitLab iid, SourceCraft — счётчик. */
+  number: z.number().int().nonnegative().optional(),
+  /** Workflow прогона: GitHub — один, SourceCraft — все в прогоне, GitLab — имя пайплайна, если задано. */
+  workflows: z.array(z.string().min(1).max(500)).max(100),
+  status: ciStatusSchema,
+  event: z.object({ category: ciEventCategorySchema, name: z.string().min(1).max(100) }).optional(),
+  /** Ветка или тег прогона. */
+  ref: z.string().min(1).max(500).optional(),
+  sha: z.string().regex(/^[0-9a-f]{7,64}$/).optional(),
+  /** Кто запустил — логин или slug трекера. */
+  actor: z.string().min(1).max(200).optional(),
+  /** Ключ PR того же трекера, для которого прогон. */
+  pullRequest: z.string().min(1).max(200).optional(),
+  /** Попытка прогона (GitHub run_attempt). */
+  attempt: z.number().int().positive().optional(),
+  /** Ошибки прогона от трекера (SourceCraft error_messages). */
+  errors: z.array(z.string().min(1).max(4e3)).max(20).optional(),
+  links: z.array(issueLinkSchema).max(10),
+  createdAt: timestampSchema.optional(),
+  startedAt: timestampSchema.optional(),
+  finishedAt: timestampSchema.optional(),
+  updatedAt: timestampSchema.optional()
+});
+var ciJobSchema = z.object({
+  /** Ключ задания: GitHub и GitLab — job id, SourceCraft — `<run>/<workflow>/<task>/<cube>`, части через encodeURIComponent. */
+  key: z.string().min(1).max(1e3),
+  runKey: z.string().min(1).max(200),
+  name: z.string().min(1).max(500),
+  /** Группа: GitLab — stage, SourceCraft — `<workflow>/<task>`; у GitHub нет. */
+  stage: z.string().min(1).max(1e3).optional(),
+  status: ciStatusSchema,
+  /** Шаги GitHub: где упало; у остальных нет. */
+  steps: z.array(z.object({ number: z.number().int().nonnegative(), name: z.string().min(1).max(500), status: ciStatusSchema })).max(1e3).optional(),
+  attempt: z.number().int().positive().optional(),
+  links: z.array(issueLinkSchema).max(10),
+  createdAt: timestampSchema.optional(),
+  startedAt: timestampSchema.optional(),
+  finishedAt: timestampSchema.optional()
+});
+var ciLogSchema = z.object({
+  /** Окно лога: очищено от ANSI (если не raw), секреты замаскированы. */
+  text: z.string().max(CI_LOG_MAX_BYTES),
+  /** Окно не покрывает весь лог от курсора: срезано спереди (tail), сзади (head) или упёрлись в потолок чтения. */
+  truncated: z.boolean(),
+  /** Задание закончилось — лог больше не растёт. */
+  complete: z.boolean(),
+  /** Курсор дочитывания: передайте в log() — придёт текст после этого места. Нет — дальше ничего не будет. */
+  nextCursor: z.string().min(1).max(200).optional(),
+  /** Размер лога в байтах, если тело прочитано целиком. */
+  size: z.number().int().nonnegative().optional()
+});
+
+// src/tracker/ci.lib.ts
+function ciAdapterOf(definition, context) {
+  if (definition.ci === void 0) throw new TrackerError("unsupported", `\u0422\u0440\u0435\u043A\u0435\u0440 ${definition.descriptor.title} \u043D\u0435 \u0432\u0435\u0434\u0451\u0442 CI.`);
+  return definition.ci.create(context);
+}
+var LOG_CURSOR = /^c:(\d{1,15}):(\d{1,15})$/;
+function logWindow(query) {
+  const bytes = query.maxBytes ?? CI_LOG_DEFAULT_BYTES;
+  if (!Number.isInteger(bytes) || bytes < 1 || bytes > CI_LOG_MAX_BYTES) {
+    throw new TrackerError("invalid_request", `\u041E\u043A\u043D\u043E \u043B\u043E\u0433\u0430 maxBytes \u2014 \u0446\u0435\u043B\u043E\u0435 \u043E\u0442 1 \u0434\u043E ${String(CI_LOG_MAX_BYTES)}.`);
+  }
+  const from = query.from ?? "tail";
+  if (from !== "head" && from !== "tail") throw new TrackerError("invalid_request", "\u041D\u0430\u0447\u0430\u043B\u043E \u043E\u043A\u043D\u0430 \u043B\u043E\u0433\u0430 from \u2014 head \u0438\u043B\u0438 tail.");
+  if (query.cursor === void 0) return { bytes, from };
+  const match = LOG_CURSOR.exec(query.cursor);
+  if (match === null) {
+    throw new TrackerError("invalid_request", "\u041A\u0443\u0440\u0441\u043E\u0440 \u043B\u043E\u0433\u0430 \u043D\u0435\u0432\u0435\u0440\u0435\u043D: \u043F\u0435\u0440\u0435\u0434\u0430\u0439\u0442\u0435 nextCursor \u043F\u0440\u043E\u0448\u043B\u043E\u0433\u043E \u043E\u0442\u0432\u0435\u0442\u0430 log() \u0438\u043B\u0438 \u043D\u0435 \u043F\u0435\u0440\u0435\u0434\u0430\u0432\u0430\u0439\u0442\u0435 cursor.");
+  }
+  return { bytes, from: "head", resume: { page: Number(match[1]), offset: Number(match[2]) } };
+}
+function logCursor(page, offset) {
+  return `c:${String(page)}:${String(offset)}`;
+}
+function logOf(input) {
+  const stalled = input.text === "" && input.more;
+  const follow = !input.complete || input.more && !stalled;
+  const window = lineWindow(input.text, { start: input.startCut ?? (input.truncated && !input.more), end: follow, endBytes: input.end });
+  const clean = maskKeyTail(input.raw ? window.text : cleanLogText(window.text));
+  const text2 = clipText(redactSecretText(clean), CI_LOG_MAX_BYTES);
+  return {
+    text: text2,
+    truncated: input.truncated,
+    complete: input.complete,
+    ...follow ? { nextCursor: logCursor(input.page, input.end - window.held) } : {},
+    ...input.size === void 0 ? {} : { size: input.size }
+  };
+}
+var KEY_BEGIN = /-----BEGIN [A-Z ]*PRIVATE KEY-----/g;
+var KEY_END = /-----END [A-Z ]*PRIVATE KEY-----/;
+var WHOLE_ANSI_SEQUENCE = /^(?:\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[ -/]*(?![[\]])[0-~])/;
+var VALUE_KEY = /(?:[A-Za-z][\w.-]{0,63}["']?\s*[=:]|\b(?:Bearer|Basic|Token))\s*["']?$/i;
+var VALUE_KEY_LOOKBACK = 80;
+function lineWindow(text2, cut) {
+  let to = text2.length;
+  if (cut.end) {
+    const line = text2.lastIndexOf("\n");
+    to = keyStart(text2, line >= 0 ? line + 1 : wordCut(text2, byteCut(text2)));
+  }
+  let held = to === text2.length ? 0 : utf8Length(text2.slice(to));
+  if (held > cut.endBytes) {
+    to = suffixStart(text2, cut.endBytes);
+    held = cut.endBytes;
+  }
+  let from = 0;
+  if (cut.start) {
+    const line = text2.indexOf("\n");
+    from = Math.min(line >= 0 ? line + 1 : firstWordEnd(text2), to);
+  }
+  return { text: text2.slice(from, to), held };
+}
+function byteCut(text2) {
+  let to = text2.length;
+  const escape = text2.lastIndexOf("\x1B");
+  if (escape > 0 && !WHOLE_ANSI_SEQUENCE.test(text2.slice(escape))) to = escape;
+  if (to > 1 && text2[to - 1] === "\r") to -= 1;
+  return to;
+}
+function wordCut(text2, to) {
+  let space = to - 1;
+  while (space >= 0 && !/\s/.test(text2.charAt(space))) space -= 1;
+  if (space < 0) return to;
+  const word = space + 1;
+  const before = text2.slice(Math.max(0, word - VALUE_KEY_LOOKBACK), word);
+  const key = VALUE_KEY.exec(before);
+  const keyed = key === null ? word : word - before.length + key.index;
+  return keyed > 0 ? keyed : word;
+}
+function firstWordEnd(text2) {
+  const space = /\s+/.exec(text2);
+  return space === null ? 0 : space.index + space[0].length;
+}
+function keyStart(text2, to) {
+  const head = text2.slice(0, to);
+  const begin = [...head.matchAll(KEY_BEGIN)].at(-1);
+  if (begin === void 0 || KEY_END.test(head.slice(begin.index))) return to;
+  const line = head.lastIndexOf("\n", begin.index) + 1;
+  return line > 0 ? line : begin.index > 0 ? begin.index : to;
+}
+function maskKeyTail(text2) {
+  const end = KEY_END.exec(text2);
+  if (end !== null && [...text2.slice(0, end.index).matchAll(KEY_BEGIN)].length === 0) return REDACTED + text2.slice(end.index + end[0].length);
+  let at = 0;
+  for (; ; ) {
+    const next = text2.indexOf("\n", at);
+    if (!isKeyBodyLine(text2.slice(at, next < 0 ? text2.length : next))) break;
+    at = next < 0 ? text2.length : next + 1;
+    if (next < 0) break;
+  }
+  if (at === 0) return text2;
+  return REDACTED + (text2[at - 1] === "\n" ? text2.slice(at - 1) : "");
+}
+function isKeyBodyLine(line) {
+  const body = line.endsWith("\r") ? line.slice(0, -1) : line;
+  return /^[A-Za-z0-9+/]{16,76}={0,2}$/.test(body) && /[A-Z]/.test(body) && /[a-z]/.test(body) && /\d/.test(body);
+}
+var utf8 = new TextEncoder();
+function utf8Length(text2) {
+  return utf8.encode(text2).length;
+}
+function suffixStart(text2, bytes) {
+  let index = text2.length;
+  let count = 0;
+  while (index > 0 && count < bytes) {
+    const low = text2.charCodeAt(index - 1);
+    const pair = index > 1 && low >= 56320 && low <= 57343 && text2.charCodeAt(index - 2) >= 55296 && text2.charCodeAt(index - 2) <= 56319;
+    count += utf8Length(text2.slice(index - (pair ? 2 : 1), index));
+    index -= pair ? 2 : 1;
+  }
+  return index;
+}
+var ANSI_SEQUENCE = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\|$)|\x1b[ -/]*[0-~]/g;
+var GITLAB_SECTION_MARKER = /section_(?:start|end):\d+:[A-Za-z0-9_.-]+(?:\[[^\]\r\n]*\])?\r?/g;
+function cleanLogText(text2) {
+  const plain = text2.replace(ANSI_SEQUENCE, "").replace(GITLAB_SECTION_MARKER, "").replace(/\r+\n/g, "\n");
+  if (!plain.includes("\r")) return plain;
+  return plain.split("\n").map((line) => line.includes("\r") ? line.split("\r").findLast((part) => part !== "") ?? "" : line).join("\n");
+}
+function isFinished(category) {
+  return CI_FINISHED_STATUSES.includes(category);
+}
+
+// src/tracker/github-ci.lib.ts
+var DEFAULT_API = "https://api.github.com";
+var TARGET = /^[\w.-]+\/[\w.-]+$/;
+var ID = /^[1-9]\d{0,19}$/;
+var SHA = /^[0-9a-f]{7,64}$/;
+var DISPATCH_INPUTS_MAX = 25;
+var RUN_FILTERS = ciRunFilterSchema.options;
+var JOB_FILTERS = ciJobFilterSchema.options;
+var RUNS_SUBJECT = "\u041F\u0440\u043E\u0433\u043E\u043D\u044B CI GitHub";
+var JOBS_SUBJECT = "\u0417\u0430\u0434\u0430\u043D\u0438\u044F CI GitHub";
+var WORKFLOWS_SUBJECT = "\u0421\u043F\u0438\u0441\u043E\u043A workflow GitHub";
+var TRIGGER_SUBJECT = "\u0417\u0430\u043F\u0443\u0441\u043A CI GitHub";
+var CAPABILITIES = {
+  workflows: true,
+  runs: { filters: RUN_FILTERS, clientSide: ["status", "event", "updatedAfter", "updatedBefore"], sorts: [] },
+  jobs: { filters: JOB_FILTERS, clientSide: ["status"], sorts: [] },
+  log: { live: false, cursor: true },
+  trigger: { supported: true, workflows: "one", inputs: true, tags: true },
+  rerun: { all: true, failedOnly: true, job: true, debug: true },
+  cancel: { run: true, job: false }
+};
+function githubCi() {
+  return { capabilities: CAPABILITIES, create: (context) => createGithubCiAdapter(context) };
+}
+function createGithubCiAdapter({ connection, fetch }) {
+  const target = requireTarget(connection.target, "owner/repo \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F GitHub");
+  if (!TARGET.test(target)) throw new TrackerError("invalid_request", "target GitHub \u2014 owner/repo.");
+  const api = baseUrl(connection.url, DEFAULT_API);
+  const root = `${api}/repos/${target}`;
+  const actions = `${root}/actions`;
+  const headers = {
+    accept: "application/vnd.github+json",
+    "x-github-api-version": "2022-11-28",
+    ...connection.token === void 0 || connection.token === "" ? {} : { authorization: `Bearer ${connection.token}` }
+  };
+  const runKey = (key) => {
+    if (!ID.test(key)) throw new TrackerError("not_found", `\u0412 GitHub \u043D\u0435\u0442 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 ${key}.`);
+    return key;
+  };
+  const jobKey = (key) => {
+    if (!ID.test(key)) throw new TrackerError("not_found", `\u0412 GitHub \u043D\u0435\u0442 \u0437\u0430\u0434\u0430\u043D\u0438\u044F ${key}.`);
+    return key;
+  };
+  const missingRun = (key) => ({ failure: "not_found", message: `\u0412 GitHub \u043D\u0435\u0442 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 ${key}.` });
+  const missingJob = (key) => ({ failure: "not_found", message: `\u0412 GitHub \u043D\u0435\u0442 \u0437\u0430\u0434\u0430\u043D\u0438\u044F ${key}.` });
+  const getRun = async (key) => runOf((await requestJson(`${actions}/runs/${runKey(key)}`, { fetch, headers, missing: missingRun(key) })).body);
+  const headShaOf = async (query) => {
+    if (query.pullRequest === void 0) return query.sha;
+    if (query.sha !== void 0) throw new TrackerError("invalid_request", `${RUNS_SUBJECT}: sha \u0438 pullRequest \u0437\u0430\u0434\u0430\u044E\u0442\u0441\u044F \u043F\u043E \u043E\u0442\u0434\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u0438 \u2014 \u043F\u0440\u043E\u0433\u043E\u043D\u044B PR \u0431\u0435\u0440\u0443\u0442\u0441\u044F \u043F\u043E \u0435\u0433\u043E \u0433\u043E\u043B\u043E\u0432\u0435.`);
+    const pull = query.pullRequest;
+    if (!ID.test(pull)) throw new TrackerError("not_found", `\u0412 GitHub \u043D\u0435\u0442 pull request ${pull}.`);
+    const { body } = await requestJson(`${root}/pulls/${pull}`, { fetch, headers, missing: { failure: "not_found", message: `\u0412 GitHub \u043D\u0435\u0442 pull request ${pull}.` } });
+    const head = isRecord(body) && isRecord(body.head) ? text(body.head.sha) : void 0;
+    if (head === void 0) throw new TrackerError("failed", "GitHub \u043D\u0435 \u0432\u0435\u0440\u043D\u0443\u043B \u0433\u043E\u043B\u043E\u0432\u0443 pull request.");
+    return head;
+  };
+  return {
+    listWorkflows: async (query) => {
+      assertListQuery(WORKFLOWS_SUBJECT, { filters: [], clientSide: [], sorts: [] }, query, []);
+      const page = pageOf(query.cursor);
+      const params = new URLSearchParams({ per_page: String(query.limit), page: String(page) });
+      const { body, headers: responseHeaders } = await requestJson(`${actions}/workflows?${params.toString()}`, { fetch, headers });
+      return { items: rowsOf(body, "workflows").map(workflowOf), ...nextCursorOf(page, responseHeaders.get("link") ?? "") };
+    },
+    listRuns: async (query) => {
+      assertListQuery(RUNS_SUBJECT, CAPABILITIES.runs, query, RUN_FILTERS);
+      const page = pageOf(query.cursor);
+      const sha = await headShaOf(query);
+      const params = new URLSearchParams({ per_page: String(query.limit), page: String(page) });
+      if (query.ref !== void 0) params.set("branch", query.ref);
+      if (sha !== void 0) params.set("head_sha", sha);
+      if (query.actor !== void 0) params.set("actor", query.actor);
+      const status = statusParam(query.status);
+      if (status !== void 0) params.set("status", status);
+      const event = eventParam(query.event);
+      if (event !== void 0) params.set("event", event);
+      const created = createdParam(query);
+      if (created !== void 0) params.set("created", created);
+      const path = query.workflow === void 0 ? `${actions}/runs` : `${actions}/workflows/${encodeURIComponent(query.workflow)}/runs`;
+      const { body, headers: responseHeaders } = await requestJson(`${path}?${params.toString()}`, { fetch, headers });
+      const items = rowsOf(body, "workflow_runs").map(runOf).filter(
+        (run) => (query.status === void 0 || query.status.includes(run.status.category)) && (query.event === void 0 || run.event !== void 0 && query.event.includes(run.event.category)) && inTimeRange(run.updatedAt, query.updatedAfter, query.updatedBefore)
+      );
+      return { items, ...nextCursorOf(page, responseHeaders.get("link") ?? "") };
+    },
+    getRun,
+    listJobs: async (key, query) => {
+      const run = runKey(key);
+      const { allAttempts, ...rest } = query;
+      assertListQuery(JOBS_SUBJECT, CAPABILITIES.jobs, rest, JOB_FILTERS);
+      const page = pageOf(query.cursor);
+      const params = new URLSearchParams({ per_page: String(query.limit), page: String(page), filter: allAttempts === true ? "all" : "latest" });
+      const { body, headers: responseHeaders } = await requestJson(`${actions}/runs/${run}/jobs?${params.toString()}`, { fetch, headers, missing: missingRun(run) });
+      const items = rowsOf(body, "jobs").map(jobOf).filter((job) => query.status === void 0 || query.status.includes(job.status.category));
+      return { items, ...nextCursorOf(page, responseHeaders.get("link") ?? "") };
+    },
+    getJob: async (key) => {
+      const id = jobKey(key);
+      return jobOf((await requestJson(`${actions}/jobs/${id}`, { fetch, headers, missing: missingJob(id) })).body);
+    },
+    log: async (key, query) => {
+      const id = jobKey(key);
+      const window = logWindow(query);
+      const job = (await requestJson(`${actions}/jobs/${id}`, { fetch, headers, missing: missingJob(id) })).body;
+      const complete = isFinished(statusOf(isRecord(job) ? job : {}).category);
+      if (!complete) return { text: "", truncated: false, complete: false, nextCursor: logCursor(0, 0) };
+      const response = await requestText(`${actions}/jobs/${id}/logs`, {
+        fetch,
+        headers,
+        skip: window.resume?.offset ?? 0,
+        keep: { bytes: window.bytes, from: window.from },
+        missing: missingJob(id)
+      });
+      return logOf({
+        text: response.text,
+        truncated: window.from === "tail" ? response.start > 0 : !response.whole,
+        complete,
+        page: 0,
+        end: response.end,
+        // Курсор дальше имеет смысл только когда окно head оборвалось раньше конца тела: tail уже читает конец.
+        more: window.from === "head" && !response.whole,
+        ...response.whole ? { size: response.read } : {},
+        raw: query.raw ?? false
+      });
+    },
+    trigger: async (input) => {
+      const workflows = input.workflows ?? [];
+      const workflow = workflows[0];
+      if (workflows.length !== 1 || workflow === void 0) {
+        throw new TrackerError("invalid_request", `${TRIGGER_SUBJECT}: \u043D\u0443\u0436\u0435\u043D \u0440\u043E\u0432\u043D\u043E \u043E\u0434\u0438\u043D workflow \u2014 id \u0438\u043B\u0438 \u0438\u043C\u044F \u0444\u0430\u0439\u043B\u0430.`);
+      }
+      const inputs = input.inputs ?? {};
+      const count = Object.keys(inputs).length;
+      if (count > DISPATCH_INPUTS_MAX) throw new TrackerError("invalid_request", `${TRIGGER_SUBJECT}: workflow_dispatch \u043F\u0440\u0438\u043D\u0438\u043C\u0430\u0435\u0442 \u043D\u0435 \u0431\u043E\u043B\u044C\u0448\u0435 ${String(DISPATCH_INPUTS_MAX)} \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u043E\u0432.`);
+      const { body } = await requestJson(`${actions}/workflows/${encodeURIComponent(workflow)}/dispatches`, {
+        fetch,
+        headers,
+        method: "POST",
+        body: { ref: input.ref, ...count === 0 ? {} : { inputs }, return_run_details: true }
+      });
+      const run = runIdOf(isRecord(body) ? body.workflow_run_id : void 0);
+      return run === void 0 ? {} : { run: await getRun(run) };
+    },
+    rerun: async (key, input) => {
+      const run = runKey(key);
+      await requestJson(`${actions}/runs/${run}/${input.failedOnly === true ? "rerun-failed-jobs" : "rerun"}`, {
+        fetch,
+        headers,
+        method: "POST",
+        body: { enable_debug_logging: input.debug === true },
+        missing: missingRun(run)
+      });
+      return getRun(run);
+    },
+    rerunJob: async (key, input) => {
+      const id = jobKey(key);
+      const job = (await requestJson(`${actions}/jobs/${id}`, { fetch, headers, missing: missingJob(id) })).body;
+      const run = runIdOf(isRecord(job) ? job.run_id : void 0);
+      if (run === void 0) throw new TrackerError("failed", "GitHub \u043D\u0435 \u0432\u0435\u0440\u043D\u0443\u043B \u043F\u0440\u043E\u0433\u043E\u043D \u0437\u0430\u0434\u0430\u043D\u0438\u044F.");
+      await requestJson(`${actions}/jobs/${id}/rerun`, { fetch, headers, method: "POST", body: { enable_debug_logging: input.debug === true }, missing: missingJob(id) });
+      return getRun(run);
+    },
+    cancel: async (key) => {
+      const run = runKey(key);
+      await requestJson(`${actions}/runs/${run}/cancel`, { fetch, headers, method: "POST", conflictOn: [409], missing: missingRun(run) });
+      return getRun(run);
+    },
+    cancelJob: async () => {
+      throw new TrackerError("unsupported", "\u041E\u0442\u043C\u0435\u043D\u0430 CI GitHub: \u0437\u0430\u0434\u0430\u043D\u0438\u044F \u043F\u043E \u043E\u0442\u0434\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u0438 \u043D\u0435 \u043E\u0442\u043C\u0435\u043D\u044F\u044E\u0442\u0441\u044F, \u043E\u0442\u043C\u0435\u043D\u044F\u0435\u0442\u0441\u044F \u043F\u0440\u043E\u0433\u043E\u043D.");
+    }
+  };
+}
+function pageOf(cursor) {
+  const page = cursor === void 0 ? 1 : Number(cursor);
+  return Number.isInteger(page) && page >= 1 ? page : 1;
+}
+function nextCursorOf(page, link) {
+  return /rel="next"/.test(link) ? { nextCursor: String(page + 1) } : {};
+}
+function rowsOf(body, field) {
+  const rows = isRecord(body) ? body[field] : void 0;
+  return Array.isArray(rows) ? rows : [];
+}
+function keyOf(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value)) return String(value);
+  return typeof value === "string" && value !== "" ? value : "?";
+}
+function positiveInt(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+function runIdOf(value) {
+  const id = positiveInt(value);
+  return id === void 0 ? void 0 : String(id);
+}
+function statusOf(item) {
+  const raw = text(item.status) ?? "unknown";
+  if (raw !== "completed") return { category: lookup(GITHUB_RUN_STATUSES, raw, "running"), name: raw };
+  const conclusion = text(item.conclusion);
+  return { category: lookup(GITHUB_RUN_CONCLUSIONS, conclusion, "failed"), name: conclusion ?? raw };
+}
+function statusParam(status) {
+  if (status === void 0 || status.length === 0) return void 0;
+  if (status.every(isFinished)) return "completed";
+  return status.length === 1 && status[0] === "running" ? "in_progress" : void 0;
+}
+function eventParam(event) {
+  if (event === void 0 || event.length !== 1) return void 0;
+  const raws = keysFor(GITHUB_RUN_EVENTS, event);
+  return raws.length === 1 ? raws[0] : void 0;
+}
+function createdParam(query) {
+  const { createdAfter: after, createdBefore: before } = query;
+  if (after !== void 0 && before !== void 0) return `${isoTime(after)}..${isoTime(before)}`;
+  if (after !== void 0) return `>=${isoTime(after)}`;
+  return before !== void 0 ? `<=${isoTime(before)}` : void 0;
+}
+function workflowOf(raw) {
+  const item = isRecord(raw) ? raw : {};
+  const key = keyOf(item.id);
+  const path = text(item.path);
+  return { key, name: text(item.name) ?? key, ...path === void 0 ? {} : { path }, enabled: item.state === "active" };
+}
+function runOf(raw) {
+  const item = isRecord(raw) ? raw : {};
+  const key = keyOf(item.id);
+  const status = statusOf(item);
+  const name = text(item.name) ?? text(item.path);
+  const branch = text(item.head_branch);
+  const sha = text(item.head_sha);
+  const actor = isRecord(item.actor) ? text(item.actor.login) : void 0;
+  const pull = Array.isArray(item.pull_requests) ? item.pull_requests[0] : void 0;
+  const pullNumber = isRecord(pull) && typeof pull.number === "number" ? String(pull.number) : void 0;
+  const number = positiveInt(item.run_number);
+  const attempt = positiveInt(item.run_attempt);
+  const url = text(item.html_url);
+  const createdAt = toTimestamp(item.created_at);
+  const startedAt = toTimestamp(item.run_started_at);
+  const updatedAt = toTimestamp(item.updated_at);
+  const finishedAt = text(item.status) === "completed" ? updatedAt : void 0;
+  const event = text(item.event);
+  return {
+    key,
+    ...number === void 0 ? {} : { number },
+    workflows: name === void 0 ? [] : [name],
+    status,
+    ...event === void 0 ? {} : { event: { category: lookup(GITHUB_RUN_EVENTS, event, "other"), name: event } },
+    ...branch === void 0 ? {} : { ref: branch },
+    ...sha === void 0 || !SHA.test(sha) ? {} : { sha },
+    ...actor === void 0 ? {} : { actor },
+    ...pullNumber === void 0 ? {} : { pullRequest: pullNumber },
+    ...attempt === void 0 ? {} : { attempt },
+    links: url === void 0 ? [] : [{ url, title: "GitHub Actions" }],
+    ...createdAt === void 0 ? {} : { createdAt },
+    ...startedAt === void 0 ? {} : { startedAt },
+    ...finishedAt === void 0 ? {} : { finishedAt },
+    ...updatedAt === void 0 ? {} : { updatedAt }
+  };
+}
+function jobOf(raw) {
+  const item = isRecord(raw) ? raw : {};
+  const key = keyOf(item.id);
+  const url = text(item.html_url);
+  const startedAt = toTimestamp(item.started_at);
+  const finishedAt = toTimestamp(item.completed_at);
+  const steps = Array.isArray(item.steps) ? item.steps.map(stepOf) : void 0;
+  return {
+    key,
+    runKey: runIdOf(item.run_id) ?? "?",
+    name: text(item.name) ?? key,
+    status: statusOf(item),
+    ...steps === void 0 ? {} : { steps },
+    links: url === void 0 ? [] : [{ url, title: "GitHub Actions" }],
+    ...startedAt === void 0 ? {} : { startedAt },
+    ...finishedAt === void 0 ? {} : { finishedAt }
+  };
+}
+function stepOf(raw) {
+  const item = isRecord(raw) ? raw : {};
+  const number = positiveInt(item.number) ?? 0;
+  return { number, name: text(item.name) ?? String(number), status: statusOf(item) };
+}
+
+// src/tracker/gitlab-ci.lib.ts
+var DEFAULT_URL = "https://gitlab.com";
+var TARGET2 = /^(\d{1,15}|[\w.-]+(\/[\w.-]+)+)$/;
+var ID2 = /^[1-9]\d{0,19}$/;
+var RUN_FILTERS2 = ciRunFilterSchema.options;
+var JOB_FILTERS2 = ciJobFilterSchema.options;
+var CAPABILITIES2 = {
+  workflows: false,
+  runs: { filters: RUN_FILTERS2, clientSide: ["status", "event"], sorts: ["created", "updated"] },
+  jobs: { filters: JOB_FILTERS2, clientSide: [], sorts: [] },
+  log: { live: true, cursor: true },
+  trigger: { supported: true, workflows: "none", inputs: true, tags: true },
+  rerun: { all: false, failedOnly: true, job: true, debug: false },
+  cancel: { run: true, job: true }
+};
+function gitlabCi() {
+  return { capabilities: CAPABILITIES2, create: (context) => createGitlabCiAdapter(context) };
+}
+function createGitlabCiAdapter({ connection, fetch }) {
+  const target = requireTarget(connection.target, "\u043F\u0443\u0442\u044C \u043F\u0440\u043E\u0435\u043A\u0442\u0430 GitLab, group/project, \u0438\u043B\u0438 \u0435\u0433\u043E id");
+  if (!TARGET2.test(target)) throw new TrackerError("invalid_request", "target GitLab \u2014 group/project \u0438\u043B\u0438 \u0447\u0438\u0441\u043B\u043E\u0432\u043E\u0439 id.");
+  const api = `${baseUrl(connection.url, DEFAULT_URL)}/api/v4`;
+  const project = `${api}/projects/${encodeURIComponent(target)}`;
+  const headers = connection.token === void 0 || connection.token === "" ? {} : { "private-token": connection.token };
+  const rawOf = (table, categories) => {
+    if (categories === void 0 || categories.length !== 1) return void 0;
+    const raws = keysFor(table, categories);
+    return raws.length === 1 ? raws[0] : void 0;
+  };
+  const pipelineKey = (key) => {
+    if (!ID2.test(key)) throw new TrackerError("not_found", `\u0412 GitLab \u043D\u0435\u0442 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 ${key}.`);
+    return key;
+  };
+  const jobKey = (key) => {
+    if (!ID2.test(key)) throw new TrackerError("not_found", `\u0412 GitLab \u043D\u0435\u0442 \u0437\u0430\u0434\u0430\u043D\u0438\u044F ${key}.`);
+    return key;
+  };
+  const missingPipeline = (key) => ({ failure: "not_found", message: `\u0412 GitLab \u043D\u0435\u0442 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 ${key}.` });
+  const missingJob = (key) => ({ failure: "not_found", message: `\u0412 GitLab \u043D\u0435\u0442 \u0437\u0430\u0434\u0430\u043D\u0438\u044F ${key}.` });
+  const getPipeline = async (key) => runOf2((await requestJson(`${project}/pipelines/${pipelineKey(key)}`, { fetch, headers, missing: missingPipeline(key) })).body);
+  return {
+    listWorkflows: async () => {
+      throw new TrackerError("unsupported", "\u041F\u0440\u043E\u0433\u043E\u043D\u044B CI GitLab: \u0441\u043F\u0438\u0441\u043A\u0430 workflow \u0443 GitLab \u043D\u0435\u0442.");
+    },
+    listRuns: async (query) => {
+      assertListQuery("\u041F\u0440\u043E\u0433\u043E\u043D\u044B CI GitLab", CAPABILITIES2.runs, query, RUN_FILTERS2);
+      const params = new URLSearchParams({ per_page: String(query.limit), page: String(pageOf2(query.cursor)) });
+      let body;
+      let responseHeaders;
+      let keep;
+      if (query.pullRequest !== void 0) {
+        const mr = query.pullRequest;
+        if (!ID2.test(mr)) throw new TrackerError("not_found", `\u0412 GitLab \u043D\u0435\u0442 merge request ${mr}.`);
+        if (query.sort !== void 0) throw new TrackerError("unsupported", "\u041F\u0440\u043E\u0433\u043E\u043D\u044B CI GitLab \u0434\u043B\u044F merge request: \u0441\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u043A\u0430 \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F.");
+        if (query.actor !== void 0) throw new TrackerError("unsupported", "\u041F\u0440\u043E\u0433\u043E\u043D\u044B CI GitLab \u0434\u043B\u044F merge request: \u0444\u0438\u043B\u044C\u0442\u0440 actor \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F.");
+        if (query.workflow !== void 0) throw new TrackerError("unsupported", "\u041F\u0440\u043E\u0433\u043E\u043D\u044B CI GitLab \u0434\u043B\u044F merge request: \u0444\u0438\u043B\u044C\u0442\u0440 workflow \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F.");
+        const result = await requestJson(`${project}/merge_requests/${mr}/pipelines?${params.toString()}`, { fetch, headers, missing: { failure: "not_found", message: `\u0412 GitLab \u043D\u0435\u0442 merge request ${mr}.` } });
+        body = result.body;
+        responseHeaders = result.headers;
+        keep = (run) => (query.status === void 0 || query.status.includes(run.status.category)) && (query.event === void 0 || run.event !== void 0 && query.event.includes(run.event.category)) && (query.ref === void 0 || run.ref === query.ref) && (query.sha === void 0 || run.sha === query.sha) && inTimeRange(run.createdAt, query.createdAfter, query.createdBefore) && inTimeRange(run.updatedAt, query.updatedAfter, query.updatedBefore);
+      } else {
+        if (query.ref !== void 0) params.set("ref", query.ref);
+        if (query.sha !== void 0) params.set("sha", query.sha);
+        if (query.actor !== void 0) params.set("username", query.actor);
+        if (query.workflow !== void 0) params.set("name", query.workflow);
+        if (query.status !== void 0 && query.status.length > 0) {
+          const status = rawOf(GITLAB_CI_STATUSES, query.status);
+          if (status !== void 0) params.set("status", status);
+          if (status === void 0 && query.status.every(isFinished)) params.set("scope", "finished");
+        }
+        const source = rawOf(GITLAB_PIPELINE_SOURCES, query.event);
+        if (source !== void 0) params.set("source", source);
+        if (query.createdAfter !== void 0) params.set("created_after", isoTime(query.createdAfter));
+        if (query.createdBefore !== void 0) params.set("created_before", isoTime(query.createdBefore));
+        if (query.updatedAfter !== void 0) params.set("updated_after", isoTime(query.updatedAfter));
+        if (query.updatedBefore !== void 0) params.set("updated_before", isoTime(query.updatedBefore));
+        params.set("order_by", query.sort?.field === "updated" ? "updated_at" : "id");
+        params.set("sort", query.sort?.direction ?? "desc");
+        const result = await requestJson(`${project}/pipelines?${params.toString()}`, { fetch, headers });
+        body = result.body;
+        responseHeaders = result.headers;
+        keep = (run) => (query.status === void 0 || query.status.includes(run.status.category)) && (query.event === void 0 || run.event !== void 0 && query.event.includes(run.event.category));
+      }
+      const items = (Array.isArray(body) ? body : []).map(runOf2).filter(keep);
+      const next = responseHeaders.get("x-next-page");
+      return { items, ...next === null || next === "" ? {} : { nextCursor: next } };
+    },
+    getRun: getPipeline,
+    listJobs: async (runKey, query) => {
+      const { allAttempts, ...rest } = query;
+      assertListQuery("\u0417\u0430\u0434\u0430\u043D\u0438\u044F CI GitLab", CAPABILITIES2.jobs, rest, JOB_FILTERS2);
+      const params = new URLSearchParams({ per_page: String(query.limit), page: String(pageOf2(query.cursor)), include_retried: String(allAttempts ?? false) });
+      for (const scope of keysFor(GITLAB_CI_STATUSES, query.status ?? [])) params.append("scope[]", scope);
+      const { body, headers: responseHeaders } = await requestJson(`${project}/pipelines/${pipelineKey(runKey)}/jobs?${params.toString()}`, { fetch, headers, missing: missingPipeline(runKey) });
+      const items = (Array.isArray(body) ? body : []).map(jobOf2);
+      const next = responseHeaders.get("x-next-page");
+      return { items, ...next === null || next === "" ? {} : { nextCursor: next } };
+    },
+    getJob: async (key) => jobOf2((await requestJson(`${project}/jobs/${jobKey(key)}`, { fetch, headers, missing: missingJob(key) })).body),
+    log: async (key, query) => {
+      const window = logWindow(query);
+      const job = (await requestJson(`${project}/jobs/${jobKey(key)}`, { fetch, headers, missing: missingJob(key) })).body;
+      const rawStatus = isRecord(job) && typeof job.status === "string" ? job.status : "unknown";
+      const complete = isFinished(lookup(GITLAB_CI_STATUSES, rawStatus, "running"));
+      const response = await requestText(`${project}/jobs/${jobKey(key)}/trace`, { fetch, headers, skip: window.resume?.offset ?? 0, keep: { bytes: window.bytes, from: window.from }, missing: missingJob(key) });
+      return logOf({
+        text: response.text,
+        truncated: window.from === "tail" ? response.start > 0 : !response.whole,
+        complete,
+        page: 0,
+        end: response.end,
+        more: !response.whole,
+        ...response.whole ? { size: response.read } : {},
+        // Кольцевой буфер отрезал начало хвоста и при потолке чтения (whole=false): там default
+        // startCut (truncated && !more) молчит, а первая неполная строка в окне остаётся.
+        startCut: window.from === "tail" && response.start > 0,
+        raw: query.raw ?? false
+      });
+    },
+    trigger: async (input) => {
+      if (input.workflows !== void 0 && input.workflows.length > 0) {
+        throw new TrackerError("unsupported", "\u0417\u0430\u043F\u0443\u0441\u043A CI GitLab: workflow \u043D\u0435 \u0437\u0430\u0434\u0430\u0451\u0442\u0441\u044F \u2014 \u0442\u043E\u043B\u044C\u043A\u043E ref \u0438 \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u044B\u0435.");
+      }
+      const variables = Object.entries(input.inputs ?? {}).map(([key, value]) => ({ key, value, variable_type: "env_var" }));
+      const { body } = await requestJson(`${project}/pipeline`, {
+        fetch,
+        headers,
+        method: "POST",
+        body: { ref: input.ref, ...variables.length === 0 ? {} : { variables } },
+        missing: { failure: "not_found", message: `\u0412 GitLab \u043D\u0435\u0442 \u0432\u0435\u0442\u043A\u0438 \u0438\u043B\u0438 \u0442\u0435\u0433\u0430 ${input.ref}.` }
+      });
+      return { run: runOf2(body) };
+    },
+    rerun: async (runKey, input) => {
+      if (input.failedOnly !== true) throw new TrackerError("unsupported", "\u041F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A CI GitLab \u0443\u043C\u0435\u0435\u0442 \u0442\u043E\u043B\u044C\u043A\u043E \u0443\u043F\u0430\u0432\u0448\u0438\u0435 \u0437\u0430\u0434\u0430\u043D\u0438\u044F: \u0437\u0430\u0434\u0430\u0439\u0442\u0435 failedOnly.");
+      if (input.debug === true) throw new TrackerError("unsupported", "\u041F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A CI GitLab \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442 \u043E\u0442\u043B\u0430\u0434\u043E\u0447\u043D\u043E\u0435 \u043B\u043E\u0433\u0438\u0440\u043E\u0432\u0430\u043D\u0438\u0435.");
+      return runOf2((await requestJson(`${project}/pipelines/${pipelineKey(runKey)}/retry`, { fetch, headers, method: "POST", missing: missingPipeline(runKey) })).body);
+    },
+    rerunJob: async (jobKeyValue, input) => {
+      if (input.debug === true) throw new TrackerError("unsupported", "\u041F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A \u0437\u0430\u0434\u0430\u043D\u0438\u044F GitLab \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442 \u043E\u0442\u043B\u0430\u0434\u043E\u0447\u043D\u043E\u0435 \u043B\u043E\u0433\u0438\u0440\u043E\u0432\u0430\u043D\u0438\u0435.");
+      const body = (await requestJson(`${project}/jobs/${jobKey(jobKeyValue)}/retry`, { fetch, headers, method: "POST", missing: missingJob(jobKeyValue) })).body;
+      const pipeline = isRecord(body) && isRecord(body.pipeline) && typeof body.pipeline.id === "number" ? String(body.pipeline.id) : void 0;
+      if (pipeline === void 0) throw new TrackerError("failed", "GitLab \u043D\u0435 \u0432\u0435\u0440\u043D\u0443\u043B \u043F\u0430\u0439\u043F\u043B\u0430\u0439\u043D \u043D\u043E\u0432\u043E\u0433\u043E \u0437\u0430\u0434\u0430\u043D\u0438\u044F.");
+      return getPipeline(pipeline);
+    },
+    cancel: async (runKey) => runOf2((await requestJson(`${project}/pipelines/${pipelineKey(runKey)}/cancel`, { fetch, headers, method: "POST", missing: missingPipeline(runKey) })).body),
+    cancelJob: async (jobKeyValue) => jobOf2((await requestJson(`${project}/jobs/${jobKey(jobKeyValue)}/cancel`, { fetch, headers, method: "POST", missing: missingJob(jobKeyValue) })).body)
+  };
+}
+function pageOf2(cursor) {
+  const page = cursor === void 0 ? 1 : Number(cursor);
+  return Number.isInteger(page) && page >= 1 ? page : 1;
+}
+function runOf2(raw) {
+  const item = isRecord(raw) ? raw : {};
+  const key = typeof item.id === "number" ? String(item.id) : "?";
+  const rawStatus = typeof item.status === "string" ? item.status : "unknown";
+  const rawSource = text(item.source);
+  const mr = typeof item.ref === "string" ? /^refs\/merge-requests\/(\d+)\/head$/.exec(item.ref) : null;
+  const user = isRecord(item.user) ? text(item.user.username) : void 0;
+  const url = text(item.web_url);
+  const name = text(item.name);
+  const createdAt = toTimestamp(item.created_at);
+  const startedAt = toTimestamp(item.started_at);
+  const finishedAt = toTimestamp(item.finished_at);
+  const updatedAt = toTimestamp(item.updated_at);
+  return {
+    key,
+    ...typeof item.iid === "number" ? { number: item.iid } : {},
+    workflows: name === void 0 ? [] : [name],
+    status: { category: lookup(GITLAB_CI_STATUSES, rawStatus, "running"), name: rawStatus },
+    ...rawSource === void 0 ? {} : { event: { category: lookup(GITLAB_PIPELINE_SOURCES, rawSource, "other"), name: rawSource } },
+    ...typeof item.ref === "string" && item.ref !== "" ? { ref: item.ref } : {},
+    ...typeof item.sha === "string" && /^[0-9a-f]{7,64}$/.test(item.sha) ? { sha: item.sha } : {},
+    ...user === void 0 ? {} : { actor: user },
+    ...mr === null ? {} : { pullRequest: mr[1] },
+    links: url === void 0 ? [] : [{ url, title: "GitLab" }],
+    ...createdAt === void 0 ? {} : { createdAt },
+    ...startedAt === void 0 ? {} : { startedAt },
+    ...finishedAt === void 0 ? {} : { finishedAt },
+    ...updatedAt === void 0 ? {} : { updatedAt }
+  };
+}
+function jobOf2(raw) {
+  const item = isRecord(raw) ? raw : {};
+  const key = typeof item.id === "number" ? String(item.id) : "?";
+  const rawStatus = typeof item.status === "string" ? item.status : "unknown";
+  const pipeline = isRecord(item.pipeline) && typeof item.pipeline.id === "number" ? String(item.pipeline.id) : "?";
+  const url = text(item.web_url);
+  const stage = text(item.stage);
+  const startedAt = toTimestamp(item.started_at);
+  const finishedAt = toTimestamp(item.finished_at);
+  return {
+    key,
+    runKey: pipeline,
+    name: text(item.name) ?? key,
+    ...stage === void 0 ? {} : { stage },
+    status: { category: lookup(GITLAB_CI_STATUSES, rawStatus, "running"), name: rawStatus },
+    links: url === void 0 ? [] : [{ url, title: "GitLab" }],
+    ...startedAt === void 0 ? {} : { startedAt },
+    ...finishedAt === void 0 ? {} : { finishedAt }
+  };
+}
+
+// src/tracker/sourcecraft-ci.lib.ts
+var DEFAULT_API2 = "https://api.sourcecraft.tech";
+var TARGET3 = /^[\w.-]+\/[\w.-]+$/;
+var RUN_SLUG = /^\d{1,20}$/;
+var PR_SLUG = /^[\w-]{1,100}$/;
+var JOB_KEY = /^([^/]+)\/([^/]+)\/([^/]+)\/([^/]+)$/;
+var EXTERNAL_USER = "<external-user>";
+var JOB_OFFSET_CURSOR = /^o:(\d{1,15})$/;
+var RUN_FILTER_NAMES = ciRunFilterSchema.options;
+var RUN_FILTERS3 = RUN_FILTER_NAMES.filter((name) => name !== "ref" && name !== "sha");
+var JOB_FILTER_NAMES = ciJobFilterSchema.options;
+var JOB_FILTERS3 = ["status"];
+var CAPABILITIES3 = {
+  workflows: false,
+  runs: { filters: RUN_FILTERS3, clientSide: RUN_FILTERS3, sorts: [] },
+  jobs: { filters: JOB_FILTERS3, clientSide: JOB_FILTERS3, sorts: [] },
+  log: { live: true, cursor: true },
+  trigger: { supported: true, workflows: "many", inputs: true, tags: true },
+  rerun: { all: false, failedOnly: false, job: false, debug: false },
+  cancel: { run: false, job: false }
+};
+function sourcecraftCi() {
+  return { capabilities: CAPABILITIES3, create: (context) => createSourceCraftCiAdapter(context) };
+}
+function createSourceCraftCiAdapter({ connection, fetch }) {
+  const target = requireTarget(connection.target, "org/repo \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F SourceCraft");
+  if (!TARGET3.test(target)) throw new TrackerError("invalid_request", "target SourceCraft \u2014 org/repo.");
+  const repo = `${baseUrl(connection.url, DEFAULT_API2)}/repos/${target}`;
+  const root = `${repo}/cicd`;
+  const headers = { authorization: `Bearer ${connection.token ?? ""}` };
+  const missingRun = (key) => ({ failure: "not_found", message: `\u0412 SourceCraft \u043D\u0435\u0442 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 ${key}.` });
+  const missingJob = (key) => ({ failure: "not_found", message: `\u0412 SourceCraft \u043D\u0435\u0442 \u0437\u0430\u0434\u0430\u043D\u0438\u044F ${key}.` });
+  const missingWorkflow = (run, workflow) => ({ failure: "not_found", message: `\u0412 \u043F\u0440\u043E\u0433\u043E\u043D\u0435 ${run} SourceCraft \u043D\u0435\u0442 workflow ${workflow}.` });
+  const runKey = (key) => {
+    if (!RUN_SLUG.test(key)) throw new TrackerError("not_found", `\u0412 SourceCraft \u043D\u0435\u0442 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 ${key}.`);
+    return key;
+  };
+  const jobPath = (key) => {
+    const match = JOB_KEY.exec(key);
+    if (match === null) throw new TrackerError("not_found", `\u0412 SourceCraft \u043D\u0435\u0442 \u0437\u0430\u0434\u0430\u043D\u0438\u044F ${key}.`);
+    const path = { run: partOf(match[1], key), workflow: partOf(match[2], key), task: partOf(match[3], key), cube: partOf(match[4], key) };
+    runKey(path.run);
+    return path;
+  };
+  const getRun = async (key) => runOf3((await requestJson(`${root}/runs/${runKey(key)}`, { fetch, headers, missing: missingRun(key) })).body);
+  const getWorkflow = async (run, workflow) => {
+    const { body } = await requestJson(`${root}/runs/${runKey(run)}/${encodeURIComponent(workflow)}`, { fetch, headers, missing: missingWorkflow(run, workflow) });
+    return isRecord(body) ? body : {};
+  };
+  const pullIdOf = async (slug) => {
+    if (!PR_SLUG.test(slug)) throw new TrackerError("invalid_request", `\u041A\u043B\u044E\u0447 pull request SourceCraft \u2014 slug \u0438\u0437 \u0431\u0443\u043A\u0432, \u0446\u0438\u0444\u0440, _ \u0438 - \u0434\u043B\u0438\u043D\u043E\u0439 \u0434\u043E 100.`);
+    const { body } = await requestJson(`${repo}/pulls/${slug}`, { fetch, headers, missing: { failure: "not_found", message: `\u0412 SourceCraft \u043D\u0435\u0442 pull request ${slug}.` } });
+    const id = isRecord(body) ? text(body.id) : void 0;
+    if (id === void 0) throw new TrackerError("failed", `\u041E\u0442\u0432\u0435\u0442 SourceCraft \u043D\u0430 /pulls/${slug} \u043D\u0435 \u0441\u043E\u0434\u0435\u0440\u0436\u0438\u0442 id.`);
+    return id;
+  };
+  const flattenJobs = async (run) => {
+    const jobs = [];
+    for (const workflow of (await getRun(run)).workflows) {
+      const tree = await getWorkflow(run, workflow);
+      for (const task of recordList(tree.tasks)) {
+        const taskSlug = text(task.slug);
+        if (taskSlug === void 0) continue;
+        for (const cube of recordList(task.cubes)) {
+          const cubeSlug = text(cube.slug);
+          if (cubeSlug === void 0) continue;
+          jobs.push(jobOf3(run, workflow, taskSlug, cubeSlug, cube));
+        }
+      }
+    }
+    return jobs;
+  };
+  return {
+    listWorkflows: async () => {
+      throw new TrackerError("unsupported", "\u041F\u0440\u043E\u0433\u043E\u043D\u044B CI SourceCraft: \u043E\u0442\u0434\u0435\u043B\u044C\u043D\u043E\u0433\u043E \u0441\u043F\u0438\u0441\u043A\u0430 workflow \u043D\u0435\u0442, workflow \u0435\u0441\u0442\u044C \u0443 \u043F\u0440\u043E\u0433\u043E\u043D\u0430.");
+    },
+    listRuns: async (query) => {
+      assertListQuery("\u041F\u0440\u043E\u0433\u043E\u043D\u044B CI SourceCraft", CAPABILITIES3.runs, query, RUN_FILTER_NAMES);
+      const pullId = query.pullRequest === void 0 ? void 0 : await pullIdOf(query.pullRequest);
+      const params = new URLSearchParams({ page_size: String(query.limit) });
+      if (query.cursor !== void 0) params.set("page_token", query.cursor);
+      const { body } = await requestJson(`${root}/runs?${params.toString()}`, { fetch, headers });
+      const record = isRecord(body) ? body : {};
+      const items = recordList(record.runs).map((raw) => pullSlugOf(runOf3(raw), raw, pullId, query.pullRequest)).filter((run) => keepsRun(run, query));
+      const token = text(record.next_page_token);
+      return { items, ...token === void 0 ? {} : { nextCursor: token } };
+    },
+    getRun,
+    listJobs: async (runKeyValue, query) => {
+      assertListQuery("\u0417\u0430\u0434\u0430\u043D\u0438\u044F CI SourceCraft", CAPABILITIES3.jobs, query, JOB_FILTER_NAMES);
+      const jobs = await flattenJobs(runKey(runKeyValue));
+      const from = offsetOf(query.cursor);
+      const next = from + query.limit;
+      const page = jobs.slice(from, next);
+      const items = query.status === void 0 ? page : page.filter((job) => query.status?.includes(job.status.category) === true);
+      return { items, ...next < jobs.length ? { nextCursor: `o:${String(next)}` } : {} };
+    },
+    getJob: async (key) => {
+      const path = jobPath(key);
+      const tree = await getWorkflow(path.run, path.workflow);
+      for (const task of recordList(tree.tasks)) {
+        if (text(task.slug) !== path.task) continue;
+        const cube = recordList(task.cubes).find((item) => text(item.slug) === path.cube);
+        if (cube !== void 0) return jobOf3(path.run, path.workflow, path.task, path.cube, cube);
+      }
+      throw new TrackerError("not_found", `\u0412 SourceCraft \u043D\u0435\u0442 \u0437\u0430\u0434\u0430\u043D\u0438\u044F ${key}.`);
+    },
+    log: async (key, query) => {
+      const parsed = jobPath(key);
+      if (parsed.cube.startsWith("#")) {
+        throw new TrackerError("unsupported", `\u041B\u043E\u0433 \u0437\u0430\u0434\u0430\u043D\u0438\u044F SourceCraft ${key}: \u0441\u043B\u0443\u0436\u0435\u0431\u043D\u044B\u0439 \u043A\u0443\u0431, \u043B\u043E\u0433 \u0447\u0435\u0440\u0435\u0437 API \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D.`);
+      }
+      const window = logWindow(query);
+      const path = pathOf(parsed);
+      const tail = window.resume === void 0 && window.from === "tail";
+      const first = window.resume?.page ?? 1;
+      const deadline = Date.now() + CI_LOG_TIMEOUT_MS;
+      let page = first;
+      let skip = window.resume?.offset ?? 0;
+      let kept = new Uint8Array(0);
+      let dropped = 0;
+      let seen = 0;
+      let lastPage = first;
+      let lastEnd = 0;
+      let done = false;
+      let unread = false;
+      const encoder = new TextEncoder();
+      const decoder = new TextDecoder("utf-8");
+      for (; ; ) {
+        if (!tail && kept.length >= window.bytes) {
+          unread = true;
+          break;
+        }
+        const { body } = await requestJson(`${root}/logs/${path}?page=${String(page)}`, { fetch, headers, missing: missingJob(key) });
+        const record = isRecord(body) ? body : {};
+        const data = encoder.encode(text(record.logs) ?? "");
+        const rest = skip >= data.length ? new Uint8Array(0) : data.subarray(skip);
+        let slice = rest;
+        if (!tail) {
+          const room = rest.subarray(0, Math.min(window.bytes - kept.length, rest.length));
+          slice = room.subarray(0, room.length - trailingByte(room));
+        }
+        const merged = concat(kept, slice);
+        if (merged.length > window.bytes) {
+          const fitted = merged.subarray(merged.length - window.bytes);
+          dropped += merged.length - fitted.length;
+          kept = fitted;
+        } else {
+          kept = merged;
+        }
+        seen += data.length;
+        lastPage = page;
+        lastEnd = tail ? data.length : skip + slice.length;
+        skip = 0;
+        done = record.done === true;
+        if (!tail && rest.length > slice.length) {
+          unread = true;
+          break;
+        }
+        if (done || record.page_complete === false) break;
+        if (page - first + 1 >= CI_LOG_PAGES_MAX || seen >= CI_LOG_READ_MAX_BYTES || Date.now() >= deadline) {
+          unread = true;
+          break;
+        }
+        page += 1;
+      }
+      return logOf({
+        text: decoder.decode(kept.subarray(leadingByte(kept))),
+        truncated: dropped > 0 || unread,
+        complete: done,
+        page: lastPage,
+        end: lastEnd,
+        more: unread,
+        // Размер всего лога известен, только если с первой страницы прочитали их все.
+        size: window.resume === void 0 && !unread ? seen : void 0,
+        // Страниц было прочитано больше окна: начало хвоста отрезано кольцевым буфером, и первая неполная
+        // строка уходит из окна даже когда за ним ещё есть страницы (default startCut там молчит).
+        startCut: tail && dropped > 0,
+        raw: query.raw ?? false
+      });
+    },
+    trigger: async (input) => {
+      const workflows = input.workflows ?? [];
+      if (workflows.length === 0) throw new TrackerError("invalid_request", "\u0417\u0430\u043F\u0443\u0441\u043A CI SourceCraft: \u043D\u0443\u0436\u0435\u043D \u0445\u043E\u0442\u044F \u0431\u044B \u043E\u0434\u0438\u043D workflow.");
+      const values = Object.entries(input.inputs ?? {}).map(([name, value]) => ({ name, value }));
+      const head = input.refType === "tag" ? { tag: input.ref } : { branch: input.ref };
+      const { body } = await requestJson(`${root}/runs`, { fetch, headers, method: "POST", body: { head, workflows: workflows.map((name) => ({ name, values })) } });
+      return { run: runOf3(body) };
+    },
+    // Публичный API SourceCraft не умеет ни перезапускать, ни отменять (§1.3): отказ без запроса (§3.6).
+    rerun: async () => {
+      throw new TrackerError("unsupported", "\u041F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A \u043F\u0440\u043E\u0433\u043E\u043D\u0430 CI SourceCraft \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D: \u0443 \u043F\u043B\u043E\u0449\u0430\u0434\u043A\u0438 \u043D\u0435\u0442 \u0442\u0430\u043A\u043E\u0433\u043E \u0437\u0430\u043F\u0440\u043E\u0441\u0430 \u0432 API.");
+    },
+    rerunJob: async () => {
+      throw new TrackerError("unsupported", "\u041F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A \u0437\u0430\u0434\u0430\u043D\u0438\u044F CI SourceCraft \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D: \u0443 \u043F\u043B\u043E\u0449\u0430\u0434\u043A\u0438 \u043D\u0435\u0442 \u0442\u0430\u043A\u043E\u0433\u043E \u0437\u0430\u043F\u0440\u043E\u0441\u0430 \u0432 API.");
+    },
+    cancel: async () => {
+      throw new TrackerError("unsupported", "\u041E\u0442\u043C\u0435\u043D\u0430 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 CI SourceCraft \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u0430: \u0443 \u043F\u043B\u043E\u0449\u0430\u0434\u043A\u0438 \u043D\u0435\u0442 \u0442\u0430\u043A\u043E\u0433\u043E \u0437\u0430\u043F\u0440\u043E\u0441\u0430 \u0432 API.");
+    },
+    cancelJob: async () => {
+      throw new TrackerError("unsupported", "\u041E\u0442\u043C\u0435\u043D\u0430 \u0437\u0430\u0434\u0430\u043D\u0438\u044F CI SourceCraft \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u0430: \u0443 \u043F\u043B\u043E\u0449\u0430\u0434\u043A\u0438 \u043D\u0435\u0442 \u0442\u0430\u043A\u043E\u0433\u043E \u0437\u0430\u043F\u0440\u043E\u0441\u0430 \u0432 API.");
+    }
+  };
+}
+function partOf(value, key) {
+  const refusal = new TrackerError("not_found", `\u0412 SourceCraft \u043D\u0435\u0442 \u0437\u0430\u0434\u0430\u043D\u0438\u044F ${key}.`);
+  if (value === void 0) throw refusal;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(value);
+  } catch {
+    throw refusal;
+  }
+  if (decoded === "") throw refusal;
+  return decoded;
+}
+function pathOf(path) {
+  return [path.run, path.workflow, path.task, path.cube].map(encodeURIComponent).join("/");
+}
+function recordList(value) {
+  return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+function offsetOf(cursor) {
+  if (cursor === void 0) return 0;
+  const match = JOB_OFFSET_CURSOR.exec(cursor);
+  if (match === null) return 0;
+  const from = Number(match[1]);
+  return Number.isSafeInteger(from) && from >= 0 ? from : 0;
+}
+function runOf3(raw) {
+  const item = isRecord(raw) ? raw : {};
+  const key = text(item.slug) ?? "?";
+  const rawStatus = text(item.status) ?? "unknown";
+  const rawEvent = text(item.event_type);
+  const user = isRecord(item.user) ? text(item.user.slug) : void 0;
+  const pull = isRecord(item.pull) ? text(item.pull.slug) : void 0;
+  const dates = isRecord(item.dates) ? item.dates : {};
+  const createdAt = toTimestamp(dates.created_at);
+  const startedAt = toTimestamp(dates.started_at);
+  const finishedAt = toTimestamp(dates.finished_at);
+  const updatedAt = toTimestamp(dates.updated_at);
+  const errors = stringList(item.error_messages);
+  return {
+    key,
+    ...RUN_SLUG.test(key) ? { number: Number(key) } : {},
+    workflows: stringList(recordList(item.workflows).map((workflow) => workflow.slug)),
+    status: { category: lookup(SOURCECRAFT_CI_STATUSES, rawStatus, "running"), name: rawStatus },
+    ...rawEvent === void 0 ? {} : { event: { category: lookup(SOURCECRAFT_RUN_EVENTS, rawEvent, "other"), name: rawEvent } },
+    ...user === void 0 || user === EXTERNAL_USER ? {} : { actor: user },
+    ...pull === void 0 ? {} : { pullRequest: pull },
+    ...errors.length === 0 ? {} : { errors },
+    links: [],
+    ...createdAt === void 0 ? {} : { createdAt },
+    ...startedAt === void 0 ? {} : { startedAt },
+    ...finishedAt === void 0 ? {} : { finishedAt },
+    ...updatedAt === void 0 ? {} : { updatedAt }
+  };
+}
+function jobOf3(run, workflow, task, cubeSlug, cube) {
+  const rawStatus = text(cube.status) ?? "unknown";
+  const dates = isRecord(cube.dates) ? cube.dates : {};
+  const createdAt = toTimestamp(dates.created_at);
+  const startedAt = toTimestamp(dates.started_at);
+  const finishedAt = toTimestamp(dates.finished_at);
+  return {
+    key: [run, workflow, task, cubeSlug].map(encodeURIComponent).join("/"),
+    runKey: run,
+    name: cubeSlug,
+    stage: `${workflow}/${task}`,
+    status: { category: lookup(SOURCECRAFT_CI_STATUSES, rawStatus, "running"), name: rawStatus },
+    links: [],
+    ...createdAt === void 0 ? {} : { createdAt },
+    ...startedAt === void 0 ? {} : { startedAt },
+    ...finishedAt === void 0 ? {} : { finishedAt }
+  };
+}
+function keepsRun(run, query) {
+  return (query.status === void 0 || query.status.includes(run.status.category)) && (query.event === void 0 || run.event !== void 0 && query.event.includes(run.event.category)) && (query.workflow === void 0 || run.workflows.includes(query.workflow)) && (query.actor === void 0 || run.actor === query.actor) && (query.pullRequest === void 0 || run.pullRequest === query.pullRequest) && inTimeRange(run.createdAt, query.createdAfter, query.createdBefore) && inTimeRange(run.updatedAt, query.updatedAfter, query.updatedBefore);
+}
+function pullSlugOf(run, raw, pullId, slug) {
+  if (run.pullRequest !== void 0 || pullId === void 0 || slug === void 0) return run;
+  const id = isRecord(raw.pull) ? text(raw.pull.id) : void 0;
+  return id === pullId ? { ...run, pullRequest: slug } : run;
+}
+function leadingByte(window) {
+  let count = 0;
+  while (count < 3 && count < window.length && ((window[count] ?? 0) & 192) === 128) count += 1;
+  return count;
+}
+function trailingByte(window) {
+  for (let back = 1; back <= Math.min(4, window.length); back += 1) {
+    const byte = window[window.length - back] ?? 0;
+    if ((byte & 192) === 128) continue;
+    const size = byte >= 240 ? 4 : byte >= 224 ? 3 : byte >= 192 ? 2 : 1;
+    return size > back ? back : 0;
+  }
+  return 0;
+}
+function concat(head, tail) {
+  if (head.length === 0) return tail;
+  if (tail.length === 0) return head;
+  const merged = new Uint8Array(head.length + tail.length);
+  merged.set(head, 0);
+  merged.set(tail, head.length);
+  return merged;
+}
+
 // src/tracker/registry.lib.ts
 var definitions = /* @__PURE__ */ new Map();
 function registerTracker(definition) {
@@ -319,28 +1523,28 @@ function listTrackers() {
 }
 
 // src/tracker/pull.schema.ts
-import { z } from "zod";
-var pullRequestStatusCategorySchema = z.enum(["draft", "open", "merged", "closed"]);
-var pullRequestFilterSchema = z.enum(["status", "author", "source", "target", "labels", "search", "createdAfter", "createdBefore", "updatedAfter", "updatedBefore"]);
-var pullRequestSortFieldSchema = z.enum(["created", "updated", "title"]);
-var mergeMethodSchema = z.enum(["merge", "squash", "rebase"]);
-var pullRequestSchema = z.object({
+import { z as z2 } from "zod";
+var pullRequestStatusCategorySchema = z2.enum(["draft", "open", "merged", "closed"]);
+var pullRequestFilterSchema = z2.enum(["status", "author", "source", "target", "labels", "search", "createdAfter", "createdBefore", "updatedAfter", "updatedBefore"]);
+var pullRequestSortFieldSchema = z2.enum(["created", "updated", "title"]);
+var mergeMethodSchema = z2.enum(["merge", "squash", "rebase"]);
+var pullRequestSchema = z2.object({
   /** Номер PR в своём трекере: GitHub number, GitLab iid, SourceCraft slug; для клиента непрозрачная строка. */
-  key: z.string().min(1).max(200),
-  title: z.string().min(1).max(1024),
-  description: z.string().max(1048576).optional(),
-  status: z.object({ category: pullRequestStatusCategorySchema, name: z.string().min(1).max(200) }),
+  key: z2.string().min(1).max(200),
+  title: z2.string().min(1).max(1024),
+  description: z2.string().max(1048576).optional(),
+  status: z2.object({ category: pullRequestStatusCategorySchema, name: z2.string().min(1).max(200) }),
   /** Автор — логин или slug трекера. */
-  author: z.string().min(1).max(200).optional(),
+  author: z2.string().min(1).max(200).optional(),
   /** Ветка-источник и целевая ветка — имя без refs/heads/. */
-  source: z.string().min(1).max(500),
-  target: z.string().min(1).max(500),
+  source: z2.string().min(1).max(500),
+  target: z2.string().min(1).max(500),
   /** Коммит головы источника. */
-  headSha: z.string().regex(/^[0-9a-f]{7,64}$/).optional(),
-  labels: z.array(z.string().min(1).max(200)).max(100),
+  headSha: z2.string().regex(/^[0-9a-f]{7,64}$/).optional(),
+  labels: z2.array(z2.string().min(1).max(200)).max(100),
   /** Запрошенные ревьюеры; нет — трекер их в PR не отдаёт. */
-  reviewers: z.array(z.string().min(1).max(200)).max(100).optional(),
-  links: z.array(issueLinkSchema).max(100),
+  reviewers: z2.array(z2.string().min(1).max(200)).max(100).optional(),
+  links: z2.array(issueLinkSchema).max(100),
   createdAt: timestampSchema.optional(),
   updatedAt: timestampSchema.optional(),
   mergedAt: timestampSchema.optional(),
@@ -348,10 +1552,10 @@ var pullRequestSchema = z.object({
 });
 
 // src/tracker/github-pull.lib.ts
-var DEFAULT_API = "https://api.github.com";
-var TARGET = /^[\w.-]+\/[\w.-]+$/;
+var DEFAULT_API3 = "https://api.github.com";
+var TARGET4 = /^[\w.-]+\/[\w.-]+$/;
 var NUMBER = /^[1-9]\d{0,19}$/;
-var SHA = /^[0-9a-f]{7,64}$/;
+var SHA2 = /^[0-9a-f]{7,64}$/;
 var LIST_SUBJECT = "PR GitHub";
 var COMMENTS_SUBJECT = "\u041A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438 PR GitHub";
 var PULL_CAPABILITIES = {
@@ -377,8 +1581,8 @@ function githubPulls() {
 }
 function createGithubPullAdapter({ connection, fetch }) {
   const target = requireTarget(connection.target, "owner/repo \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F GitHub");
-  if (!TARGET.test(target)) throw new TrackerError("invalid_request", "target GitHub \u2014 owner/repo.");
-  const api = baseUrl(connection.url, DEFAULT_API);
+  if (!TARGET4.test(target)) throw new TrackerError("invalid_request", "target GitHub \u2014 owner/repo.");
+  const api = baseUrl(connection.url, DEFAULT_API3);
   const root = `${api}/repos/${target}/pulls`;
   const issues = `${api}/repos/${target}/issues`;
   const owner = target.split("/")[0] ?? target;
@@ -397,7 +1601,7 @@ function createGithubPullAdapter({ connection, fetch }) {
     list: async (query) => {
       assertListQuery(LIST_SUBJECT, PULL_CAPABILITIES.list, query, pullRequestFilterSchema.options);
       const status = usedStatuses(query.status);
-      const page = pageOf(query.cursor);
+      const page = pageOf3(query.cursor);
       const params = new URLSearchParams({ state: stateFilter(status), per_page: String(query.limit), page: String(page) });
       if (query.source !== void 0) params.set("head", `${owner}:${query.source}`);
       if (query.target !== void 0) params.set("base", query.target);
@@ -428,7 +1632,7 @@ function createGithubPullAdapter({ connection, fetch }) {
     },
     comments: async (key, query) => {
       assertCommentQuery(COMMENTS_SUBJECT, PULL_CAPABILITIES.comments, query);
-      const page = pageOf(query.cursor);
+      const page = pageOf3(query.cursor);
       const params = new URLSearchParams({ per_page: String(query.limit), page: String(page) });
       if (query.updatedAfter !== void 0) params.set("since", isoTime(query.updatedAfter));
       const { body, headers: responseHeaders } = await requestJson(`${issues}/${number(key)}/comments?${params.toString()}`, { fetch, headers, missing: missing(key) });
@@ -437,7 +1641,7 @@ function createGithubPullAdapter({ connection, fetch }) {
     comment: async (key, body) => commentOf((await requestJson(`${issues}/${number(key)}/comments`, { fetch, headers, method: "POST", body: { body }, missing: missing(key) })).body)
   };
 }
-function pageOf(cursor) {
+function pageOf3(cursor) {
   const page = cursor === void 0 ? 1 : Number(cursor);
   return Number.isInteger(page) && page >= 1 ? page : 1;
 }
@@ -516,7 +1720,7 @@ function pullOf(raw) {
     ...author === void 0 ? {} : { author },
     source: text(head.ref) ?? "?",
     target: text(base.ref) ?? "?",
-    ...sha !== void 0 && SHA.test(sha) ? { headSha: sha } : {},
+    ...sha !== void 0 && SHA2.test(sha) ? { headSha: sha } : {},
     labels: Array.isArray(item.labels) ? stringList(item.labels.map((label) => isRecord(label) ? label.name : label)) : [],
     reviewers: logins(item.requested_reviewers),
     links: url === void 0 ? [] : [{ url, title: "GitHub" }],
@@ -539,8 +1743,8 @@ function commentOf(raw) {
 }
 
 // src/tracker/github.lib.ts
-var DEFAULT_API2 = "https://api.github.com";
-var TARGET2 = /^[\w.-]+\/[\w.-]+$/;
+var DEFAULT_API4 = "https://api.github.com";
+var TARGET5 = /^[\w.-]+\/[\w.-]+$/;
 var NUMBER2 = /^[1-9]\d{0,14}$/;
 var LIST_SUBJECT2 = "\u0417\u0430\u0434\u0430\u0447\u0438 GitHub";
 var COMMENTS_SUBJECT2 = "\u041A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438 GitHub";
@@ -562,13 +1766,14 @@ function githubTracker() {
     },
     create: (context) => createGithubAdapter(context, issues),
     issues,
-    pulls: githubPulls()
+    pulls: githubPulls(),
+    ci: githubCi()
   };
 }
 function createGithubAdapter({ connection, fetch }, capabilities) {
   const target = requireTarget(connection.target, "owner/repo \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F GitHub");
-  if (!TARGET2.test(target)) throw new TrackerError("invalid_request", "target GitHub \u2014 owner/repo.");
-  const api = baseUrl(connection.url, DEFAULT_API2);
+  if (!TARGET5.test(target)) throw new TrackerError("invalid_request", "target GitHub \u2014 owner/repo.");
+  const api = baseUrl(connection.url, DEFAULT_API4);
   const root = `${api}/repos/${target}/issues`;
   const headers = {
     accept: "application/vnd.github+json",
@@ -587,11 +1792,11 @@ function createGithubAdapter({ connection, fetch }, capabilities) {
     list: async (query) => {
       assertListQuery(LIST_SUBJECT2, capabilities.list, query, ISSUE_FILTERS);
       assertCsvLabels(query.labels);
-      const page = pageOf2(query.cursor);
+      const page = pageOf4(query.cursor);
       const search = needsSearch(query);
       const params = search ? searchParams(target, query, page) : issuesParams(query, page);
       const { body, headers: responseHeaders } = await requestJson(`${search ? `${api}/search/issues` : root}?${params.toString()}`, { fetch, headers });
-      return issuePageOf(rowsOf(body, search), query, responseHeaders.get("link") ?? "", page);
+      return issuePageOf(rowsOf2(body, search), query, responseHeaders.get("link") ?? "", page);
     },
     get: async (key) => issueOf(await rawOf(key)),
     create: async (input) => {
@@ -611,7 +1816,7 @@ function createGithubAdapter({ connection, fetch }, capabilities) {
     },
     comments: async (key, query) => {
       assertCommentQuery(COMMENTS_SUBJECT2, capabilities.comments, query);
-      const page = pageOf2(query.cursor);
+      const page = pageOf4(query.cursor);
       const params = new URLSearchParams({ per_page: String(query.limit), page: String(page) });
       if (query.updatedAfter !== void 0) params.set("since", isoTime(query.updatedAfter));
       const { body, headers: responseHeaders } = await requestJson(`${root}/${number(key)}/comments?${params.toString()}`, { fetch, headers, missingIsIssue: true });
@@ -620,7 +1825,7 @@ function createGithubAdapter({ connection, fetch }, capabilities) {
     comment: async (key, body) => commentOf2((await requestJson(`${root}/${number(key)}/comments`, { fetch, headers, method: "POST", body: { body }, missingIsIssue: true })).body)
   };
 }
-function pageOf2(cursor) {
+function pageOf4(cursor) {
   const page = cursor === void 0 ? 1 : Number(cursor);
   return Number.isInteger(page) && page >= 1 ? page : 1;
 }
@@ -675,7 +1880,7 @@ function timeRangeQualifier(field, after, before) {
   if (before !== void 0) return `${field}:<=${isoTime(before)}`;
   return void 0;
 }
-function rowsOf(body, search) {
+function rowsOf2(body, search) {
   if (!search) return Array.isArray(body) ? body : [];
   return isRecord(body) && Array.isArray(body.items) ? body.items : [];
 }
@@ -740,10 +1945,10 @@ function commentOf2(raw) {
 }
 
 // src/tracker/gitlab-pull.lib.ts
-var DEFAULT_URL = "https://gitlab.com";
-var TARGET3 = /^(\d{1,15}|[\w.-]+(\/[\w.-]+)+)$/;
+var DEFAULT_URL2 = "https://gitlab.com";
+var TARGET6 = /^(\d{1,15}|[\w.-]+(\/[\w.-]+)+)$/;
 var IID = /^[1-9]\d{0,19}$/;
-var SHA2 = /^[0-9a-f]{7,64}$/;
+var SHA3 = /^[0-9a-f]{7,64}$/;
 var PULL_CAPABILITIES2 = {
   list: { filters: pullRequestFilterSchema.options, clientSide: ["status"], sorts: ["created", "updated", "title"] },
   comments: { filters: COMMENT_FILTERS, clientSide: COMMENT_FILTERS, order: ["asc", "desc"] },
@@ -764,8 +1969,8 @@ function gitlabPulls() {
 }
 function createGitlabPullAdapter({ connection, fetch }) {
   const target = requireTarget(connection.target, "\u043F\u0443\u0442\u044C \u043F\u0440\u043E\u0435\u043A\u0442\u0430 GitLab, group/project, \u0438\u043B\u0438 \u0435\u0433\u043E id");
-  if (!TARGET3.test(target)) throw new TrackerError("invalid_request", "target GitLab \u2014 group/project \u0438\u043B\u0438 \u0447\u0438\u0441\u043B\u043E\u0432\u043E\u0439 id.");
-  const root = `${baseUrl(connection.url, DEFAULT_URL)}/api/v4/projects/${encodeURIComponent(target)}/merge_requests`;
+  if (!TARGET6.test(target)) throw new TrackerError("invalid_request", "target GitLab \u2014 group/project \u0438\u043B\u0438 \u0447\u0438\u0441\u043B\u043E\u0432\u043E\u0439 id.");
+  const root = `${baseUrl(connection.url, DEFAULT_URL2)}/api/v4/projects/${encodeURIComponent(target)}/merge_requests`;
   const headers = connection.token === void 0 || connection.token === "" ? {} : { "private-token": connection.token };
   const iid = (key) => {
     if (!IID.test(key)) throw new TrackerError("not_found", `\u0412 GitLab \u043D\u0435\u0442 MR ${key}.`);
@@ -776,7 +1981,7 @@ function createGitlabPullAdapter({ connection, fetch }) {
     list: async (query) => {
       assertListQuery("PR GitLab", PULL_CAPABILITIES2.list, query, pullRequestFilterSchema.options);
       const status = usedStatuses2(query.status);
-      const page = pageOf3(query.cursor);
+      const page = pageOf5(query.cursor);
       const params = new URLSearchParams({
         state: stateFilter3(status),
         per_page: String(query.limit),
@@ -838,7 +2043,7 @@ function createGitlabPullAdapter({ connection, fetch }) {
     },
     comments: async (key, query) => {
       assertCommentQuery("\u041A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438 GitLab", PULL_CAPABILITIES2.comments, query);
-      const page = pageOf3(query.cursor);
+      const page = pageOf5(query.cursor);
       const params = new URLSearchParams({ sort: query.order ?? "asc", order_by: "created_at", per_page: String(query.limit), page: String(page) });
       const { body, headers: responseHeaders } = await requestJson(`${root}/${iid(key)}/notes?${params.toString()}`, { fetch, headers, missing: { failure: "not_found", message: `\u0412 GitLab \u043D\u0435\u0442 MR ${key}.` } });
       const next = responseHeaders.get("x-next-page");
@@ -848,7 +2053,7 @@ function createGitlabPullAdapter({ connection, fetch }) {
     comment: async (key, body) => commentOf3((await requestJson(`${root}/${iid(key)}/notes`, { fetch, headers, method: "POST", body: { body }, missing: { failure: "not_found", message: `\u0412 GitLab \u043D\u0435\u0442 MR ${key}.` } })).body)
   };
 }
-function pageOf3(cursor) {
+function pageOf5(cursor) {
   const page = cursor === void 0 ? 1 : Number(cursor);
   return Number.isInteger(page) && page >= 1 ? page : 1;
 }
@@ -916,7 +2121,7 @@ function pullOf2(raw) {
     ...author === void 0 ? {} : { author },
     source: text(item.source_branch) ?? "?",
     target: text(item.target_branch) ?? "?",
-    ...sha !== void 0 && SHA2.test(sha) ? { headSha: sha } : {},
+    ...sha !== void 0 && SHA3.test(sha) ? { headSha: sha } : {},
     labels: labelNames(item.labels),
     reviewers: usernames(item.reviewers),
     links: url === void 0 ? [] : [{ url, title: "GitLab" }],
@@ -934,8 +2139,8 @@ function commentOf3(raw) {
 }
 
 // src/tracker/gitlab.lib.ts
-var DEFAULT_URL2 = "https://gitlab.com";
-var TARGET4 = /^(\d{1,15}|[\w.-]+(\/[\w.-]+)+)$/;
+var DEFAULT_URL3 = "https://gitlab.com";
+var TARGET7 = /^(\d{1,15}|[\w.-]+(\/[\w.-]+)+)$/;
 var IID2 = /^[1-9]\d{0,14}$/;
 var ISSUE_CAPABILITIES = {
   list: { filters: ISSUE_FILTERS, clientSide: ["status"], sorts: ["created", "updated", "priority", "title"] },
@@ -961,13 +2166,14 @@ function gitlabTracker() {
     },
     create: (context) => createGitlabAdapter(context),
     issues: ISSUE_CAPABILITIES,
-    pulls: gitlabPulls()
+    pulls: gitlabPulls(),
+    ci: gitlabCi()
   };
 }
 function createGitlabAdapter({ connection, fetch }) {
   const target = requireTarget(connection.target, "\u043F\u0443\u0442\u044C \u043F\u0440\u043E\u0435\u043A\u0442\u0430 GitLab, group/project, \u0438\u043B\u0438 \u0435\u0433\u043E id");
-  if (!TARGET4.test(target)) throw new TrackerError("invalid_request", "target GitLab \u2014 group/project \u0438\u043B\u0438 \u0447\u0438\u0441\u043B\u043E\u0432\u043E\u0439 id.");
-  const root = `${baseUrl(connection.url, DEFAULT_URL2)}/api/v4/projects/${encodeURIComponent(target)}/issues`;
+  if (!TARGET7.test(target)) throw new TrackerError("invalid_request", "target GitLab \u2014 group/project \u0438\u043B\u0438 \u0447\u0438\u0441\u043B\u043E\u0432\u043E\u0439 id.");
+  const root = `${baseUrl(connection.url, DEFAULT_URL3)}/api/v4/projects/${encodeURIComponent(target)}/issues`;
   const headers = connection.token === void 0 || connection.token === "" ? {} : { "private-token": connection.token };
   const iid = (key) => {
     if (!IID2.test(key)) throw new TrackerError("unknown_issue", `\u0412 GitLab \u043D\u0435\u0442 \u0437\u0430\u0434\u0430\u0447\u0438 ${key}.`);
@@ -977,7 +2183,7 @@ function createGitlabAdapter({ connection, fetch }) {
   return {
     list: async (query) => {
       assertListQuery("\u0417\u0430\u0434\u0430\u0447\u0438 GitLab", ISSUE_CAPABILITIES.list, query, ISSUE_FILTERS);
-      const page = pageOf4(query.cursor);
+      const page = pageOf6(query.cursor);
       const params = new URLSearchParams({
         state: stateFilter4(query.status),
         per_page: String(query.limit),
@@ -1016,7 +2222,7 @@ function createGitlabAdapter({ connection, fetch }) {
     },
     comments: async (key, query) => {
       assertCommentQuery("\u041A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438 GitLab", ISSUE_CAPABILITIES.comments, query);
-      const page = pageOf4(query.cursor);
+      const page = pageOf6(query.cursor);
       const params = new URLSearchParams({ sort: query.order ?? "asc", order_by: "created_at", per_page: String(query.limit), page: String(page) });
       const { body, headers: responseHeaders } = await requestJson(`${root}/${iid(key)}/notes?${params.toString()}`, { fetch, headers, missingIsIssue: true });
       const next = responseHeaders.get("x-next-page");
@@ -1026,7 +2232,7 @@ function createGitlabAdapter({ connection, fetch }) {
     comment: async (key, body) => commentOf4((await requestJson(`${root}/${iid(key)}/notes`, { fetch, headers, method: "POST", body: { body }, missingIsIssue: true })).body)
   };
 }
-function pageOf4(cursor) {
+function pageOf6(cursor) {
   const page = cursor === void 0 ? 1 : Number(cursor);
   return Number.isInteger(page) && page >= 1 ? page : 1;
 }
@@ -1345,10 +2551,10 @@ function toComment(row) {
 }
 
 // src/tracker/sourcecraft-pull.lib.ts
-var DEFAULT_API3 = "https://api.sourcecraft.tech";
-var TARGET5 = /^[\w.-]+\/[\w.-]+$/;
+var DEFAULT_API5 = "https://api.sourcecraft.tech";
+var TARGET8 = /^[\w.-]+\/[\w.-]+$/;
 var SLUG = /^[\w-]{1,100}$/;
-var SHA3 = /^[0-9a-f]{7,64}$/;
+var SHA4 = /^[0-9a-f]{7,64}$/;
 var PULL_SORT_FIELDS_UPSTREAM = {
   created: "created_at",
   updated: "updated_at",
@@ -1374,8 +2580,8 @@ function sourcecraftPulls() {
 }
 function createPullAdapter({ connection, fetch }) {
   const target = requireTarget(connection.target, "org/repo \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F SourceCraft");
-  if (!TARGET5.test(target)) throw new TrackerError("invalid_request", "target SourceCraft \u2014 org/repo.");
-  const api = baseUrl(connection.url, DEFAULT_API3);
+  if (!TARGET8.test(target)) throw new TrackerError("invalid_request", "target SourceCraft \u2014 org/repo.");
+  const api = baseUrl(connection.url, DEFAULT_API5);
   const root = `${api}/repos/${target}/pulls`;
   const headers = { authorization: `Bearer ${connection.token ?? ""}` };
   const missing = (key) => ({ failure: "not_found", message: `\u0412 SourceCraft \u043D\u0435\u0442 PR ${key}.` });
@@ -1529,7 +2735,7 @@ function pullOf3(raw) {
     ...author === void 0 ? {} : { author },
     source: text(source.ref) ?? text(item.source_branch) ?? "?",
     target: text(target.ref) ?? text(item.target_branch) ?? "?",
-    ...headSha !== void 0 && SHA3.test(headSha) ? { headSha } : {},
+    ...headSha !== void 0 && SHA4.test(headSha) ? { headSha } : {},
     labels: Array.isArray(item.labels) ? stringList(item.labels.map((label) => isRecord(label) ? label.name : void 0)) : [],
     links: [],
     ...createdAt === void 0 ? {} : { createdAt },
@@ -1546,9 +2752,9 @@ function commentOf6(raw) {
 }
 
 // src/tracker/sourcecraft.lib.ts
-var DEFAULT_API4 = "https://api.sourcecraft.tech";
+var DEFAULT_API6 = "https://api.sourcecraft.tech";
 var DEFAULT_WEB = "https://sourcecraft.dev";
-var TARGET6 = /^[\w.-]+\/[\w.-]+$/;
+var TARGET9 = /^[\w.-]+\/[\w.-]+$/;
 var SLUG2 = /^[\w-]{1,100}$/;
 var ISSUE_SORT_FIELDS_UPSTREAM = {
   created: "created_at",
@@ -1574,13 +2780,14 @@ function sourcecraftTracker() {
     },
     issues: ISSUE_CAPABILITIES4,
     create: (context) => createSourceCraftAdapter(context),
-    pulls: sourcecraftPulls()
+    pulls: sourcecraftPulls(),
+    ci: sourcecraftCi()
   };
 }
 function createSourceCraftAdapter({ connection, fetch }) {
   const target = requireTarget(connection.target, "org/repo \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F SourceCraft");
-  if (!TARGET6.test(target)) throw new TrackerError("invalid_request", "target SourceCraft \u2014 org/repo.");
-  const api = baseUrl(connection.url, DEFAULT_API4);
+  if (!TARGET9.test(target)) throw new TrackerError("invalid_request", "target SourceCraft \u2014 org/repo.");
+  const api = baseUrl(connection.url, DEFAULT_API6);
   const root = `${api}/repos/${target}/issues`;
   const headers = { authorization: `Bearer ${connection.token ?? ""}` };
   const web = connection.url === void 0 ? `${DEFAULT_WEB}/${target}/issues` : void 0;
@@ -1752,14 +2959,25 @@ function pullRequestAdapterOf(definition, context) {
 }
 export {
   ALL_STATUSES,
+  CI_FINISHED_STATUSES,
+  CI_LOG_DEFAULT_BYTES,
+  CI_LOG_MAX_BYTES,
+  CI_LOG_PAGES_MAX,
+  CI_LOG_READ_MAX_BYTES,
+  CI_LOG_TIMEOUT_MS,
   COMMENT_FILTERS,
   GITHUB_CLOSE_REASONS,
   GITHUB_IN_PROGRESS_LABEL,
   GITHUB_PRIORITY_LABELS,
+  GITHUB_RUN_CONCLUSIONS,
+  GITHUB_RUN_EVENTS,
+  GITHUB_RUN_STATUSES,
+  GITLAB_CI_STATUSES,
   GITLAB_DRAFT_PATTERN,
   GITLAB_DRAFT_PREFIX,
   GITLAB_IN_PROGRESS_LABEL,
   GITLAB_MERGE_REQUEST_STATES,
+  GITLAB_PIPELINE_SOURCES,
   GITLAB_PRIORITY_LABELS,
   ISSUE_FILTERS,
   ISSUE_SORT_FIELDS,
@@ -1768,8 +2986,10 @@ export {
   JIRA_PRIORITY_NAMES,
   JIRA_STATUS_CATEGORIES,
   LEGACY_ISSUE_CAPABILITIES,
+  SOURCECRAFT_CI_STATUSES,
   SOURCECRAFT_PRIORITIES,
   SOURCECRAFT_PULL_STATUSES,
+  SOURCECRAFT_RUN_EVENTS,
   SOURCECRAFT_STATUSES,
   SOURCECRAFT_STATUS_FILTER,
   SOURCECRAFT_STATUS_SLUGS,
@@ -1782,16 +3002,31 @@ export {
   assertCommentQuery,
   assertListQuery,
   baseUrl,
+  ciAdapterOf,
+  ciEventCategorySchema,
+  ciJobFilterSchema,
+  ciJobSchema,
+  ciLogSchema,
+  ciRunFilterSchema,
+  ciRunSchema,
+  ciRunSortFieldSchema,
+  ciStatusCategorySchema,
+  ciStatusSchema,
+  ciWorkflowSchema,
+  cleanLogText,
   clipText,
   containsText,
   deleteTrackerToken,
   findTracker,
+  githubCi,
   githubPulls,
   githubTracker,
+  gitlabCi,
   gitlabPulls,
   gitlabTracker,
   hasTrackerToken,
   inTimeRange,
+  isFinished,
   isRecord,
   isoTime,
   issueCapabilitiesOf,
@@ -1799,6 +3034,9 @@ export {
   keysFor,
   listTrackers,
   localTracker,
+  logCursor,
+  logOf,
+  logWindow,
   lookup,
   mergeMethodSchema,
   nameOf,
@@ -1813,7 +3051,9 @@ export {
   registerBuiltinTrackers,
   registerTracker,
   requestJson,
+  requestText,
   requireTarget,
+  sourcecraftCi,
   sourcecraftPulls,
   sourcecraftTracker,
   stringList,