@h-rig/server 0.0.6-alpha.0

package/dist/src/server-helpers/github-auth-store.js

@@ -0,0 +1,155 @@
+// @bun
+// packages/server/src/server-helpers/github-auth-store.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+
+// packages/server/src/server-helpers/server-paths.ts
+import { dirname, resolve } from "path";
+import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
+function resolveServerAuthorityPaths(projectRoot) {
+  const taskWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  const explicitStateDir = process.env.RIG_STATE_DIR?.trim();
+  const explicitLogsDir = process.env.RIG_LOGS_DIR?.trim();
+  const explicitSessionFile = process.env.RIG_SESSION_FILE?.trim();
+  const monorepoRoot = resolveMonorepoRoot(projectRoot);
+  const stateRoot = taskWorkspace ? resolve(taskWorkspace, ".rig") : explicitStateDir ? dirname(resolve(explicitStateDir)) : explicitLogsDir ? dirname(resolve(explicitLogsDir)) : explicitSessionFile ? dirname(dirname(resolve(explicitSessionFile))) : resolve(monorepoRoot, ".rig");
+  const stateDir = explicitStateDir ? resolve(explicitStateDir) : resolve(stateRoot, "state");
+  const logsDir = explicitLogsDir ? resolve(explicitLogsDir) : resolve(stateRoot, "logs");
+  const sessionFile = explicitSessionFile ? resolve(explicitSessionFile) : resolve(stateRoot, "session", "session.json");
+  const artifactsDir = taskWorkspace ? resolve(taskWorkspace, "artifacts") : resolve(monorepoRoot, "artifacts");
+  return {
+    stateRoot,
+    stateDir,
+    logsDir,
+    controlPlaneEventsFile: resolve(logsDir, "control-plane.events.jsonl"),
+    sessionFile,
+    artifactsDir
+  };
+}
+
+// packages/server/src/server-helpers/github-auth-store.ts
+function cleanString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function cleanScopes(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    const clean = cleanString(entry);
+    return clean ? [clean] : [];
+  });
+}
+function readStoredAuth(stateFile) {
+  if (!existsSync(stateFile))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync(stateFile, "utf8"));
+    return {
+      ...cleanString(parsed.token) ? { token: cleanString(parsed.token) } : {},
+      login: cleanString(parsed.login),
+      userId: cleanString(parsed.userId),
+      scopes: cleanScopes(parsed.scopes),
+      selectedRepo: cleanString(parsed.selectedRepo),
+      tokenSource: parsed.tokenSource === "oauth-device" || parsed.tokenSource === "manual-token" || parsed.tokenSource === "env" ? parsed.tokenSource : undefined,
+      pendingDevice: parsePendingDevice(parsed.pendingDevice),
+      updatedAt: cleanString(parsed.updatedAt) ?? undefined
+    };
+  } catch {
+    return {};
+  }
+}
+function parsePendingDevice(value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const record = value;
+  const pollId = cleanString(record.pollId);
+  const deviceCode = cleanString(record.deviceCode);
+  const expiresAt = cleanString(record.expiresAt);
+  const intervalSeconds = typeof record.intervalSeconds === "number" && Number.isFinite(record.intervalSeconds) ? Math.max(1, Math.floor(record.intervalSeconds)) : null;
+  if (!pollId || !deviceCode || !expiresAt || !intervalSeconds)
+    return null;
+  return { pollId, deviceCode, expiresAt, intervalSeconds };
+}
+function writeStoredAuth(stateFile, payload) {
+  mkdirSync(resolve2(stateFile, ".."), { recursive: true });
+  writeFileSync(stateFile, `${JSON.stringify(payload, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  try {
+    chmodSync(stateFile, 384);
+  } catch {}
+}
+function resolveGitHubAuthStateFile(projectRoot) {
+  return resolve2(resolveServerAuthorityPaths(projectRoot).stateDir, "github-auth.json");
+}
+function createGitHubAuthStore(projectRoot) {
+  const stateFile = resolveGitHubAuthStateFile(projectRoot);
+  return {
+    stateFile,
+    status(options) {
+      const stored = readStoredAuth(stateFile);
+      const token = cleanString(stored.token);
+      return {
+        signedIn: Boolean(token),
+        login: cleanString(stored.login),
+        userId: cleanString(stored.userId),
+        scopes: cleanScopes(stored.scopes),
+        selectedRepo: cleanString(stored.selectedRepo),
+        oauthConfigured: options?.oauthConfigured === true,
+        tokenSource: token ? stored.tokenSource ?? "manual-token" : null
+      };
+    },
+    readToken() {
+      return cleanString(readStoredAuth(stateFile).token);
+    },
+    saveToken(input) {
+      const previous = readStoredAuth(stateFile);
+      writeStoredAuth(stateFile, {
+        ...previous,
+        token: input.token,
+        tokenSource: input.tokenSource,
+        login: input.login ?? null,
+        userId: input.userId ?? null,
+        scopes: input.scopes ?? [],
+        selectedRepo: input.selectedRepo ?? previous.selectedRepo ?? null,
+        pendingDevice: null,
+        updatedAt: new Date().toISOString()
+      });
+    },
+    savePendingDevice(input) {
+      const previous = readStoredAuth(stateFile);
+      writeStoredAuth(stateFile, {
+        ...previous,
+        pendingDevice: input,
+        updatedAt: new Date().toISOString()
+      });
+    },
+    saveSelectedRepo(selectedRepo) {
+      const previous = readStoredAuth(stateFile);
+      writeStoredAuth(stateFile, {
+        ...previous,
+        selectedRepo: selectedRepo ?? null,
+        updatedAt: new Date().toISOString()
+      });
+    },
+    readPendingDevice(pollId) {
+      const pending = readStoredAuth(stateFile).pendingDevice ?? null;
+      if (!pending || pending.pollId !== pollId)
+        return null;
+      if (Date.parse(pending.expiresAt) <= Date.now())
+        return null;
+      return pending;
+    },
+    clearPendingDevice() {
+      const previous = readStoredAuth(stateFile);
+      writeStoredAuth(stateFile, {
+        ...previous,
+        pendingDevice: null,
+        updatedAt: new Date().toISOString()
+      });
+    }
+  };
+}
+export {
+  resolveGitHubAuthStateFile,
+  createGitHubAuthStore
+};

package/dist/src/server-helpers/github-credentials.js

@@ -0,0 +1,38 @@
+// @bun
+// packages/server/src/server-helpers/github-credentials.ts
+function selectedRepoTokenKey(input) {
+  return `user:${input.userId}|repo:${input.owner}/${input.repo}|workspace:${input.workspaceId}`;
+}
+function cleanToken(value) {
+  const trimmed = value?.trim() ?? "";
+  return trimmed.length > 0 ? trimmed : null;
+}
+function createGitHubCredentialProvider(options = {}) {
+  const sessionTokens = options.sessionTokens ?? {};
+  const hostToken = cleanToken(options.hostToken ?? process.env.GH_TOKEN ?? null);
+  return {
+    async resolveGitHubToken(input) {
+      const owner = input.owner.trim();
+      const repo = input.repo.trim();
+      const workspaceId = input.workspaceId.trim();
+      const userId = input.userId?.trim() ?? "";
+      if (input.purpose === "selected-repo") {
+        if (!owner || !repo || !workspaceId || !userId) {
+          throw new Error("No signed-in GitHub token is available for the selected repo; sign in to GitHub for this workspace.");
+        }
+        const token = cleanToken(sessionTokens[selectedRepoTokenKey({ owner, repo, workspaceId, userId })]);
+        if (!token) {
+          throw new Error("No signed-in GitHub token is available for the selected repo; sign in to GitHub for this workspace.");
+        }
+        return { token, source: "signed-in-user" };
+      }
+      if (hostToken) {
+        return { token: hostToken, source: "host-admin-fallback" };
+      }
+      throw new Error("No host GitHub token is configured for the explicit admin fallback operation.");
+    }
+  };
+}
+export {
+  createGitHubCredentialProvider
+};

package/dist/src/server-helpers/github-project-status-sync.js

@@ -0,0 +1,196 @@
+// @bun
+// packages/server/src/server-helpers/github-projects.ts
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+async function defaultGraphQLFetch(query, variables, token) {
+  const response = await fetch("https://api.github.com/graphql", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`,
+      accept: "application/vnd.github+json"
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  const json = await response.json().catch(() => ({}));
+  if (!response.ok || json.errors) {
+    throw new Error(`GitHub Projects GraphQL request failed: ${JSON.stringify(json.errors ?? { status: response.status })}`);
+  }
+  return json.data;
+}
+async function resolveProjectStatusField(input) {
+  const query = `
+    query RigProjectStatusField($projectId: ID!) {
+      node(id: $projectId) {
+        ... on ProjectV2 {
+          fields(first: 50) {
+            nodes {
+              ... on ProjectV2FieldCommon { id name }
+              ... on ProjectV2SingleSelectField { id name options { id name } }
+            }
+          }
+        }
+      }
+    }
+  `;
+  const fetchGraphQL = input.fetchGraphQL ?? defaultGraphQLFetch;
+  const data = await fetchGraphQL(query, { projectId: input.projectId }, input.token);
+  const fields = asRecord(asRecord(asRecord(data)?.node)?.fields)?.nodes;
+  for (const node of Array.isArray(fields) ? fields : []) {
+    const record = asRecord(node);
+    if (asString(record?.name)?.toLowerCase() !== "status")
+      continue;
+    const id = asString(record?.id);
+    if (!id)
+      continue;
+    const options = Array.isArray(record?.options) ? record.options.flatMap((option) => {
+      const optionRecord = asRecord(option);
+      const optionId = asString(optionRecord?.id);
+      const name = asString(optionRecord?.name);
+      return optionId && name ? [{ id: optionId, name }] : [];
+    }) : [];
+    return { id, name: "Status", options };
+  }
+  throw new Error(`GitHub Project ${input.projectId} does not expose a Status single-select field.`);
+}
+async function ensureIssueProjectItem(input) {
+  const query = `
+    query RigFindProjectIssueItem($projectId: ID!, $issueNodeId: ID!) {
+      node(id: $projectId) {
+        ... on ProjectV2 {
+          items(first: 100) { nodes { id content { ... on Issue { id } } } }
+        }
+      }
+    }
+  `;
+  const fetchGraphQL = input.fetchGraphQL ?? defaultGraphQLFetch;
+  const data = await fetchGraphQL(query, { projectId: input.projectId, issueNodeId: input.issueNodeId }, input.token);
+  const nodes = asRecord(asRecord(asRecord(data)?.node)?.items)?.nodes;
+  for (const node of Array.isArray(nodes) ? nodes : []) {
+    const record = asRecord(node);
+    const content = asRecord(record?.content);
+    if (asString(content?.id) === input.issueNodeId) {
+      const id2 = asString(record?.id);
+      if (id2)
+        return { id: id2, created: false };
+    }
+  }
+  const mutation = `
+    mutation RigAddIssueToProject($projectId: ID!, $contentId: ID!) {
+      addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) { item { id } }
+    }
+  `;
+  const created = await fetchGraphQL(mutation, { projectId: input.projectId, contentId: input.issueNodeId }, input.token);
+  const addResult = asRecord(asRecord(created)?.addProjectV2ItemById);
+  const id = asString(asRecord(addResult?.item)?.id);
+  if (!id)
+    throw new Error("GitHub Project item creation did not return an item id.");
+  return { id, created: true };
+}
+async function updateIssueProjectStatus(input) {
+  const mutation = `
+    mutation RigUpdateProjectStatus($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+      updateProjectV2ItemFieldValue(input: {
+        projectId: $projectId,
+        itemId: $itemId,
+        fieldId: $fieldId,
+        value: { singleSelectOptionId: $optionId }
+      }) { projectV2Item { id } }
+    }
+  `;
+  const fetchGraphQL = input.fetchGraphQL ?? defaultGraphQLFetch;
+  await fetchGraphQL(mutation, {
+    projectId: input.projectId,
+    itemId: input.itemId,
+    fieldId: input.fieldId,
+    optionId: input.optionId
+  }, input.token);
+}
+
+// packages/server/src/server-helpers/github-project-status-sync.ts
+var DEFAULT_PROJECT_STATUSES = {
+  running: "In Progress",
+  prOpen: "In Review",
+  ciFixing: "In Review",
+  done: "Done",
+  needsAttention: "Needs Attention"
+};
+function lifecycleStatusForTaskStatus(status) {
+  const normalized = status?.trim().toLowerCase().replace(/[-\s]+/g, "_");
+  if (!normalized)
+    return null;
+  if (normalized === "closed" || normalized === "done")
+    return "done";
+  if (normalized === "under_review" || normalized === "review" || normalized === "pr_open")
+    return "prOpen";
+  if (normalized === "ci_fixing" || normalized === "fixing")
+    return "ciFixing";
+  if (normalized === "failed" || normalized === "needs_attention" || normalized === "blocked")
+    return "needsAttention";
+  if (normalized === "in_progress" || normalized === "running" || normalized === "ready" || normalized === "open")
+    return "running";
+  return null;
+}
+function cleanString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function projectConfigFrom(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config))
+    return null;
+  const root = config;
+  return root.github?.projects ?? null;
+}
+async function syncGitHubProjectStatusForTaskUpdate(input) {
+  const projects = projectConfigFrom(input.config);
+  if (!projects?.enabled)
+    return { synced: false, reason: "project-sync-disabled" };
+  const projectId = cleanString(projects.projectId);
+  if (!projectId)
+    return { synced: false, reason: "missing-project-id" };
+  const token = cleanString(input.token);
+  if (!token)
+    return { synced: false, reason: "missing-token" };
+  const lifecycleStatus = lifecycleStatusForTaskStatus(input.status);
+  if (!lifecycleStatus)
+    return { synced: false, reason: "missing-status" };
+  const issueNodeId = cleanString(input.issueNodeId);
+  if (!issueNodeId)
+    return { synced: false, reason: "missing-issue-node-id" };
+  const projectStatus = cleanString(projects.statuses?.[lifecycleStatus]) ?? DEFAULT_PROJECT_STATUSES[lifecycleStatus];
+  const field = await resolveProjectStatusField({ projectId, token, fetchGraphQL: input.fetchGraphQL });
+  const option = field.options.find((candidate) => candidate.name.toLowerCase() === projectStatus.toLowerCase() || candidate.id === projectStatus);
+  if (!option)
+    return { synced: false, reason: "missing-project-status-option" };
+  const item = await ensureIssueProjectItem({ projectId, issueNodeId, token, fetchGraphQL: input.fetchGraphQL });
+  await updateIssueProjectStatus({
+    projectId,
+    itemId: item.id,
+    fieldId: cleanString(projects.statusFieldId) ?? field.id,
+    optionId: option.id,
+    token,
+    fetchGraphQL: input.fetchGraphQL
+  });
+  return { synced: true, lifecycleStatus, projectStatus, itemId: item.id };
+}
+function extractGitHubIssueNodeId(task) {
+  if (!task || typeof task !== "object" || Array.isArray(task))
+    return null;
+  const record = task;
+  const direct = cleanString(record.issueNodeId) ?? cleanString(record.nodeId) ?? cleanString(record.node_id);
+  if (direct)
+    return direct;
+  const raw = record.raw;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return null;
+  const rawRecord = raw;
+  return cleanString(rawRecord.id) ?? cleanString(rawRecord.nodeId) ?? cleanString(rawRecord.node_id);
+}
+export {
+  syncGitHubProjectStatusForTaskUpdate,
+  lifecycleStatusForTaskStatus,
+  extractGitHubIssueNodeId
+};

package/dist/src/server-helpers/github-projects.js

@@ -0,0 +1,147 @@
+// @bun
+// packages/server/src/server-helpers/github-projects.ts
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+async function defaultGraphQLFetch(query, variables, token) {
+  const response = await fetch("https://api.github.com/graphql", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`,
+      accept: "application/vnd.github+json"
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  const json = await response.json().catch(() => ({}));
+  if (!response.ok || json.errors) {
+    throw new Error(`GitHub Projects GraphQL request failed: ${JSON.stringify(json.errors ?? { status: response.status })}`);
+  }
+  return json.data;
+}
+function projectNodesFrom(data) {
+  const root = asRecord(data);
+  const owner = asRecord(root?.organization) ?? asRecord(root?.user);
+  const projects = asRecord(owner?.projectsV2);
+  const nodes = projects?.nodes;
+  return Array.isArray(nodes) ? nodes : [];
+}
+async function listGitHubProjects(input) {
+  const query = `
+    query RigListProjects($owner: String!, $first: Int!) {
+      organization(login: $owner) { projectsV2(first: $first, orderBy: { field: UPDATED_AT, direction: DESC }) { nodes { id number title url } } }
+      user(login: $owner) { projectsV2(first: $first, orderBy: { field: UPDATED_AT, direction: DESC }) { nodes { id number title url } } }
+    }
+  `;
+  const fetchGraphQL = input.fetchGraphQL ?? defaultGraphQLFetch;
+  const data = await fetchGraphQL(query, { owner: input.owner, first: input.first ?? 20 }, input.token);
+  return projectNodesFrom(data).flatMap((node) => {
+    const record = asRecord(node);
+    const id = asString(record?.id);
+    const number = asNumber(record?.number);
+    const title = asString(record?.title);
+    if (!id || number === undefined || !title)
+      return [];
+    return [{ id, number, title, ...asString(record?.url) ? { url: asString(record?.url) } : {} }];
+  });
+}
+async function resolveProjectStatusField(input) {
+  const query = `
+    query RigProjectStatusField($projectId: ID!) {
+      node(id: $projectId) {
+        ... on ProjectV2 {
+          fields(first: 50) {
+            nodes {
+              ... on ProjectV2FieldCommon { id name }
+              ... on ProjectV2SingleSelectField { id name options { id name } }
+            }
+          }
+        }
+      }
+    }
+  `;
+  const fetchGraphQL = input.fetchGraphQL ?? defaultGraphQLFetch;
+  const data = await fetchGraphQL(query, { projectId: input.projectId }, input.token);
+  const fields = asRecord(asRecord(asRecord(data)?.node)?.fields)?.nodes;
+  for (const node of Array.isArray(fields) ? fields : []) {
+    const record = asRecord(node);
+    if (asString(record?.name)?.toLowerCase() !== "status")
+      continue;
+    const id = asString(record?.id);
+    if (!id)
+      continue;
+    const options = Array.isArray(record?.options) ? record.options.flatMap((option) => {
+      const optionRecord = asRecord(option);
+      const optionId = asString(optionRecord?.id);
+      const name = asString(optionRecord?.name);
+      return optionId && name ? [{ id: optionId, name }] : [];
+    }) : [];
+    return { id, name: "Status", options };
+  }
+  throw new Error(`GitHub Project ${input.projectId} does not expose a Status single-select field.`);
+}
+async function ensureIssueProjectItem(input) {
+  const query = `
+    query RigFindProjectIssueItem($projectId: ID!, $issueNodeId: ID!) {
+      node(id: $projectId) {
+        ... on ProjectV2 {
+          items(first: 100) { nodes { id content { ... on Issue { id } } } }
+        }
+      }
+    }
+  `;
+  const fetchGraphQL = input.fetchGraphQL ?? defaultGraphQLFetch;
+  const data = await fetchGraphQL(query, { projectId: input.projectId, issueNodeId: input.issueNodeId }, input.token);
+  const nodes = asRecord(asRecord(asRecord(data)?.node)?.items)?.nodes;
+  for (const node of Array.isArray(nodes) ? nodes : []) {
+    const record = asRecord(node);
+    const content = asRecord(record?.content);
+    if (asString(content?.id) === input.issueNodeId) {
+      const id2 = asString(record?.id);
+      if (id2)
+        return { id: id2, created: false };
+    }
+  }
+  const mutation = `
+    mutation RigAddIssueToProject($projectId: ID!, $contentId: ID!) {
+      addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) { item { id } }
+    }
+  `;
+  const created = await fetchGraphQL(mutation, { projectId: input.projectId, contentId: input.issueNodeId }, input.token);
+  const addResult = asRecord(asRecord(created)?.addProjectV2ItemById);
+  const id = asString(asRecord(addResult?.item)?.id);
+  if (!id)
+    throw new Error("GitHub Project item creation did not return an item id.");
+  return { id, created: true };
+}
+async function updateIssueProjectStatus(input) {
+  const mutation = `
+    mutation RigUpdateProjectStatus($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+      updateProjectV2ItemFieldValue(input: {
+        projectId: $projectId,
+        itemId: $itemId,
+        fieldId: $fieldId,
+        value: { singleSelectOptionId: $optionId }
+      }) { projectV2Item { id } }
+    }
+  `;
+  const fetchGraphQL = input.fetchGraphQL ?? defaultGraphQLFetch;
+  await fetchGraphQL(mutation, {
+    projectId: input.projectId,
+    itemId: input.itemId,
+    fieldId: input.fieldId,
+    optionId: input.optionId
+  }, input.token);
+}
+export {
+  updateIssueProjectStatus,
+  resolveProjectStatusField,
+  listGitHubProjects,
+  ensureIssueProjectItem
+};

package/dist/src/server-helpers/github-reconciler.js

@@ -0,0 +1,89 @@
+// @bun
+// packages/server/src/server-helpers/task-projection.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+function projectionPath(projectRoot) {
+  return resolve(projectRoot, ".rig", "state", "task-projection.json");
+}
+function stateDir(projectRoot) {
+  return resolve(projectRoot, ".rig", "state");
+}
+function cloneTask(task) {
+  return { ...task };
+}
+function writeTaskProjection(projectRoot, input) {
+  const activeByTask = new Map((input.activeRuns ?? []).map((run) => [run.taskId, run]));
+  const tasks = input.tasks.map((task) => {
+    const projected = cloneTask(task);
+    const active = activeByTask.get(task.id);
+    if (active) {
+      projected.status = "in_progress";
+      projected.activeRun = {
+        runId: active.runId,
+        ...active.status ? { status: active.status } : {},
+        ...active.stage ? { stage: active.stage } : {}
+      };
+    }
+    return projected;
+  });
+  const snapshot = {
+    version: 1,
+    source: input.source,
+    reason: input.reason,
+    refreshedAt: input.refreshedAt ?? new Date().toISOString(),
+    tasks
+  };
+  mkdirSync(stateDir(projectRoot), { recursive: true });
+  writeFileSync(projectionPath(projectRoot), JSON.stringify(snapshot, null, 2), "utf8");
+  return snapshot;
+}
+async function refreshTaskProjection(projectRoot, input) {
+  const tasks = typeof input.tasks === "function" ? await input.tasks() : input.tasks;
+  const activeRuns = typeof input.activeRuns === "function" ? await input.activeRuns() : input.activeRuns;
+  return writeTaskProjection(projectRoot, {
+    source: input.source,
+    reason: input.reason ?? "refresh",
+    tasks,
+    activeRuns
+  });
+}
+
+// packages/server/src/server-helpers/github-reconciler.ts
+function createGitHubTaskReconciler(input) {
+  let timer = null;
+  const intervalMs = Math.max(1000, Math.trunc(input.intervalMs ?? 60000));
+  const tick = async (reason = "poll") => {
+    const projection = await refreshTaskProjection(input.projectRoot, {
+      source: input.source ?? "github-issues",
+      reason,
+      tasks: input.listTasks,
+      activeRuns: input.listActiveRuns
+    });
+    input.onRefresh?.(projection);
+    return projection;
+  };
+  return {
+    tick,
+    start() {
+      if (timer)
+        return;
+      timer = setInterval(() => {
+        tick("poll").catch(() => {});
+      }, intervalMs);
+      if (typeof timer.unref === "function")
+        timer.unref();
+    },
+    stop() {
+      if (!timer)
+        return;
+      clearInterval(timer);
+      timer = null;
+    },
+    isRunning() {
+      return timer !== null;
+    }
+  };
+}
+export {
+  createGitHubTaskReconciler
+};