@agentshouse/kit 0.1.0-alpha.3 → 0.1.0-alpha.30

package/src/skill-set.js

@@ -0,0 +1,85 @@
+import { readFileSync } from "node:fs";
+import { cp, lstat, mkdir, readdir, realpath, rm, symlink } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { KitRefusal } from "./refusal.js";
+import { readNote, writeNote, writeText } from "./state.js";
+
+export const SKILL_SET_SOURCE = fileURLToPath(new URL("skill-set/", import.meta.url));
+const KIT_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+
+function recordPath(directory) {
+  return join(directory, "state", "skill-set.json");
+}
+
+function howWeWorkNotePath(directory) {
+  return join(directory, "state", "how-we-work");
+}
+
+function placed(home, name) {
+  return {
+    skill: join(home, ".agents", "skills", name),
+    link: join(home, ".claude", "skills", name),
+  };
+}
+
+async function present(path) {
+  try {
+    await lstat(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+async function removeRecorded(home, names) {
+  for (const name of names) {
+    const { skill, link } = placed(home, name);
+    await rm(link, { recursive: true, force: true });
+    await rm(skill, { recursive: true, force: true });
+  }
+}
+
+async function installed(directory, home, version) {
+  const names = [];
+  for (const name of (await readdir(SKILL_SET_SOURCE)).sort()) {
+    const { skill, link } = placed(home, name);
+    if (!(await present(skill)) && !(await present(link))) names.push(name);
+  }
+  await writeNote(recordPath(directory), { names });
+  await mkdir(join(home, ".agents", "skills"), { recursive: true });
+  await mkdir(join(home, ".claude", "skills"), { recursive: true });
+  const shared =
+    (await realpath(join(home, ".claude", "skills"))) === (await realpath(join(home, ".agents", "skills")));
+  for (const name of names) {
+    const { skill, link } = placed(home, name);
+    await cp(join(SKILL_SET_SOURCE, name), skill, { recursive: true });
+    if (!shared) await symlink(join("..", "..", ".agents", "skills", name), link);
+  }
+  await writeNote(recordPath(directory), { version, names });
+}
+
+export async function reconcileSkillSet({ directory, home, accepted, version = KIT_VERSION }) {
+  try {
+    const record = await readNote(recordPath(directory), null);
+    if (accepted && record?.version === version) return;
+    if (record !== null) await removeRecorded(home, record.names);
+    if (accepted) await installed(directory, home, version);
+    else await rm(recordPath(directory), { force: true });
+  } catch (error) {
+    if (error instanceof KitRefusal) throw error;
+    throw new KitRefusal("kit_skill_set_unavailable", `${error.path ?? home} (${error.code ?? "unknown"})`);
+  }
+}
+
+export async function howWeWorkOwed(directory) {
+  return (
+    (await readNote(recordPath(directory), null)) !== null &&
+    !(await present(howWeWorkNotePath(directory)))
+  );
+}
+
+export async function noteHowWeWork(directory) {
+  await writeText(howWeWorkNotePath(directory), "");
+}

package/src/source.js

@@ -12,8 +12,9 @@ import {
   newCheckpoint,
   stallOf,
 } from "./delivery.js";
-import { captureBatch, openSession } from "./house.js";
-import { googlePage } from "./google/source.js";
+import { captureBatch, maintainControl, openSession } from "./house.js";
+import { GOOGLE_SOURCES } from "./google/oauth.js";
+import { googlePage, recordAccountEmail } from "./google/source.js";
 import { houseAnswered, houseAnsweredFailure, houseFailed, KitRefusal } from "./refusal.js";
 import { recordAcceptedOriginals, sameReference, saveSourceOriginals } from "./source-originals.js";
 import {
@@ -29,14 +30,15 @@ import {
   writeCheckpoint,
 } from "./state.js";
 
+const GOOGLE = Object.freeze({ id: GOOGLE_SOURCES, preset: "google" });
+
 async function acquire(context, service, checkpoint, limit) {
-  if (context.instance.preset === "google") {
+  if (service.google !== undefined) {
     return googlePage(
       {
         directory: context.directory,
-        instance: context.instance.id,
-        client: context.googleOAuthClient,
-        service,
+        account: service.google.account,
+        service: service.google.service,
         cursor: checkpoint.cursor,
         limit,
         backfillFloor:
@@ -169,6 +171,7 @@ async function deliverService(context, service) {
       context.instance.preset === "custom"
         ? { ...context, environment: await resolveEnvironment(service.connector) }
         : context;
+    if (service.google !== undefined) await recordAccountEmail(context, service.google);
     await runDeliveryLoop(resolved, service, progress);
   } catch (refusal) {
     if (!(refusal instanceof KitRefusal) || refusal.code === "kit_command_cancelled") throw refusal;
@@ -197,25 +200,70 @@ async function deliverService(context, service) {
   };
 }
 
+function initialBackfill(initial) {
+  if (initial.new === true) return { kind: "days", bound: 0 };
+  if (initial.days !== undefined) return { kind: "days", bound: initial.days };
+  if (initial.items !== undefined) return { kind: "count", bound: initial.items };
+  return { kind: "all" };
+}
+
+export async function captureEntry(context, entry) {
+  const delivered = await deliverService(
+    { ...context, instance: GOOGLE },
+    {
+      service: entry.source,
+      sourceRef: entry.source,
+      rooms: entry.rooms,
+      backfill: initialBackfill(entry.initial),
+      google: { account: entry.account, service: entry.service },
+    },
+  );
+  return { ...delivered, service: entry.service };
+}
+
 export async function captureSource(options, dependencies = {}) {
   const configuration = await readConfiguration(options.configuration);
   const instance = sourceInstance(configuration, options.instance);
   const services = declaredServices(instance, options.service ?? null);
-  const googleOAuthClient =
-    instance.preset === "google" ? dependencies.googleOAuthClient() : null;
   const session = await openSession(options, dependencies);
-  const context = {
-    instance,
+  return maintainControl(
     session,
-    directory: options.directory,
-    signal: options.signal,
-    now: session.now,
-    dependencies,
-    googleOAuthClient,
+    async (signal) => {
+      const context = {
+        instance,
+        session,
+        directory: options.directory,
+        signal,
+        now: session.now,
+        dependencies,
+      };
+      const delivered = [];
+      for (const service of services) delivered.push(await deliverService(context, service));
+      return { instance: instance.id, services: delivered };
+    },
+    options.signal,
+  );
+}
+
+export async function localServiceState(directory, instance, service) {
+  return {
+    health: (await readHealth(directory, instance, service)) ?? {
+      state: "pending",
+      category: null,
+      observed_at: null,
+    },
+    checkpoint: await readCheckpoint(directory, instance, service),
+    gaps: await readCoverageGaps(directory, instance, service),
+    dropped: await readDroppedItems(directory, instance, service),
+    originals: (await readSourceOriginals(directory, instance, service)).map((reference) => ({
+      room: reference.room,
+      record: reference.record,
+      position: reference.position,
+      native_object_id: reference.native_object_id,
+      save: reference.save,
+      error: reference.error,
+    })),
   };
-  const delivered = [];
-  for (const service of services) delivered.push(await deliverService(context, service));
-  return { instance: instance.id, services: delivered };
 }
 
 export async function sourceStatus(options) {
@@ -228,24 +276,7 @@ export async function sourceStatus(options) {
       service: service.service,
       source_ref: service.sourceRef,
       rooms: service.rooms,
-      health: (await readHealth(options.directory, instance.id, service.service)) ?? {
-        state: "pending",
-        category: null,
-        observed_at: null,
-      },
-      checkpoint: await readCheckpoint(options.directory, instance.id, service.service),
-      gaps: await readCoverageGaps(options.directory, instance.id, service.service),
-      dropped: await readDroppedItems(options.directory, instance.id, service.service),
-      originals: (await readSourceOriginals(options.directory, instance.id, service.service)).map(
-        (reference) => ({
-          room: reference.room,
-          record: reference.record,
-          position: reference.position,
-          native_object_id: reference.native_object_id,
-          save: reference.save,
-          error: reference.error,
-        }),
-      ),
+      ...(await localServiceState(options.directory, instance.id, service.service)),
     });
   }
   return { instance: instance.id, preset: instance.preset, services: reported };
@@ -255,32 +286,40 @@ export async function retrySourceOriginals(options, dependencies = {}) {
   const configuration = await readConfiguration(options.configuration);
   const instance = sourceInstance(configuration, options.instance);
   const services = declaredServices(instance, options.service ?? null);
-  const context = { instance, directory: options.directory, signal: options.signal };
   const outstanding = [];
   for (const service of services) {
     outstanding.push((await readSourceOriginals(options.directory, instance.id, service.service)).length);
   }
-  if (outstanding.some((count) => count > 0)) context.session = await openSession(options, dependencies);
-  const retried = [];
-  for (const [position, service] of services.entries()) {
-    retried.push({
-      service: service.service,
-      originals:
-        outstanding[position] === 0
-          ? []
-          : await saveSourceOriginals(context, serviceBinding(context, service)),
-    });
-  }
-  return { instance: instance.id, services: retried };
+  const retry = async (context) => {
+    const retried = [];
+    for (const [position, service] of services.entries()) {
+      retried.push({
+        service: service.service,
+        originals:
+          outstanding[position] === 0
+            ? []
+            : await saveSourceOriginals(context, serviceBinding(context, service)),
+      });
+    }
+    return { instance: instance.id, services: retried };
+  };
+  const context = { instance, directory: options.directory, signal: options.signal };
+  if (outstanding.every((count) => count === 0)) return retry(context);
+  const session = await openSession(options, dependencies);
+  return maintainControl(session, (signal) => retry({ ...context, session, signal }), options.signal);
 }
 
 export async function resetSource(options, dependencies = {}) {
   const configuration = await readConfiguration(options.configuration);
   const instance = sourceInstance(configuration, options.instance);
   declaredServices(instance, options.service);
-  await openSession(options, dependencies);
-  return {
-    instance: instance.id,
-    services: await resetCheckpoints(options.directory, instance.id, options.service),
-  };
+  const session = await openSession(options, dependencies);
+  return maintainControl(
+    session,
+    async () => ({
+      instance: instance.id,
+      services: await resetCheckpoints(options.directory, instance.id, options.service),
+    }),
+    options.signal,
+  );
 }

package/src/state.js

@@ -9,10 +9,28 @@ function segment(name) {
   return name;
 }
 
-function notePath(directory, instance, service, kind) {
+export function notePath(directory, instance, service, kind) {
   return join(directory, "state", segment(instance), kind, `${segment(service)}.json`);
 }
 
+export async function noteNames(directory, instance, kind) {
+  let present;
+  try {
+    present = await readdir(join(directory, "state", segment(instance), kind));
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw new KitRefusal("kit_state_unreadable", kind);
+  }
+  return present
+    .filter((name) => name.endsWith(".json"))
+    .map((name) => name.slice(0, -".json".length))
+    .sort();
+}
+
+export async function removeNotes(directory, instance, service, kinds) {
+  for (const kind of kinds) await rm(notePath(directory, instance, service, kind), { force: true });
+}
+
 function repositoryPath(directory, key) {
   if (!/^[a-f0-9]{64}$/.test(key)) throw new KitRefusal("kit_state_name_invalid", key);
   return join(directory, "state", "repositories", `${key}.json`);

package/src/sync-library.js

@@ -100,13 +100,12 @@ function recordedMap(authority) {
   return new Map(authority.files.map((file) => [file.path, file]));
 }
 
-function structuredOrReplace(root, relative, recorded, content) {
+export function structuredOrReplace(root, relative, recorded, content) {
   const path = housePath(root, relative);
+  const whole = [{ op: "replace", path, base: recorded.revision, content }];
   const before = parse(recorded.content, relative);
   const after = parse(content, relative);
-  if (!before.ok || !after.ok) {
-    return [{ op: "replace", path, base: recorded.revision, content }];
-  }
+  if (!before.ok || !after.ok) return whole;
   const ops = [];
   if (before.document.preamble !== after.document.preamble) {
     ops.push({
@@ -124,9 +123,7 @@ function structuredOrReplace(root, relative, recorded, content) {
     if (JSON.stringify(before.document.fields[name]) === JSON.stringify(after.document.fields[name])) {
       continue;
     }
-    if (after.document.fields[name] === undefined) {
-      return [{ op: "replace", path, base: recorded.revision, content }];
-    }
+    if (after.document.fields[name] === undefined) return whole;
     const change = { op: "set_field", path, field: name, value: after.document.fields[name] };
     if (before.document.fields[name] !== undefined) change.base = before.document.fields[name];
     ops.push(change);
@@ -139,12 +136,11 @@ function structuredOrReplace(root, relative, recorded, content) {
     const prior = before.document.sections[name];
     const next = after.document.sections[name];
     if (prior === next) continue;
-    if (prior === undefined || next === undefined) {
-      return [{ op: "replace", path, base: recorded.revision, content }];
-    }
+    if (prior === undefined || next === undefined) return whole;
     ops.push({ op: "replace_section", path, section: name, base: prior, content: next });
   }
-  return ops.length === 0 ? [{ op: "replace", path, base: recorded.revision, content }] : ops;
+  if (ops.length === 0) return whole;
+  return applyChanges({ [relative]: recorded.content }, ops, root)[relative] === content ? ops : whole;
 }
 
 export function deriveChanges(state, authority, localFiles) {

package/src/sync-state.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
-import { mkdir, readFile, readdir, realpath, rm } from "node:fs/promises";
-import { join, relative, resolve } from "node:path";
+import { mkdir, readFile, readdir, realpath, rm, rmdir } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
 import { EXPLICIT_SYNC_VERSION } from "./contract.js";
 import { KitRefusal } from "./refusal.js";
 import { readNote, writeNote, writeText } from "./state.js";
@@ -26,6 +26,9 @@ function syncFile(directory, key, kind = "") {
 function recordedAuthority(authority) {
   const operations = authority?.operations;
   return (
+    authority?.kind === "room" &&
+    typeof authority.authority === "string" &&
+    typeof authority.path === "string" &&
     typeof authority?.log_epoch === "string" &&
     operations !== null &&
     typeof operations === "object" &&
@@ -43,6 +46,7 @@ export async function readReplicaState(directory, replica) {
   }
   const state = await readNote(syncFile(directory, replicaKey(canonical)), null);
   if (state === null) return null;
+  if (state.version !== EXPLICIT_SYNC_VERSION) return null;
   if (!Array.isArray(state.authorities) || !state.authorities.every(recordedAuthority)) return null;
   return state;
 }
@@ -81,12 +85,21 @@ export async function writeReplicaFile(path, content, signal) {
   return writeText(path, content, signal, 0o644);
 }
 
-export async function removeReplicaFile(path) {
+export async function removeReplicaFile(replica, rootPath, file) {
+  const root = locate(replica, rootPath);
+  const path = locate(replica, rootPath, file);
   try {
     await rm(path);
   } catch (error) {
     if (error.code !== "ENOENT") throw new KitRefusal("kit_state_unreadable", path);
   }
+  for (let directory = dirname(path); directory.startsWith(`${root}/`); directory = dirname(directory)) {
+    try {
+      await rmdir(directory);
+    } catch (error) {
+      if (error.code !== "ENOENT") return;
+    }
+  }
 }
 
 export async function listFiles(root) {

package/src/sync.js

@@ -41,12 +41,12 @@ function sessionDependencies(options, dependencies) {
   };
 }
 
-async function withSession(options, dependencies, operation) {
+export async function withSession(options, dependencies, operation) {
   const session = await openSession(options, sessionDependencies(options, dependencies));
   return maintainControl(session, (signal) => operation(session, signal), options.signal);
 }
 
-async function door(session, path, body, signal) {
+export async function door(session, path, body, signal) {
   return houseRequest(
     session.house,
     await heldControl(session, signal),
@@ -83,7 +83,7 @@ function changePosition(value, declaration) {
   return { position: value.position, log_epoch: value.log_epoch };
 }
 
-function discoveryOf(value) {
+export function discoveryOf(value) {
   if (typeof value?.md_model_version !== "string" || !Array.isArray(value.authorities)) {
     throw new KitRefusal("kit_sync_rejected", "discover");
   }
@@ -93,7 +93,7 @@ function discoveryOf(value) {
   return value;
 }
 
-async function bootstrapBundle(session, prefixes, signal) {
+export async function bootstrapBundle(session, prefixes, signal) {
   const answer = await door(session, KIT_DOOR_BOOTSTRAP_PATH, { prefixes }, signal);
   if (typeof answer?.transfer?.url === "string") {
     const granted = await houseGetJson(answer.transfer.url, session.dependencies, signal);
@@ -105,15 +105,12 @@ async function bootstrapBundle(session, prefixes, signal) {
 }
 
 function matchedDiscovery(discovery, scope) {
-  if (scope.manifest?.scope === "private") {
-    return discovery.authorities.find((entry) => entry.kind === "private");
-  }
   return discovery.authorities.find(
     (entry) => entry.kind === "room" && entry.room_ref === scope.manifest?.anchor,
   );
 }
 
-async function writeScope(replica, scope, signal) {
+function scopeContents(replica, scope) {
   if (
     typeof scope?.manifest?.path !== "string" ||
     typeof scope.manifest.position !== "string" ||
@@ -124,11 +121,18 @@ async function writeScope(replica, scope, signal) {
   if (!Array.isArray(scope.contents) || !Array.isArray(scope.manifest.files)) {
     throw new KitRefusal("kit_bootstrap_rejected");
   }
-  const files = [];
   for (const entry of scope.contents) {
     if (typeof entry?.path !== "string" || typeof entry.content !== "string") {
       throw new KitRefusal("kit_bootstrap_rejected");
     }
+    locate(replica, scope.manifest.path, entry.path);
+  }
+  return scope.contents;
+}
+
+async function writeScope(replica, scope, signal) {
+  const files = [];
+  for (const entry of scopeContents(replica, scope)) {
     const meta = scope.manifest.files.find((file) => file.path === entry.path);
     await writeReplicaFile(locate(replica, scope.manifest.path, entry.path), entry.content, signal);
     files.push({
@@ -142,18 +146,21 @@ async function writeScope(replica, scope, signal) {
 }
 
 async function replaceScope(replica, previous, scope, signal) {
-  const next = await writeScope(replica, scope, signal);
-  const kept = new Set(next.map((file) => file.path));
+  const kept = new Set(scopeContents(replica, scope).map((entry) => entry.path));
   const root = locate(replica, scope.manifest.path);
   for (const path of await listFiles(root)) {
-    if (!kept.has(path)) await removeReplicaFile(locate(replica, scope.manifest.path, path));
+    if (!kept.has(path)) await removeReplicaFile(replica, scope.manifest.path, path);
   }
   if (previous !== undefined) {
     for (const file of previous.files) {
-      if (!kept.has(file.path)) await removeReplicaFile(locate(replica, previous.path, file.path));
+      if (!kept.has(file.path)) await removeReplicaFile(replica, previous.path, file.path);
     }
   }
-  return next;
+  return writeScope(replica, scope, signal);
+}
+
+function removalsFirst(entries, removal) {
+  return [...entries.filter(removal), ...entries.filter((entry) => !removal(entry))];
 }
 
 function stringList(value) {
@@ -173,11 +180,17 @@ function operationsOf(value) {
 function authorityRecord(scope, discovery, files) {
   const found = matchedDiscovery(discovery, scope);
   const operations = found === undefined ? null : operationsOf(found.operations);
-  if (found === undefined || !stringList(found.protected_paths) || operations === null) {
+  if (
+    scope.manifest?.scope !== "room" ||
+    typeof scope.manifest.anchor !== "string" ||
+    found === undefined ||
+    !stringList(found.protected_paths) ||
+    operations === null
+  ) {
     throw new KitRefusal("kit_bootstrap_rejected");
   }
   return {
-    kind: scope.manifest.scope === "private" ? "private" : "room",
+    kind: "room",
     authority: scope.manifest.anchor,
     room_handle: scope.manifest.room_handle,
     path: scope.manifest.path,
@@ -192,9 +205,10 @@ function authorityRecord(scope, discovery, files) {
 async function materialize(options, discovery, bundle, signal, previous = null) {
   const authorities = [];
   for (const scope of bundle.scopes) {
+    const record = authorityRecord(scope, discovery, []);
     const held = previous?.authorities.find((entry) => entry.authority === scope.manifest?.anchor);
     const files = await replaceScope(options.replica, held, scope, signal);
-    authorities.push(authorityRecord(scope, discovery, files));
+    authorities.push({ ...record, files });
   }
   const state = {
     version: EXPLICIT_SYNC_VERSION,
@@ -241,10 +255,10 @@ async function applyEnumeration(options, state, enumeration, signal) {
     if (authority === undefined) throw new KitRefusal("kit_sync_rejected", view.authority);
     const reached = changePosition(view, "enumerate");
     const recorded = new Map(authority.files.map((file) => [file.path, file]));
-    for (const change of view.changes ?? []) {
+    for (const change of removalsFirst(view.changes ?? [], (change) => change?.removed === true)) {
       if (typeof change?.path !== "string") throw new KitRefusal("kit_sync_rejected", "enumerate");
       if (change.removed === true) {
-        await removeReplicaFile(locate(options.replica, authority.path, change.path));
+        await removeReplicaFile(options.replica, authority.path, change.path);
         recorded.delete(change.path);
         continue;
       }
@@ -301,7 +315,7 @@ async function acceptBatch(options, state, outcome, signal, pending = null) {
   const reached = changePosition(outcome, "batch");
   const recorded = new Map(authority.files.map((file) => [file.path, file]));
   const predicted = predictedReplica(authority, pending);
-  for (const file of outcome.contents ?? []) {
+  for (const file of removalsFirst(outcome.contents ?? [], (file) => file?.content === null)) {
     const relative = relativeTo(authority.path, file.path);
     const destination = locate(options.replica, authority.path, relative);
     const local = await replicaText(destination);
@@ -315,7 +329,7 @@ async function acceptBatch(options, state, outcome, signal, pending = null) {
       local !== accepted &&
       local !== expected;
     if (accepted === null) {
-      if (!preserve) await removeReplicaFile(destination);
+      if (!preserve) await removeReplicaFile(options.replica, authority.path, relative);
       recorded.delete(relative);
       continue;
     }
@@ -409,6 +423,7 @@ export async function bootstrap(options, dependencies = {}) {
   const canonical = await canonicalReplica(options.replica);
   const existing = await readReplicaState(options.directory, canonical);
   if (existing !== null) throw new KitRefusal("kit_sync_already_bootstrapped", canonical);
+  await clearPending(options.directory, canonical);
   return withSession(options, dependencies, async (session, signal) => {
     const discovery = discoveryOf(
       await door(session, KIT_DOOR_DISCOVER_PATH, { prefixes: options.prefixes }, signal),

package/src/tasks.js

@@ -0,0 +1,75 @@
+import { setTimeout as delay } from "node:timers/promises";
+
+export function coalescedTask(signal, fail, work) {
+  let pending = false;
+  let task = null;
+  const trigger = () => {
+    pending = true;
+    if (task !== null) return;
+    task = (async () => {
+      while (pending && !signal.aborted) {
+        pending = false;
+        await work();
+      }
+    })()
+      .catch((error) => {
+        if (signal.aborted) return;
+        fail(error);
+      })
+      .finally(() => {
+        task = null;
+        if (pending && !signal.aborted) trigger();
+      });
+  };
+  return { trigger, idle: () => task === null, settled: () => task };
+}
+
+export function residentWake() {
+  let pending = false;
+  let release = null;
+  return {
+    notify() {
+      pending = true;
+      release?.();
+    },
+    async wait(milliseconds, signal) {
+      if (!pending && !signal.aborted) {
+        const pause = new AbortController();
+        const paused = AbortSignal.any([signal, pause.signal]);
+        try {
+          await Promise.race([
+            new Promise((resolve) => {
+              release = resolve;
+            }),
+            Number.isFinite(milliseconds)
+              ? delay(milliseconds, undefined, { signal: paused })
+              : new Promise((resolve) => paused.addEventListener("abort", resolve, { once: true })),
+          ]);
+        } catch (error) {
+          if (!signal.aborted) throw error;
+        } finally {
+          release = null;
+          pause.abort();
+        }
+      }
+      const woken = pending;
+      pending = false;
+      return woken;
+    },
+  };
+}
+
+const turns = new Map();
+
+export function exclusively(path, work) {
+  const turn = (turns.get(path) ?? Promise.resolve()).then(work);
+  const settled = turn.then(
+    () => undefined,
+    () => undefined,
+  );
+  turns.set(path, settled);
+  void settled.then(() => {
+    if (turns.get(path) === settled) turns.delete(path);
+  });
+  return turn;
+}