@agentshouse/kit 0.1.0-alpha.20 → 0.1.0-alpha.21

package/README.md

@@ -10,7 +10,7 @@ On Linux `amd64` or `arm64` with a working Docker Engine, run the published,
 versioned bootstrap once:
 
 ```sh
-bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.20/connect-linux.sh)
+bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.21/connect-linux.sh)
 ```
 
 The release asset pins one immutable multi-architecture image digest. It creates
@@ -1261,9 +1261,35 @@ committed.
 Local edits, staging and commits change nothing in House until a commit is
 pushed. `refs/house/received` records the House content last received; each
 commit Kit wrote there, and each commit it acknowledged for a push, is a House
-state. The House revision of every file content Kit received, keyed by path and
-Git blob, stays in Kit home under `state/working-copies/`, outside the
-repository. A local commit is a local tree, never a House revision.
+state. The House revision of every file content Kit received, keyed by path,
+Git blob and the House state that received it, stays in Kit home under
+`state/working-copies/`, outside the repository. A local commit is a local tree, never a House revision.
+
+The resident Kit keeps every active copy current. On each pass, and whenever
+it reads the saved choice, one `POST /kit/door/discover` tells it where each
+copied Room stands, and for a Room that moved on it reads the changes after the
+copy's recorded position through `POST /kit/door/enumerate`. A changed, new or
+removed authored file becomes a commit on `refs/house/received`, its House
+revision kept in Kit home; changed, new or removed read-only content, such as
+Capture with its provenance sidecar or a House projection, is written into or
+removed from the ignored local tree, and `.gitignore` and `.ignore` follow it.
+Delivery never touches the branch, the index or a tracked file, and a push
+waiting for its outcome or its local integration keeps its record. A push takes
+each file's revision from the newest House state in its own base's history that
+received that content, so a local commit keeps the base it was made on even when
+House returns to the same text under a newer revision. A file new to the copy is tracked when a write scope
+House declares for the Room covers it more closely than a declared protected
+path, and a local file already sitting where new read-only content arrives
+stays yours: Kit neither overwrites nor later removes it. When the write scopes
+or protected paths House declares for the Room change, Kit reads the Room again
+as a reselection does. A position older than House
+retains, or from before House's database was restored, makes Kit read the Room
+again as a reselection does; while House's replica has not reached the position
+the copy waits for the next pass. A Room House no longer answers under its
+recorded handle makes Kit read the saved choice again, which follows a handle
+change or marks the copy inactive, and a Room that lost sync is named on
+standard error as `operation_denied` and keeps what it holds. `kit worker run`
+delivers once, after reading the saved choice.
 
 `house git push [commit]`, run anywhere inside a copy or one of its linked
 worktrees, submits one commit, `HEAD` by default, resolved once. Kit compares
@@ -1319,7 +1345,10 @@ commits, and pushes again. After acceptance Kit records House's result for the
 pushed paths, the contents an owner push receives or each accepted revision
 read by name, in a commit that covers the pushed one and in
 `refs/house/received`; a read-only path House regenerates, such as the Wiki
-index, stays out of Git. Kit then
+index, stays out of Git. The copy's recorded position goes back to where it
+stood when the push was sent, so the next delivery brings again anything House
+changed after the push's result, including what delivery received while the
+push awaited its answer. Kit then
 fast-forwards a clean branch still at the pushed commit, or rebases only its
 later commits. A result not yet readable, uncommitted tracked changes,
 a moved branch or a rebase conflict leave the branch as it was, with no stash or
@@ -1335,8 +1364,8 @@ Room again: if House holds the pushed content the push finishes as accepted,
 otherwise it is dropped and the next push submits it as a new operation.
 
 Deselecting a Room, or losing read access to it, marks its copy inactive:
-launches omit it, a new push is refused as `kit_working_copy_inactive`, and
-nothing local is deleted; a push already sent still settles and integrates. Selecting it again reads the Room
+launches omit it, delivery stops, a new push is refused as
+`kit_working_copy_inactive`, and nothing local is deleted; a push already sent still settles and integrates. Selecting it again reads the Room
 again, advances `refs/house/received`, and replaces only the read-only content
 Kit wrote, never the branch, the index or a tracked file. A Room the owner may
 read without sync is refused as `operation_denied` and stays uncopied, while its

package/bootstrap.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
-  "version": "0.1.0-alpha.20",
+  "version": "0.1.0-alpha.21",
   "hosts": {
     "linux": {
-      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.20/connect-linux.sh)",
+      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.21/connect-linux.sh)",
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.20/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.21/connect-linux.sh"
       },
       "workspace": {
         "argument": "--workspace",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.1.0-alpha.20",
+  "version": "0.1.0-alpha.21",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/contract.js

@@ -297,7 +297,7 @@ export const EXPLICIT_SYNC_VERSION = "explicit-sync/2";
 export const KIT_DOOR_UNMOUNT_PATH = "/kit/door/unmount";
 
 export const KIT_WORKING_COPY_SELECTION_PATH = "/kit/working-copy/selection";
-export const WORKING_COPY_VERSION = "working-copy-state/2";
+export const WORKING_COPY_VERSION = "working-copy-state/3";
 export const WORKING_COPIES_HOME = "working-copies";
 export const WORKING_COPY_ROOM_HOMES = ["capture", "library", "collaboration"];
 export const WORKING_COPY_PRIVATE_HOMES = ["library", "collaboration", "rooms", "agents", "house"];

package/src/worker.js

@@ -19,7 +19,14 @@ import { localFiles } from "./local-files.js";
 import { answerText, answerYaml } from "./mcp.js";
 import { inheritedEnvironment } from "./command.js";
 import { watchKitWork } from "./kit-work-stream.js";
-import { applyWorkingCopies, ownerCaller, pushWorkingCopy, recordIndexChange, workingCopyPaths } from "./working-copy.js";
+import {
+  applyWorkingCopies,
+  deliverWorkingCopies,
+  ownerCaller,
+  pushWorkingCopy,
+  recordIndexChange,
+  workingCopyPaths,
+} from "./working-copy.js";
 import { readConfiguration } from "./configuration.js";
 import { launchBase, readyLaunchDirectory } from "./directory.js";
 import {
@@ -863,7 +870,7 @@ export async function runWorkers(options, dependencies = {}) {
   const { context, tmux } = await workerContext(options, dependencies);
   const { session, runtime } = context;
   const supervised = await maintainControl(session, async (signal) => {
-    await applySavedWorkingCopies(context, signal);
+    await reportedWorkingCopies(applyWorkingCopies, context, signal);
     return controlledPass(context, dependencies, context.configuration, signal);
   }, session.signal);
   return {
@@ -884,9 +891,8 @@ function reported(line) {
   process.stderr.write(`kit: ${line}\n`);
 }
 
-async function applySavedWorkingCopies(context, signal) {
-  const applied = await applyWorkingCopies(context, signal);
-  for (const refused of applied.refused) {
+async function reportedWorkingCopies(act, context, signal) {
+  for (const refused of (await act(context, signal)).refused) {
     reported(`working copy ${refused.path} refused: ${refused.code}`);
   }
 }
@@ -1078,10 +1084,12 @@ export async function runResident(options, dependencies = {}) {
       const needsLogin = await queueAgentRefresh(context, dependencies, signal, undefined, true);
       context.startLogins(needsLogin);
     });
-    const copies = coalescedTask(
-      signal,
-      (error) => reported(`working copies unavailable: ${error?.message ?? error}`),
-      () => applySavedWorkingCopies(context, signal),
+    const unavailable = (error) => reported(`working copies unavailable: ${error?.message ?? error}`);
+    const copies = coalescedTask(signal, unavailable, () =>
+      reportedWorkingCopies(applyWorkingCopies, context, signal),
+    );
+    const deliveries = coalescedTask(signal, unavailable, () =>
+      reportedWorkingCopies(deliverWorkingCopies, context, signal),
     );
     const pointer = () => {
       if (!update.requested) agentRefresh.trigger();
@@ -1114,18 +1122,20 @@ export async function runResident(options, dependencies = {}) {
           if (sessions.length > 0) update.answer({ ready: false, sessions });
           else if (
             session.refused ||
-            (!served.serving() && logins.size === 0 && agentRefresh.idle() && copies.idle())
+            (!served.serving() && logins.size === 0 && agentRefresh.idle() && copies.idle() && deliveries.idle())
           ) {
             return;
           }
         }
         await wake.wait(interval, signal);
+        if (!update.requested && !session.refused) deliveries.trigger();
       }
     } finally {
       watcher.abort();
       await watching;
       await agentRefresh.settled();
       await copies.settled();
+      await deliveries.settled();
       for (const running of logins.values()) running.controller.abort();
       await Promise.all([...logins.values()].map((running) => running.task));
       await context.agentRefresh;

package/src/working-copy.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { mkdir, readdir, realpath, rename, rm, stat } from "node:fs/promises";
+import { mkdir, readdir, readFile, realpath, rename, rm, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { readBindings } from "./binding.js";
 import {
@@ -21,7 +21,7 @@ import { operationId } from "./operation.js";
 import { formatCommandError, houseAnswered, houseFailed, KitRefusal } from "./refusal.js";
 import { readNote, writeNote, writeText } from "./state.js";
 import { bootstrapBundle, discoveryOf, door, withSession } from "./sync.js";
-import { sidecarPath, structuredOrReplace } from "./sync-library.js";
+import { isGeneratedProvenance, sidecarPath, structuredOrReplace } from "./sync-library.js";
 import { locate, removeReplicaFile, writeReplicaFile } from "./sync-state.js";
 
 const COMMITTER_NAME = "House Kit";
@@ -134,6 +134,7 @@ async function readScope(session, scope, signal) {
   if (
     authority === undefined ||
     !Array.isArray(authority.protected_paths) ||
+    !Array.isArray(authority.operations?.write) ||
     (scope.kind === "room" && view.manifest.anchor !== scope.ref)
   ) {
     throw rejected("discover");
@@ -142,11 +143,16 @@ async function readScope(session, scope, signal) {
     anchor: view.manifest.anchor,
     position: view.manifest.position,
     logEpoch: view.manifest.log_epoch,
-    protectedPaths: authority.protected_paths.filter((path) => typeof path === "string"),
+    protectedPaths: authority.protected_paths,
+    declared: declaration(authority),
     files,
   };
 }
 
+function declaration(authority) {
+  return { write: authority.operations.write, protected: authority.protected_paths };
+}
+
 function importData(text) {
   const bytes = Buffer.from(text, "utf8");
   return [Buffer.from(`data ${bytes.length}\n`), bytes, Buffer.from("\n")];
@@ -210,16 +216,28 @@ async function commitOf(repository, name, signal) {
   return commit.toString("utf8").trim();
 }
 
-async function remembered(repository, revisions, commit, files, signal) {
+async function remembered(repository, revisions, commit, files, signal, acknowledged = false) {
   const tree = await treeOf(repository, commit, signal);
   const next = { ...revisions };
   for (const { path, revision } of files) {
     const entry = tree.get(path);
-    if (entry !== undefined && revision !== null) next[path] = { ...next[path], [entry.object]: revision };
+    if (entry === undefined || revision === null) continue;
+    const seen = next[path]?.[entry.object] ?? [];
+    if (acknowledged || seen.at(-1)?.revision !== revision) {
+      next[path] = { ...next[path], [entry.object]: [...seen, { commit, revision }] };
+    }
   }
   return next;
 }
 
+async function revisionAt(copy, path, entry, base, signal) {
+  const seen = entry === undefined ? [] : (copy.revisions[path]?.[entry.object] ?? []);
+  for (const known of seen.toReversed()) {
+    if (seen.length === 1 || (await contains(copy.repository, known.commit, base, signal))) return known.revision;
+  }
+  return undefined;
+}
+
 function readOnlyContents(read) {
   const contents = new Map();
   for (const file of read.files) {
@@ -244,19 +262,22 @@ async function trackedPaths(repository, signal) {
   return new Set(listed.toString("utf8").split("\0").filter((path) => path !== ""));
 }
 
-async function replaceReadOnly(repository, previous, next, signal) {
+async function replaceReadOnly(repository, held, written, removed, signal) {
   const tracked = await trackedPaths(repository, signal);
-  const held = new Set(previous);
-  for (const [path, content] of next) {
+  const holding = new Set(held);
+  for (const [path, content] of written) {
     if (tracked.has(path)) continue;
     const target = locate(repository, "", path);
     if (!held.has(path) && (await present(target))) continue;
     await writeReplicaFile(target, content, signal);
+    holding.add(path);
   }
-  for (const path of held) {
-    if (next.has(path) || tracked.has(path)) continue;
-    await removeReplicaFile(locate(repository, "", path));
+  for (const path of removed) {
+    if (!held.has(path)) continue;
+    if (!tracked.has(path)) await removeReplicaFile(locate(repository, "", path));
+    holding.delete(path);
   }
+  return [...holding];
 }
 
 function covers(path, prefix) {
@@ -304,17 +325,16 @@ async function writeIgnoreRules(repository, read, signal) {
     ...[...house, ...granted].map((pattern) => `!${pattern}`),
     "",
   ];
-  await writeText(join(repository, ".gitignore"), gitignore.join("\n"), signal, 0o644);
-  await writeText(join(repository, ".ignore"), ignore.join("\n"), signal, 0o644);
+  await ruled(join(repository, ".gitignore"), gitignore.join("\n"), signal);
+  await ruled(join(repository, ".ignore"), ignore.join("\n"), signal);
 }
 
-function manifest(read, commit) {
-  return {
-    commit,
-    position: read.position,
-    log_epoch: read.logEpoch,
-    read_only: [...readOnlyContents(read).keys()],
-  };
+async function ruled(path, rules, signal) {
+  if ((await readFile(path, "utf8").catch(() => null)) !== rules) await writeText(path, rules, signal, 0o644);
+}
+
+function manifest(read, commit, readOnly) {
+  return { commit, position: read.position, log_epoch: read.logEpoch, read_only: readOnly, declared: read.declared };
 }
 
 function copyPath(directory, copy) {
@@ -376,6 +396,7 @@ async function materialize(context, scope, signal) {
   const imported = received(scope, read, []);
   let commit;
   let revisions;
+  let readOnly;
   try {
     await runGit(staging, ["init", "-q", "-b", WORKING_COPY_BRANCH], { signal, failure: GIT_FAILED });
     commit = (await importReceived(staging, imported, signal)).received;
@@ -385,7 +406,7 @@ async function materialize(context, scope, signal) {
       failure: GIT_FAILED,
     });
     await runGit(staging, ["read-tree", "-m", "-u", "HEAD"], { signal, failure: GIT_FAILED });
-    await replaceReadOnly(staging, [], readOnlyContents(read), signal);
+    readOnly = await replaceReadOnly(staging, new Set(), readOnlyContents(read), [], signal);
     await writeIgnoreRules(staging, read, signal);
     await rename(staging, repository);
   } catch (error) {
@@ -399,7 +420,7 @@ async function materialize(context, scope, signal) {
     room_handle: scope.handle,
     repository,
     active: true,
-    received: manifest(read, commit),
+    received: manifest(read, commit, readOnly),
     revisions,
   });
 }
@@ -409,11 +430,14 @@ async function receive(context, copy, scope, signal) {
   if (read.anchor !== copy.room_ref) throw rejected("bootstrap");
   const imported = received(scope, read, [copy.received.commit]);
   const commit = (await importReceived(copy.repository, imported, signal)).received;
-  await replaceReadOnly(copy.repository, copy.received.read_only, readOnlyContents(read), signal);
+  const next = readOnlyContents(read);
+  const held = copy.received.read_only;
+  const removed = held.filter((path) => !next.has(path));
+  const readOnly = await replaceReadOnly(copy.repository, new Set(held), next, removed, signal);
   await writeIgnoreRules(copy.repository, read, signal);
   return {
     ...copy,
-    received: manifest(read, commit),
+    received: manifest(read, commit, readOnly),
     revisions: await remembered(copy.repository, copy.revisions, commit, imported.files, signal),
   };
 }
@@ -432,6 +456,117 @@ function scopeRefused(error) {
   return error instanceof KitRefusal && (houseAnswered(error) || error.code.startsWith("kit_working_copy_"));
 }
 
+function declaredWritable(path, authority) {
+  const deepest = (scopes) =>
+    Math.max(-1, ...scopes.filter((scope) => scope === "" || covers(path, scope)).map((scope) => scope.length));
+  return deepest(authority.operations.write) > deepest(authority.protected_paths);
+}
+
+async function incorporated(copy, view, authority, signal) {
+  const tree = await treeOf(copy.repository, copy.received.commit, signal);
+  const held = new Set(copy.received.read_only);
+  const files = [];
+  const written = new Map();
+  const removed = [];
+  for (const change of view.changes) {
+    const gone = change.removed === true;
+    if (tree.has(change.path) || (!gone && !held.has(change.path) && declaredWritable(change.path, authority))) {
+      files.push({ path: change.path, revision: gone ? null : change.revision, content: gone ? null : change.content });
+    } else if (gone) {
+      removed.push(change.path, sidecarPath(change.path));
+    } else {
+      written.set(change.path, change.content);
+      if (typeof change.provenance === "string") written.set(sidecarPath(change.path), change.provenance);
+    }
+  }
+  const message = `House ${housePath(scopeOf(copy))} at position ${view.position}`;
+  const commit =
+    files.length === 0
+      ? copy.received.commit
+      : (await importReceived(copy.repository, { message, parents: [copy.received.commit], files }, signal)).received;
+  const readOnly = await replaceReadOnly(copy.repository, held, written, removed, signal);
+  if (view.changes.length > 0) {
+    const listed = [
+      ...[...(await treeOf(copy.repository, commit, signal)).keys()].map((path) => ({ path, writable: true })),
+      ...readOnly.filter((path) => !isGeneratedProvenance(path)).map((path) => ({ path, writable: false })),
+    ].sort((left, right) => (left.path < right.path ? -1 : 1));
+    await writeIgnoreRules(copy.repository, { files: listed, protectedPaths: authority.protected_paths }, signal);
+  }
+  return {
+    ...copy,
+    received: { ...copy.received, commit, position: view.position, log_epoch: view.log_epoch, read_only: readOnly },
+    revisions: await remembered(copy.repository, copy.revisions, commit, files, signal),
+  };
+}
+
+async function deliver(context, path, authority, signal) {
+  if (
+    typeof authority.position !== "string" ||
+    typeof authority.log_epoch !== "string" ||
+    !Array.isArray(authority.protected_paths) ||
+    !Array.isArray(authority.operations?.write)
+  ) {
+    throw rejected("discover");
+  }
+  let copy = await readCopy(path);
+  if (copy?.active && JSON.stringify(copy.received.declared) !== JSON.stringify(declaration(authority))) {
+    await writeCopy(context.directory, await receive(context, copy, scopeOf(copy), signal), signal);
+    return;
+  }
+  while (
+    copy?.active &&
+    (copy.received.log_epoch !== authority.log_epoch || BigInt(copy.received.position) < BigInt(authority.position))
+  ) {
+    const since = { position: copy.received.position, log_epoch: copy.received.log_epoch };
+    let view;
+    try {
+      view = await enumerated(context, copy, since, signal);
+    } catch (error) {
+      if (error.code === "replica_behind") return;
+      if (error.code !== "position_expired") throw error;
+      await writeCopy(context.directory, await receive(context, copy, scopeOf(copy), signal), signal);
+      return;
+    }
+    if (view.position === since.position) return;
+    copy = await incorporated(copy, view, authority, signal);
+    await writeCopy(context.directory, copy, signal);
+  }
+}
+
+async function delivering(context, signal) {
+  const copies = (await heldCopies(context.directory)).filter((copy) => copy.active);
+  if (copies.length === 0) return { refused: [], lost: false };
+  const prefixes = copies.flatMap((copy) => selectedPrefixes(scopeOf(copy)));
+  const discovery = discoveryOf(await door(context.session, KIT_DOOR_DISCOVER_PATH, { prefixes }, signal));
+  const refused = [];
+  let lost = false;
+  for (const copy of copies) {
+    const at = housePath(scopeOf(copy));
+    const authority = discovery.authorities.find((entry) => entry?.room_ref === copy.room_ref);
+    if (authority === undefined) {
+      lost = true;
+      continue;
+    }
+    if (authority.managed_replication !== "admitted") {
+      refused.push({ path: at, code: "operation_denied" });
+      continue;
+    }
+    const path = copyPath(context.directory, copy);
+    try {
+      await exclusively(path, () => deliver(context, path, authority, signal));
+    } catch (error) {
+      if (!scopeRefused(error)) throw error;
+      refused.push({ path: at, code: error.code });
+    }
+  }
+  return { refused, lost };
+}
+
+export async function deliverWorkingCopies(context, signal) {
+  const delivered = await delivering(context, signal);
+  return delivered.lost ? applyWorkingCopies(context, signal) : { refused: delivered.refused };
+}
+
 export async function applyWorkingCopies(context, signal) {
   const selected = (await savedSelection(context.session, signal)).filter(
     (scope) => scope.kind === "private" || scope.handle !== null,
@@ -461,7 +596,7 @@ export async function applyWorkingCopies(context, signal) {
       refused.push({ path: housePath(scope), code: error.code });
     }
   }
-  return { refused };
+  return { refused: [...refused, ...(await delivering(context, signal)).refused] };
 }
 
 export async function workingCopyPaths(directory) {
@@ -694,8 +829,8 @@ function renamed(chains, reached, before, after) {
   return new Map(pairs.filter(([from, to]) => pairs.filter((pair) => pair[0] === from || pair[1] === to).length === 1));
 }
 
-async function relocated(copy, root, [from, to], prior, next, signal) {
-  const base = copy.revisions[from]?.[prior.object];
+async function relocated(copy, root, [from, to], [prior, next], house, signal) {
+  const base = await revisionAt(copy, from, prior, house, signal);
   const rename = { op: "rename", path: `${root}/${from}`, to: `${root}/${to}`, base };
   if (prior.object === next.object) return [rename];
   return [rename, { op: "replace", path: `${root}/${to}`, base, content: await blobText(copy.repository, next, to, signal) }];
@@ -713,13 +848,13 @@ async function derived(copy, base, commit, signal) {
     const prior = before.get(path);
     if (moved.has(path)) {
       const to = moved.get(path);
-      changes.push(...(await relocated(copy, root, [path, to], prior, after.get(to), signal)));
+      changes.push(...(await relocated(copy, root, [path, to], [prior, after.get(to)], base, signal)));
       continue;
     }
     const next = after.get(path);
     if (prior?.object === next?.object) continue;
     const target = `${root}/${path}`;
-    const revision = copy.revisions[path]?.[prior?.object];
+    const revision = await revisionAt(copy, path, prior, base, signal);
     if (next === undefined) {
       changes.push({ op: "remove", path: target, base: revision });
       continue;
@@ -761,8 +896,15 @@ async function recorded(copy, files, message, acknowledging, signal) {
   return {
     copy: {
       ...copy,
-      received: { ...copy.received, commit: imported.received },
-      revisions: await remembered(copy.repository, copy.revisions, imported.received, files, signal),
+      received: { ...copy.received, commit: imported.received, ...(acknowledging === null ? {} : copy.push.from) },
+      revisions: await remembered(
+        copy.repository,
+        copy.revisions,
+        imported.acknowledged ?? imported.received,
+        files,
+        signal,
+        imported.acknowledged !== null,
+      ),
     },
     acknowledged: imported.acknowledged,
   };
@@ -952,11 +1094,12 @@ async function expired(context, copy, text, signal) {
     const entry = house.get(path);
     written.push({
       path: `${root}/${path}`,
-      revision: entry === undefined ? null : confirmed.revisions[path][entry.object],
+      revision: entry === undefined ? null : await revisionAt(confirmed, path, entry, confirmed.received.commit, signal),
       content: await blobText(copy.repository, entry, path, signal),
     });
   }
-  const accepted = { ...confirmed, push: { ...push, state: "accepted", written } };
+  const from = { position: confirmed.received.position, log_epoch: confirmed.received.log_epoch };
+  const accepted = { ...confirmed, push: { ...push, state: "accepted", written, from } };
   await writeCopy(context.directory, accepted, signal);
   return finish(context, accepted, signal);
 }
@@ -1030,6 +1173,7 @@ async function pushed(context, path, at, selector, caller, signal) {
       operation_id: operationId(),
       changes,
       commit,
+      from: { position: copy.received.position, log_epoch: copy.received.log_epoch },
       worktree: at.worktree,
       branch,
       ...(since === null ? {} : { since }),