mastracode 0.22.2 → 0.22.3-alpha.1

package/dist/{chunk-NFF7IH5X.cjs → chunk-A4W5D25I.cjs}

@@ -9,12 +9,6 @@ var openaiCompatible = require('@ai-sdk/openai-compatible');
 var schemaCompat = require('@mastra/schema-compat');
 var openai = require('@ai-sdk/openai');
 var llm = require('@mastra/core/llm');
-var crypto = require('crypto');
-var promises = require('fs/promises');
-var os = require('os');
-var util = require('util');
-var tools = require('@mastra/core/tools');
-var z = require('zod');
 var chalk = require('chalk');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -39,7 +33,6 @@ function _interopNamespace(e) {
 
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var z__default = /*#__PURE__*/_interopDefault(z);
 var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 
 var MEMORY_GATEWAY_PROVIDER = "mastra-gateway";
@@ -1284,1091 +1277,6 @@ function getDynamicModel({ requestContext }) {
   const thinkingLevel = harnessContext?.state?.thinkingLevel;
   return resolveModel(modelId, { thinkingLevel, requestContext });
 }
-var _execFileAsync;
-async function execFileAsync(file, args, options) {
-  if (!_execFileAsync) {
-    const cp = await import('child_process');
-    _execFileAsync = util.promisify(cp.execFile);
-  }
-  return _execFileAsync(file, args, options);
-}
-var GITHUB_SUBSCRIBE_PR_TAG = "github-subscribe-pr";
-var GITHUB_UNSUBSCRIBE_PR_TAG = "github-unsubscribe-pr";
-var GITHUB_SYNC_STATUS_TAG = "github-sync-status";
-var GITHUB_SIGNALS_METADATA_KEY = "githubSignals";
-var createGithubTool = tools.createTool;
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readString(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function readNumber(value) {
-  if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
-  if (typeof value === "string" && /^\d+$/.test(value)) return Number(value);
-  return void 0;
-}
-function stableJson(value) {
-  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
-  if (isPlainObject(value)) {
-    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-function snapshotHash(value) {
-  return crypto.createHash("sha256").update(stableJson(value)).digest("hex");
-}
-function resolveHomePath(path2) {
-  return path2.startsWith("~/") ? path.join(os.homedir(), path2.slice(2)) : path2;
-}
-async function getGitcrawlDbPath() {
-  if (process.env.GITCRAWL_DB_PATH) return resolveHomePath(process.env.GITCRAWL_DB_PATH);
-  const configPath = process.env.GITCRAWL_CONFIG_PATH ?? path.join(os.homedir(), ".config", "gitcrawl", "config.toml");
-  try {
-    const config = await promises.readFile(resolveHomePath(configPath), "utf8");
-    const match = /^\s*db_path\s*=\s*['\"]([^'\"]+)['\"]/m.exec(config);
-    if (match?.[1]) return resolveHomePath(match[1]);
-  } catch {
-  }
-  return path.join(os.homedir(), ".config", "gitcrawl", "gitcrawl.db");
-}
-async function queryGitcrawlDb(sql) {
-  const dbPath = await getGitcrawlDbPath();
-  const { stdout } = await execFileAsync("sqlite3", ["-json", dbPath, sql], { maxBuffer: 10 * 1024 * 1024 });
-  return JSON.parse(stdout || "[]");
-}
-function sqlString(value) {
-  return `'${value.replaceAll("'", "''")}'`;
-}
-function getSignalMetadata(message) {
-  if (message.role !== "signal") return void 0;
-  const signal = message.content.metadata?.signal;
-  return isPlainObject(signal) ? signal : void 0;
-}
-function getGithubMetadata(threadMetadata) {
-  const mastra2 = isPlainObject(threadMetadata?.mastra) ? threadMetadata.mastra : {};
-  const githubSignals = isPlainObject(mastra2[GITHUB_SIGNALS_METADATA_KEY]) ? mastra2[GITHUB_SIGNALS_METADATA_KEY] : {};
-  const rawSubscriptions = Array.isArray(githubSignals.subscriptions) ? githubSignals.subscriptions : [];
-  const subscriptions = [];
-  for (const rawSubscription of rawSubscriptions) {
-    if (!isPlainObject(rawSubscription)) continue;
-    const owner = readString(rawSubscription.owner);
-    const repo = readString(rawSubscription.repo);
-    const number = readNumber(rawSubscription.number);
-    const subscribedAt = readString(rawSubscription.subscribedAt);
-    const updatedAt = readString(rawSubscription.updatedAt);
-    const lastSubscribeSignalId = readString(rawSubscription.lastSubscribeSignalId);
-    if (!owner || !repo || !number || !subscribedAt || !updatedAt || !lastSubscribeSignalId) continue;
-    subscriptions.push({
-      owner,
-      repo,
-      number,
-      subscribedAt,
-      updatedAt,
-      lastSubscribeSignalId,
-      ...readString(rawSubscription.lastSyncAt) ? { lastSyncAt: readString(rawSubscription.lastSyncAt) } : {},
-      ...rawSubscription.lastSyncStatus === "success" || rawSubscription.lastSyncStatus === "error" || rawSubscription.lastSyncStatus === "skipped" ? { lastSyncStatus: rawSubscription.lastSyncStatus } : {},
-      ...readString(rawSubscription.lastSyncError) ? { lastSyncError: readString(rawSubscription.lastSyncError) } : {},
-      ...readString(rawSubscription.lastObservedGithubUpdatedAt) ? { lastObservedGithubUpdatedAt: readString(rawSubscription.lastObservedGithubUpdatedAt) } : {},
-      ...readString(rawSubscription.lastObservedContentHash) ? { lastObservedContentHash: readString(rawSubscription.lastObservedContentHash) } : {},
-      ...readString(rawSubscription.lastObservedThreadContentHash) ? { lastObservedThreadContentHash: readString(rawSubscription.lastObservedThreadContentHash) } : {},
-      ...readString(rawSubscription.lastObservedHeadSha) ? { lastObservedHeadSha: readString(rawSubscription.lastObservedHeadSha) } : {},
-      ...readString(rawSubscription.lastObservedState) ? { lastObservedState: readString(rawSubscription.lastObservedState) } : {},
-      ...readString(rawSubscription.lastObservedMergeableState) ? { lastObservedMergeableState: readString(rawSubscription.lastObservedMergeableState) } : {},
-      ...readString(rawSubscription.lastObservedCiState) ? { lastObservedCiState: readString(rawSubscription.lastObservedCiState) } : {},
-      ...readString(rawSubscription.lastObservedReviewStateHash) ? { lastObservedReviewStateHash: readString(rawSubscription.lastObservedReviewStateHash) } : {},
-      ...readString(rawSubscription.lastNotificationAt) ? { lastNotificationAt: readString(rawSubscription.lastNotificationAt) } : {},
-      ...readString(rawSubscription.lastNotificationKind) ? { lastNotificationKind: readString(rawSubscription.lastNotificationKind) } : {},
-      ...rawSubscription.lastNotificationPriority === "medium" || rawSubscription.lastNotificationPriority === "high" ? { lastNotificationPriority: rawSubscription.lastNotificationPriority } : {},
-      ...readString(rawSubscription.lastNotificationSummary) ? { lastNotificationSummary: readString(rawSubscription.lastNotificationSummary) } : {}
-    });
-  }
-  return {
-    subscriptions,
-    ...githubSignals.subscriptionHintShown === true ? { subscriptionHintShown: true } : {}
-  };
-}
-function setGithubMetadata(threadMetadata, githubSignals) {
-  const existing = threadMetadata ?? {};
-  const mastra2 = isPlainObject(existing.mastra) ? existing.mastra : {};
-  const existingGithubSignals = isPlainObject(mastra2[GITHUB_SIGNALS_METADATA_KEY]) ? mastra2[GITHUB_SIGNALS_METADATA_KEY] : {};
-  return {
-    ...existing,
-    mastra: {
-      ...mastra2,
-      [GITHUB_SIGNALS_METADATA_KEY]: {
-        ...existingGithubSignals,
-        ...githubSignals
-      }
-    }
-  };
-}
-function getFailingChecks(snapshot) {
-  return (snapshot.checks ?? []).filter((check) => check.conclusion === "failure" || check.conclusion === "timed_out");
-}
-function getPendingChecks(snapshot) {
-  return (snapshot.checks ?? []).filter((check) => check.status && check.status !== "completed");
-}
-function getPrLabel(subscription, snapshot) {
-  const pr = `${subscription.owner}/${subscription.repo}#${subscription.number}`;
-  return snapshot?.title ? `${pr}: ${snapshot.title}` : pr;
-}
-function getMergedNotificationSummary(label) {
-  return `${label} was merged. This thread has been automatically unsubscribed from this PR. Resubscribe if you still need updates.`;
-}
-function getCheckUpdatedTime(check) {
-  const value = check.updatedAt ? Date.parse(check.updatedAt) : Number.NaN;
-  return Number.isFinite(value) ? value : 0;
-}
-function getCheckKey(check) {
-  return `${check.name || "check"}:${check.detailsUrl || check.workflowName || ""}`;
-}
-function normalizeGithubChecksForSnapshot(input) {
-  const latestCheckUpdatedAt = input.checkRows.reduce(
-    (latest, check) => Math.max(latest, getCheckUpdatedTime(check)),
-    0
-  );
-  const rows = [
-    ...input.checkRows,
-    ...input.workflowRows.filter(
-      (workflow) => input.checkRows.length === 0 || getCheckUpdatedTime(workflow) >= latestCheckUpdatedAt
-    )
-  ];
-  const byKey = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const key = getCheckKey(row);
-    const existing = byKey.get(key);
-    if (!existing) {
-      byKey.set(key, row);
-      continue;
-    }
-    const rowTime = getCheckUpdatedTime(row);
-    const existingTime = getCheckUpdatedTime(existing);
-    if (rowTime > existingTime || rowTime === existingTime && existing.source === "workflow" && row.source === "check") {
-      byKey.set(key, row);
-    }
-  }
-  return [...byKey.values()].map(({ source: _source, ...check }) => check).sort((a, b) => `${a.name}:${a.detailsUrl ?? ""}`.localeCompare(`${b.name}:${b.detailsUrl ?? ""}`));
-}
-function isBotOnlyActivity(snapshot) {
-  return snapshot.latestCommentIsBot === true && (!snapshot.ciState || snapshot.ciState === "unknown");
-}
-function stringifyEvidence(value) {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "";
-  }
-}
-function detectPrWorkEvidence(input) {
-  const evidence = [
-    input.text ?? "",
-    ...(input.toolCalls ?? []).map((toolCall) => `${toolCall.toolName} ${stringifyEvidence(toolCall.args)}`)
-  ].join("\n");
-  if (!evidence.trim()) return void 0;
-  const url = /github\.com\/([^\s/#]+)\/([^\s/#]+)\/pull\/(\d+)/i.exec(evidence);
-  if (url?.[1] && url[2] && url[3]) return { owner: url[1], repo: url[2], number: Number(url[3]) };
-  const repoRef = /\b([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)#(\d+)\b/.exec(evidence);
-  if (repoRef?.[1] && repoRef[2] && repoRef[3])
-    return { owner: repoRef[1], repo: repoRef[2], number: Number(repoRef[3]) };
-  const ghCommand = /\bgh\s+(?:pr\s+(?:view|checks|status|comment|diff|checkout)|run\s+(?:rerun|view))\b/i.test(
-    evidence
-  );
-  if (!ghCommand) return void 0;
-  const numberMatch = /(?:^|\s)#?(\d{2,})(?:\s|$)/.exec(evidence);
-  return numberMatch?.[1] ? { number: Number(numberMatch[1]) } : void 0;
-}
-function classifyGithubActivityNotification(input) {
-  const pr = `${input.subscription.owner}/${input.subscription.repo}#${input.subscription.number}`;
-  const label = getPrLabel(input.subscription, input.snapshot);
-  if (input.snapshot.state && input.subscription.lastObservedState !== input.snapshot.state) {
-    if (input.snapshot.state === "merged")
-      return {
-        kind: "pull-request-merged",
-        priority: "high",
-        summary: getMergedNotificationSummary(label)
-      };
-    if (input.snapshot.state === "closed")
-      return { kind: "pull-request-closed", priority: "high", summary: `${label} was closed` };
-    if (input.subscription.lastObservedState && input.snapshot.state === "open")
-      return { kind: "pull-request-reopened", priority: "medium", summary: `${label} was reopened` };
-  }
-  const failingChecks = getFailingChecks(input.snapshot);
-  if (input.snapshot.ciState === "failure" && input.subscription.lastObservedCiState !== "failure") {
-    const names = failingChecks.slice(0, 3).map((check) => check.name).join(", ");
-    return {
-      kind: "pull-request-ci-failure",
-      priority: "high",
-      summary: `${pr} has failing CI${names ? `: ${names}` : ""}`
-    };
-  }
-  if (input.snapshot.mergeableState === "dirty" && input.subscription.lastObservedMergeableState !== "dirty") {
-    return {
-      kind: "pull-request-conflict",
-      priority: "high",
-      summary: `${pr} has merge conflicts${input.snapshot.title ? `: ${input.snapshot.title}` : ""}`
-    };
-  }
-  if (input.snapshot.mergeableState && input.subscription.lastObservedMergeableState === "dirty" && input.snapshot.mergeableState !== "dirty") {
-    return {
-      kind: "pull-request-conflict-resolved",
-      priority: "medium",
-      summary: `${pr} merge conflicts were resolved`
-    };
-  }
-  if (input.snapshot.mergeableState === "dirty") return void 0;
-  if (input.snapshot.ciState === "success" && input.subscription.lastObservedCiState && input.subscription.lastObservedCiState !== "success") {
-    return { kind: "pull-request-ci-recovered", priority: "medium", summary: `${pr} CI recovered` };
-  }
-  if (input.snapshot.reviewStateHash && input.subscription.lastObservedReviewStateHash && input.snapshot.reviewStateHash !== input.subscription.lastObservedReviewStateHash && (input.snapshot.unresolvedReviewThreads ?? 0) > 0) {
-    return {
-      kind: "pull-request-review-activity",
-      priority: "medium",
-      summary: `${pr} has ${input.snapshot.unresolvedReviewThreads} unresolved review thread${input.snapshot.unresolvedReviewThreads === 1 ? "" : "s"}`
-    };
-  }
-  const pendingChecks = getPendingChecks(input.snapshot);
-  if (input.snapshot.ciState === "pending" && input.subscription.lastObservedCiState !== "pending" && pendingChecks.length > 0) {
-    const names = pendingChecks.slice(0, 3).map((check) => check.name).join(", ");
-    return {
-      kind: "pull-request-ci-pending",
-      priority: "medium",
-      summary: `${pr} has CI still running${names ? `: ${names}` : ""}`
-    };
-  }
-  if (input.snapshot.ciState === "pending" && input.subscription.lastObservedCiState === "pending") return void 0;
-  if (isBotOnlyActivity(input.snapshot)) return void 0;
-  return {
-    kind: "pull-request-activity",
-    priority: "medium",
-    summary: `${pr} has new activity${input.snapshot.title ? `: ${input.snapshot.title}` : ""}`
-  };
-}
-function classifyGithubBaselineNotification(input) {
-  const pr = `${input.subscription.owner}/${input.subscription.repo}#${input.subscription.number}`;
-  const failingChecks = getFailingChecks(input.snapshot);
-  const reviewCount = input.snapshot.unresolvedReviewThreads ?? 0;
-  const high = input.snapshot.ciState === "failure" || input.snapshot.mergeableState === "dirty";
-  const details = [
-    input.snapshot.state ? `state: ${input.snapshot.state}` : void 0,
-    input.snapshot.ciState && input.snapshot.ciState !== "unknown" ? `CI: ${input.snapshot.ciState}` : void 0,
-    input.snapshot.mergeableState ? `mergeability: ${input.snapshot.mergeableState}` : void 0,
-    reviewCount > 0 ? `${reviewCount} unresolved review thread${reviewCount === 1 ? "" : "s"}` : void 0,
-    failingChecks.length > 0 ? `failing: ${failingChecks.slice(0, 3).map((check) => check.name).join(", ")}` : void 0
-  ].filter(Boolean);
-  return {
-    kind: "pull-request-baseline",
-    priority: high ? "high" : "medium",
-    summary: `${pr} subscribed${input.snapshot.title ? `: ${input.snapshot.title}` : ""}${details.length ? ` (${details.join("; ")})` : ""}`
-  };
-}
-function applySnapshotCursor(subscription, snapshot) {
-  if (snapshot.githubUpdatedAt) subscription.lastObservedGithubUpdatedAt = snapshot.githubUpdatedAt;
-  if (snapshot.contentHash) subscription.lastObservedContentHash = snapshot.contentHash;
-  if (snapshot.threadContentHash) subscription.lastObservedThreadContentHash = snapshot.threadContentHash;
-  if (snapshot.headSha) subscription.lastObservedHeadSha = snapshot.headSha;
-  if (snapshot.state) subscription.lastObservedState = snapshot.state;
-  if (snapshot.mergeableState) subscription.lastObservedMergeableState = snapshot.mergeableState;
-  if (snapshot.ciState) subscription.lastObservedCiState = snapshot.ciState;
-  if (snapshot.reviewStateHash) subscription.lastObservedReviewStateHash = snapshot.reviewStateHash;
-}
-function parseGitHubRemoteUrl(remoteUrl) {
-  const trimmed = remoteUrl.trim().replace(/\.git$/, "");
-  const httpsMatch = /^https:\/\/github\.com\/([^/]+)\/([^/]+)$/.exec(trimmed);
-  if (httpsMatch?.[1] && httpsMatch[2]) return { owner: httpsMatch[1], repo: httpsMatch[2] };
-  const sshMatch = /^git@github\.com:([^/]+)\/([^/]+)$/.exec(trimmed);
-  if (sshMatch?.[1] && sshMatch[2]) return { owner: sshMatch[1], repo: sshMatch[2] };
-  return void 0;
-}
-var GitRemoteRepositoryResolver = class {
-  async resolveRepository(input) {
-    try {
-      const { stdout } = await execFileAsync("git", ["remote", "get-url", "origin"], {
-        cwd: input.cwd,
-        signal: input.abortSignal
-      });
-      return parseGitHubRemoteUrl(stdout);
-    } catch {
-      return void 0;
-    }
-  }
-};
-var GitcrawlSyncClient = class {
-  #command;
-  constructor(options = {}) {
-    this.#command = options.command ?? "gitcrawl";
-  }
-  async syncPullRequest(input) {
-    try {
-      const args = [
-        "sync",
-        `${input.owner}/${input.repo}`,
-        "--numbers",
-        String(input.number),
-        ...input.includeComments === false ? [] : ["--include-comments"],
-        "--with",
-        "pr-details",
-        "--json"
-      ];
-      const { stdout, stderr } = await execFileAsync(this.#command, args, {
-        cwd: input.cwd,
-        signal: input.abortSignal,
-        maxBuffer: 10 * 1024 * 1024
-      });
-      return { ok: true, stdout, stderr };
-    } catch (error) {
-      return { ok: false, error: error instanceof Error ? error.message : String(error) };
-    }
-  }
-  async getPullRequestSnapshot(input) {
-    try {
-      const { stdout } = await execFileAsync(
-        this.#command,
-        ["threads", `${input.owner}/${input.repo}`, "--numbers", String(input.number), "--json"],
-        {
-          cwd: input.cwd,
-          signal: input.abortSignal,
-          maxBuffer: 10 * 1024 * 1024
-        }
-      );
-      const parsed = JSON.parse(stdout);
-      const thread = parsed.threads?.find((item) => readNumber(item.number) === input.number);
-      if (!thread) return void 0;
-      const owner = sqlString(input.owner);
-      const repo = sqlString(input.repo);
-      const number = input.number;
-      const [threadDetails] = await queryGitcrawlDb(`select t.state, t.closed_at_gh, t.merged_at_gh
-          from threads t
-          join repositories r on r.id=t.repo_id
-         where r.owner=${owner} and r.name=${repo} and t.number=${number}
-         limit 1`);
-      const [details] = await queryGitcrawlDb(`select d.head_sha, d.head_ref, d.mergeable_state,
-                 json_extract(d.raw_json, '$.merged_at') as merged_at
-          from pull_request_details d
-          join threads t on t.id=d.thread_id
-          join repositories r on r.id=t.repo_id
-         where r.owner=${owner} and r.name=${repo} and t.number=${number}
-         limit 1`);
-      const headSha = readString(details?.head_sha);
-      const checkRows = await queryGitcrawlDb(`select c.name, c.status, c.conclusion, c.workflow_name, c.details_url,
-                 coalesce(c.completed_at, c.started_at, c.fetched_at) as updated_at
-            from pull_request_checks c
-            join threads t on t.id=c.thread_id
-            join repositories r on r.id=t.repo_id
-           where r.owner=${owner} and r.name=${repo} and t.number=${number}${headSha ? ` and json_extract(c.raw_json, '$.head_sha')=${sqlString(headSha)}` : ""}`);
-      const workflowRows = details?.head_sha ? await queryGitcrawlDb(`select workflow_name, status, conclusion, html_url, updated_at_gh
-                from github_workflow_runs w
-                join repositories r on r.id=w.repo_id
-               where r.owner=${owner} and r.name=${repo} and w.head_sha=${sqlString(details.head_sha)}`) : [];
-      const [reviewState] = await queryGitcrawlDb(`select count(*) as unresolved_count,
-                 max(coalesce(first_comment_updated_at, first_comment_created_at, fetched_at)) as latest_review_thread_at
-            from pull_request_review_threads rt
-            join threads t on t.id=rt.thread_id
-            join repositories r on r.id=t.repo_id
-           where r.owner=${owner} and r.name=${repo} and t.number=${number} and rt.is_resolved=0`);
-      const [latestComment] = await queryGitcrawlDb(`select c.author_login, c.author_type, c.is_bot
-            from comments c
-            join threads t on t.id=c.thread_id
-            join repositories r on r.id=t.repo_id
-           where r.owner=${owner} and r.name=${repo} and t.number=${number}
-           order by coalesce(c.updated_at_gh, c.created_at_gh) desc
-           limit 1`);
-      const checks = normalizeGithubChecksForSnapshot({
-        checkRows: checkRows.map((row) => ({
-          source: "check",
-          name: readString(row.name) ?? "check",
-          status: readString(row.status),
-          conclusion: readString(row.conclusion),
-          workflowName: readString(row.workflow_name),
-          detailsUrl: readString(row.details_url),
-          updatedAt: readString(row.updated_at)
-        })),
-        workflowRows: workflowRows.map((row) => ({
-          source: "workflow",
-          name: readString(row.workflow_name) ?? "workflow",
-          status: readString(row.status),
-          conclusion: readString(row.conclusion),
-          workflowName: readString(row.workflow_name),
-          detailsUrl: readString(row.html_url),
-          updatedAt: readString(row.updated_at_gh)
-        }))
-      });
-      const ciState = checks.some((check) => check.conclusion === "failure" || check.conclusion === "timed_out") ? "failure" : checks.some((check) => check.status && check.status !== "completed") ? "pending" : checks.length > 0 ? "success" : "unknown";
-      const threadContentHash = readString(thread.content_hash);
-      const unresolvedReviewThreads = Number(reviewState?.unresolved_count ?? 0);
-      const reviewStateHash = snapshotHash({
-        unresolvedReviewThreads,
-        latestReviewThreadAt: reviewState?.latest_review_thread_at
-      });
-      const contentHash = snapshotHash({
-        threadContentHash,
-        state: thread.state,
-        headSha: details?.head_sha,
-        mergeableState: details?.mergeable_state,
-        ciState,
-        reviewStateHash,
-        checks: checks.map((check) => ({
-          name: check.name,
-          status: check.status,
-          conclusion: check.conclusion,
-          detailsUrl: check.detailsUrl,
-          updatedAt: check.updatedAt
-        }))
-      });
-      return {
-        title: readString(thread.title),
-        state: readString(details?.merged_at) || readString(threadDetails?.merged_at_gh) ? "merged" : readString(threadDetails?.state) ?? readString(thread.state),
-        htmlUrl: readString(thread.html_url),
-        githubUpdatedAt: readString(thread.updated_at_gh),
-        closedAt: readString(threadDetails?.closed_at_gh),
-        mergedAt: readString(details?.merged_at) ?? readString(threadDetails?.merged_at_gh),
-        threadContentHash,
-        contentHash,
-        headSha: readString(details?.head_sha),
-        headRef: readString(details?.head_ref),
-        mergeableState: readString(details?.mergeable_state),
-        checks,
-        ciState,
-        unresolvedReviewThreads,
-        reviewStateHash,
-        latestReviewThreadAt: readString(reviewState?.latest_review_thread_at),
-        latestCommentAuthor: readString(latestComment?.author_login),
-        latestCommentAuthorType: readString(latestComment?.author_type),
-        latestCommentIsBot: latestComment?.is_bot === 1
-      };
-    } catch {
-      return void 0;
-    }
-  }
-};
-var GithubSignals = class {
-  id = "github-signals";
-  name = "GitHub Signals";
-  mastra;
-  static signals = {
-    subscribeToPR(input) {
-      const normalized = typeof input === "number" ? { number: input } : input;
-      return {
-        type: "reactive",
-        tagName: GITHUB_SUBSCRIBE_PR_TAG,
-        contents: `Subscribe to GitHub PR #${normalized.number}`,
-        attributes: {
-          ...normalized.owner ? { owner: normalized.owner } : {},
-          ...normalized.repo ? { repo: normalized.repo } : {},
-          number: normalized.number
-        },
-        metadata: {
-          github: {
-            action: "subscribeToPR",
-            ...normalized
-          }
-        }
-      };
-    },
-    unsubscribeFromPR(input) {
-      const normalized = typeof input === "number" ? { number: input } : input;
-      return {
-        type: "reactive",
-        tagName: GITHUB_UNSUBSCRIBE_PR_TAG,
-        contents: `Unsubscribe from GitHub PR #${normalized.number}`,
-        attributes: {
-          ...normalized.owner ? { owner: normalized.owner } : {},
-          ...normalized.repo ? { repo: normalized.repo } : {},
-          number: normalized.number
-        },
-        metadata: {
-          github: {
-            action: "unsubscribeFromPR",
-            ...normalized
-          }
-        }
-      };
-    }
-  };
-  #options;
-  #syncClient;
-  #repositoryResolver;
-  #polling = /* @__PURE__ */ new Map();
-  #agent;
-  #agentOptions = {};
-  #subscriptionsChangedHandler;
-  constructor(options = {}) {
-    this.#options = options;
-    this.#syncClient = options.syncClient ?? new GitcrawlSyncClient({ command: options.gitcrawlCommand });
-    this.#repositoryResolver = options.repositoryResolver ?? new GitRemoteRepositoryResolver();
-  }
-  addAgent(agent, options = {}) {
-    this.#agent = agent;
-    this.#agentOptions = options;
-  }
-  onSubscriptionsChanged(handler) {
-    this.#subscriptionsChangedHandler = handler;
-  }
-  __registerMastra(mastra2) {
-    this.mastra = mastra2;
-  }
-  async syncThreadNow(input) {
-    return this.#pollThread(input, { includeComments: true });
-  }
-  async subscribeThreadToPR(input) {
-    const pr = typeof input.pr === "number" ? { number: input.pr } : input.pr;
-    return this.#subscribe({
-      id: `github-command-subscribe-${crypto.randomUUID()}`,
-      ...pr,
-      threadId: input.threadId,
-      resourceId: input.resourceId
-    });
-  }
-  async unsubscribeThreadFromPR(input) {
-    const pr = typeof input.pr === "number" ? { number: input.pr } : input.pr;
-    return this.#unsubscribe({
-      id: `github-command-unsubscribe-${crypto.randomUUID()}`,
-      ...pr,
-      threadId: input.threadId,
-      resourceId: input.resourceId
-    });
-  }
-  async startPollingForThread(input, options = {}) {
-    const subscriptions = await this.#getThreadSubscriptions(input);
-    if (subscriptions.length === 0) {
-      this.stopPollingForThread(input);
-      return false;
-    }
-    const key = this.#pollingKey(input);
-    for (const [pollingKey, state] of this.#polling.entries()) {
-      if (pollingKey === key) continue;
-      clearInterval(state.timer);
-      this.#polling.delete(pollingKey);
-    }
-    if (this.#polling.has(key)) return true;
-    let scheduledPollCount = options.pollImmediately ? 1 : 0;
-    const runPoll = (pollOptions = {}) => {
-      void this.#pollThread(input, pollOptions).catch((error) => {
-        console.warn("GitHub PR polling failed:", error);
-      });
-    };
-    const timer = setInterval(() => {
-      scheduledPollCount += 1;
-      runPoll({ includeComments: scheduledPollCount % 2 === 1 });
-    }, this.#options.pollIntervalMs ?? 3e5);
-    if (options.pollImmediately) runPoll({ includeComments: true });
-    timer.unref?.();
-    this.#polling.set(key, { ...input, timer, running: false });
-    return true;
-  }
-  stopPollingForThread(input) {
-    const key = this.#pollingKey(input);
-    const state = this.#polling.get(key);
-    if (!state) return;
-    clearInterval(state.timer);
-    this.#polling.delete(key);
-  }
-  isPollingThread(input) {
-    return this.#polling.has(this.#pollingKey(input));
-  }
-  getPollIntervalMs() {
-    return this.#options.pollIntervalMs ?? 3e5;
-  }
-  stopAllPolling() {
-    for (const state of this.#polling.values()) clearInterval(state.timer);
-    this.#polling.clear();
-  }
-  async pollThreadNow(input) {
-    return this.#pollThread(input, { includeComments: true });
-  }
-  async processInputStep(args) {
-    const tools = this.#createTools(args);
-    if (args.stepNumber !== 0) return { tools };
-    const signal = this.#findLatestGithubSignal(args.messages);
-    if (!signal) return { tools };
-    const threadContext = this.#getThreadContext(args);
-    if (signal.tagName === GITHUB_UNSUBSCRIBE_PR_TAG) {
-      const result2 = await this.#unsubscribe({ ...signal, ...threadContext, abortSignal: args.abortSignal });
-      await this.#sendStatus(args, result2, {
-        status: result2.removed ? "unsubscribed" : "not_subscribed",
-        action: "unsubscribeFromPR",
-        message: result2.removed ? `Unsubscribed from ${result2.owner}/${result2.repo}#${result2.number}.` : `No GitHub subscription found for ${result2.owner}/${result2.repo}#${result2.number}.`
-      });
-      return { tools };
-    }
-    const result = await this.#subscribe({ ...signal, ...threadContext, abortSignal: args.abortSignal });
-    if (result.alreadyProcessed) return { tools };
-    await this.#sendStatus(args, result, {
-      status: result.syncResult?.ok === false ? "sync_error" : "subscribed",
-      action: "subscribeToPR",
-      message: result.syncResult?.ok === false ? `Subscribed to ${result.owner}/${result.repo}#${result.number}, but gitcrawl sync failed: ${result.syncResult.error}` : `Subscribed to ${result.owner}/${result.repo}#${result.number}.`
-    });
-    return { tools };
-  }
-  async processOutputStep(args) {
-    const evidence = detectPrWorkEvidence({ text: args.text, toolCalls: args.toolCalls });
-    if (!evidence) return args.messages;
-    const threadContext = this.#getThreadContext(args);
-    if (!threadContext.threadId || !threadContext.resourceId) return args.messages;
-    const { threadStore, loadedThread } = await this.#loadThread(threadContext);
-    const githubMetadata = getGithubMetadata(loadedThread.metadata);
-    if (githubMetadata.subscriptionHintShown || githubMetadata.subscriptions.length > 0) return args.messages;
-    let repository;
-    try {
-      repository = await this.#resolveRepository({
-        id: "github-subscription-hint",
-        owner: evidence.owner,
-        repo: evidence.repo,
-        number: evidence.number
-      });
-    } catch {
-      return args.messages;
-    }
-    await threadStore.saveThread({
-      thread: {
-        ...loadedThread,
-        id: threadContext.threadId,
-        resourceId: threadContext.resourceId,
-        createdAt: loadedThread.createdAt ?? /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date(),
-        metadata: setGithubMetadata(loadedThread.metadata, { ...githubMetadata, subscriptionHintShown: true })
-      }
-    });
-    await args.sendSignal?.({
-      type: "reactive",
-      tagName: "system-reminder",
-      contents: `Looks like you're working with ${repository.owner}/${repository.repo}#${evidence.number}. Use /github subscribe ${evidence.number} or the github_subscribe_pr tool to follow updates.`,
-      attributes: { type: "github-subscription-hint" },
-      metadata: {
-        github: {
-          action: "subscriptionHint",
-          owner: repository.owner,
-          repo: repository.repo,
-          number: evidence.number
-        }
-      }
-    });
-    return args.messages;
-  }
-  async #resolveThreadStore() {
-    if (this.#options.threadStore) return this.#options.threadStore;
-    const storage = this.mastra?.getStorage?.();
-    const memoryStore = storage?.getStore ? await storage.getStore("memory") : void 0;
-    return memoryStore;
-  }
-  #getThreadContext(args) {
-    const memoryContext = args.requestContext?.get("MastraMemory");
-    return { threadId: memoryContext?.thread?.id, resourceId: memoryContext?.resourceId };
-  }
-  #createTools(args) {
-    const threadContext = this.#getThreadContext(args);
-    return {
-      ...args.tools,
-      github_subscribe_pr: createGithubTool({
-        id: "github_subscribe_pr",
-        description: "Subscribe this thread to a GitHub pull request. Syncs only the requested PR with gitcrawl and stores the subscription on the thread.",
-        inputSchema: z__default.default.object({
-          number: z__default.default.number().int().positive(),
-          owner: z__default.default.string().optional(),
-          repo: z__default.default.string().optional()
-        }),
-        execute: async (input) => {
-          const result = await this.#subscribe({
-            id: `github-tool-subscribe-${crypto.randomUUID()}`,
-            owner: input.owner,
-            repo: input.repo,
-            number: input.number,
-            threadId: threadContext.threadId,
-            resourceId: threadContext.resourceId
-          });
-          return {
-            subscribed: true,
-            owner: result.owner,
-            repo: result.repo,
-            number: result.number,
-            syncStatus: result.syncResult?.ok === false ? "error" : result.syncResult ? "success" : void 0,
-            message: result.syncResult?.ok === false ? `Subscribed to ${result.owner}/${result.repo}#${result.number}, but gitcrawl sync failed: ${result.syncResult.error}` : `Subscribed to ${result.owner}/${result.repo}#${result.number}.`
-          };
-        }
-      }),
-      github_unsubscribe_pr: createGithubTool({
-        id: "github_unsubscribe_pr",
-        description: "Unsubscribe this thread from a GitHub pull request.",
-        inputSchema: z__default.default.object({
-          number: z__default.default.number().int().positive(),
-          owner: z__default.default.string().optional(),
-          repo: z__default.default.string().optional()
-        }),
-        execute: async (input) => {
-          const result = await this.#unsubscribe({
-            id: `github-tool-unsubscribe-${crypto.randomUUID()}`,
-            owner: input.owner,
-            repo: input.repo,
-            number: input.number,
-            threadId: threadContext.threadId,
-            resourceId: threadContext.resourceId
-          });
-          return {
-            unsubscribed: result.removed ?? false,
-            owner: result.owner,
-            repo: result.repo,
-            number: result.number,
-            remainingSubscriptions: result.remainingSubscriptions,
-            message: result.removed ? `Unsubscribed from ${result.owner}/${result.repo}#${result.number}.` : `No GitHub subscription found for ${result.owner}/${result.repo}#${result.number}.`
-          };
-        }
-      })
-    };
-  }
-  async #resolveRepository(input) {
-    const resolvedRepository = input.owner && input.repo ? { owner: input.owner, repo: input.repo } : this.#options.owner && this.#options.repo ? { owner: this.#options.owner, repo: this.#options.repo } : await this.#repositoryResolver.resolveRepository({
-      cwd: this.#options.cwd,
-      abortSignal: input.abortSignal
-    });
-    if (!resolvedRepository?.owner || !resolvedRepository.repo) {
-      throw new Error(
-        "GitHub PR subscription requires owner and repo. Run inside a GitHub repo or pass owner and repo."
-      );
-    }
-    return resolvedRepository;
-  }
-  async #loadThread(input) {
-    const threadStore = await this.#resolveThreadStore();
-    if (!threadStore) throw new Error("GitHub PR subscription requires memory-backed thread storage.");
-    if (!input.threadId || !input.resourceId)
-      throw new Error("GitHub PR subscription requires threadId and resourceId.");
-    const loadedThread = await threadStore.getThreadById({ threadId: input.threadId, resourceId: input.resourceId }) ?? void 0;
-    if (!loadedThread) throw new Error(`Could not load thread ${input.threadId}.`);
-    return { threadStore, loadedThread };
-  }
-  #pollingKey(input) {
-    return `${input.resourceId}:${input.threadId}`;
-  }
-  #getNotificationAgent(_input) {
-    if (this.#agent) return this.#agent;
-    const agentId = _input?.agentId ?? this.#options.agentId;
-    return agentId ? this.mastra?.getAgentById?.(agentId) : void 0;
-  }
-  async #getThreadSubscriptions(input) {
-    const { loadedThread } = await this.#loadThread(input);
-    return getGithubMetadata(loadedThread.metadata).subscriptions;
-  }
-  #notifySubscriptionsChanged(input) {
-    this.#subscriptionsChangedHandler?.(input);
-  }
-  async #pollThread(input, options = {}) {
-    const key = this.#pollingKey(input);
-    const state = this.#polling.get(key);
-    if (state?.running) {
-      return 0;
-    }
-    if (state) state.running = true;
-    try {
-      const { threadStore, loadedThread } = await this.#loadThread(input);
-      const githubMetadata = getGithubMetadata(loadedThread.metadata);
-      if (githubMetadata.subscriptions.length === 0) {
-        this.stopPollingForThread(input);
-        return 0;
-      }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const subscriptions = [];
-      for (const subscription of githubMetadata.subscriptions) {
-        const syncInput = {
-          owner: subscription.owner,
-          repo: subscription.repo,
-          number: subscription.number,
-          cwd: this.#options.cwd,
-          includeComments: options.includeComments
-        };
-        const syncResult = await this.#syncClient.syncPullRequest(syncInput);
-        const snapshot = syncResult.ok ? await this.#syncClient.getPullRequestSnapshot?.(syncInput) : void 0;
-        const nextSubscription = {
-          ...subscription,
-          updatedAt: now,
-          lastSyncAt: now,
-          lastSyncStatus: syncResult.ok ? "success" : "error"
-        };
-        if (syncResult.error) nextSubscription.lastSyncError = syncResult.error;
-        else delete nextSubscription.lastSyncError;
-        const previousGithubUpdatedAt = subscription.lastObservedGithubUpdatedAt;
-        const previousContentHash = subscription.lastObservedContentHash;
-        const previousThreadContentHash = subscription.lastObservedThreadContentHash;
-        const previousHeadSha = subscription.lastObservedHeadSha;
-        if (snapshot) applySnapshotCursor(nextSubscription, snapshot);
-        const isFirstObservation = syncResult.ok && snapshot && !previousGithubUpdatedAt && !previousContentHash;
-        const legacyAggregateChanged = previousContentHash && snapshot?.contentHash && previousContentHash !== snapshot.contentHash && !previousThreadContentHash && !previousHeadSha;
-        const changed = isFirstObservation || syncResult.ok && snapshot && (legacyAggregateChanged || previousThreadContentHash && snapshot.threadContentHash && previousThreadContentHash !== snapshot.threadContentHash || previousHeadSha && snapshot.headSha && previousHeadSha !== snapshot.headSha || subscription.lastObservedState && snapshot.state && subscription.lastObservedState !== snapshot.state || subscription.lastObservedMergeableState && snapshot.mergeableState && subscription.lastObservedMergeableState !== snapshot.mergeableState || subscription.lastObservedCiState && snapshot.ciState && subscription.lastObservedCiState !== snapshot.ciState || subscription.lastObservedReviewStateHash && snapshot.reviewStateHash && subscription.lastObservedReviewStateHash !== snapshot.reviewStateHash);
-        let shouldKeepSubscription = true;
-        if (changed) {
-          const notification = await this.#sendActivityNotification({
-            polling: input,
-            subscription,
-            snapshot,
-            previousGithubUpdatedAt,
-            previousContentHash
-          });
-          if (notification) {
-            nextSubscription.lastNotificationAt = now;
-            nextSubscription.lastNotificationKind = notification.kind;
-            nextSubscription.lastNotificationPriority = notification.priority;
-            nextSubscription.lastNotificationSummary = notification.summary;
-            shouldKeepSubscription = notification.kind !== "pull-request-merged";
-          }
-        }
-        if (shouldKeepSubscription) subscriptions.push(nextSubscription);
-      }
-      await threadStore.saveThread({
-        thread: {
-          ...loadedThread,
-          id: input.threadId,
-          resourceId: input.resourceId,
-          createdAt: loadedThread.createdAt ?? /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date(),
-          metadata: setGithubMetadata(loadedThread.metadata, { subscriptions })
-        }
-      });
-      this.#notifySubscriptionsChanged({ threadId: input.threadId, resourceId: input.resourceId, subscriptions });
-      if (subscriptions.length === 0) this.stopPollingForThread(input);
-      return subscriptions.length;
-    } catch (error) {
-      throw error;
-    } finally {
-      const latestState = this.#polling.get(key);
-      if (latestState) latestState.running = false;
-    }
-  }
-  async #sendGithubNotification(input) {
-    const failingChecks = getFailingChecks(input.snapshot);
-    const pendingChecks = getPendingChecks(input.snapshot);
-    const notificationInput = {
-      source: "github",
-      kind: input.notification.kind,
-      priority: input.notification.priority,
-      summary: input.notification.summary,
-      dedupeKey: `github:${input.subscription.owner}/${input.subscription.repo}#${input.subscription.number}:${input.dedupeSuffix}`,
-      coalesceKey: `github:${input.subscription.owner}/${input.subscription.repo}#${input.subscription.number}:${input.notification.kind}`,
-      attributes: {
-        owner: input.subscription.owner,
-        repo: input.subscription.repo,
-        number: input.subscription.number,
-        ...input.snapshot.title ? { title: input.snapshot.title } : {},
-        ...input.snapshot.state ? { state: input.snapshot.state } : {},
-        ...input.snapshot.htmlUrl ? { url: input.snapshot.htmlUrl } : {},
-        ...input.snapshot.githubUpdatedAt ? { githubUpdatedAt: input.snapshot.githubUpdatedAt } : {},
-        ...input.previousGithubUpdatedAt ? { previousGithubUpdatedAt: input.previousGithubUpdatedAt } : {},
-        ...input.snapshot.mergeableState ? { mergeableState: input.snapshot.mergeableState } : {},
-        ...input.snapshot.ciState ? { ciState: input.snapshot.ciState } : {},
-        ...input.snapshot.unresolvedReviewThreads !== void 0 ? { unresolvedReviewThreads: input.snapshot.unresolvedReviewThreads } : {},
-        ...failingChecks.length > 0 ? { failingChecks: failingChecks.map((check) => check.name).join(", ") } : {},
-        ...pendingChecks.length > 0 ? { pendingChecks: pendingChecks.map((check) => check.name).join(", ") } : {}
-      },
-      metadata: {
-        github: {
-          owner: input.subscription.owner,
-          repo: input.subscription.repo,
-          number: input.subscription.number,
-          title: input.snapshot.title,
-          state: input.snapshot.state,
-          htmlUrl: input.snapshot.htmlUrl,
-          githubUpdatedAt: input.snapshot.githubUpdatedAt,
-          previousGithubUpdatedAt: input.previousGithubUpdatedAt,
-          contentHash: input.snapshot.contentHash,
-          previousContentHash: input.previousContentHash,
-          threadContentHash: input.snapshot.threadContentHash,
-          headSha: input.snapshot.headSha,
-          headRef: input.snapshot.headRef,
-          mergeableState: input.snapshot.mergeableState,
-          ciState: input.snapshot.ciState,
-          closedAt: input.snapshot.closedAt,
-          mergedAt: input.snapshot.mergedAt,
-          unresolvedReviewThreads: input.snapshot.unresolvedReviewThreads,
-          reviewStateHash: input.snapshot.reviewStateHash,
-          latestReviewThreadAt: input.snapshot.latestReviewThreadAt,
-          latestCommentAuthor: input.snapshot.latestCommentAuthor,
-          latestCommentAuthorType: input.snapshot.latestCommentAuthorType,
-          latestCommentIsBot: input.snapshot.latestCommentIsBot,
-          failingChecks,
-          pendingChecks
-        }
-      }
-    };
-    const streamOptions = await this.#agentOptions.getNotificationStreamOptions?.(input.target);
-    await input.agent?.sendNotificationSignal?.(
-      notificationInput,
-      streamOptions ? { ...input.target, ifIdle: { streamOptions } } : input.target
-    );
-  }
-  async #sendBaselineNotification(input) {
-    const agent = this.#getNotificationAgent({});
-    if (!agent?.sendNotificationSignal) return;
-    await this.#sendGithubNotification({
-      agent,
-      subscription: input.subscription,
-      snapshot: input.snapshot,
-      notification: classifyGithubBaselineNotification({ subscription: input.subscription, snapshot: input.snapshot }),
-      target: { resourceId: input.resourceId, threadId: input.threadId },
-      dedupeSuffix: `baseline:${input.subscription.lastSubscribeSignalId}`
-    });
-  }
-  async #sendActivityNotification(input) {
-    const agent = this.#getNotificationAgent(input.polling);
-    if (!agent?.sendNotificationSignal) return void 0;
-    const notification = classifyGithubActivityNotification({
-      subscription: input.subscription,
-      snapshot: input.snapshot
-    });
-    if (!notification) return void 0;
-    await this.#sendGithubNotification({
-      agent,
-      subscription: input.subscription,
-      snapshot: input.snapshot,
-      notification,
-      target: { resourceId: input.polling.resourceId, threadId: input.polling.threadId },
-      dedupeSuffix: input.snapshot.contentHash ?? input.snapshot.githubUpdatedAt ?? String(Date.now()),
-      previousGithubUpdatedAt: input.previousGithubUpdatedAt,
-      previousContentHash: input.previousContentHash
-    });
-    return notification;
-  }
-  async #subscribe(input) {
-    const { owner, repo } = await this.#resolveRepository(input);
-    const { threadStore, loadedThread } = await this.#loadThread(input);
-    const githubMetadata = getGithubMetadata(loadedThread.metadata);
-    const existingIndex = githubMetadata.subscriptions.findIndex(
-      (subscription2) => subscription2.owner === owner && subscription2.repo === repo && subscription2.number === input.number
-    );
-    const existing = existingIndex >= 0 ? githubMetadata.subscriptions[existingIndex] : void 0;
-    if (existing?.lastSubscribeSignalId === input.id) {
-      return { owner, repo, number: input.number, subscription: existing, alreadyProcessed: true };
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const subscription = {
-      owner,
-      repo,
-      number: input.number,
-      subscribedAt: existing?.subscribedAt ?? now,
-      updatedAt: now,
-      lastSubscribeSignalId: input.id,
-      ...existing?.lastSyncAt ? { lastSyncAt: existing.lastSyncAt } : {},
-      ...existing?.lastSyncStatus ? { lastSyncStatus: existing.lastSyncStatus } : {},
-      ...existing?.lastSyncError ? { lastSyncError: existing.lastSyncError } : {},
-      ...existing?.lastObservedGithubUpdatedAt ? { lastObservedGithubUpdatedAt: existing.lastObservedGithubUpdatedAt } : {},
-      ...existing?.lastObservedContentHash ? { lastObservedContentHash: existing.lastObservedContentHash } : {},
-      ...existing?.lastObservedThreadContentHash ? { lastObservedThreadContentHash: existing.lastObservedThreadContentHash } : {},
-      ...existing?.lastObservedHeadSha ? { lastObservedHeadSha: existing.lastObservedHeadSha } : {},
-      ...existing?.lastObservedState ? { lastObservedState: existing.lastObservedState } : {},
-      ...existing?.lastObservedMergeableState ? { lastObservedMergeableState: existing.lastObservedMergeableState } : {},
-      ...existing?.lastObservedCiState ? { lastObservedCiState: existing.lastObservedCiState } : {},
-      ...existing?.lastObservedReviewStateHash ? { lastObservedReviewStateHash: existing.lastObservedReviewStateHash } : {}
-    };
-    let syncResult;
-    let baselineSnapshot;
-    if (this.#options.syncOnSubscribe !== false) {
-      const syncInput = {
-        owner,
-        repo,
-        number: input.number,
-        cwd: this.#options.cwd,
-        abortSignal: input.abortSignal
-      };
-      syncResult = await this.#syncClient.syncPullRequest(syncInput);
-      subscription.lastSyncAt = (/* @__PURE__ */ new Date()).toISOString();
-      subscription.lastSyncStatus = syncResult.ok ? "success" : "error";
-      if (syncResult.error) subscription.lastSyncError = syncResult.error;
-      else delete subscription.lastSyncError;
-      const snapshot = syncResult.ok ? await this.#syncClient.getPullRequestSnapshot?.(syncInput) : void 0;
-      baselineSnapshot = snapshot;
-      if (snapshot) applySnapshotCursor(subscription, snapshot);
-    } else {
-      subscription.lastSyncStatus = "skipped";
-    }
-    const subscriptions = [subscription];
-    await threadStore.saveThread({
-      thread: {
-        ...loadedThread,
-        id: input.threadId,
-        resourceId: input.resourceId,
-        createdAt: loadedThread.createdAt ?? /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date(),
-        metadata: setGithubMetadata(loadedThread.metadata, { subscriptions })
-      }
-    });
-    this.#notifySubscriptionsChanged({ threadId: input.threadId, resourceId: input.resourceId, subscriptions });
-    if (baselineSnapshot) {
-      await this.#sendBaselineNotification({
-        threadId: input.threadId,
-        resourceId: input.resourceId,
-        subscription,
-        snapshot: baselineSnapshot
-      });
-    }
-    await this.startPollingForThread({ threadId: input.threadId, resourceId: input.resourceId });
-    return { owner, repo, number: input.number, subscription, syncResult };
-  }
-  async #unsubscribe(input) {
-    const { owner, repo } = await this.#resolveRepository(input);
-    const { threadStore, loadedThread } = await this.#loadThread(input);
-    const githubMetadata = getGithubMetadata(loadedThread.metadata);
-    const subscriptions = githubMetadata.subscriptions.filter(
-      (subscription) => !(subscription.owner === owner && subscription.repo === repo && subscription.number === input.number)
-    );
-    const removed = subscriptions.length !== githubMetadata.subscriptions.length;
-    if (removed) {
-      await threadStore.saveThread({
-        thread: {
-          ...loadedThread,
-          id: input.threadId,
-          resourceId: input.resourceId,
-          createdAt: loadedThread.createdAt ?? /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date(),
-          metadata: setGithubMetadata(loadedThread.metadata, { subscriptions })
-        }
-      });
-      this.#notifySubscriptionsChanged({ threadId: input.threadId, resourceId: input.resourceId, subscriptions });
-      if (subscriptions.length === 0)
-        this.stopPollingForThread({ threadId: input.threadId, resourceId: input.resourceId });
-    }
-    return { owner, repo, number: input.number, removed, remainingSubscriptions: subscriptions.length };
-  }
-  #findLatestGithubSignal(messages) {
-    const message = messages.at(-1);
-    if (!message) return void 0;
-    const signal = getSignalMetadata(message);
-    if (!signal || signal.tagName !== GITHUB_SUBSCRIBE_PR_TAG && signal.tagName !== GITHUB_UNSUBSCRIBE_PR_TAG) {
-      return void 0;
-    }
-    const attributes = isPlainObject(signal.attributes) ? signal.attributes : {};
-    const metadata = isPlainObject(signal.metadata) ? signal.metadata : {};
-    const github = isPlainObject(metadata.github) ? metadata.github : {};
-    const number = readNumber(attributes.number) ?? readNumber(github.number);
-    if (!number) return void 0;
-    return {
-      tagName: String(signal.tagName),
-      id: readString(signal.id) ?? message.id,
-      owner: readString(attributes.owner) ?? readString(github.owner),
-      repo: readString(attributes.repo) ?? readString(github.repo),
-      number
-    };
-  }
-  async #sendStatus(args, signal, status) {
-    await args.sendSignal?.({
-      type: "reactive",
-      tagName: GITHUB_SYNC_STATUS_TAG,
-      contents: status.message,
-      attributes: {
-        status: status.status,
-        owner: signal.owner,
-        repo: signal.repo,
-        number: signal.number
-      },
-      metadata: {
-        github: {
-          action: status.action,
-          status: status.status,
-          owner: signal.owner,
-          repo: signal.repo,
-          number: signal.number
-        }
-      }
-    });
-  }
-};
 
 // src/onboarding/packs.ts
 function getAvailableModePacks(access, savedCustomPacks = []) {
@@ -3014,8 +1922,6 @@ function releaseAllThreadLocks() {
 exports.BOX_INDENT = BOX_INDENT;
 exports.BOX_INDENT_STR = BOX_INDENT_STR;
 exports.CHAT_INDENT = CHAT_INDENT;
-exports.GITHUB_SIGNALS_METADATA_KEY = GITHUB_SIGNALS_METADATA_KEY;
-exports.GithubSignals = GithubSignals;
 exports.MEMORY_GATEWAY_DEFAULT_URL = MEMORY_GATEWAY_DEFAULT_URL;
 exports.MEMORY_GATEWAY_PROVIDER = MEMORY_GATEWAY_PROVIDER;
 exports.OBSERVABILITY_AUTH_PREFIX = OBSERVABILITY_AUTH_PREFIX;
@@ -3059,5 +1965,5 @@ exports.setProfileProvider = setProfileProvider;
 exports.theme = theme;
 exports.tintHex = tintHex;
 exports.toCustomProviderModelId = toCustomProviderModelId;
-//# sourceMappingURL=chunk-NFF7IH5X.cjs.map
-//# sourceMappingURL=chunk-NFF7IH5X.cjs.map
+//# sourceMappingURL=chunk-A4W5D25I.cjs.map
+//# sourceMappingURL=chunk-A4W5D25I.cjs.map