syncstaff-mcp 0.2.3

package/dist/lib/path-warnings.js

@@ -0,0 +1,90 @@
+/**
+ * Declared paths that match nothing in the checkout.
+ *
+ * Computed by the AGENT, in the agent's own checkout, and sent with the
+ * declaration. It used to be computed on the server against `repo_path` — a
+ * copy of the repository on the server's own disk, at whatever commit it last
+ * pulled, which is nobody's working tree. That made the same declaration
+ * warn on one instance and stay silent on another, and it was the last thing
+ * keeping a filesystem dependency inside a Keel process
+ * (inv_01KZWPAT93H32HB3X48FNPTA1E).
+ *
+ * Only filenames are read, never file contents, so this never breached the
+ * "must not process raw code" half of the boundary the way the blast-radius
+ * fallback did. It was simply asking the wrong machine.
+ *
+ * Living in lib/ rather than in the server because both ends need it: the
+ * adapter to produce the warnings, and the tests to check the logic without
+ * standing up an HTTP server for arithmetic on strings.
+ */
+import { globMatches, isGlob } from "./globs.js";
+export function declaredPathWarnings(paths, files) {
+    // An EMPTY file list is "could not look", not "the repository is empty",
+    // and conflating them turns this into a machine for crying wolf. That is not
+    // hypothetical: `repo_path` still said /opt/charter/sync after the
+    // Charter -> Keel rename, the walk returned [], and every declared path came
+    // back as a warning — including `keel/src/server/app.ts`, which obviously
+    // exists. A check that fires on everything is worse than no check, because
+    // it teaches the reader to skip the one that matters.
+    //
+    // The guard lives here rather than in each caller because the caller that
+    // forgets it is exactly how the incident happened.
+    if (files.length === 0)
+        return null;
+    const dirs = new Set();
+    const byBasename = new Map();
+    for (const file of files) {
+        const parts = file.split("/");
+        for (let i = 1; i < parts.length; i++)
+            dirs.add(parts.slice(0, i).join("/"));
+        const base = parts[parts.length - 1];
+        const bucket = byBasename.get(base);
+        if (bucket)
+            bucket.push(file);
+        else
+            byBasename.set(base, [file]);
+    }
+    const warnings = [];
+    for (const path of paths) {
+        if (typeof path !== "string" || !path.trim())
+            continue;
+        const clean = path.replace(/^\.\//, "").replace(/\/+$/, "");
+        // Paths under .claude/, .codex/, .github/ or .agents/ are never warned
+        // about. Those directories hold the hook configs agents legitimately edit.
+        //
+        // This used to be compensation rather than policy: the old `listRepoFiles`
+        // walk skipped any directory whose name began with a dot, so such files
+        // could not appear in `files` at all, and warning would have reported the
+        // walker's blind spot as the caller's mistake. That walk is gone —
+        // `discoverFiles` asks git, which returns tracked dot-directory files
+        // normally — so the skip is now a deliberate choice rather than a
+        // workaround, and is kept because the behaviour it produces was right for
+        // its own reasons. Revisit it as policy, not as a bug.
+        //
+        // A dotfile at a visible path is still checked: only directory segments
+        // are skipped, so `.mcp.json` at the root is warned about as normal.
+        if (clean.split("/").slice(0, -1).some((segment) => segment.startsWith(".")))
+            continue;
+        if (isGlob(clean)) {
+            // A glob that matches nothing today is weaker evidence — it may be
+            // written for files this very intent will create. Still worth saying.
+            if (!files.some((f) => globMatches(clean, f))) {
+                warnings.push({ path, reason: "no_match", did_you_mean: [] });
+            }
+            continue;
+        }
+        if (files.includes(clean) || dirs.has(clean))
+            continue;
+        const slash = clean.lastIndexOf("/");
+        const parent = slash === -1 ? "" : clean.slice(0, slash);
+        const base = clean.slice(slash + 1);
+        warnings.push({
+            path,
+            // A missing parent directory is the strong signal: the file cannot be
+            // new, because there is nowhere for it to be new in.
+            reason: parent && !dirs.has(parent) ? "no_parent_directory" : "no_match",
+            did_you_mean: (byBasename.get(base) ?? []).slice(0, 3),
+        });
+    }
+    return warnings;
+}

package/dist/lib/protocol.js

@@ -0,0 +1,95 @@
+/**
+ * The coordination protocol, as a single source of truth.
+ *
+ * This text is served to every MCP client through the server's
+ * `instructions` field at connect time, which is what makes the
+ * experience uniform: a client with no hook support and no repo-local
+ * doc file (Cursor, Gemini CLI, a homegrown agent) still receives the
+ * protocol before its first tool call. `CLAUDE.md` / `AGENTS.md` remain
+ * useful for hook-enforced clients, but they are no longer the only way
+ * an agent learns the rules.
+ */
+/** Rendered into MCP `instructions`; also returned by the protocol tool. */
+export const PROTOCOL_INSTRUCTIONS = `Sync — cross-agent coordination. MANDATORY protocol.
+
+You share this codebase with other AI agents working simultaneously,
+possibly on other machines, directed by a different human. You cannot see
+their work directly. Other agents are relying on your calls being real.
+
+PATHS. Every path you pass to a Sync tool is relative to the git
+repository root, never to your current working directory. In a monorepo
+that means "packages/api/src/db.ts", never "src/db.ts". Getting this
+wrong means two agents hold "leases" on the same physical file under
+different strings and never see each other — collision detection
+silently stops working while every call still succeeds. Call
+sync_whoami if you are unsure what the repository root is.
+
+AT SESSION START. Call sync_get. It returns the project's purpose,
+non-goals, and binding invariants. If a task requires violating an
+invariant, do not proceed: call sync_propose_amendment and work on
+something else while a human decides.
+
+BOARD TRACKING. Material work goes on the board before it starts. A change
+spanning two or more files, or changing a named interface, is material:
+create or find an active board item first and pass that item's id as task_id
+to intent_declare. An unlinked material declaration is escalated and must not
+acquire leases until a human approves an exception. The gate is re-checked
+when you acquire the lease, against the paths you actually ask for — a narrow
+declaration does not buy a wide lease. Every declaration response carries
+board_policy, which tells you whether the requirement is on for this project
+and what it is missing.
+
+BEFORE EDITING ANY FILE.
+1. intent_declare with a one-sentence summary, every path you will
+   touch, and every interface you will add, remove, or change the
+   signature of. The response includes an arbiter verdict, a blast
+   radius, and an "overlaps" list naming any other agent already working
+   on those files or directories.
+2. If the verdict is not "clear", stop this line of work. A human has
+   been notified. Pick up a different task.
+3. lease_acquire on those paths.
+4. If the lease is denied, the response names the blocking agent and
+   their intent. Take the partial grant, re-scope to non-conflicting
+   paths, or claim a different task. Do not wait idly, and never edit a
+   path you were denied.
+5. If you are unsure whether a specific file is covered, call
+   lease_check before writing to it. Some clients block unleased edits
+   automatically; if yours does not, lease_check is how you self-police.
+
+WHILE WORKING. Leases expire. Call lease_renew on long tasks.
+
+HUMAN DECISIONS. When intent_declare returns an escalation, the MCP call
+actively waits for the durable arbiter decision and returns automatically
+when it is resolved. The adapter listens to the coordinator SSE stream,
+reconnects after interruptions, and polls as a fallback. Do not ask the
+human to come back and repeat an approval they already gave. If the bounded
+wait expires, the escalation remains durable and the response includes its id.
+
+WHEN FINISHED, IN THIS ORDER.
+1. Commit the finished work. intent_complete fails while any leased path
+   is still uncommitted or when the checkout cannot be verified. Its result
+   warns, but does not block, when HEAD is ahead of its configured upstream
+   or the upstream cannot be checked; push before calling work shared or
+   deployed when your repository workflow requires it.
+2. surface_delta_publish with every exported symbol, route, schema,
+   config key, env var, or dependency you changed. Other agents build
+   against this; omitting it hands them a stale picture of your code.
+3. intent_complete.
+4. lease_release.
+
+ON INTERFACE CHANGES. When your intent changes a signature or removes an
+export, the server resolves every call site before granting your lease.
+Free call sites are added to your lease — you are then expected to fix
+them before releasing. Never release a lease leaving known-broken call
+sites behind.
+
+ENFORCEMENT. Coverage differs by client: some block unleased writes at
+the tool level, others cannot. Writes made through a shell (redirects,
+sed -i) bypass tool-level blocking everywhere. Unleased changes to the
+working tree are detected and reported to both humans regardless of
+client, so the protocol is not optional for anyone.`;
+/** Compact reminder suitable for embedding in a tool response. */
+export const PROTOCOL_REMINDER = "Sync protocol: intent_declare -> lease_acquire -> edit -> commit -> " +
+    "surface_delta_publish -> intent_complete -> lease_release. " +
+    "All paths are relative to the git repository root.";
+export const TASK_REOPEN_RULE = "Completed tasks may be reopened only through POST /tasks/:id/reopen with a durable reason; the transition is recorded as in_progress.";

package/dist/lib/types.js

@@ -0,0 +1,69 @@
+export const DEFAULT_SETTINGS = {
+    lease_default_ttl_seconds: 900,
+    heartbeat_interval_seconds: 30,
+    arbiter_model: "claude-haiku-4-5",
+    model_roles: {},
+    arbiter_enabled: true,
+    escalation_batch_window_seconds: 60,
+    stuck_threshold_seconds: 600,
+    escalation_ttl_days: 7,
+    declared_intent_ttl_hours: 4,
+    blast_radius_enabled: true,
+    blast_radius_escalation_threshold: 15,
+    blast_radius_auto_widen: true,
+    shadow_merge_enabled: false,
+    preflight_mode: "fail_open",
+    // Default to same_file, not same_dir. Directory proximity between three
+    // agents in one monorepo is constant, and an alert that always fires trains
+    // everyone to ignore Telegram — which costs the actionable alerts too.
+    overlap_alerts: "same_file",
+    // On by default. The gate landed opt-in and every project inherited `false`,
+    // which meant the requirement existed only in the protocol text agents are
+    // asked to follow — and a rule nothing checks is a rule that is followed
+    // when it is convenient. Material work is a change spanning two or more
+    // files or changing a named interface; that is the class of work another
+    // agent, or a human reading the board a week later, has to be able to see
+    // coming. Small investigations stay frictionless, and a project that wants
+    // the old behaviour sets this to false explicitly rather than by omission.
+    board_required_for_material_work: true,
+};
+// ---------------------------------------------------------------------------
+// M9b — the board (§9 of the 12 Aug decision list)
+// ---------------------------------------------------------------------------
+/**
+ * The canonical status set, ratified rather than inferred.
+ *
+ * These are the values `tasks.status` already used (`available`,
+ * `in_progress`, `completed`) plus the three a board needs to say why nothing
+ * is happening. The deployed M9d page guessed a different union; §9 decision 2
+ * settles it here so the UI has one list to render and the importer has one
+ * mapping to write: open -> available, in flight / `[~]` -> in_progress,
+ * done -> completed.
+ */
+export const BOARD_STATUSES = [
+    "available",
+    "in_progress",
+    "blocked",
+    "needs_human",
+    "completed",
+    "abandoned",
+];
+/**
+ * The canonical kind set. `decision` and `finding` are why this is not just a
+ * task tracker: the 8.11/8.12 pages spent most of their length on findings
+ * that were not work items and decisions that were not either, and losing
+ * those to a feature/chore/bug vocabulary is what made each page go stale
+ * within a day.
+ */
+export const BOARD_KINDS = ["phase", "item", "debt", "decision", "finding"];
+/**
+ * An owner, §9 decision 3: a *set* of typed principals rather than one
+ * `owner_vendor` string.
+ *
+ * Two facts force this. Items on the current board are jointly owned ("human
+ * ratifies, agent implements"), and several agents legitimately share one
+ * vendor — so a vendor string identifies a population, not a party. The live
+ * agent id stays in `claimed_by`, which is a different question: ownership is
+ * durable, a claim is a lease on attention.
+ */
+export const BOARD_PRINCIPAL_TYPES = ["vendor", "account"];

package/dist/lib/version.js

@@ -0,0 +1,21 @@
+/** Release version shared by the server and the published MCP adapter. */
+export const KEEL_RELEASE_VERSION = "0.2.3";
+/**
+ * Adapter/API compatibility level.
+ *
+ * This changes only when the adapter's HTTP calls stop being compatible with
+ * the server. It is deliberately separate from the npm package version so a
+ * bug-fix release does not manufacture a protocol break.
+ */
+export const KEEL_ADAPTER_PROTOCOL_VERSION = 1;
+export const KEEL_ADAPTER_VERSION_HEADER = "x-keel-adapter-version";
+export const KEEL_ADAPTER_PROTOCOL_HEADER = "x-keel-adapter-protocol";
+export const KEEL_SERVER_VERSION_HEADER = "x-keel-server-version";
+export const KEEL_SUPPORTED_ADAPTER_PROTOCOL_HEADER = "x-keel-supported-adapter-protocol";
+/** Headers attached to every adapter-to-server request. */
+export function adapterRequestHeaders() {
+    return {
+        [KEEL_ADAPTER_VERSION_HEADER]: KEEL_RELEASE_VERSION,
+        [KEEL_ADAPTER_PROTOCOL_HEADER]: String(KEEL_ADAPTER_PROTOCOL_VERSION),
+    };
+}

package/dist/lib/worktree.js

@@ -0,0 +1,211 @@
+/**
+ * Unleased-write detection.
+ *
+ * Tool-level blocking (Claude Code hooks, Codex apply_patch hooks) is not
+ * available on every client, and no client blocks shell writes. This module
+ * closes that gap the one way that works everywhere: it reads the local git
+ * working tree and reports files that changed while nobody held a lease on
+ * them. It runs inside whichever process has the checkout — the MCP adapter
+ * or the CLI — so a Cursor, Gemini, or homegrown client is covered by the
+ * same mechanism as a hook-enforced one.
+ *
+ * Detection, not prevention: the point is that a silent violation becomes a
+ * visible one, alerted to both humans.
+ *
+ * What this module can and cannot know is load-bearing. `git status` reports
+ * that the *worktree* changed, never which process changed it. When several
+ * agents share one checkout — the normal case on a developer's machine — every
+ * one of them observes every dirty file. So a report is an *observation*, and
+ * naming the observer as the writer is a claim the mechanism cannot support.
+ * Attribution is decided server-side, where the set of agents sharing a
+ * checkout is known; see POST /unleased-writes in server/app.ts.
+ */
+import { execFileSync } from "node:child_process";
+import { join } from "node:path";
+import { globMatches, isGlob, pathsOverlap } from "./globs.js";
+/**
+ * Paths changed in the working tree, relative to the git root.
+ * Renames report both sides. Throws when git cannot inspect the checkout.
+ *
+ * Completion uses this fail-closed form: an unreadable worktree is unknown,
+ * not clean, and therefore cannot prove that an intent's work landed.
+ */
+export function listWorktreeChangesStrict(repoRoot) {
+    // -uall expands untracked directories into individual files. Without it
+    // git reports a collapsed "dir/" entry, which no lease path would match
+    // — a false unleased-write alert for files that are in fact covered.
+    const out = execFileSync("git", ["-C", repoRoot, "status", "--porcelain=v1", "-z", "-uall"], {
+        encoding: "utf8",
+        maxBuffer: 8 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    const changes = [];
+    // NUL-separated records; a rename/copy record is followed by an extra
+    // NUL-terminated field holding the original path.
+    const fields = out.split("\0");
+    for (let i = 0; i < fields.length; i++) {
+        const record = fields[i];
+        if (record.length < 4)
+            continue;
+        const status = record.slice(0, 2);
+        const path = record.slice(3);
+        if (status[0] === "R" || status[0] === "C") {
+            const from = fields[++i];
+            if (from)
+                changes.push({ path: from, status });
+        }
+        if (path)
+            changes.push({ path, status });
+    }
+    return changes;
+}
+/**
+ * Number of local commits absent from the branch's configured upstream.
+ *
+ * Like the strict worktree reader above, this throws when git cannot prove the
+ * answer. Callers decide policy: intent completion blocks on unknown dirtiness,
+ * but an unknown/ahead upstream is a warning because holding a lease until a
+ * deploy or push succeeds would obstruct every other agent.
+ */
+export function commitsAheadOfUpstreamStrict(repoRoot) {
+    const out = execFileSync("git", ["-C", repoRoot, "rev-list", "--count", "@{upstream}..HEAD"], {
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024,
+        stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+    if (!/^\d+$/.test(out)) {
+        throw new Error(`git returned an invalid upstream ahead count: ${JSON.stringify(out)}`);
+    }
+    const count = Number(out);
+    if (!Number.isSafeInteger(count)) {
+        throw new Error(`git returned an unsafe upstream ahead count: ${JSON.stringify(out)}`);
+    }
+    return count;
+}
+/** Non-blocking completion metadata derived from the strict ahead count. */
+export function upstreamLandingReport(repoRoot) {
+    try {
+        const aheadCount = commitsAheadOfUpstreamStrict(repoRoot);
+        if (aheadCount === 0) {
+            return { upstream_status: "synced", ahead_count: 0 };
+        }
+        return {
+            upstream_status: "ahead",
+            ahead_count: aheadCount,
+            warning: `Intent completed, but HEAD is ${aheadCount} ` +
+                `commit${aheadCount === 1 ? "" : "s"} ahead of its configured upstream. ` +
+                "Push before treating this work as shared or deployed.",
+        };
+    }
+    catch {
+        return {
+            upstream_status: "unknown",
+            ahead_count: null,
+            warning: "Intent completed, but Keel could not verify whether HEAD is published to an " +
+                "upstream branch. Configure a tracking branch or verify and push manually.",
+        };
+    }
+}
+/**
+ * Best-effort worktree inspection for background unleased-write detection.
+ * Detection must never break unrelated tool calls, so this compatibility
+ * wrapper preserves the historical [] result when git is unavailable.
+ */
+export function listWorktreeChanges(repoRoot) {
+    try {
+        return listWorktreeChangesStrict(repoRoot);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Changed paths not covered by any of `leasedPaths`.
+ *
+ * `ignore` drops paths that are never coordination-relevant (Keel's own
+ * per-session state, build output, dependencies). Directories must be given
+ * with a trailing slash.
+ */
+export function findUnleasedWrites(changes, leasedPaths, ignore = DEFAULT_IGNORES) {
+    const unleased = [];
+    const seen = new Set();
+    for (const change of changes) {
+        if (ignore.some((i) => (i.endsWith("/") ? change.path.startsWith(i) : change.path === i))) {
+            continue;
+        }
+        const covered = leasedPaths.some((p) => isGlob(p) ? globMatches(p, change.path) : pathsOverlap(p, change.path));
+        if (covered || seen.has(change.path))
+            continue;
+        seen.add(change.path);
+        unleased.push(change);
+    }
+    return unleased;
+}
+/**
+ * Attach a content hash to each change.
+ *
+ * `git hash-object` is the cheap way to get git's own blob id without staging
+ * anything. Deleted files have no content, and a hash that cannot be taken
+ * falls back to a *stable* placeholder — a changing placeholder would defeat
+ * the dedupe it exists to feed and reinstate the alert storm.
+ */
+export function fingerprintWrites(repoRoot, changes) {
+    const present = changes.filter((c) => !c.status.includes("D"));
+    const hashes = new Map();
+    if (present.length > 0) {
+        try {
+            const out = execFileSync("git", ["-C", repoRoot, "hash-object", "--stdin-paths"], {
+                input: present.map((c) => join(repoRoot, c.path)).join("\n") + "\n",
+                encoding: "utf8",
+                maxBuffer: 8 * 1024 * 1024,
+            });
+            const lines = out.split("\n").filter((line) => line.length > 0);
+            // A partial result cannot be aligned back to its inputs, so take it only
+            // when every path answered.
+            if (lines.length === present.length) {
+                present.forEach((change, i) => hashes.set(change.path, lines[i]));
+            }
+        }
+        catch {
+            // unreadable file, race with a delete, no git — fall through
+        }
+    }
+    return changes.map((change) => ({
+        ...change,
+        fingerprint: hashes.get(change.path) ?? (change.status.includes("D") ? "deleted" : "unhashed"),
+    }));
+}
+const describe = (a) => `${a.vendor} · ${a.human_owner}`;
+/** Telegram text for an unleased-write report. */
+export function formatUnleasedWriteAlert(report, writes) {
+    const { observer, attributed } = report;
+    const machine = observer.machine_id ? ` · ${observer.machine_id}` : "";
+    const lines = attributed
+        ? ["🚨 Unleased write detected", `${describe(observer)}${machine}`]
+        : ["🚨 Unleased change in a shared checkout", `seen by ${describe(observer)}${machine}`];
+    lines.push("", "changed without holding a lease:");
+    for (const w of writes.slice(0, 10)) {
+        lines.push(`  ${w.path}${w.status.includes("?") ? " (untracked)" : ""}`);
+    }
+    if (writes.length > 10)
+        lines.push(`  …and ${writes.length - 10} more`);
+    if (!attributed) {
+        const others = report.sharing ?? [];
+        lines.push("", `${others.length + 1} agents share this checkout, so the writer cannot be identified:`, [observer, ...others].map(describe).join(", "));
+    }
+    return lines.join("\n");
+}
+export const DEFAULT_IGNORES = [
+    ".keel/",
+    "node_modules/",
+    "dist/",
+    "build/",
+    ".git/",
+    // Per-agent client configuration. These live in the repo so the protocol
+    // travels with a checkout, but they are edited by whichever client owns
+    // them and are never coordination-relevant. Left in, an untracked one is a
+    // permanent dirty file and therefore a permanent alert.
+    ".claude/",
+    ".codex/",
+    ".gemini/",
+];

package/dist/mcp/cloud-connector.js

@@ -0,0 +1,99 @@
+/**
+ * Privacy-bounded outbound connection from a local MCP runtime to Syncstaff
+ * Cloud. The cloud may ask for one Phase 1 operation (`health_check`), but all
+ * execution remains local and the response is a bounded status code.
+ */
+const DEFAULT_INTERVAL_MS = 30_000;
+export function startCloudConnector(options) {
+    let installationId = null;
+    let priorLatencyMs = null;
+    let pendingErrorCode = null;
+    let active = null;
+    let stopped = false;
+    const cycle = async () => {
+        if (stopped)
+            return;
+        try {
+            if (!installationId) {
+                const registration = await options.api('POST', '/cloud/installations', {
+                    machine_id: options.machineId,
+                    display_name: options.displayName ?? options.machineId,
+                    client_version: options.clientVersion,
+                    protocol_version: options.protocolVersion,
+                    platform: options.platform,
+                });
+                if (typeof registration.id !== 'string' || !registration.id) {
+                    pendingErrorCode = 'registration_invalid';
+                    return;
+                }
+                installationId = registration.id;
+            }
+            let agentCount = 1;
+            let activeAgentCount = 1;
+            try {
+                const agents = await options.api('GET', `/agents?project_id=${encodeURIComponent(options.projectId)}`);
+                if (Array.isArray(agents)) {
+                    agentCount = agents.length;
+                    activeAgentCount = agents.filter((agent) => agent.status === 'active').length;
+                }
+            }
+            catch {
+                // The connector remains useful when the aggregate snapshot is
+                // unavailable; one running local adapter is still known to be active.
+            }
+            const heartbeatStarted = Date.now();
+            await options.api('POST', `/cloud/installations/${installationId}/heartbeat`, {
+                client_version: options.clientVersion,
+                protocol_version: options.protocolVersion,
+                platform: options.platform,
+                latency_ms: priorLatencyMs,
+                error_code: pendingErrorCode,
+                agent_count: agentCount,
+                active_agent_count: activeAgentCount,
+                // Token reporting has its own explicit tool and provider semantics.
+                // Until a durable per-installation aggregate exists, zero is truthful;
+                // inventing or double-counting usage here would be worse.
+                input_tokens_total: 0,
+                output_tokens_total: 0,
+            });
+            priorLatencyMs = Math.max(0, Date.now() - heartbeatStarted);
+            pendingErrorCode = null;
+            try {
+                const command = await options.api('GET', `/cloud/installations/${installationId}/commands/next`);
+                if (typeof command?.id !== 'string' || !command.id)
+                    return;
+                const supported = command.kind === 'health_check';
+                await options.api('POST', `/cloud/installations/${installationId}/commands/${encodeURIComponent(command.id)}/result`, supported
+                    ? { status: 'succeeded', result_code: 'healthy' }
+                    : { status: 'failed', result_code: 'unsupported_command' });
+            }
+            catch {
+                pendingErrorCode = 'command_poll_failed';
+            }
+        }
+        catch {
+            pendingErrorCode = 'cloud_connection_failed';
+        }
+    };
+    const runOnce = () => {
+        if (active)
+            return active;
+        active = cycle().finally(() => {
+            active = null;
+        });
+        return active;
+    };
+    const intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+    const timer = intervalMs > 0 ? setInterval(() => void runOnce(), intervalMs) : null;
+    timer?.unref();
+    const ready = runOnce();
+    return {
+        ready,
+        runOnce,
+        stop() {
+            stopped = true;
+            if (timer)
+                clearInterval(timer);
+        },
+    };
+}