paperclip-github-plugin 0.4.1 → 0.4.3

package/dist/worker.js

@@ -618,23 +618,27 @@ var CANCELLING_SYNC_MESSAGE = "Cancellation requested. GitHub sync will stop aft
 var SYNC_PROGRESS_PERSIST_INTERVAL_MS = 250;
 var MAX_SYNC_FAILURE_LOG_ENTRIES = 25;
 var GITHUB_SECONDARY_RATE_LIMIT_FALLBACK_MS = 6e4;
+var IMPORTED_ISSUE_WAKEUP_CONCURRENCY = 4;
 var MISSING_GITHUB_TOKEN_SYNC_MESSAGE = "Configure a GitHub token before running sync.";
 var MISSING_GITHUB_TOKEN_SYNC_ACTION = 'Open settings and save a GitHub token secret, or create $PAPERCLIP_HOME/plugins/github-sync/config.json (or ~/.paperclip/plugins/github-sync/config.json when PAPERCLIP_HOME is unset) with a "githubToken" value, and then run sync again.';
 var MISSING_MAPPING_SYNC_MESSAGE = "Save at least one mapping with a created Paperclip project before running sync.";
 var MISSING_MAPPING_SYNC_ACTION = "Open settings, add a repository mapping, let Paperclip create the target project, and then retry sync.";
 var MISSING_BOARD_ACCESS_SYNC_MESSAGE = "Connect Paperclip board access before running sync on this authenticated deployment.";
 var MISSING_BOARD_ACCESS_SYNC_ACTION = "Open plugin settings for each mapped company that sync will touch, connect Paperclip board access, approve the flow, and then run sync again.";
+var IMPORTED_ISSUE_WAKE_REASON = "GitHub Sync imported an assigned issue that is ready for work.";
 var ISSUE_LINK_ENTITY_TYPE = "paperclip-github-plugin.issue-link";
 var PULL_REQUEST_LINK_ENTITY_TYPE = "paperclip-github-plugin.pull-request-link";
 var COMMENT_ANNOTATION_ENTITY_TYPE = "paperclip-github-plugin.comment-annotation";
 var AI_AUTHORED_COMMENT_FOOTER_PREFIX = "Created by a Paperclip AI agent using ";
 var HIDDEN_GITHUB_IMPORT_MARKER_PREFIX = "<!-- paperclip-github-plugin-imported-from: ";
 var HIDDEN_GITHUB_IMPORT_MARKER_SUFFIX = " -->";
+var EMPTY_GITHUB_ISSUE_DESCRIPTION_PLACEHOLDER = "_No description provided on GitHub._";
 function normalizeCompanyId(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 var activeSyncPromise = null;
 var activeRunningSyncState = null;
+var activeRunningSyncCompanyId;
 var activePaperclipApiAuthTokensByCompanyId = null;
 var activeExternalConfigWarningKey = null;
 var activeProjectPullRequestPageCache = /* @__PURE__ */ new Map();
@@ -710,6 +714,7 @@ var FAILED_STATUS_CONTEXT_STATES = /* @__PURE__ */ new Set(["ERROR", "FAILURE"])
 var PENDING_STATUS_CONTEXT_STATES = /* @__PURE__ */ new Set(["EXPECTED", "PENDING"]);
 var GITHUB_REPOSITORY_MAINTAINER_WARMUP_CONCURRENCY = 4;
 var GITHUB_REPOSITORY_MAINTAINER_ROLE_NAMES = /* @__PURE__ */ new Set(["admin", "maintain"]);
+var GITHUB_REPOSITORY_TRUSTED_AUTHOR_ASSOCIATIONS = /* @__PURE__ */ new Set(["collaborator", "member", "owner"]);
 var GITHUB_ISSUE_STATUS_SNAPSHOT_QUERY = `
   query GitHubIssueStatusSnapshot($owner: String!, $repo: String!, $issueNumber: Int!, $after: String) {
     repository(owner: $owner, name: $repo) {
@@ -1613,6 +1618,20 @@ function normalizeGitHubUserLogin(value) {
 function normalizeGitHubTokenRef(value) {
   return normalizeSecretRef(value);
 }
+function normalizeGitHubTokenRefs(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const entries = Object.entries(value).map(([companyId, secretRef]) => {
+    const normalizedCompanyId = normalizeCompanyId(companyId);
+    const normalizedSecretRef = normalizeGitHubTokenRef(secretRef);
+    return normalizedCompanyId && normalizedSecretRef ? [normalizedCompanyId, normalizedSecretRef] : null;
+  }).filter((entry) => entry !== null);
+  if (entries.length === 0) {
+    return void 0;
+  }
+  return Object.fromEntries(entries);
+}
 function formatUtcTimestamp(value) {
   const parsed = new Date(value);
   if (Number.isNaN(parsed.getTime())) {
@@ -2410,9 +2429,9 @@ function extractGitHubLinksFromCommentBody(body) {
   return [...links.values()];
 }
 async function buildToolbarSyncState(ctx, input) {
-  const settings = await getActiveOrCurrentSyncState(ctx);
-  const config = await getResolvedConfig(ctx);
   const companyId = typeof input.companyId === "string" && input.companyId.trim() ? input.companyId.trim() : void 0;
+  const settings = await getActiveOrCurrentSyncState(ctx, companyId);
+  const config = await getResolvedConfig(ctx);
   const githubTokenConfigured = hasConfiguredGithubToken(settings, config, companyId);
   const entityId = typeof input.entityId === "string" && input.entityId.trim() ? input.entityId.trim() : void 0;
   const entityType = typeof input.entityType === "string" && input.entityType.trim() ? input.entityType.trim() : void 0;
@@ -2454,7 +2473,7 @@ async function buildToolbarSyncState(ctx, input) {
     }) : [];
     return {
       kind: "issue",
-      visible: Boolean(link),
+      visible: false,
       canRun: githubTokenConfigured && mappings.length > 0,
       label: link?.githubIssueNumber ? `Sync #${link.githubIssueNumber}` : "Sync issue",
       message: link ? `Sync ${link.repositoryUrl.replace(/^https:\/\/github\.com\//, "")} issue #${link.githubIssueNumber}.` : "This Paperclip issue is not linked to GitHub yet.",
@@ -2626,15 +2645,25 @@ function sanitizeSettingsForCurrentSetup(settings, setup) {
 function getPublicSettings(settings) {
   const {
     githubTokenRefs: _githubTokenRefs,
-    githubTokenLoginsByCompanyId: _githubTokenLoginsByCompanyId,
+    githubTokenLoginByCompanyId: _githubTokenLoginByCompanyId,
     githubTokenRef: _githubTokenRef,
     paperclipBoardApiTokenRefs: _paperclipBoardApiTokenRefs,
     paperclipBoardAccessIdentityByCompanyId: _paperclipBoardAccessIdentityByCompanyId,
     companyAdvancedSettingsByCompanyId: _companyAdvancedSettingsByCompanyId,
+    syncStateByCompanyId: _syncStateByCompanyId,
+    scheduleFrequencyMinutesByCompanyId: _scheduleFrequencyMinutesByCompanyId,
+    paperclipApiBaseUrlByCompanyId: _paperclipApiBaseUrlByCompanyId,
     ...publicSettings
   } = settings;
   return publicSettings;
 }
+function getGitHubTokenLogin(settings, companyId) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  if (!normalizedCompanyId) {
+    return void 0;
+  }
+  return normalizeOptionalString2(settings.githubTokenLoginByCompanyId?.[normalizedCompanyId]) ?? normalizeOptionalString2(settings.githubTokenLogin);
+}
 function getPaperclipBoardAccessIdentity(settings, companyId) {
   const normalizedCompanyId = normalizeCompanyId(companyId);
   if (!normalizedCompanyId) {
@@ -2644,34 +2673,16 @@ function getPaperclipBoardAccessIdentity(settings, companyId) {
 }
 function getPublicSettingsForScope(settings, companyId) {
   const publicSettings = getPublicSettings(settings);
+  const githubTokenLogin = getGitHubTokenLogin(settings, companyId);
   const paperclipBoardAccessIdentity = getPaperclipBoardAccessIdentity(settings, companyId);
   return {
     ...publicSettings,
     mappings: filterMappingsByCompany(publicSettings.mappings, companyId),
     advancedSettings: getCompanyAdvancedSettings(settings, companyId),
+    ...githubTokenLogin ? { githubTokenLogin } : {},
     ...paperclipBoardAccessIdentity ? { paperclipBoardAccessIdentity } : {}
   };
 }
-function getSavedGitHubTokenRef(settings, companyId) {
-  const normalizedCompanyId = normalizeCompanyId(companyId);
-  if (normalizedCompanyId) {
-    const scopedSecretRef = normalizeSecretRef(settings?.githubTokenRefs?.[normalizedCompanyId]);
-    if (scopedSecretRef) {
-      return scopedSecretRef;
-    }
-  }
-  return normalizeGitHubTokenRef(settings?.githubTokenRef);
-}
-function getSavedGitHubTokenLogin(settings, companyId) {
-  const normalizedCompanyId = normalizeCompanyId(companyId);
-  if (normalizedCompanyId) {
-    const scopedLogin = normalizeOptionalString2(settings?.githubTokenLoginsByCompanyId?.[normalizedCompanyId]);
-    if (scopedLogin) {
-      return scopedLogin;
-    }
-  }
-  return normalizeOptionalString2(settings?.githubTokenLogin);
-}
 async function listAvailableAssignees(ctx, companyId) {
   try {
     const agents = await ctx.agents.list({
@@ -2852,14 +2863,11 @@ function createSetupConfigurationErrorSyncState(issue, trigger) {
       });
   }
 }
-async function saveSettingsSyncState(ctx, settings, syncState) {
-  const next = {
-    ...settings,
-    syncState
-  };
+async function saveSettingsSyncState(ctx, settings, syncState, companyId) {
+  const next = upsertScopedSyncState(normalizeSettings(settings), syncState, companyId);
   await ctx.state.set(SETTINGS_SCOPE, next);
-  await ctx.state.set(SYNC_STATE_SCOPE, next.syncState);
-  return next;
+  await ctx.state.set(SYNC_STATE_SCOPE, syncState);
+  return materializeScopedSettings(next, null, companyId);
 }
 async function setSyncCancellationRequest(ctx, request) {
   if (request) {
@@ -2884,8 +2892,8 @@ function buildCancelledSyncMessage(target, progress) {
   const completionSummary = completedIssueCount !== void 0 && totalIssueCount !== void 0 ? ` Completed ${Math.min(completedIssueCount, totalIssueCount)} of ${totalIssueCount} issues before stopping.` : "";
   return `${scopeLabel} was cancelled before it finished.${completionSummary}`;
 }
-async function createUnexpectedSyncErrorResult(ctx, trigger, error) {
-  const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
+async function createUnexpectedSyncErrorResult(ctx, trigger, error, companyId) {
+  const settings = materializeScopedSettings(normalizeSettings(await ctx.state.get(SETTINGS_SCOPE)), null, companyId);
   const errorDetails = buildSyncErrorDetails(error, {
     phase: "configuration"
   });
@@ -2910,7 +2918,8 @@ async function createUnexpectedSyncErrorResult(ctx, trigger, error) {
           errorDetails
         })
       )
-    })
+    }),
+    companyId
   );
 }
 async function waitForSyncResultWithinGracePeriod(promise, timeoutMs) {
@@ -2928,15 +2937,13 @@ async function waitForSyncResultWithinGracePeriod(promise, timeoutMs) {
     }
   }
 }
-async function getActiveOrCurrentSyncState(ctx) {
-  if (activeRunningSyncState?.syncState.status === "running") {
-    return activeRunningSyncState;
+async function getActiveOrCurrentSyncState(ctx, companyId) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  if (activeRunningSyncState?.syncState.status === "running" && activeRunningSyncCompanyId === normalizedCompanyId) {
+    return materializeScopedSettings(activeRunningSyncState, null, normalizedCompanyId);
   }
   const current = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
-  if (current.syncState.status === "running") {
-    return current;
-  }
-  return current;
+  return materializeScopedSettings(current, null, normalizedCompanyId);
 }
 function updateSyncFailureContext(current, next) {
   if ("phase" in next) {
@@ -3060,12 +3067,6 @@ async function readExternalConfig(ctx) {
   }
 }
 function normalizePaperclipBoardApiTokenRefs(value) {
-  return normalizeCompanySecretRefs(value);
-}
-function normalizeGitHubTokenRefs(value) {
-  return normalizeCompanySecretRefs(value);
-}
-function normalizeCompanySecretRefs(value) {
   if (!value || typeof value !== "object") {
     return void 0;
   }
@@ -3079,7 +3080,7 @@ function normalizeCompanySecretRefs(value) {
   }
   return Object.fromEntries(entries);
 }
-function normalizeGitHubTokenLoginsByCompanyId(value) {
+function normalizeGitHubTokenLoginByCompanyId(value) {
   if (!value || typeof value !== "object") {
     return void 0;
   }
@@ -3126,14 +3127,14 @@ function normalizeSyncState(value) {
   const recentFailures = normalizeSyncFailureLogEntries(record.recentFailures);
   return {
     status: status === "running" || status === "success" || status === "error" || status === "cancelled" ? status : "idle",
-    message: typeof record.message === "string" ? record.message : void 0,
-    checkedAt: typeof record.checkedAt === "string" ? record.checkedAt : void 0,
-    syncedIssuesCount: typeof record.syncedIssuesCount === "number" ? record.syncedIssuesCount : void 0,
-    createdIssuesCount: typeof record.createdIssuesCount === "number" ? record.createdIssuesCount : void 0,
-    skippedIssuesCount: typeof record.skippedIssuesCount === "number" ? record.skippedIssuesCount : void 0,
-    erroredIssuesCount: typeof record.erroredIssuesCount === "number" ? record.erroredIssuesCount : void 0,
-    lastRunTrigger: lastRunTrigger === "manual" || lastRunTrigger === "schedule" || lastRunTrigger === "retry" ? lastRunTrigger : void 0,
-    cancelRequestedAt: typeof record.cancelRequestedAt === "string" ? record.cancelRequestedAt : void 0,
+    ...typeof record.message === "string" ? { message: record.message } : {},
+    ...typeof record.checkedAt === "string" ? { checkedAt: record.checkedAt } : {},
+    ...typeof record.syncedIssuesCount === "number" ? { syncedIssuesCount: record.syncedIssuesCount } : {},
+    ...typeof record.createdIssuesCount === "number" ? { createdIssuesCount: record.createdIssuesCount } : {},
+    ...typeof record.skippedIssuesCount === "number" ? { skippedIssuesCount: record.skippedIssuesCount } : {},
+    ...typeof record.erroredIssuesCount === "number" ? { erroredIssuesCount: record.erroredIssuesCount } : {},
+    ...lastRunTrigger === "manual" || lastRunTrigger === "schedule" || lastRunTrigger === "retry" ? { lastRunTrigger } : {},
+    ...typeof record.cancelRequestedAt === "string" ? { cancelRequestedAt: record.cancelRequestedAt } : {},
     ...progress ? { progress } : {},
     ...errorDetails ? { errorDetails } : {},
     ...recentFailures ? { recentFailures } : {}
@@ -3243,6 +3244,26 @@ function normalizeScheduleFrequencyMinutes(value) {
   }
   return Math.floor(numericValue);
 }
+function normalizeSyncStateByCompanyId(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const entries = Object.entries(value).map(([companyId, syncState]) => {
+    const normalizedCompanyId = normalizeCompanyId(companyId);
+    return normalizedCompanyId ? [normalizedCompanyId, normalizeSyncState(syncState)] : null;
+  }).filter((entry) => entry !== null);
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function normalizeScheduleFrequencyMinutesByCompanyId(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const entries = Object.entries(value).map(([companyId, scheduleFrequencyMinutes]) => {
+    const normalizedCompanyId = normalizeCompanyId(companyId);
+    return normalizedCompanyId ? [normalizedCompanyId, normalizeScheduleFrequencyMinutes(scheduleFrequencyMinutes)] : null;
+  }).filter((entry) => entry !== null);
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
 function normalizePaperclipApiBaseUrl(value) {
   if (typeof value !== "string") {
     return void 0;
@@ -3257,6 +3278,17 @@ function normalizePaperclipApiBaseUrl(value) {
     return void 0;
   }
 }
+function normalizePaperclipApiBaseUrlByCompanyId(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const entries = Object.entries(value).map(([companyId, paperclipApiBaseUrl]) => {
+    const normalizedCompanyId = normalizeCompanyId(companyId);
+    const normalizedPaperclipApiBaseUrl = normalizePaperclipApiBaseUrl(paperclipApiBaseUrl);
+    return normalizedCompanyId && normalizedPaperclipApiBaseUrl ? [normalizedCompanyId, normalizedPaperclipApiBaseUrl] : null;
+  }).filter((entry) => entry !== null);
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
 function getRuntimePaperclipApiBaseUrl() {
   if (typeof process === "undefined" || !process?.env) {
     return void 0;
@@ -3276,19 +3308,26 @@ function resolvePaperclipApiBaseUrl(...values) {
   }
   return void 0;
 }
-function getConfiguredPaperclipApiBaseUrl(settings, config) {
-  return resolvePaperclipApiBaseUrl(config?.paperclipApiBaseUrl, settings?.paperclipApiBaseUrl);
+function getConfiguredPaperclipApiBaseUrl(settings, config, companyId) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  return normalizedCompanyId ? resolvePaperclipApiBaseUrl(
+    config?.paperclipApiBaseUrl,
+    settings?.paperclipApiBaseUrlByCompanyId?.[normalizedCompanyId],
+    settings?.paperclipApiBaseUrl
+  ) : resolvePaperclipApiBaseUrl(config?.paperclipApiBaseUrl, settings?.paperclipApiBaseUrl);
 }
-function resolveTrustedPaperclipApiBaseUrlInput(value, settings, config) {
+function resolveTrustedPaperclipApiBaseUrlInput(value, settings, config, companyId) {
   const runtimePaperclipApiBaseUrl = getRuntimePaperclipApiBaseUrl();
   if (runtimePaperclipApiBaseUrl) {
     return runtimePaperclipApiBaseUrl;
   }
   const requestedPaperclipApiBaseUrl = normalizePaperclipApiBaseUrl(value);
   const configuredPaperclipApiBaseUrl = normalizePaperclipApiBaseUrl(config?.paperclipApiBaseUrl);
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  const savedCompanyPaperclipApiBaseUrl = normalizedCompanyId ? normalizePaperclipApiBaseUrl(settings?.paperclipApiBaseUrlByCompanyId?.[normalizedCompanyId]) : void 0;
   const savedPaperclipApiBaseUrl = normalizePaperclipApiBaseUrl(settings?.paperclipApiBaseUrl);
   if (!requestedPaperclipApiBaseUrl) {
-    return configuredPaperclipApiBaseUrl ?? savedPaperclipApiBaseUrl;
+    return configuredPaperclipApiBaseUrl ?? savedCompanyPaperclipApiBaseUrl ?? savedPaperclipApiBaseUrl;
   }
   if (configuredPaperclipApiBaseUrl) {
     if (requestedPaperclipApiBaseUrl !== configuredPaperclipApiBaseUrl) {
@@ -3298,6 +3337,9 @@ function resolveTrustedPaperclipApiBaseUrlInput(value, settings, config) {
     }
     return configuredPaperclipApiBaseUrl;
   }
+  if (savedCompanyPaperclipApiBaseUrl && requestedPaperclipApiBaseUrl === savedCompanyPaperclipApiBaseUrl) {
+    return savedCompanyPaperclipApiBaseUrl;
+  }
   if (savedPaperclipApiBaseUrl && requestedPaperclipApiBaseUrl === savedPaperclipApiBaseUrl) {
     return savedPaperclipApiBaseUrl;
   }
@@ -3310,9 +3352,14 @@ function normalizeSettings(value) {
     return DEFAULT_SETTINGS;
   }
   const record = value;
+  const syncStateByCompanyId = normalizeSyncStateByCompanyId(record.syncStateByCompanyId);
+  const scheduleFrequencyMinutesByCompanyId = normalizeScheduleFrequencyMinutesByCompanyId(
+    record.scheduleFrequencyMinutesByCompanyId
+  );
   const paperclipApiBaseUrl = resolvePaperclipApiBaseUrl(record.paperclipApiBaseUrl);
+  const paperclipApiBaseUrlByCompanyId = normalizePaperclipApiBaseUrlByCompanyId(record.paperclipApiBaseUrlByCompanyId);
   const githubTokenRefs = normalizeGitHubTokenRefs(record.githubTokenRefs);
-  const githubTokenLoginsByCompanyId = normalizeGitHubTokenLoginsByCompanyId(record.githubTokenLoginsByCompanyId);
+  const githubTokenLoginByCompanyId = normalizeGitHubTokenLoginByCompanyId(record.githubTokenLoginByCompanyId);
   const githubTokenRef = normalizeGitHubTokenRef(record.githubTokenRef);
   const githubTokenLogin = normalizeOptionalString2(record.githubTokenLogin);
   const paperclipBoardApiTokenRefs = normalizePaperclipBoardApiTokenRefs(record.paperclipBoardApiTokenRefs);
@@ -3323,10 +3370,13 @@ function normalizeSettings(value) {
   return {
     mappings: normalizeMappings(record.mappings),
     syncState: normalizeSyncState(record.syncState),
+    ...syncStateByCompanyId ? { syncStateByCompanyId } : {},
     scheduleFrequencyMinutes: normalizeScheduleFrequencyMinutes(record.scheduleFrequencyMinutes),
+    ...scheduleFrequencyMinutesByCompanyId ? { scheduleFrequencyMinutesByCompanyId } : {},
     ...paperclipApiBaseUrl ? { paperclipApiBaseUrl } : {},
+    ...paperclipApiBaseUrlByCompanyId ? { paperclipApiBaseUrlByCompanyId } : {},
     ...githubTokenRefs ? { githubTokenRefs } : {},
-    ...githubTokenLoginsByCompanyId ? { githubTokenLoginsByCompanyId } : {},
+    ...githubTokenLoginByCompanyId ? { githubTokenLoginByCompanyId } : {},
     ...githubTokenRef ? { githubTokenRef } : {},
     ...githubTokenLogin ? { githubTokenLogin } : {},
     ...paperclipBoardApiTokenRefs ? { paperclipBoardApiTokenRefs } : {},
@@ -3335,6 +3385,103 @@ function normalizeSettings(value) {
     updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : void 0
   };
 }
+function getScopedSyncState(settings, companyId) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  if (!normalizedCompanyId) {
+    return normalizeSyncState(settings.syncState);
+  }
+  const scopedSyncState = settings.syncStateByCompanyId?.[normalizedCompanyId];
+  return scopedSyncState ? normalizeSyncState(scopedSyncState) : normalizeSyncState(settings.syncState);
+}
+function getScopedScheduleFrequencyMinutes(settings, companyId) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  if (!normalizedCompanyId) {
+    return normalizeScheduleFrequencyMinutes(settings.scheduleFrequencyMinutes);
+  }
+  const scopedScheduleFrequencyMinutes = settings.scheduleFrequencyMinutesByCompanyId?.[normalizedCompanyId];
+  return scopedScheduleFrequencyMinutes !== void 0 ? normalizeScheduleFrequencyMinutes(scopedScheduleFrequencyMinutes) : normalizeScheduleFrequencyMinutes(settings.scheduleFrequencyMinutes);
+}
+function materializeScopedSettings(settings, config, companyId) {
+  const syncState = getScopedSyncState(settings, companyId);
+  const scheduleFrequencyMinutes = getScopedScheduleFrequencyMinutes(settings, companyId);
+  const paperclipApiBaseUrl = getConfiguredPaperclipApiBaseUrl(settings, config, companyId);
+  return {
+    ...settings,
+    syncState,
+    scheduleFrequencyMinutes,
+    ...paperclipApiBaseUrl ? { paperclipApiBaseUrl } : {}
+  };
+}
+function upsertScopedSyncState(settings, syncState, companyId) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  if (!normalizedCompanyId) {
+    return {
+      ...settings,
+      syncState
+    };
+  }
+  return {
+    ...settings,
+    syncState,
+    syncStateByCompanyId: {
+      ...settings.syncStateByCompanyId ?? {},
+      [normalizedCompanyId]: syncState
+    }
+  };
+}
+function upsertScopedScheduleFrequencyMinutes(settings, scheduleFrequencyMinutes, companyId) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  if (!normalizedCompanyId) {
+    return {
+      ...settings,
+      scheduleFrequencyMinutes
+    };
+  }
+  return {
+    ...settings,
+    scheduleFrequencyMinutes,
+    scheduleFrequencyMinutesByCompanyId: {
+      ...settings.scheduleFrequencyMinutesByCompanyId ?? {},
+      [normalizedCompanyId]: scheduleFrequencyMinutes
+    }
+  };
+}
+function upsertScopedPaperclipApiBaseUrl(settings, paperclipApiBaseUrl, companyId) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  if (!normalizedCompanyId) {
+    return {
+      ...settings,
+      ...paperclipApiBaseUrl ? { paperclipApiBaseUrl } : {}
+    };
+  }
+  const nextPaperclipApiBaseUrlByCompanyId = {
+    ...settings.paperclipApiBaseUrlByCompanyId ?? {}
+  };
+  if (paperclipApiBaseUrl) {
+    nextPaperclipApiBaseUrlByCompanyId[normalizedCompanyId] = paperclipApiBaseUrl;
+  } else {
+    delete nextPaperclipApiBaseUrlByCompanyId[normalizedCompanyId];
+  }
+  return {
+    ...settings,
+    ...paperclipApiBaseUrl ? { paperclipApiBaseUrl } : {},
+    ...Object.keys(nextPaperclipApiBaseUrlByCompanyId).length > 0 ? { paperclipApiBaseUrlByCompanyId: nextPaperclipApiBaseUrlByCompanyId } : {}
+  };
+}
+function getScopedSyncTarget(companyId) {
+  return {
+    kind: "company",
+    companyId,
+    displayLabel: "this company"
+  };
+}
+function getSyncableMappingsForScope(mappings, companyId) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  return normalizedCompanyId ? getSyncableMappingsForTarget(mappings, getScopedSyncTarget(normalizedCompanyId)) : getSyncableMappings(mappings);
+}
+function hasAnyScopedValue(valueByCompanyId) {
+  return Boolean(valueByCompanyId && Object.keys(valueByCompanyId).length > 0);
+}
 function normalizeImportRegistry(value) {
   if (!Array.isArray(value)) {
     return [];
@@ -3494,6 +3641,7 @@ function normalizeGitHubIssueRecord(issue) {
     body: typeof issue.body === "string" ? stripNullBytes(issue.body) : null,
     htmlUrl: issue.html_url,
     ...normalizeGitHubUsername(issue.user?.login) ? { authorLogin: normalizeGitHubUsername(issue.user?.login) } : {},
+    ...normalizeGitHubLowercaseString(issue.author_association) ? { authorAssociation: normalizeGitHubLowercaseString(issue.author_association) } : {},
     labels: normalizeGitHubIssueLabels(issue.labels),
     state: issue.state === "closed" ? "closed" : "open",
     stateReason: normalizeGitHubIssueStateReason(issue.state_reason),
@@ -4274,6 +4422,22 @@ async function getGitHubIssueStatusSnapshot(octokit, repository, issueNumber, gi
 function buildGitHubRepositoryActorCacheKey(repository, login) {
   return `${repository.owner.toLowerCase()}/${repository.repo.toLowerCase()}:${login}`;
 }
+function getGitHubRepositoryTrustedAuthorStatusFromAssociation(authorAssociation) {
+  const normalizedAssociation = normalizeGitHubLowercaseString(authorAssociation);
+  if (!normalizedAssociation) {
+    return void 0;
+  }
+  return GITHUB_REPOSITORY_TRUSTED_AUTHOR_ASSOCIATIONS.has(normalizedAssociation);
+}
+function cacheGitHubRepositoryTrustedAuthorStatusFromAssociation(repository, login, authorAssociation, cache) {
+  const normalizedLogin = normalizeGitHubUserLogin(login);
+  const trustedAuthorStatus = getGitHubRepositoryTrustedAuthorStatusFromAssociation(authorAssociation);
+  if (!normalizedLogin || trustedAuthorStatus === void 0) {
+    return trustedAuthorStatus;
+  }
+  cache.set(buildGitHubRepositoryActorCacheKey(repository, normalizedLogin), trustedAuthorStatus);
+  return trustedAuthorStatus;
+}
 async function isGitHubUserRepositoryMaintainer(octokit, repository, login, cache) {
   const normalizedLogin = normalizeGitHubUserLogin(login);
   if (!normalizedLogin) {
@@ -4339,6 +4503,7 @@ async function listNewGitHubIssueCommentsSinceCount(octokit, repository, issueNu
         body: typeof comment.body === "string" ? stripNullBytes(comment.body) : "",
         url: comment.html_url ?? void 0,
         authorLogin: normalizeGitHubUserLogin(comment.user?.login),
+        ...normalizeGitHubLowercaseString(comment.author_association) ? { authorAssociation: normalizeGitHubLowercaseString(comment.author_association) } : {},
         createdAt: comment.created_at ?? void 0,
         updatedAt: comment.updated_at ?? void 0
       });
@@ -4380,6 +4545,18 @@ async function hasTrustedNewGitHubIssueComment(params) {
     if (originalPosterLogin && authorLogin === originalPosterLogin) {
       return true;
     }
+    const trustedAuthorStatus = cacheGitHubRepositoryTrustedAuthorStatusFromAssociation(
+      params.repository,
+      authorLogin,
+      comment.authorAssociation,
+      params.maintainerCache
+    );
+    if (trustedAuthorStatus === true) {
+      return true;
+    }
+    if (trustedAuthorStatus === false) {
+      continue;
+    }
     unseenAuthors.add(authorLogin);
   }
   for (const authorLogin of unseenAuthors) {
@@ -4399,6 +4576,15 @@ async function isMaintainerAuthoredGitHubIssue(params) {
   if (!authorLogin) {
     return false;
   }
+  const trustedAuthorStatus = cacheGitHubRepositoryTrustedAuthorStatusFromAssociation(
+    params.repository,
+    authorLogin,
+    params.githubIssue.authorAssociation,
+    params.maintainerCache
+  );
+  if (trustedAuthorStatus !== void 0) {
+    return trustedAuthorStatus;
+  }
   return isGitHubUserRepositoryMaintainer(
     params.octokit,
     params.repository,
@@ -4408,7 +4594,19 @@ async function isMaintainerAuthoredGitHubIssue(params) {
 }
 async function warmGitHubRepositoryMaintainerCache(params) {
   const uniqueAuthorLogins = [...new Set(
-    params.githubIssues.map((issue) => normalizeGitHubUserLogin(issue.authorLogin)).filter((authorLogin) => Boolean(authorLogin))
+    params.githubIssues.flatMap((issue) => {
+      const authorLogin = normalizeGitHubUserLogin(issue.authorLogin);
+      if (!authorLogin) {
+        return [];
+      }
+      const trustedAuthorStatus = cacheGitHubRepositoryTrustedAuthorStatusFromAssociation(
+        params.repository,
+        authorLogin,
+        issue.authorAssociation,
+        params.maintainerCache
+      );
+      return trustedAuthorStatus === void 0 ? [authorLogin] : [];
+    })
   )].filter((authorLogin) => !params.maintainerCache.has(buildGitHubRepositoryActorCacheKey(params.repository, authorLogin)));
   if (uniqueAuthorLogins.length === 0) {
     return;
@@ -4623,7 +4821,9 @@ function buildPaperclipIssueDescription(issue, linkedPullRequestNumbers = []) {
     return normalizedBody ?? "";
   }
   if (!normalizedBody) {
-    return hiddenImportMarker;
+    return `${EMPTY_GITHUB_ISSUE_DESCRIPTION_PLACEHOLDER}
+
+${hiddenImportMarker}`;
   }
   return `${normalizedBody}
 
@@ -5027,6 +5227,9 @@ function getPaperclipIssueEndpoint(baseUrl, issueId) {
 function getPaperclipHealthEndpoint(baseUrl) {
   return new URL("/api/health", baseUrl).toString();
 }
+function getPaperclipAgentWakeupEndpoint(baseUrl, agentId) {
+  return new URL(`/api/agents/${agentId}/wakeup`, baseUrl).toString();
+}
 function getActivePaperclipApiAuthToken(companyId) {
   if (!companyId) {
     return void 0;
@@ -5071,6 +5274,46 @@ async function detectPaperclipBoardAccessRequirement(paperclipApiBaseUrl) {
     return false;
   }
 }
+async function wakePaperclipAssigneeForImportedIssue(ctx, params) {
+  if (!params.assigneeAgentId || !params.paperclipApiBaseUrl) {
+    return;
+  }
+  try {
+    const response = await fetchPaperclipApi(
+      getPaperclipAgentWakeupEndpoint(params.paperclipApiBaseUrl, params.assigneeAgentId),
+      {
+        method: "POST",
+        headers: {
+          accept: "application/json",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          source: "assignment",
+          triggerDetail: "system",
+          reason: IMPORTED_ISSUE_WAKE_REASON,
+          payload: {
+            issueId: params.paperclipIssueId,
+            mutation: "import"
+          }
+        })
+      },
+      {
+        companyId: params.companyId
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Wakeup request failed with status ${response.status}.`);
+    }
+  } catch (error) {
+    ctx.logger.warn("GitHub sync could not wake the assignee for an imported Paperclip issue.", {
+      issueId: params.paperclipIssueId,
+      agentId: params.assigneeAgentId,
+      companyId: params.companyId,
+      paperclipApiBaseUrl: params.paperclipApiBaseUrl,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
 function parsePaperclipIssueDescription(value) {
   if (!value || typeof value !== "object") {
     return void 0;
@@ -6028,6 +6271,7 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
   let updatedDescriptionsCount = 0;
   let completedIssueCount = 0;
   const totalIssueCount = importedIssues.length;
+  const queuedImportedIssueWakeups = [];
   for (const importedIssue of importedIssues) {
     if (assertNotCancelled) {
       await assertNotCancelled();
@@ -6159,9 +6403,16 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
         defaultImportedStatus: advancedSettings.defaultStatus,
         maintainerAuthoredImportedIssue
       });
+      const shouldWakeImportedAssignee = wasImportedThisRun && nextStatus === "todo" && Boolean(paperclipIssue.assigneeAgentId);
       importedIssue.githubIssueNumber = githubIssue.number;
       importedIssue.lastSeenCommentCount = snapshot.commentCount;
       if (paperclipIssue.status === nextStatus) {
+        if (shouldWakeImportedAssignee) {
+          queuedImportedIssueWakeups.push({
+            assigneeAgentId: paperclipIssue.assigneeAgentId,
+            paperclipIssueId: importedIssue.paperclipIssueId
+          });
+        }
         continue;
       }
       const transitionComment = buildPaperclipIssueStatusTransitionComment({
@@ -6187,6 +6438,12 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
         paperclipApiBaseUrl
       });
       updatedStatusesCount += 1;
+      if (shouldWakeImportedAssignee) {
+        queuedImportedIssueWakeups.push({
+          assigneeAgentId: paperclipIssue.assigneeAgentId,
+          paperclipIssueId: importedIssue.paperclipIssueId
+        });
+      }
     } catch (error) {
       if (isGitHubRateLimitError(error)) {
         throw error;
@@ -6205,6 +6462,16 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
       }
     }
   }
+  await mapWithConcurrency(
+    queuedImportedIssueWakeups,
+    IMPORTED_ISSUE_WAKEUP_CONCURRENCY,
+    async (queuedWakeup) => wakePaperclipAssigneeForImportedIssue(ctx, {
+      assigneeAgentId: queuedWakeup.assigneeAgentId,
+      paperclipIssueId: queuedWakeup.paperclipIssueId,
+      companyId: mapping.companyId,
+      paperclipApiBaseUrl
+    })
+  );
   return {
     updatedStatusesCount,
     updatedLabelsCount,
@@ -6223,19 +6490,32 @@ async function getResolvedConfig(ctx) {
 }
 function getConfiguredGithubTokenSource(settings, config, companyId) {
   const normalizedCompanyId = normalizeCompanyId(companyId);
-  const secretRef = (normalizedCompanyId ? normalizeSecretRef(config.githubTokenRefs?.[normalizedCompanyId]) ?? getSavedGitHubTokenRef(settings, normalizedCompanyId) : void 0) ?? normalizeGitHubTokenRef(config.githubTokenRef) ?? getSavedGitHubTokenRef(settings);
+  const hasScopedGitHubTokenRefs = hasAnyScopedValue(settings?.githubTokenRefs) || hasAnyScopedValue(config.githubTokenRefs);
+  const secretRef = normalizedCompanyId ? normalizeSecretRef(config.githubTokenRefs?.[normalizedCompanyId]) ?? normalizeSecretRef(settings?.githubTokenRefs?.[normalizedCompanyId]) ?? (!hasScopedGitHubTokenRefs ? normalizeGitHubTokenRef(config.githubTokenRef) ?? normalizeGitHubTokenRef(settings?.githubTokenRef) : void 0) : normalizeGitHubTokenRef(config.githubTokenRef) ?? normalizeGitHubTokenRef(settings?.githubTokenRef) ?? (() => {
+    const configuredRefs = [
+      ...Object.values(config.githubTokenRefs ?? {}),
+      ...Object.values(settings?.githubTokenRefs ?? {})
+    ].map((value) => normalizeGitHubTokenRef(value)).filter((value) => Boolean(value));
+    const uniqueRefs = [...new Set(configuredRefs)];
+    return uniqueRefs.length === 1 ? uniqueRefs[0] : void 0;
+  })();
   if (secretRef) {
     return { secretRef };
   }
-  const token = normalizeGitHubToken(config.githubToken);
+  const token = !normalizedCompanyId || !hasScopedGitHubTokenRefs ? normalizeGitHubToken(config.githubToken) : void 0;
   return token ? { token } : {};
 }
-function getConfiguredGithubTokenRef(settings, config, companyId) {
-  return getConfiguredGithubTokenSource(settings, config, companyId).secretRef;
-}
 function hasConfiguredGithubToken(settings, config, companyId) {
   const configuredTokenSource = getConfiguredGithubTokenSource(settings, config, companyId);
-  return Boolean(configuredTokenSource.secretRef ?? configuredTokenSource.token);
+  if (configuredTokenSource.secretRef ?? configuredTokenSource.token) {
+    return true;
+  }
+  if (normalizeCompanyId(companyId)) {
+    return false;
+  }
+  return Boolean(
+    settings?.githubTokenRefs && Object.keys(settings.githubTokenRefs).length > 0 || config.githubTokenRefs && Object.keys(config.githubTokenRefs).length > 0
+  );
 }
 function getSavedPaperclipBoardApiTokenRef(settings, companyId) {
   if (!companyId) {
@@ -6937,6 +7217,7 @@ async function listAllGitHubIssueComments(octokit, repository, issueNumber) {
         body: typeof comment.body === "string" ? stripNullBytes(comment.body) : "",
         url: comment.html_url ?? void 0,
         authorLogin: normalizeGitHubUserLogin(comment.user?.login),
+        ...normalizeGitHubLowercaseString(comment.author_association) ? { authorAssociation: normalizeGitHubLowercaseString(comment.author_association) } : {},
         authorUrl: comment.user?.html_url ?? void 0,
         authorAvatarUrl: comment.user?.avatar_url ?? void 0,
         createdAt: comment.created_at ?? void 0,
@@ -8079,7 +8360,7 @@ async function buildProjectPullRequestsPageData(ctx, input) {
   }
   const scope = await requireProjectPullRequestScope(ctx, input, projectMappings);
   const config = await getResolvedConfig(ctx);
-  if (!hasConfiguredGithubToken(settings, config, companyId)) {
+  if (!hasConfiguredGithubToken(settings, config, scope.companyId)) {
     return {
       status: "missing_token",
       projectId,
@@ -8098,7 +8379,7 @@ async function buildProjectPullRequestsPageData(ctx, input) {
     };
   }
   try {
-    const octokit = await createGitHubToolOctokit(ctx, companyId);
+    const octokit = await createGitHubToolOctokit(ctx, scope.companyId);
     const pageCacheKey = buildProjectPullRequestPageCacheKey(scope, filter, pageIndex, cursor);
     const cachedPage = getFreshCacheValue(activeProjectPullRequestPageCache, pageCacheKey);
     if (cachedPage) {
@@ -9171,12 +9452,25 @@ function shouldRunScheduledSync(settings, scheduledAt) {
   }
   return now - lastCheckedAt >= settings.scheduleFrequencyMinutes * 6e4;
 }
+function listScheduledSyncTargets(settings) {
+  const companyIds = [
+    ...new Set(
+      settings.mappings.map((mapping) => normalizeCompanyId(mapping.companyId)).filter((companyId) => Boolean(companyId))
+    )
+  ];
+  if (companyIds.length === 0) {
+    return settings.mappings.length > 0 ? [void 0] : [];
+  }
+  return companyIds.map((companyId) => getScopedSyncTarget(companyId));
+}
 async function performSync(ctx, trigger, options = {}) {
-  const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
+  const targetCompanyId = normalizeCompanyId(options.target?.companyId);
+  const baseSettings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
   const config = await getResolvedConfig(ctx);
+  const settings = materializeScopedSettings(baseSettings, config, targetCompanyId);
   const importRegistry = normalizeImportRegistry(await ctx.state.get(IMPORT_REGISTRY_SCOPE));
-  const token = typeof options.resolvedToken === "string" ? options.resolvedToken : await resolveGithubToken(ctx);
-  const paperclipApiBaseUrl = getConfiguredPaperclipApiBaseUrl(settings, config);
+  const token = typeof options.resolvedToken === "string" ? options.resolvedToken : await resolveGithubToken(ctx, { companyId: targetCompanyId });
+  const paperclipApiBaseUrl = getConfiguredPaperclipApiBaseUrl(baseSettings, config, targetCompanyId);
   const mappings = getSyncableMappingsForTarget(settings.mappings, options.target);
   activePaperclipApiAuthTokensByCompanyId = null;
   const failureContext = {
@@ -9187,18 +9481,14 @@ async function performSync(ctx, trigger, options = {}) {
       ...settings,
       syncState: createSetupConfigurationErrorSyncState("missing_token", trigger)
     };
-    await ctx.state.set(SETTINGS_SCOPE, next);
-    await ctx.state.set(SYNC_STATE_SCOPE, next.syncState);
-    return next;
+    return saveSettingsSyncState(ctx, settings, next.syncState, targetCompanyId);
   }
   if (mappings.length === 0) {
     const next = {
       ...settings,
       syncState: createSetupConfigurationErrorSyncState("missing_mapping", trigger)
     };
-    await ctx.state.set(SETTINGS_SCOPE, next);
-    await ctx.state.set(SYNC_STATE_SCOPE, next.syncState);
-    return next;
+    return saveSettingsSyncState(ctx, settings, next.syncState, targetCompanyId);
   }
   const mappingsMissingBoardAccess = getMappingsMissingPaperclipBoardAccess(settings, config, mappings);
   if (mappingsMissingBoardAccess.length > 0 && await detectPaperclipBoardAccessRequirement(paperclipApiBaseUrl)) {
@@ -9206,9 +9496,7 @@ async function performSync(ctx, trigger, options = {}) {
       ...settings,
       syncState: createSetupConfigurationErrorSyncState("missing_board_access", trigger)
     };
-    await ctx.state.set(SETTINGS_SCOPE, next);
-    await ctx.state.set(SYNC_STATE_SCOPE, next.syncState);
-    return next;
+    return saveSettingsSyncState(ctx, settings, next.syncState, targetCompanyId);
   }
   if (!ctx.issues || typeof ctx.issues.create !== "function") {
     const errorDetails = {
@@ -9234,9 +9522,7 @@ async function performSync(ctx, trigger, options = {}) {
         )
       })
     };
-    await ctx.state.set(SETTINGS_SCOPE, next);
-    await ctx.state.set(SYNC_STATE_SCOPE, next.syncState);
-    return next;
+    return saveSettingsSyncState(ctx, settings, next.syncState, targetCompanyId);
   }
   activePaperclipApiAuthTokensByCompanyId = await resolvePaperclipApiAuthTokens(ctx, settings, config, mappings);
   const octokit = new Octokit({ auth: token });
@@ -9304,7 +9590,8 @@ async function performSync(ctx, trigger, options = {}) {
         erroredIssuesCount: recoverableFailures.length,
         progress,
         recentFailures
-      })
+      }),
+      targetCompanyId
     );
     activeRunningSyncState = currentSettings;
     lastProgressPersistedAt = now;
@@ -9641,10 +9928,9 @@ async function performSync(ctx, trigger, options = {}) {
           recentFailures: buildRecentSyncFailureLogEntries(recoverableFailures)
         })
       };
-      await ctx.state.set(SETTINGS_SCOPE, next2);
-      await ctx.state.set(SYNC_STATE_SCOPE, next2.syncState);
+      await saveSettingsSyncState(ctx, currentSettings, next2.syncState, targetCompanyId);
       await ctx.state.set(IMPORT_REGISTRY_SCOPE, nextRegistry);
-      return next2;
+      return materializeScopedSettings(next2, config, targetCompanyId);
     }
     const next = {
       ...currentSettings,
@@ -9700,10 +9986,9 @@ async function performSync(ctx, trigger, options = {}) {
         )
       })
     };
-    await ctx.state.set(SETTINGS_SCOPE, next);
-    await ctx.state.set(SYNC_STATE_SCOPE, next.syncState);
+    await saveSettingsSyncState(ctx, currentSettings, next.syncState, targetCompanyId);
     await ctx.state.set(IMPORT_REGISTRY_SCOPE, nextRegistry);
-    return next;
+    return materializeScopedSettings(next, config, targetCompanyId);
   }
 }
 async function startSync(ctx, trigger, options = {}) {
@@ -9721,28 +10006,32 @@ async function startSync(ctx, trigger, options = {}) {
     getResolvedConfig(ctx),
     ctx.state.get(SETTINGS_SCOPE).then((value) => normalizeSettings(value))
   ]);
-  const targetCompanyId = options.target?.companyId;
+  const targetCompanyId = normalizeCompanyId(options.target?.companyId);
   const token = await resolveGithubToken(ctx, {
+    companyId: targetCompanyId,
     config,
-    settings: persistedSettings,
-    companyId: targetCompanyId
+    settings: persistedSettings
   }).catch(() => "");
-  let currentSettings = sanitizeSettingsForCurrentSetup(persistedSettings, {
+  let currentSettings = sanitizeSettingsForCurrentSetup(materializeScopedSettings(persistedSettings, config, targetCompanyId), {
     hasToken: Boolean(token.trim()),
-    hasMappings: getSyncableMappings(persistedSettings.mappings).length > 0
+    hasMappings: getSyncableMappingsForScope(persistedSettings.mappings, targetCompanyId).length > 0
   });
-  const nextPaperclipApiBaseUrl = trigger === "manual" ? resolveTrustedPaperclipApiBaseUrlInput(options.paperclipApiBaseUrl, currentSettings, config) : getConfiguredPaperclipApiBaseUrl(currentSettings, config);
+  const nextPaperclipApiBaseUrl = trigger === "manual" ? resolveTrustedPaperclipApiBaseUrlInput(options.paperclipApiBaseUrl, persistedSettings, config, targetCompanyId) : getConfiguredPaperclipApiBaseUrl(persistedSettings, config, targetCompanyId);
   if (nextPaperclipApiBaseUrl !== currentSettings.paperclipApiBaseUrl) {
-    currentSettings = {
-      ...currentSettings,
-      ...nextPaperclipApiBaseUrl ? { paperclipApiBaseUrl: nextPaperclipApiBaseUrl } : {},
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await ctx.state.set(SETTINGS_SCOPE, currentSettings);
+    const nextPersistedSettings = upsertScopedPaperclipApiBaseUrl(
+      {
+        ...persistedSettings,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      nextPaperclipApiBaseUrl,
+      targetCompanyId
+    );
+    await ctx.state.set(SETTINGS_SCOPE, nextPersistedSettings);
     await ctx.state.set(SYNC_STATE_SCOPE, currentSettings.syncState);
+    currentSettings = materializeScopedSettings(nextPersistedSettings, config, targetCompanyId);
   }
-  if (currentSettings !== persistedSettings) {
-    await saveSettingsSyncState(ctx, currentSettings, currentSettings.syncState);
+  if (JSON.stringify(currentSettings.syncState) !== JSON.stringify(getScopedSyncState(persistedSettings, targetCompanyId))) {
+    await saveSettingsSyncState(ctx, persistedSettings, currentSettings.syncState, targetCompanyId);
   }
   if (getActiveGitHubRateLimitPause(currentSettings.syncState)) {
     return currentSettings;
@@ -9771,7 +10060,8 @@ async function startSync(ctx, trigger, options = {}) {
       ...currentSettings,
       syncState
     };
-    return saveSettingsSyncState(ctx, currentSettings, syncState);
+    activeRunningSyncCompanyId = targetCompanyId;
+    return saveSettingsSyncState(ctx, currentSettings, syncState, targetCompanyId);
   })();
   activeSyncPromise = (async () => {
     try {
@@ -9781,11 +10071,12 @@ async function startSync(ctx, trigger, options = {}) {
         target: options.target
       });
     } catch (error) {
-      return await createUnexpectedSyncErrorResult(ctx, trigger, error);
+      return await createUnexpectedSyncErrorResult(ctx, trigger, error, targetCompanyId);
     } finally {
       await setSyncCancellationRequest(ctx, null);
       activePaperclipApiAuthTokensByCompanyId = null;
       activeRunningSyncState = null;
+      activeRunningSyncCompanyId = void 0;
       activeSyncPromise = null;
     }
   })();
@@ -10575,38 +10866,18 @@ var plugin = definePlugin({
       const importRegistry = normalizeImportRegistry(await ctx.state.get(IMPORT_REGISTRY_SCOPE));
       const normalizedSettings = normalizeSettings(saved);
       const config = await getResolvedConfig(ctx);
-      const configuredGitHubTokenRef = requestedCompanyId ? normalizeSecretRef(config.githubTokenRefs?.[requestedCompanyId]) : normalizeGitHubTokenRef(config.githubTokenRef);
-      const savedGitHubTokenRef = getSavedGitHubTokenRef(normalizedSettings, requestedCompanyId);
-      const githubTokenRef = getConfiguredGithubTokenRef(normalizedSettings, config, requestedCompanyId);
-      const githubTokenLogin = getSavedGitHubTokenLogin(normalizedSettings, requestedCompanyId);
-      const paperclipApiBaseUrl = getConfiguredPaperclipApiBaseUrl(normalizedSettings, config);
       const githubTokenConfigured = hasConfiguredGithubToken(normalizedSettings, config, requestedCompanyId);
       const configuredBoardTokenRef = getConfiguredPaperclipBoardApiTokenRef(config, requestedCompanyId);
       const savedBoardTokenRef = getSavedPaperclipBoardApiTokenRef(normalizedSettings, requestedCompanyId);
-      const settingsWithResolvedToken = githubTokenRef === getSavedGitHubTokenRef(normalizedSettings, requestedCompanyId) && githubTokenLogin === getSavedGitHubTokenLogin(normalizedSettings, requestedCompanyId) && paperclipApiBaseUrl === normalizedSettings.paperclipApiBaseUrl ? normalizedSettings : {
-        ...normalizedSettings,
-        ...requestedCompanyId && githubTokenRef ? {
-          githubTokenRefs: {
-            ...normalizedSettings.githubTokenRefs ?? {},
-            [requestedCompanyId]: githubTokenRef
-          }
-        } : {},
-        ...requestedCompanyId && githubTokenLogin ? {
-          githubTokenLoginsByCompanyId: {
-            ...normalizedSettings.githubTokenLoginsByCompanyId ?? {},
-            [requestedCompanyId]: githubTokenLogin
-          }
-        } : {},
-        ...!requestedCompanyId && githubTokenRef ? { githubTokenRef } : {},
-        ...!requestedCompanyId && githubTokenLogin ? { githubTokenLogin } : {},
-        ...paperclipApiBaseUrl ? { paperclipApiBaseUrl } : {}
-      };
-      const settingsForResponse = sanitizeSettingsForCurrentSetup(settingsWithResolvedToken, {
-        hasToken: githubTokenConfigured,
-        hasMappings: getSyncableMappings(settingsWithResolvedToken.mappings).length > 0
-      });
-      if (settingsForResponse !== normalizedSettings) {
-        await saveSettingsSyncState(ctx, settingsForResponse, settingsForResponse.syncState);
+      const settingsForResponse = sanitizeSettingsForCurrentSetup(
+        materializeScopedSettings(normalizedSettings, config, requestedCompanyId),
+        {
+          hasToken: githubTokenConfigured,
+          hasMappings: getSyncableMappingsForScope(normalizedSettings.mappings, requestedCompanyId).length > 0
+        }
+      );
+      if (JSON.stringify(settingsForResponse.syncState) !== JSON.stringify(getScopedSyncState(normalizedSettings, requestedCompanyId))) {
+        await saveSettingsSyncState(ctx, normalizedSettings, settingsForResponse.syncState, requestedCompanyId);
       }
       const scopedMappings = filterMappingsByCompany(settingsForResponse.mappings, requestedCompanyId);
       const availableAssignees = includeAssignees && requestedCompanyId ? await listAvailableAssignees(ctx, requestedCompanyId) : [];
@@ -10615,9 +10886,6 @@ var plugin = definePlugin({
         ...includeAssignees ? { availableAssignees } : {},
         totalSyncedIssuesCount: countImportedIssuesForMappings(importRegistry, scopedMappings),
         githubTokenConfigured,
-        ...githubTokenLogin ? { githubTokenLogin } : {},
-        ...savedGitHubTokenRef ? { githubTokenConfigSyncRef: savedGitHubTokenRef } : {},
-        githubTokenNeedsConfigSync: Boolean(requestedCompanyId && savedGitHubTokenRef && !configuredGitHubTokenRef),
         paperclipBoardAccessConfigured: requestedCompanyId ? hasConfiguredPaperclipBoardAccess(settingsForResponse, config, requestedCompanyId) : hasConfiguredPaperclipBoardAccessForMappings(settingsForResponse, config, scopedMappings),
         ...savedBoardTokenRef ? { paperclipBoardAccessConfigSyncRef: savedBoardTokenRef } : {},
         paperclipBoardAccessNeedsConfigSync: Boolean(savedBoardTokenRef && !configuredBoardTokenRef)
@@ -10668,34 +10936,38 @@ var plugin = definePlugin({
       const config = await getResolvedConfig(ctx);
       const record = input && typeof input === "object" ? input : {};
       const requestedCompanyId = normalizeCompanyId(record.companyId);
+      const requestedGitHubTokenLogin = "githubTokenLogin" in record ? normalizeOptionalString2(record.githubTokenLogin) : void 0;
       const hasMappingsPatch = "mappings" in record;
       const hasAdvancedSettingsPatch = "advancedSettings" in record;
-      const githubTokenRef = "githubTokenRef" in record ? normalizeGitHubTokenRef(record.githubTokenRef) : void 0;
-      const githubTokenLogin = "githubTokenLogin" in record ? normalizeOptionalString2(record.githubTokenLogin) : void 0;
-      const inputMappings = hasMappingsPatch ? normalizeMappings(record.mappings) : previous.mappings;
+      const previousScopedSettings = materializeScopedSettings(previous, config, requestedCompanyId);
       const nextGitHubTokenRefs = {
         ...previous.githubTokenRefs ?? {}
       };
-      const nextGitHubTokenLoginsByCompanyId = {
-        ...previous.githubTokenLoginsByCompanyId ?? {}
-      };
-      const nextCompanyAdvancedSettingsByCompanyId = {
-        ...previous.companyAdvancedSettingsByCompanyId ?? {}
-      };
-      if (requestedCompanyId && "githubTokenRef" in record) {
-        if (githubTokenRef) {
-          nextGitHubTokenRefs[requestedCompanyId] = githubTokenRef;
-        } else {
-          delete nextGitHubTokenRefs[requestedCompanyId];
+      if (requestedCompanyId) {
+        const companyScopedGitHubTokenRef = normalizeGitHubTokenRefs(record.githubTokenRefs)?.[requestedCompanyId] ?? ("githubTokenRef" in record ? normalizeGitHubTokenRef(record.githubTokenRef) : void 0);
+        if (companyScopedGitHubTokenRef) {
+          nextGitHubTokenRefs[requestedCompanyId] = companyScopedGitHubTokenRef;
         }
       }
+      const githubTokenRefs = Object.keys(nextGitHubTokenRefs).length > 0 ? nextGitHubTokenRefs : void 0;
+      const githubTokenRef = !requestedCompanyId && "githubTokenRef" in record ? normalizeGitHubTokenRef(record.githubTokenRef) : normalizeGitHubTokenRef(previous.githubTokenRef) ?? normalizeGitHubTokenRef(config.githubTokenRef);
+      const nextGitHubTokenLoginByCompanyId = {
+        ...previous.githubTokenLoginByCompanyId ?? {}
+      };
       if (requestedCompanyId && "githubTokenLogin" in record) {
-        if (githubTokenLogin) {
-          nextGitHubTokenLoginsByCompanyId[requestedCompanyId] = githubTokenLogin;
+        const companyScopedGitHubTokenLogin = requestedGitHubTokenLogin;
+        if (companyScopedGitHubTokenLogin) {
+          nextGitHubTokenLoginByCompanyId[requestedCompanyId] = companyScopedGitHubTokenLogin;
         } else {
-          delete nextGitHubTokenLoginsByCompanyId[requestedCompanyId];
+          delete nextGitHubTokenLoginByCompanyId[requestedCompanyId];
         }
       }
+      const githubTokenLoginByCompanyId = Object.keys(nextGitHubTokenLoginByCompanyId).length > 0 ? nextGitHubTokenLoginByCompanyId : void 0;
+      const githubTokenLogin = !requestedCompanyId && "githubTokenLogin" in record ? requestedGitHubTokenLogin : previous.githubTokenLogin;
+      const inputMappings = hasMappingsPatch ? normalizeMappings(record.mappings) : previous.mappings;
+      const nextCompanyAdvancedSettingsByCompanyId = {
+        ...previous.companyAdvancedSettingsByCompanyId ?? {}
+      };
       if (requestedCompanyId && hasAdvancedSettingsPatch) {
         nextCompanyAdvancedSettingsByCompanyId[requestedCompanyId] = normalizeAdvancedSettings(record.advancedSettings);
       }
@@ -10706,19 +10978,26 @@ var plugin = definePlugin({
           companyId: requestedCompanyId
         }))
       ] : inputMappings;
-      const current = normalizeSettings({
+      let current = normalizeSettings({
         mappings: mergedMappings,
         syncState: previous.syncState,
-        scheduleFrequencyMinutes: "scheduleFrequencyMinutes" in record ? record.scheduleFrequencyMinutes : previous.scheduleFrequencyMinutes,
-        paperclipApiBaseUrl: "paperclipApiBaseUrl" in record ? resolveTrustedPaperclipApiBaseUrlInput(record.paperclipApiBaseUrl, previous, config) : getConfiguredPaperclipApiBaseUrl(previous, config),
-        ...Object.keys(nextGitHubTokenRefs).length > 0 ? { githubTokenRefs: nextGitHubTokenRefs } : {},
-        ...Object.keys(nextGitHubTokenLoginsByCompanyId).length > 0 ? { githubTokenLoginsByCompanyId: nextGitHubTokenLoginsByCompanyId } : {},
-        ...!requestedCompanyId ? githubTokenLogin ? { githubTokenLogin } : previous.githubTokenLogin ? { githubTokenLogin: previous.githubTokenLogin } : {} : {},
+        ...previous.syncStateByCompanyId ? { syncStateByCompanyId: previous.syncStateByCompanyId } : {},
+        scheduleFrequencyMinutes: previous.scheduleFrequencyMinutes,
+        ...previous.scheduleFrequencyMinutesByCompanyId ? { scheduleFrequencyMinutesByCompanyId: previous.scheduleFrequencyMinutesByCompanyId } : {},
+        ...previous.paperclipApiBaseUrl ? { paperclipApiBaseUrl: previous.paperclipApiBaseUrl } : {},
+        ...previous.paperclipApiBaseUrlByCompanyId ? { paperclipApiBaseUrlByCompanyId: previous.paperclipApiBaseUrlByCompanyId } : {},
+        ...githubTokenRefs ? { githubTokenRefs } : {},
+        ...githubTokenLoginByCompanyId ? { githubTokenLoginByCompanyId } : {},
+        ...githubTokenLogin ? { githubTokenLogin } : {},
         paperclipBoardApiTokenRefs: previous.paperclipBoardApiTokenRefs,
         paperclipBoardAccessIdentityByCompanyId: previous.paperclipBoardAccessIdentityByCompanyId,
         ...Object.keys(nextCompanyAdvancedSettingsByCompanyId).length > 0 ? { companyAdvancedSettingsByCompanyId: nextCompanyAdvancedSettingsByCompanyId } : {},
-        ...!requestedCompanyId ? githubTokenRef ? { githubTokenRef } : previous.githubTokenRef ? { githubTokenRef: previous.githubTokenRef } : {} : {}
+        ...githubTokenRef ? { githubTokenRef } : {}
       });
+      const nextScheduleFrequencyMinutes = "scheduleFrequencyMinutes" in record ? normalizeScheduleFrequencyMinutes(record.scheduleFrequencyMinutes) : getScopedScheduleFrequencyMinutes(previous, requestedCompanyId);
+      current = upsertScopedScheduleFrequencyMinutes(current, nextScheduleFrequencyMinutes, requestedCompanyId);
+      const nextPaperclipApiBaseUrl = "paperclipApiBaseUrl" in record ? resolveTrustedPaperclipApiBaseUrlInput(record.paperclipApiBaseUrl, previous, config, requestedCompanyId) : getConfiguredPaperclipApiBaseUrl(previous, config, requestedCompanyId);
+      current = upsertScopedPaperclipApiBaseUrl(current, nextPaperclipApiBaseUrl, requestedCompanyId);
       const nextMappings = current.mappings.map((mapping, index) => ({
         id: mapping.id.trim() || createMappingId(index),
         repositoryUrl: parseRepositoryReference(mapping.repositoryUrl)?.url ?? mapping.repositoryUrl.trim(),
@@ -10726,27 +11005,29 @@ var plugin = definePlugin({
         paperclipProjectId: mapping.paperclipProjectId,
         companyId: mapping.companyId
       }));
+      const materializedCurrent = materializeScopedSettings(current, config, requestedCompanyId);
       const next = sanitizeSettingsForCurrentSetup({
+        ...current,
         mappings: nextMappings,
-        syncState: previous.syncState,
-        scheduleFrequencyMinutes: current.scheduleFrequencyMinutes,
-        ...current.paperclipApiBaseUrl ? { paperclipApiBaseUrl: current.paperclipApiBaseUrl } : {},
+        syncState: materializedCurrent.syncState,
+        scheduleFrequencyMinutes: materializedCurrent.scheduleFrequencyMinutes,
+        ...materializedCurrent.paperclipApiBaseUrl ? { paperclipApiBaseUrl: materializedCurrent.paperclipApiBaseUrl } : {},
         ...current.githubTokenRefs ? { githubTokenRefs: current.githubTokenRefs } : {},
-        ...current.githubTokenLoginsByCompanyId ? { githubTokenLoginsByCompanyId: current.githubTokenLoginsByCompanyId } : {},
+        ...current.githubTokenLoginByCompanyId ? { githubTokenLoginByCompanyId: current.githubTokenLoginByCompanyId } : {},
         ...current.githubTokenLogin ? { githubTokenLogin: current.githubTokenLogin } : {},
         ...current.paperclipBoardApiTokenRefs ? { paperclipBoardApiTokenRefs: current.paperclipBoardApiTokenRefs } : {},
         ...current.paperclipBoardAccessIdentityByCompanyId ? { paperclipBoardAccessIdentityByCompanyId: current.paperclipBoardAccessIdentityByCompanyId } : {},
         ...current.companyAdvancedSettingsByCompanyId ? { companyAdvancedSettingsByCompanyId: current.companyAdvancedSettingsByCompanyId } : {},
-        ...current.githubTokenRef ? { githubTokenRef: current.githubTokenRef } : {},
+        ...githubTokenRef ? { githubTokenRef } : {},
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       }, {
         hasToken: hasConfiguredGithubToken(current, config, requestedCompanyId),
-        hasMappings: getSyncableMappings(nextMappings).length > 0
+        hasMappings: getSyncableMappingsForScope(nextMappings, requestedCompanyId).length > 0
       });
       await ctx.state.set(SETTINGS_SCOPE, next);
       await ctx.state.set(SYNC_STATE_SCOPE, next.syncState);
       clearGitHubRepositoryTokenCapabilityAudits();
-      const scopedGitHubTokenLogin = getSavedGitHubTokenLogin(next, requestedCompanyId);
+      const scopedGitHubTokenLogin = (requestedCompanyId && "githubTokenLogin" in record ? requestedGitHubTokenLogin : void 0) ?? getGitHubTokenLogin(next, requestedCompanyId);
       return {
         ...getPublicSettingsForScope(next, requestedCompanyId),
         ...scopedGitHubTokenLogin ? { githubTokenLogin: scopedGitHubTokenLogin } : {},
@@ -10787,15 +11068,16 @@ var plugin = definePlugin({
         paperclipBoardAccessIdentityByCompanyId: _previousPaperclipBoardAccessIdentityByCompanyId,
         ...previousWithoutBoardAccess
       } = previous;
-      const next = sanitizeSettingsForCurrentSetup({
+      const nextBase = sanitizeSettingsForCurrentSetup({
         ...previousWithoutBoardAccess,
         ...Object.keys(nextPaperclipBoardApiTokenRefs).length > 0 ? { paperclipBoardApiTokenRefs: nextPaperclipBoardApiTokenRefs } : {},
         ...Object.keys(nextPaperclipBoardAccessIdentityByCompanyId).length > 0 ? { paperclipBoardAccessIdentityByCompanyId: nextPaperclipBoardAccessIdentityByCompanyId } : {},
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       }, {
         hasToken: hasConfiguredGithubToken(previous, config, companyId),
-        hasMappings: getSyncableMappings(previous.mappings).length > 0
+        hasMappings: getSyncableMappingsForScope(previous.mappings, companyId).length > 0
       });
+      const next = materializeScopedSettings(nextBase, config, companyId);
       await ctx.state.set(SETTINGS_SCOPE, next);
       await ctx.state.set(SYNC_STATE_SCOPE, next.syncState);
       return {
@@ -10866,7 +11148,7 @@ var plugin = definePlugin({
       });
     });
     ctx.actions.register("sync.cancel", async () => {
-      const currentSettings = await getActiveOrCurrentSyncState(ctx);
+      const currentSettings = await getActiveOrCurrentSyncState(ctx, activeRunningSyncCompanyId);
       if (currentSettings.syncState.status !== "running") {
         return currentSettings;
       }
@@ -10886,7 +11168,8 @@ var plugin = definePlugin({
           progress: currentSettings.syncState.progress,
           message: CANCELLING_SYNC_MESSAGE,
           cancelRequestedAt: cancellationRequest.requestedAt
-        })
+        }),
+        activeRunningSyncCompanyId
       );
       activeRunningSyncState = next;
       return next;
@@ -10894,10 +11177,22 @@ var plugin = definePlugin({
     registerGitHubAgentTools(ctx);
     ctx.jobs.register("sync.github-issues", async (job) => {
       const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
-      if (job.trigger === "schedule" && !shouldRunScheduledSync(settings, job.scheduledAt)) {
+      const trigger = job.trigger === "retry" ? "retry" : "schedule";
+      const scheduledTargets = listScheduledSyncTargets(settings);
+      if (scheduledTargets.length === 0) {
+        if (job.trigger === "schedule" && !shouldRunScheduledSync(settings, job.scheduledAt)) {
+          return;
+        }
+        await startSync(ctx, trigger);
         return;
       }
-      await startSync(ctx, job.trigger === "retry" ? "retry" : "schedule");
+      for (const target of scheduledTargets) {
+        const scopedSettings = materializeScopedSettings(settings, null, target?.companyId);
+        if (job.trigger === "schedule" && !shouldRunScheduledSync(scopedSettings, job.scheduledAt)) {
+          continue;
+        }
+        await startSync(ctx, trigger, target ? { target } : {});
+      }
     });
   }
 });