@pratik7368patil/anchor-core 0.1.40 → 0.1.41

package/dist/index.js

@@ -7496,17 +7496,849 @@ function watchCodebase(db, input) {
   return () => clearInterval(timer);
 }
 
-// src/ci.ts
+// src/autosync.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import fs10 from "fs";
+import os3 from "os";
+import path21 from "path";
+
+// src/org/config.ts
 import fs9 from "fs";
+import os2 from "os";
 import path20 from "path";
+import { z as z2 } from "zod";
+var ORG_REPO_GROUPS = ["backend", "frontend", "shared", "infra", "docs", "unknown"];
+var OrgRepoSchema = z2.object({
+  fullName: z2.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/),
+  alias: z2.string().min(1),
+  group: z2.enum(ORG_REPO_GROUPS),
+  cloneUrl: z2.string().min(1),
+  defaultBranch: z2.string().min(1),
+  enabled: z2.boolean()
+});
+var OrgConfigSchema = z2.object({
+  version: z2.literal(1),
+  org: z2.string().regex(/^[A-Za-z0-9_.-]+$/),
+  repos: z2.array(OrgRepoSchema)
+});
+function validateOrgName(org) {
+  const trimmed = org.trim();
+  if (!/^[A-Za-z0-9_.-]+$/.test(trimmed)) {
+    throw new Error("Invalid org name. Use only letters, numbers, dot, underscore, and hyphen.");
+  }
+  return trimmed;
+}
+function validateOrgRepoFullName(fullName) {
+  const trimmed = fullName.trim();
+  if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(trimmed)) {
+    throw new Error("Invalid repo name. Use owner/name.");
+  }
+  return trimmed;
+}
+function validateOrgRepoGroup(group) {
+  if (!group) return "unknown";
+  if (ORG_REPO_GROUPS.includes(group)) return group;
+  throw new Error(`Invalid repo group: ${group}`);
+}
+function defaultOrgBaseDir() {
+  if (process.env.ANCHOR_ORG_HOME) return process.env.ANCHOR_ORG_HOME;
+  return path20.join(os2.homedir(), ".anchor", "orgs");
+}
+function orgRoot(org, baseDir = defaultOrgBaseDir()) {
+  return path20.join(baseDir, validateOrgName(org));
+}
+function orgConfigPath(org, baseDir = defaultOrgBaseDir()) {
+  return path20.join(orgRoot(org, baseDir), "org.json");
+}
+function orgDatabasePath(org, baseDir = defaultOrgBaseDir()) {
+  return path20.join(orgRoot(org, baseDir), "org.sqlite");
+}
+function orgReposRoot(org, baseDir = defaultOrgBaseDir()) {
+  return path20.join(orgRoot(org, baseDir), "repos");
+}
+function repoAliasFromFullName(fullName) {
+  return validateOrgRepoFullName(fullName).split("/")[1] ?? fullName.replace(/\W+/g, "-");
+}
+function defaultOrgCloneUrl(fullName) {
+  return `https://github.com/${validateOrgRepoFullName(fullName)}.git`;
+}
+function orgRepoLocalPath(org, repo, baseDir = defaultOrgBaseDir()) {
+  const safeAlias = repo.alias.replace(/[^A-Za-z0-9_.-]/g, "-") || repoAliasFromFullName(repo.fullName);
+  return path20.join(orgReposRoot(org, baseDir), safeAlias);
+}
+function parseOrgConfig(text) {
+  const parsed = OrgConfigSchema.parse(JSON.parse(text));
+  return parsed;
+}
+function atomicWriteJson(filePath, value) {
+  fs9.mkdirSync(path20.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs9.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  fs9.renameSync(tmp, filePath);
+}
+function loadOrgConfig(org, baseDir = defaultOrgBaseDir()) {
+  const filePath = orgConfigPath(org, baseDir);
+  if (!fs9.existsSync(filePath)) {
+    throw new Error(
+      `Anchor org config not found at ${filePath}. Run anchor org init --org ${org}.`
+    );
+  }
+  return parseOrgConfig(fs9.readFileSync(filePath, "utf8"));
+}
+function maybeLoadOrgConfig(org, baseDir = defaultOrgBaseDir()) {
+  const filePath = orgConfigPath(org, baseDir);
+  if (!fs9.existsSync(filePath)) return void 0;
+  return loadOrgConfig(org, baseDir);
+}
+function saveOrgConfig(config, baseDir = defaultOrgBaseDir()) {
+  const parsed = OrgConfigSchema.parse(config);
+  atomicWriteJson(orgConfigPath(parsed.org, baseDir), parsed);
+  return parsed;
+}
+function initOrgConfig(org, baseDir = defaultOrgBaseDir()) {
+  const normalizedOrg = validateOrgName(org);
+  fs9.mkdirSync(orgReposRoot(normalizedOrg, baseDir), { recursive: true });
+  const existing = maybeLoadOrgConfig(normalizedOrg, baseDir);
+  if (existing) return existing;
+  return saveOrgConfig({ version: 1, org: normalizedOrg, repos: [] }, baseDir);
+}
+function addOrgRepoConfig(org, repoFullName, input = {}, baseDir = defaultOrgBaseDir()) {
+  const config = initOrgConfig(org, baseDir);
+  const fullName = validateOrgRepoFullName(repoFullName);
+  const existing = config.repos.find((repo) => repo.fullName === fullName);
+  const candidate = {
+    fullName,
+    alias: input.alias?.trim() || existing?.alias || repoAliasFromFullName(fullName),
+    group: validateOrgRepoGroup(input.group ?? existing?.group),
+    cloneUrl: input.cloneUrl?.trim() || existing?.cloneUrl || defaultOrgCloneUrl(fullName),
+    defaultBranch: input.defaultBranch?.trim() || existing?.defaultBranch || "main",
+    enabled: true
+  };
+  const repos = existing ? config.repos.map((repo) => repo.fullName === fullName ? candidate : repo) : [...config.repos, candidate];
+  return saveOrgConfig(
+    { ...config, repos: repos.sort((a, b) => a.fullName.localeCompare(b.fullName)) },
+    baseDir
+  );
+}
+function removeOrgRepoConfig(org, repoFullName, baseDir = defaultOrgBaseDir()) {
+  const config = loadOrgConfig(org, baseDir);
+  const fullName = validateOrgRepoFullName(repoFullName);
+  return saveOrgConfig(
+    {
+      ...config,
+      repos: config.repos.map(
+        (repo) => repo.fullName === fullName ? { ...repo, enabled: false } : repo
+      )
+    },
+    baseDir
+  );
+}
+function listOrgNames(baseDir = defaultOrgBaseDir()) {
+  if (!fs9.existsSync(baseDir)) return [];
+  return fs9.readdirSync(baseDir, { withFileTypes: true }).filter(
+    (entry) => entry.isDirectory() && fs9.existsSync(path20.join(baseDir, entry.name, "org.json"))
+  ).map((entry) => entry.name).sort();
+}
+function resolveOrgForTool(org, baseDir = defaultOrgBaseDir()) {
+  if (org) return validateOrgName(org);
+  const names = listOrgNames(baseDir);
+  if (names.length === 1) return names[0] ?? "";
+  if (names.length === 0) {
+    throw new Error("No Anchor org configured. Run anchor org init --org <org>.");
+  }
+  throw new Error(`Multiple Anchor orgs configured (${names.join(", ")}). Pass org explicitly.`);
+}
+
+// src/autosync.ts
+var CONFIG_VERSION = 1;
+var REPO_TIMEOUT_MS = 45 * 60 * 1e3;
+var ORG_TIMEOUT_MS = 2 * 60 * 60 * 1e3;
+var GRAPH_TIMEOUT_MS = 2 * 60 * 60 * 1e3;
+var STALE_RUN_MS = 36 * 60 * 60 * 1e3;
+function autosyncRoot(homeDir = os3.homedir()) {
+  return path21.join(homeDir, ".anchor");
+}
+function autosyncConfigPath(homeDir = os3.homedir()) {
+  return path21.join(autosyncRoot(homeDir), "autosync", "config.json");
+}
+function autosyncLogsRoot(homeDir = os3.homedir()) {
+  return path21.join(autosyncRoot(homeDir), "logs", "autosync");
+}
+function autosyncLocksRoot(homeDir = os3.homedir()) {
+  return path21.join(autosyncRoot(homeDir), "locks", "autosync");
+}
+function autosyncJobIdForRepo(repoRoot) {
+  return `repo-${stableHashText(path21.resolve(repoRoot))}`;
+}
+function autosyncJobIdForOrg(org) {
+  return `org-${safeName(org)}`;
+}
+function autosyncJobIdForOrgGraph(org) {
+  return `org-graph-${safeName(org)}`;
+}
+function autosyncLockPath(jobId, homeDir = os3.homedir()) {
+  return path21.join(autosyncLocksRoot(homeDir), `${safeName(jobId)}.lock`);
+}
+function defaultCommandRunner(command, args, options = {}) {
+  return execFileSync4(command, args, {
+    cwd: options.cwd,
+    input: options.input,
+    encoding: "utf8",
+    stdio: options.input === void 0 ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function readAutosyncConfig(homeDir = os3.homedir()) {
+  const filePath = autosyncConfigPath(homeDir);
+  if (!fs10.existsSync(filePath)) return void 0;
+  return normalizeAutosyncConfig(JSON.parse(fs10.readFileSync(filePath, "utf8")));
+}
+function writeAutosyncConfig(config, homeDir = os3.homedir()) {
+  const filePath = autosyncConfigPath(homeDir);
+  fs10.mkdirSync(path21.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs10.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  fs10.renameSync(tmp, filePath);
+}
+function installDefaultAutosync(options) {
+  const homeDir = options.homeDir ?? os3.homedir();
+  if (options.mode === "off") return disableAutosync({ ...options, homeDir });
+  const gitRoot = detectGitRoot(options.cwd);
+  if (!gitRoot) {
+    return {
+      enabled: false,
+      configPath: autosyncConfigPath(homeDir),
+      jobs: [],
+      warnings: ["Autosync was not installed because no git repository was detected."]
+    };
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = readAutosyncConfig(homeDir) ?? {
+    version: CONFIG_VERSION,
+    enabled: true,
+    updatedAt: now,
+    jobs: []
+  };
+  const repo = detectGitHubRepo(gitRoot)?.fullName;
+  const nodePath = path21.resolve(options.nodePath ?? process.execPath);
+  const anchorScriptPath = path21.resolve(options.anchorScriptPath);
+  const jobs = new Map(existing.jobs.map((job) => [job.id, job]));
+  const installJobs = [];
+  const repoJob = buildRepoJob({
+    repoRoot: gitRoot,
+    repo,
+    nodePath,
+    anchorScriptPath,
+    homeDir,
+    now,
+    previous: jobs.get(autosyncJobIdForRepo(gitRoot))
+  });
+  jobs.set(repoJob.id, repoJob);
+  installJobs.push(repoJob);
+  for (const org of discoverConfiguredOrgs(options.orgBaseDir)) {
+    const orgJob = buildOrgJob({
+      org,
+      nodePath,
+      anchorScriptPath,
+      homeDir,
+      now,
+      previous: jobs.get(autosyncJobIdForOrg(org))
+    });
+    const graphJob = buildOrgGraphJob({
+      org,
+      nodePath,
+      anchorScriptPath,
+      homeDir,
+      now,
+      previous: jobs.get(autosyncJobIdForOrgGraph(org))
+    });
+    jobs.set(orgJob.id, orgJob);
+    jobs.set(graphJob.id, graphJob);
+    installJobs.push(orgJob, graphJob);
+  }
+  const config = {
+    version: CONFIG_VERSION,
+    enabled: true,
+    updatedAt: now,
+    jobs: [...jobs.values()].sort((a, b) => a.id.localeCompare(b.id))
+  };
+  writeAutosyncConfig(config, homeDir);
+  const warnings = [];
+  const results = installJobs.map((job) => {
+    try {
+      return installSchedulerJob(job, {
+        platform: options.platform ?? process.platform,
+        homeDir,
+        runner: options.runner ?? defaultCommandRunner
+      });
+    } catch (error) {
+      warnings.push(`${job.label}: ${error instanceof Error ? error.message : String(error)}`);
+      const artifact = schedulerArtifactForJob(job, options.platform ?? process.platform, homeDir);
+      return {
+        id: job.id,
+        label: job.label,
+        kind: job.kind,
+        schedule: job.schedule,
+        scheduler: artifact.scheduler,
+        installed: false,
+        nextRunHint: artifact.nextRunHint,
+        logPath: job.logPath,
+        message: "Scheduler install failed; rerun anchor init after fixing local scheduler access."
+      };
+    }
+  });
+  return {
+    enabled: true,
+    configPath: autosyncConfigPath(homeDir),
+    jobs: results,
+    warnings
+  };
+}
+function disableAutosync(options = {}) {
+  const homeDir = options.homeDir ?? os3.homedir();
+  const config = readAutosyncConfig(homeDir);
+  const warnings = [];
+  if (config) {
+    const disabled = {
+      ...config,
+      enabled: false,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      jobs: config.jobs.map((job) => ({ ...job, enabled: false, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }))
+    };
+    writeAutosyncConfig(disabled, homeDir);
+    for (const job of config.jobs) {
+      try {
+        removeSchedulerJob(job, {
+          platform: options.platform ?? process.platform,
+          homeDir,
+          runner: options.runner ?? defaultCommandRunner
+        });
+      } catch (error) {
+        warnings.push(`${job.label}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  return {
+    enabled: false,
+    configPath: autosyncConfigPath(homeDir),
+    jobs: [],
+    warnings
+  };
+}
+function getAutosyncStatus(options = {}) {
+  const homeDir = options.homeDir ?? os3.homedir();
+  const platform = options.platform ?? process.platform;
+  const config = readAutosyncConfig(homeDir);
+  const scheduler = schedulerName(platform);
+  if (!config) {
+    return {
+      enabled: false,
+      configured: false,
+      configPath: autosyncConfigPath(homeDir),
+      scheduler,
+      jobs: [],
+      warnings: ["Autosync is not configured. Run anchor init to install local autosync."]
+    };
+  }
+  const gitRoot = options.cwd ? detectGitRoot(options.cwd) : void 0;
+  const matchingRepoJobId = gitRoot ? autosyncJobIdForRepo(gitRoot) : void 0;
+  const jobs = config.jobs.map((job) => {
+    const detected = schedulerArtifactExists(job, platform, homeDir);
+    const stale = isAutosyncJobStale(job);
+    const failing = job.lastRun?.status === "failed";
+    return {
+      id: job.id,
+      label: job.label,
+      kind: job.kind,
+      schedule: job.schedule,
+      enabled: job.enabled,
+      scheduler,
+      schedulerDetected: detected,
+      logPath: job.logPath,
+      lastRun: job.lastRun,
+      stale,
+      failing
+    };
+  });
+  const relevantJobs = matchingRepoJobId ? jobs.filter((job) => job.id === matchingRepoJobId || job.kind !== "repo") : jobs;
+  const warnings = [];
+  if (!config.enabled) warnings.push("Autosync is disabled.");
+  if (matchingRepoJobId && !jobs.some((job) => job.id === matchingRepoJobId)) {
+    warnings.push("Autosync is not installed for this repository. Run anchor init.");
+  }
+  for (const job of relevantJobs) {
+    if (job.enabled && !job.schedulerDetected) {
+      warnings.push(`${job.label} scheduler file is missing. Run anchor init.`);
+    }
+    if (job.failing) warnings.push(`${job.label} last run failed.`);
+    if (job.stale) warnings.push(`${job.label} has not completed recently.`);
+  }
+  return {
+    enabled: config.enabled,
+    configured: true,
+    configPath: autosyncConfigPath(homeDir),
+    scheduler,
+    jobs: relevantJobs,
+    lastRun: latestAutosyncRun(
+      relevantJobs.map((job) => job.lastRun).filter((run) => Boolean(run))
+    ),
+    warnings
+  };
+}
+function acquireAutosyncLock(jobId, homeDir = os3.homedir()) {
+  const lockPath = autosyncLockPath(jobId, homeDir);
+  fs10.mkdirSync(path21.dirname(lockPath), { recursive: true });
+  try {
+    fs10.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() }), {
+      flag: "wx",
+      mode: 384
+    });
+  } catch {
+    const existing = readLock(lockPath);
+    if (existing?.pid && processIsRunning(existing.pid)) {
+      return {
+        acquired: false,
+        lockPath,
+        release: () => void 0,
+        message: `Autosync job ${jobId} is already running as pid ${existing.pid}.`
+      };
+    }
+    fs10.rmSync(lockPath, { force: true });
+    fs10.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() }), {
+      flag: "wx",
+      mode: 384
+    });
+  }
+  return {
+    acquired: true,
+    lockPath,
+    release: () => fs10.rmSync(lockPath, { force: true })
+  };
+}
+function recordAutosyncRun(jobId, run, homeDir = os3.homedir()) {
+  const config = readAutosyncConfig(homeDir);
+  if (!config) return;
+  writeAutosyncConfig(
+    {
+      ...config,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      jobs: config.jobs.map(
+        (job) => job.id === jobId ? { ...job, lastRun: run, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } : job
+      )
+    },
+    homeDir
+  );
+}
+function resolveAutosyncJob(kind, input) {
+  const config = readAutosyncConfig();
+  if (!config) throw new Error("Autosync is not configured. Run anchor init.");
+  const jobId = kind === "repo" ? autosyncJobIdForRepo(input.cwd ?? process.cwd()) : kind === "org" ? autosyncJobIdForOrg(requiredOrg(input.org)) : autosyncJobIdForOrgGraph(requiredOrg(input.org));
+  const job = config.jobs.find((item) => item.id === jobId);
+  if (!job) throw new Error(`Autosync job ${jobId} is not configured. Run anchor init.`);
+  return job;
+}
+function buildRepoJob(input) {
+  const id = autosyncJobIdForRepo(input.repoRoot);
+  return {
+    id,
+    kind: "repo",
+    label: `Repo autosync${input.repo ? `: ${input.repo}` : ""}`,
+    schedule: "daily",
+    enabled: true,
+    repoRoot: input.repoRoot,
+    repo: input.repo,
+    nodePath: input.nodePath,
+    anchorScriptPath: input.anchorScriptPath,
+    args: ["internal", "autosync-run", "--kind", "repo", "--cwd", input.repoRoot],
+    logPath: path21.join(autosyncLogsRoot(input.homeDir), `${id}.log`),
+    lockPath: autosyncLockPath(id, input.homeDir),
+    timeoutMs: REPO_TIMEOUT_MS,
+    createdAt: input.previous?.createdAt ?? input.now,
+    updatedAt: input.now,
+    lastRun: input.previous?.lastRun
+  };
+}
+function buildOrgJob(input) {
+  const id = autosyncJobIdForOrg(input.org);
+  return {
+    id,
+    kind: "org",
+    label: `Org autosync: ${input.org}`,
+    schedule: "daily",
+    enabled: true,
+    org: input.org,
+    nodePath: input.nodePath,
+    anchorScriptPath: input.anchorScriptPath,
+    args: ["internal", "autosync-run", "--kind", "org", "--org", input.org, "--no-graph"],
+    logPath: path21.join(autosyncLogsRoot(input.homeDir), `${id}.log`),
+    lockPath: autosyncLockPath(id, input.homeDir),
+    timeoutMs: ORG_TIMEOUT_MS,
+    createdAt: input.previous?.createdAt ?? input.now,
+    updatedAt: input.now,
+    lastRun: input.previous?.lastRun
+  };
+}
+function buildOrgGraphJob(input) {
+  const id = autosyncJobIdForOrgGraph(input.org);
+  return {
+    id,
+    kind: "org-graph",
+    label: `Org graph autosync: ${input.org}`,
+    schedule: "weekly",
+    enabled: true,
+    org: input.org,
+    nodePath: input.nodePath,
+    anchorScriptPath: input.anchorScriptPath,
+    args: ["internal", "autosync-run", "--kind", "org-graph", "--org", input.org],
+    logPath: path21.join(autosyncLogsRoot(input.homeDir), `${id}.log`),
+    lockPath: autosyncLockPath(id, input.homeDir),
+    timeoutMs: GRAPH_TIMEOUT_MS,
+    createdAt: input.previous?.createdAt ?? input.now,
+    updatedAt: input.now,
+    lastRun: input.previous?.lastRun
+  };
+}
+function discoverConfiguredOrgs(baseDir) {
+  return listOrgNames(baseDir).filter((org) => {
+    try {
+      return loadOrgConfig(org, baseDir).repos.some((repo) => repo.enabled);
+    } catch {
+      return false;
+    }
+  });
+}
+function installSchedulerJob(job, options) {
+  fs10.mkdirSync(path21.dirname(job.logPath), { recursive: true });
+  const artifact = schedulerArtifactForJob(job, options.platform, options.homeDir);
+  if (options.platform === "darwin") installLaunchdJob(job, artifact, options.runner);
+  else if (options.platform === "linux") installLinuxJob(job, artifact, options);
+  else if (options.platform === "win32") installWindowsJob(job, artifact, options.runner);
+  else throw new Error(`Unsupported autosync scheduler platform: ${options.platform}`);
+  return {
+    id: job.id,
+    label: job.label,
+    kind: job.kind,
+    schedule: job.schedule,
+    scheduler: artifact.scheduler,
+    installed: true,
+    nextRunHint: artifact.nextRunHint,
+    logPath: job.logPath,
+    message: "Installed local scheduler job."
+  };
+}
+function removeSchedulerJob(job, options) {
+  const artifact = schedulerArtifactForJob(job, options.platform, options.homeDir);
+  if (options.platform === "darwin") {
+    const uid = process.getuid?.();
+    if (artifact.filePath && uid !== void 0) {
+      try {
+        options.runner("launchctl", ["bootout", `gui/${uid}`, artifact.filePath]);
+      } catch {
+      }
+    }
+    if (artifact.filePath) fs10.rmSync(artifact.filePath, { force: true });
+    return;
+  }
+  if (options.platform === "linux") {
+    if (artifact.filePath) {
+      const timerPath = artifact.filePath.replace(/\.service$/, ".timer");
+      try {
+        options.runner("systemctl", ["--user", "disable", "--now", path21.basename(timerPath)]);
+      } catch {
+      }
+      fs10.rmSync(artifact.filePath, { force: true });
+      fs10.rmSync(timerPath, { force: true });
+    }
+    removeCronBlock(job.id, options.runner);
+    return;
+  }
+  if (options.platform === "win32") {
+    try {
+      options.runner("schtasks", ["/Delete", "/F", "/TN", windowsTaskName(job)]);
+    } catch {
+    }
+  }
+}
+function schedulerArtifactForJob(job, platform, homeDir) {
+  const time = scheduleTime(job);
+  if (platform === "darwin") {
+    const label = `com.anchor.autosync.${safeName(job.id)}`;
+    return {
+      scheduler: "launchd",
+      label,
+      filePath: path21.join(homeDir, "Library", "LaunchAgents", `${label}.plist`),
+      nextRunHint: `${job.schedule} around ${time.hourLabel}`
+    };
+  }
+  if (platform === "linux") {
+    const unit = `anchor-autosync-${safeName(job.id)}`;
+    return {
+      scheduler: "systemd-user",
+      label: unit,
+      filePath: path21.join(homeDir, ".config", "systemd", "user", `${unit}.service`),
+      nextRunHint: `${job.schedule} around ${time.hourLabel}`
+    };
+  }
+  if (platform === "win32") {
+    return {
+      scheduler: "windows-task-scheduler",
+      label: windowsTaskName(job),
+      nextRunHint: `${job.schedule} around ${time.hourLabel}`
+    };
+  }
+  return { scheduler: "unsupported", nextRunHint: "n/a" };
+}
+function schedulerArtifactExists(job, platform, homeDir) {
+  const artifact = schedulerArtifactForJob(job, platform, homeDir);
+  if (platform === "win32") return true;
+  if (platform === "linux") {
+    return Boolean(
+      artifact.filePath && (fs10.existsSync(artifact.filePath) || fs10.existsSync(path21.join(homeDir, ".config", "systemd", "user", `${artifact.label}.timer`)) || cronHasBlock(job.id))
+    );
+  }
+  return Boolean(artifact.filePath && fs10.existsSync(artifact.filePath));
+}
+function installLaunchdJob(job, artifact, runner) {
+  if (!artifact.filePath || !artifact.label) throw new Error("Missing launchd artifact path.");
+  fs10.mkdirSync(path21.dirname(artifact.filePath), { recursive: true });
+  fs10.writeFileSync(artifact.filePath, launchdPlist(job, artifact.label), { mode: 420 });
+  const uid = process.getuid?.();
+  if (uid === void 0) return;
+  try {
+    runner("launchctl", ["bootout", `gui/${uid}`, artifact.filePath]);
+  } catch {
+  }
+  runner("launchctl", ["bootstrap", `gui/${uid}`, artifact.filePath]);
+  runner("launchctl", ["enable", `gui/${uid}/${artifact.label}`]);
+}
+function installLinuxJob(job, artifact, options) {
+  if (!artifact.filePath || !artifact.label) throw new Error("Missing systemd artifact path.");
+  const timerPath = artifact.filePath.replace(/\.service$/, ".timer");
+  fs10.mkdirSync(path21.dirname(artifact.filePath), { recursive: true });
+  fs10.writeFileSync(artifact.filePath, systemdService(job), { mode: 420 });
+  fs10.writeFileSync(timerPath, systemdTimer(job), { mode: 420 });
+  try {
+    options.runner("systemctl", ["--user", "daemon-reload"]);
+    options.runner("systemctl", ["--user", "enable", "--now", path21.basename(timerPath)]);
+  } catch {
+    installCronFallback(job, options.runner);
+  }
+}
+function installWindowsJob(job, artifact, runner) {
+  const time = scheduleTime(job);
+  const args = [
+    "/Create",
+    "/F",
+    "/TN",
+    artifact.label ?? windowsTaskName(job),
+    "/TR",
+    `${quoteWindows(job.nodePath)} ${quoteWindows(job.anchorScriptPath)} ${job.args.map(quoteWindows).join(" ")}`,
+    "/SC",
+    job.schedule === "weekly" ? "WEEKLY" : "DAILY",
+    "/ST",
+    `${pad2(time.hour)}:${pad2(time.minute)}`
+  ];
+  if (job.schedule === "weekly") args.push("/D", "MON");
+  runner("schtasks", args);
+}
+function launchdPlist(job, label) {
+  const time = scheduleTime(job);
+  const calendar = job.schedule === "weekly" ? `<dict><key>Weekday</key><integer>1</integer><key>Hour</key><integer>${time.hour}</integer><key>Minute</key><integer>${time.minute}</integer></dict>` : `<dict><key>Hour</key><integer>${time.hour}</integer><key>Minute</key><integer>${time.minute}</integer></dict>`;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${xmlEscape(label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${[job.nodePath, job.anchorScriptPath, ...job.args].map((arg) => `    <string>${xmlEscape(arg)}</string>`).join("\n")}
+  </array>
+  <key>StartCalendarInterval</key>${calendar}
+  <key>StandardOutPath</key><string>${xmlEscape(job.logPath)}</string>
+  <key>StandardErrorPath</key><string>${xmlEscape(job.logPath)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key><string>${xmlEscape(os3.homedir())}</string>
+    <key>PATH</key><string>${xmlEscape(process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin")}</string>
+    <key>SHELL</key><string>${xmlEscape(process.env.SHELL ?? "/bin/sh")}</string>
+    <key>ANCHOR_PROGRESS</key><string>plain</string>
+  </dict>
+</dict>
+</plist>
+`;
+}
+function systemdService(job) {
+  return `[Unit]
+Description=${job.label}
+
+[Service]
+Type=oneshot
+Environment=ANCHOR_PROGRESS=plain
+Environment=HOME=${systemdEscape(os3.homedir())}
+Environment=PATH=${systemdEscape(process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin")}
+Environment=SHELL=${systemdEscape(process.env.SHELL ?? "/bin/sh")}
+ExecStart=${systemdEscape(job.nodePath)} ${[job.anchorScriptPath, ...job.args].map(systemdEscape).join(" ")}
+StandardOutput=append:${job.logPath}
+StandardError=append:${job.logPath}
+`;
+}
+function systemdTimer(job) {
+  const time = scheduleTime(job);
+  const calendar = job.schedule === "weekly" ? `Mon *-*-* ${pad2(time.hour)}:${pad2(time.minute)}:00` : `*-*-* ${pad2(time.hour)}:${pad2(time.minute)}:00`;
+  return `[Unit]
+Description=${job.label} timer
+
+[Timer]
+OnCalendar=${calendar}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+}
+function installCronFallback(job, runner) {
+  const existing = readCrontab(runner);
+  const withoutBlock = removeCronBlockFromText(existing, job.id);
+  const time = scheduleTime(job);
+  const weekday = job.schedule === "weekly" ? "1" : "*";
+  const command = `HOME=${shellQuote(os3.homedir())} PATH=${shellQuote(process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin")} SHELL=${shellQuote(process.env.SHELL ?? "/bin/sh")} ANCHOR_PROGRESS=plain ${shellQuote(job.nodePath)} ${shellQuote(job.anchorScriptPath)} ${job.args.map(shellQuote).join(" ")} >> ${shellQuote(job.logPath)} 2>&1`;
+  const block = [
+    `# anchor autosync start ${job.id}`,
+    `${time.minute} ${time.hour} * * ${weekday} ${command}`,
+    `# anchor autosync end ${job.id}`
+  ].join("\n");
+  runner("crontab", ["-"], { input: `${withoutBlock.trim()}
+${block}
+` });
+}
+function removeCronBlock(jobId, runner) {
+  const existing = readCrontab(runner);
+  const next = removeCronBlockFromText(existing, jobId);
+  if (next !== existing) runner("crontab", ["-"], { input: next.trim() ? `${next.trim()}
+` : "" });
+}
+function readCrontab(runner) {
+  try {
+    return runner("crontab", ["-l"]);
+  } catch {
+    return "";
+  }
+}
+function removeCronBlockFromText(text, jobId) {
+  const start = `# anchor autosync start ${jobId}`;
+  const end = `# anchor autosync end ${jobId}`;
+  const lines = text.split("\n");
+  const kept = [];
+  let skipping = false;
+  for (const line of lines) {
+    if (line.trim() === start) {
+      skipping = true;
+      continue;
+    }
+    if (line.trim() === end) {
+      skipping = false;
+      continue;
+    }
+    if (!skipping) kept.push(line);
+  }
+  return kept.join("\n").trim();
+}
+function cronHasBlock(_jobId) {
+  return false;
+}
+function scheduleTime(job) {
+  const offset = stableHashNumber(job.id) % 180;
+  const baseHour = job.schedule === "weekly" ? 3 : 9;
+  const hour = (baseHour + Math.floor(offset / 60)) % 24;
+  const minute = offset % 60;
+  return { hour, minute, hourLabel: `${pad2(hour)}:${pad2(minute)}` };
+}
+function isAutosyncJobStale(job) {
+  if (!job.enabled) return false;
+  if (!job.lastRun?.finishedAt) return false;
+  if (job.lastRun.status === "failed") return true;
+  return Date.now() - Date.parse(job.lastRun.finishedAt) > STALE_RUN_MS;
+}
+function latestAutosyncRun(runs) {
+  return runs.sort((a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt))[0];
+}
+function normalizeAutosyncConfig(value) {
+  const candidate = value;
+  return {
+    version: CONFIG_VERSION,
+    enabled: Boolean(candidate.enabled),
+    updatedAt: candidate.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    jobs: Array.isArray(candidate.jobs) ? candidate.jobs : []
+  };
+}
+function readLock(lockPath) {
+  try {
+    return JSON.parse(fs10.readFileSync(lockPath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function processIsRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function requiredOrg(org) {
+  if (!org) throw new Error("Pass --org <org>.");
+  return org;
+}
+function schedulerName(platform) {
+  if (platform === "darwin") return "launchd";
+  if (platform === "linux") return "systemd-user";
+  if (platform === "win32") return "windows-task-scheduler";
+  return "unsupported";
+}
+function stableHashNumber(value) {
+  let hash = 5381;
+  for (const char of value) hash = (hash << 5) + hash + char.charCodeAt(0) >>> 0;
+  return hash;
+}
+function stableHashText(value) {
+  const hash = stableHashNumber(value);
+  return hash.toString(36);
+}
+function safeName(value) {
+  return value.replace(/[^A-Za-z0-9_.-]/g, "-");
+}
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+function xmlEscape(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function systemdEscape(value) {
+  return value.includes(" ") ? `"${value.replaceAll('"', '\\"')}"` : value;
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function quoteWindows(value) {
+  return `"${value.replaceAll('"', '\\"')}"`;
+}
+function windowsTaskName(job) {
+  return `AnchorAutosync-${safeName(job.id)}`;
+}
+
+// src/ci.ts
+import fs11 from "fs";
+import path22 from "path";
 function runAnchorCi(db, cwd, input = {}) {
   initializeSchema(db);
   const status = getIndexStatus(cwd, false);
   const minCoverage = input.minCoverage ?? 70;
   const rules = validateTeamRulesFile(cwd);
   const evidence = rules.ok ? checkTeamRuleEvidence(cwd) : void 0;
-  const evalsPath2 = path20.join(cwd, ANCHOR_EVALS_FILE);
-  const evals = fs9.existsSync(evalsPath2) ? runRetrievalEvals(db, cwd) : void 0;
+  const evalsPath2 = path22.join(cwd, ANCHOR_EVALS_FILE);
+  const evals = fs11.existsSync(evalsPath2) ? runRetrievalEvals(db, cwd) : void 0;
   const checks = [
     {
       name: "coverage",
@@ -9018,156 +9850,8 @@ async function fetchMergedPullRequests(options) {
   }
 }
 
-// src/org/config.ts
-import fs10 from "fs";
-import os2 from "os";
-import path21 from "path";
-import { z as z2 } from "zod";
-var ORG_REPO_GROUPS = ["backend", "frontend", "shared", "infra", "docs", "unknown"];
-var OrgRepoSchema = z2.object({
-  fullName: z2.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/),
-  alias: z2.string().min(1),
-  group: z2.enum(ORG_REPO_GROUPS),
-  cloneUrl: z2.string().min(1),
-  defaultBranch: z2.string().min(1),
-  enabled: z2.boolean()
-});
-var OrgConfigSchema = z2.object({
-  version: z2.literal(1),
-  org: z2.string().regex(/^[A-Za-z0-9_.-]+$/),
-  repos: z2.array(OrgRepoSchema)
-});
-function validateOrgName(org) {
-  const trimmed = org.trim();
-  if (!/^[A-Za-z0-9_.-]+$/.test(trimmed)) {
-    throw new Error("Invalid org name. Use only letters, numbers, dot, underscore, and hyphen.");
-  }
-  return trimmed;
-}
-function validateOrgRepoFullName(fullName) {
-  const trimmed = fullName.trim();
-  if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(trimmed)) {
-    throw new Error("Invalid repo name. Use owner/name.");
-  }
-  return trimmed;
-}
-function validateOrgRepoGroup(group) {
-  if (!group) return "unknown";
-  if (ORG_REPO_GROUPS.includes(group)) return group;
-  throw new Error(`Invalid repo group: ${group}`);
-}
-function defaultOrgBaseDir() {
-  if (process.env.ANCHOR_ORG_HOME) return process.env.ANCHOR_ORG_HOME;
-  return path21.join(os2.homedir(), ".anchor", "orgs");
-}
-function orgRoot(org, baseDir = defaultOrgBaseDir()) {
-  return path21.join(baseDir, validateOrgName(org));
-}
-function orgConfigPath(org, baseDir = defaultOrgBaseDir()) {
-  return path21.join(orgRoot(org, baseDir), "org.json");
-}
-function orgDatabasePath(org, baseDir = defaultOrgBaseDir()) {
-  return path21.join(orgRoot(org, baseDir), "org.sqlite");
-}
-function orgReposRoot(org, baseDir = defaultOrgBaseDir()) {
-  return path21.join(orgRoot(org, baseDir), "repos");
-}
-function repoAliasFromFullName(fullName) {
-  return validateOrgRepoFullName(fullName).split("/")[1] ?? fullName.replace(/\W+/g, "-");
-}
-function defaultOrgCloneUrl(fullName) {
-  return `https://github.com/${validateOrgRepoFullName(fullName)}.git`;
-}
-function orgRepoLocalPath(org, repo, baseDir = defaultOrgBaseDir()) {
-  const safeAlias = repo.alias.replace(/[^A-Za-z0-9_.-]/g, "-") || repoAliasFromFullName(repo.fullName);
-  return path21.join(orgReposRoot(org, baseDir), safeAlias);
-}
-function parseOrgConfig(text) {
-  const parsed = OrgConfigSchema.parse(JSON.parse(text));
-  return parsed;
-}
-function atomicWriteJson(filePath, value) {
-  fs10.mkdirSync(path21.dirname(filePath), { recursive: true });
-  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  fs10.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
-`, { mode: 384 });
-  fs10.renameSync(tmp, filePath);
-}
-function loadOrgConfig(org, baseDir = defaultOrgBaseDir()) {
-  const filePath = orgConfigPath(org, baseDir);
-  if (!fs10.existsSync(filePath)) {
-    throw new Error(
-      `Anchor org config not found at ${filePath}. Run anchor org init --org ${org}.`
-    );
-  }
-  return parseOrgConfig(fs10.readFileSync(filePath, "utf8"));
-}
-function maybeLoadOrgConfig(org, baseDir = defaultOrgBaseDir()) {
-  const filePath = orgConfigPath(org, baseDir);
-  if (!fs10.existsSync(filePath)) return void 0;
-  return loadOrgConfig(org, baseDir);
-}
-function saveOrgConfig(config, baseDir = defaultOrgBaseDir()) {
-  const parsed = OrgConfigSchema.parse(config);
-  atomicWriteJson(orgConfigPath(parsed.org, baseDir), parsed);
-  return parsed;
-}
-function initOrgConfig(org, baseDir = defaultOrgBaseDir()) {
-  const normalizedOrg = validateOrgName(org);
-  fs10.mkdirSync(orgReposRoot(normalizedOrg, baseDir), { recursive: true });
-  const existing = maybeLoadOrgConfig(normalizedOrg, baseDir);
-  if (existing) return existing;
-  return saveOrgConfig({ version: 1, org: normalizedOrg, repos: [] }, baseDir);
-}
-function addOrgRepoConfig(org, repoFullName, input = {}, baseDir = defaultOrgBaseDir()) {
-  const config = initOrgConfig(org, baseDir);
-  const fullName = validateOrgRepoFullName(repoFullName);
-  const existing = config.repos.find((repo) => repo.fullName === fullName);
-  const candidate = {
-    fullName,
-    alias: input.alias?.trim() || existing?.alias || repoAliasFromFullName(fullName),
-    group: validateOrgRepoGroup(input.group ?? existing?.group),
-    cloneUrl: input.cloneUrl?.trim() || existing?.cloneUrl || defaultOrgCloneUrl(fullName),
-    defaultBranch: input.defaultBranch?.trim() || existing?.defaultBranch || "main",
-    enabled: true
-  };
-  const repos = existing ? config.repos.map((repo) => repo.fullName === fullName ? candidate : repo) : [...config.repos, candidate];
-  return saveOrgConfig(
-    { ...config, repos: repos.sort((a, b) => a.fullName.localeCompare(b.fullName)) },
-    baseDir
-  );
-}
-function removeOrgRepoConfig(org, repoFullName, baseDir = defaultOrgBaseDir()) {
-  const config = loadOrgConfig(org, baseDir);
-  const fullName = validateOrgRepoFullName(repoFullName);
-  return saveOrgConfig(
-    {
-      ...config,
-      repos: config.repos.map(
-        (repo) => repo.fullName === fullName ? { ...repo, enabled: false } : repo
-      )
-    },
-    baseDir
-  );
-}
-function listOrgNames(baseDir = defaultOrgBaseDir()) {
-  if (!fs10.existsSync(baseDir)) return [];
-  return fs10.readdirSync(baseDir, { withFileTypes: true }).filter(
-    (entry) => entry.isDirectory() && fs10.existsSync(path21.join(baseDir, entry.name, "org.json"))
-  ).map((entry) => entry.name).sort();
-}
-function resolveOrgForTool(org, baseDir = defaultOrgBaseDir()) {
-  if (org) return validateOrgName(org);
-  const names = listOrgNames(baseDir);
-  if (names.length === 1) return names[0] ?? "";
-  if (names.length === 0) {
-    throw new Error("No Anchor org configured. Run anchor org init --org <org>.");
-  }
-  throw new Error(`Multiple Anchor orgs configured (${names.join(", ")}). Pass org explicitly.`);
-}
-
 // src/org/database.ts
-import fs11 from "fs";
+import fs12 from "fs";
 var DEFAULT_EDGE_DISTRIBUTION = {
   strong: 0,
   moderate: 0,
@@ -9429,7 +10113,7 @@ function getOrgStatus(db, config, baseDir, options = {}) {
     db.prepare("SELECT * FROM org_repo_state WHERE org = ?").all(config.org).map((row) => [row.repo, row])
   );
   const clonedRepoCount = enabledRepos.filter(
-    (repo) => fs11.existsSync(orgRepoLocalPath(config.org, repo, baseDir))
+    (repo) => fs12.existsSync(orgRepoLocalPath(config.org, repo, baseDir))
   ).length;
   const codeFileCount = count(db, "code_files");
   const codeChunkCount = count(db, "code_chunks");
@@ -9512,7 +10196,7 @@ function getOrgStatus(db, config, baseDir, options = {}) {
       return {
         ...repo,
         localPath,
-        cloned: fs11.existsSync(localPath),
+        cloned: fs12.existsSync(localPath),
         currentCommit: state?.current_commit ?? void 0,
         lastPulledAt: state?.last_pulled_at ?? void 0,
         lastCodeIndexedAt: state?.last_code_indexed_at ?? void 0,
@@ -9524,20 +10208,20 @@ function getOrgStatus(db, config, baseDir, options = {}) {
 }
 
 // src/org/heartbeat.ts
-import fs12 from "fs";
-import path22 from "path";
+import fs13 from "fs";
+import path23 from "path";
 var HEARTBEAT_STALE_AFTER_MS = 2 * 60 * 1e3;
 function orgHeartbeatPath(org, baseDir) {
-  return path22.join(orgRoot(validateOrgName(org), baseDir), "sync-heartbeat.json");
+  return path23.join(orgRoot(validateOrgName(org), baseDir), "sync-heartbeat.json");
 }
 function atomicWriteJson2(filePath, value) {
-  fs12.mkdirSync(path22.dirname(filePath), { recursive: true });
+  fs13.mkdirSync(path23.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  fs12.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+  fs13.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
-  fs12.renameSync(tmp, filePath);
+  fs13.renameSync(tmp, filePath);
 }
-function processIsRunning(pid) {
+function processIsRunning2(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
     process.kill(pid, 0);
@@ -9627,20 +10311,20 @@ function writeOrgHeartbeat(heartbeat, baseDir) {
 function clearOrgHeartbeat(org, baseDir) {
   try {
     const filePath = orgHeartbeatPath(org, baseDir);
-    if (fs12.existsSync(filePath)) fs12.unlinkSync(filePath);
+    if (fs13.existsSync(filePath)) fs13.unlinkSync(filePath);
   } catch {
   }
 }
 function readOrgHeartbeat(org, baseDir) {
   const filePath = orgHeartbeatPath(org, baseDir);
-  if (!fs12.existsSync(filePath)) return void 0;
+  if (!fs13.existsSync(filePath)) return void 0;
   try {
-    const heartbeat = parseHeartbeat(JSON.parse(fs12.readFileSync(filePath, "utf8")));
+    const heartbeat = parseHeartbeat(JSON.parse(fs13.readFileSync(filePath, "utf8")));
     if (!heartbeat) return void 0;
     const now = Date.now();
     const startedAtMs = Date.parse(heartbeat.startedAt);
     const updatedAtMs = Date.parse(heartbeat.updatedAt);
-    const pidRunning = processIsRunning(heartbeat.pid);
+    const pidRunning = processIsRunning2(heartbeat.pid);
     const lastUpdateAgeSeconds = Number.isFinite(updatedAtMs) ? Math.max(0, Math.floor((now - updatedAtMs) / 1e3)) : 0;
     return {
       ...heartbeat,
@@ -9655,11 +10339,11 @@ function readOrgHeartbeat(org, baseDir) {
 }
 
 // src/org/clone.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import fs13 from "fs";
-import path23 from "path";
+import { execFileSync as execFileSync5 } from "child_process";
+import fs14 from "fs";
+import path24 from "path";
 function defaultGitCommandRunner(command, args, options = {}) {
-  return execFileSync4(command, args, {
+  return execFileSync5(command, args, {
     cwd: options.cwd,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
@@ -9673,7 +10357,7 @@ function currentCommit(runner, localPath) {
   }
 }
 function plannedOrgCloneCommands(repo, localPath) {
-  if (!fs13.existsSync(path23.join(localPath, ".git"))) {
+  if (!fs14.existsSync(path24.join(localPath, ".git"))) {
     return [
       {
         command: "git",
@@ -9702,8 +10386,8 @@ function plannedOrgCloneCommands(repo, localPath) {
 function cloneOrPullOrgRepo(input) {
   const runner = input.runner ?? defaultGitCommandRunner;
   const localPath = orgRepoLocalPath(input.org, input.repo, input.baseDir);
-  const existed = fs13.existsSync(path23.join(localPath, ".git"));
-  fs13.mkdirSync(path23.dirname(localPath), { recursive: true });
+  const existed = fs14.existsSync(path24.join(localPath, ".git"));
+  fs14.mkdirSync(path24.dirname(localPath), { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   try {
     const commands = plannedOrgCloneCommands(input.repo, localPath);
@@ -9804,8 +10488,8 @@ function orgCloneStateFromResult(org, repo, result) {
 
 // src/org/graph.ts
 import crypto9 from "crypto";
-import fs14 from "fs";
-import path24 from "path";
+import fs15 from "fs";
+import path25 from "path";
 var MIN_FILE_EDGE_CONFIDENCE = 0.62;
 var MIN_REPO_EDGE_CONFIDENCE = 0.7;
 var MIN_VISIBLE_EVIDENCE = 2;
@@ -9850,10 +10534,10 @@ function evidenceJson(evidence) {
   return JSON.stringify(evidence);
 }
 function readPackageManifest(repoPath) {
-  const packagePath = path24.join(repoPath, "package.json");
-  if (!fs14.existsSync(packagePath)) return void 0;
+  const packagePath = path25.join(repoPath, "package.json");
+  if (!fs15.existsSync(packagePath)) return void 0;
   try {
-    return JSON.parse(fs14.readFileSync(packagePath, "utf8"));
+    return JSON.parse(fs15.readFileSync(packagePath, "utf8"));
   } catch {
     return void 0;
   }
@@ -10596,7 +11280,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
 }
 
 // src/org/index.ts
-import fs15 from "fs";
+import fs16 from "fs";
 var ORG_SYNC_RESUME_WINDOW_MS = 12 * 60 * 60 * 1e3;
 function readCommit(runner, cwd) {
   try {
@@ -10670,7 +11354,7 @@ async function indexOrgRepos(db, config, options = {}) {
         current: repoPosition,
         total: repos.length
       });
-      if (!fs15.existsSync(localPath)) throw new Error(missingCloneError(repo.fullName, localPath));
+      if (!fs16.existsSync(localPath)) throw new Error(missingCloneError(repo.fullName, localPath));
       emit({
         stage: "org_repo_phase",
         org: config.org,
@@ -10730,7 +11414,8 @@ async function indexOrgRepos(db, config, options = {}) {
             const pullRequests = await fetchPullRequests({
               token: auth.token,
               repo: repo.fullName,
-              limit: 200,
+              limit: options.all ? void 0 : 200,
+              all: options.all,
               since,
               detailConcurrency: options.concurrency,
               onProgress: options.onFetchProgress
@@ -10748,8 +11433,8 @@ async function indexOrgRepos(db, config, options = {}) {
             history = indexPullRequests(db, pullRequests, {
               cwd: localPath,
               repo: repo.fullName,
-              historyCoverage: "limited",
-              historyLimit: 200,
+              historyCoverage: options.all ? "all" : "limited",
+              historyLimit: options.all ? void 0 : 200,
               historySince: since,
               onProgress: options.onPrIndexProgress
             });
@@ -11639,7 +12324,7 @@ function isTestPath2(filePath) {
 }
 
 // src/doctor.ts
-import fs16 from "fs";
+import fs17 from "fs";
 function check(name, ok, message, fix) {
   return { name, ok, message, fix: ok ? void 0 : fix };
 }
@@ -11744,7 +12429,7 @@ async function runDoctor(options) {
     );
   }
   const dbPath = defaultDatabasePath(gitRoot ?? cwd);
-  const dbExists = fs16.existsSync(dbPath);
+  const dbExists = fs17.existsSync(dbPath);
   checks.push(
     check(
       ".anchor/index.sqlite exists",
@@ -11811,6 +12496,34 @@ async function runDoctor(options) {
       );
     }
   }
+  const autosyncStatus = getAutosyncStatus({ cwd: targetCwd });
+  checks.push(
+    check(
+      "autosync configured",
+      true,
+      autosyncStatus.enabled ? `${autosyncStatus.jobs.length} autosync job(s) configured using ${autosyncStatus.scheduler}.` : "Autosync is not enabled."
+    )
+  );
+  const missingSchedulers = autosyncStatus.jobs.filter(
+    (job) => job.enabled && !job.schedulerDetected
+  );
+  checks.push(
+    check(
+      "autosync scheduler installed",
+      !autosyncStatus.enabled || missingSchedulers.length === 0,
+      missingSchedulers.length === 0 ? "Autosync scheduler files are present." : `${missingSchedulers.length} autosync scheduler job(s) are missing.`,
+      "Run anchor init to reinstall local scheduler jobs."
+    )
+  );
+  const failedJobs = autosyncStatus.jobs.filter((job) => job.failing);
+  checks.push(
+    check(
+      "autosync last run healthy",
+      !autosyncStatus.enabled || failedJobs.length === 0,
+      failedJobs.length === 0 ? `Last autosync result: ${autosyncStatus.lastRun?.status ?? "not run yet"}.` : `${failedJobs.length} autosync job(s) failed recently.`,
+      "Run anchor health and inspect ~/.anchor/logs/autosync/ for the failing job log."
+    )
+  );
   return { ok: checks.every((item) => item.ok), checks };
 }
 
@@ -11824,6 +12537,9 @@ function evaluateIndexHealth(status, rulesOk) {
   if (status.staleCodeIndex) warnings.push("Code index is older than 7 days or has never run.");
   if (!rulesOk) warnings.push("Team rules file is missing or invalid.");
   if (status.lastFailedRun) warnings.push(`Last failed index run: ${status.lastFailedRun}.`);
+  if (status.autosync) {
+    warnings.push(...status.autosync.warnings.map((warning) => `Autosync: ${warning}`));
+  }
   const hasError = status.health === "missing_database" || status.health === "schema_invalid";
   const healthStatus = hasError ? "error" : warnings.length > 0 ? "warning" : "ok";
   return {
@@ -11837,11 +12553,13 @@ function evaluateIndexHealth(status, rulesOk) {
     coverageScore: status.coverageScore,
     coverageGrade: status.coverageGrade,
     coverageReasons: status.coverageReasons,
-    suggestedPrompts: status.suggestedPrompts
+    suggestedPrompts: status.suggestedPrompts,
+    autosync: status.autosync
   };
 }
 function getAnchorIndexHealth(cwd) {
   const indexStatus = getIndexStatus(cwd);
+  indexStatus.autosync = getAutosyncStatus({ cwd });
   const rulesValidation = validateTeamRulesFile(cwd);
   return {
     ...evaluateIndexHealth(indexStatus, rulesValidation.ok),
@@ -11860,12 +12578,21 @@ export {
   GitHubGraphQLError,
   SCHEMA_SQL,
   TEAM_RULES_FILE,
+  acquireAutosyncLock,
   addOrgRepoConfig,
   addRetrievalEval,
   addTeamRule,
   agentTargetLabel,
   anchorMcpEntry,
   architectureFilesFromDiff,
+  autosyncConfigPath,
+  autosyncJobIdForOrg,
+  autosyncJobIdForOrgGraph,
+  autosyncJobIdForRepo,
+  autosyncLockPath,
+  autosyncLocksRoot,
+  autosyncLogsRoot,
+  autosyncRoot,
   buildAnchorContextResult,
   buildArchitectureFromIndexedData,
   buildArchitectureIndex,
@@ -11900,6 +12627,7 @@ export {
   countValidTeamRules,
   createGitHubClient,
   createGitHubGraphQLRequester,
+  defaultCommandRunner,
   defaultDatabasePath,
   defaultGitCommandRunner,
   defaultOrgBaseDir,
@@ -11909,6 +12637,7 @@ export {
   detectGitRoot,
   detectTestCommands,
   detectTestCommandsForFile,
+  disableAutosync,
   discoverCodeFiles,
   discoverCodeFilesByPaths,
   emptyCodeIndexSummary,
@@ -11939,6 +12668,7 @@ export {
   getAnchorIndexHealth,
   getArchitectureContext,
   getArchitectureMapContext,
+  getAutosyncStatus,
   getCodeIndexStateForRepo,
   getGitHubRateLimitDelayMs,
   getGraphQLFetchCheckpoint,
@@ -11972,6 +12702,7 @@ export {
   initPlaybooks,
   initRetrievalEvals,
   initializeSchema,
+  installDefaultAutosync,
   isAnchorAgentTarget,
   isGitHubGraphQLResourceLimitError,
   isGitHubRateLimitError,
@@ -12009,10 +12740,12 @@ export {
   rankRelevantTests,
   rankTeamRules,
   rankWisdomUnits,
+  readAutosyncConfig,
   readDiscoveredCodeFileContent,
   readGitHeadCommit,
   readOrgHeartbeat,
   rebuildOrgGraph,
+  recordAutosyncRun,
   recordFeedback,
   recordIndexRun,
   recordOrgGraphState,
@@ -12027,6 +12760,7 @@ export {
   replaceCodeIndex,
   repoAliasFromFullName,
   requestWithGitHubRateLimit,
+  resolveAutosyncJob,
   resolveGitHubToken,
   resolveOrgForTool,
   resolvePullRequestDetailConcurrency,
@@ -12060,6 +12794,7 @@ export {
   validateOrgRepoGroup,
   validateTeamRulesFile,
   watchCodebase,
+  writeAutosyncConfig,
   writeOrgHeartbeat
 };
 //# sourceMappingURL=index.js.map