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

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.19/connect-linux.sh)
+bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.20/connect-linux.sh)
 ```
 
 The release asset pins one immutable multi-architecture image digest. It creates
@@ -1280,6 +1280,37 @@ control lease when a resident runs, and which otherwise acquires and releases
 its own. A Session refuses `--owner`, and a missing bridge is never replaced by
 owner authority.
 
+Inside an Agent Session `git` is Kit's shim in front of the installed Git, and
+every command runs exactly as that Git runs it. In a copy or one of its linked
+worktrees the shim compares that worktree's index before and after each
+command. When `git mv` succeeds, Git's own dry run of the same command names
+which path went where, and the shim hands each move to the resident Kit, which
+keeps every moved document's successive paths in Kit home. A staged move
+belongs to its worktree's index: a command there that takes its path out of the
+index or brings it in anew, such as `git reset`, `git restore --staged`,
+`git rm`, `git stash` or `git switch`, takes it back, and so does removing the
+worktree. A `git commit` whose commit carries the move ties it to that commit.
+A tied move counts for every pushed commit whose history holds one of its
+commits, whatever the index does meanwhile. `git commit --amend` and
+`git rebase`, Kit's own rebase onto House's result included, also tie it to
+their result when the rewritten branch still carries it, so aborting the rebase
+or resetting back to the original commit keeps it as well. A `git reset` that
+leaves every commit of the move behind without touching its latest path in the
+index returns it to that worktree's index, where the next commit ties it again.
+Any other rewrite, such as a cherry-pick, leaves the move tied to its earlier
+commits. A push sends House's rename of the same document from the path its
+House base holds to the latest of its counted paths the pushed commit holds,
+when the commit no longer has the first and the base did not have the second;
+a moved file whose content also changed follows as a
+whole-file replacement at its destination. House keeps the document's identity
+and rewrites the links and references that name it; Kit reads those rewrites
+through `POST /kit/door/enumerate` and records them in the acknowledgment.
+Anything else records no move and the push sends an ordinary removal and
+creation, which House refuses while another document still refers to the
+removed one: a failed `git mv`, one undone or never committed through the
+shim, and a move made with Git outside the shim such as in the owner's own
+shell. An accepted push drops the moves its commit's history holds.
+
 House decides before any local Git step. A refusal changes nothing in House;
 after `edit_conflict` Kit records the current content House names for the
 refused paths in `refs/house/received`, reading by revision any content the

package/bootstrap.json

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

package/package.json

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

package/src/contract.js

@@ -305,6 +305,7 @@ export const WORKING_COPY_RECEIVED_REF = "refs/house/received";
 export const WORKING_COPY_BRANCH = "main";
 export const ROOM_REFERENCE = /^r_[0-9a-z]+\.[0-9a-z]$/;
 export const WORKING_COPY_PUSH_METHOD = "house/git/push";
+export const WORKING_COPY_INDEX_METHOD = "house/git/index";
 export const WORKING_COPY_PUSH_HELP =
   "Submit a Room commit to House; default HEAD. Use --owner only outside an Agent Session. Native git push is not a House remote.";
 

package/src/git-main.js

@@ -0,0 +1,138 @@
+import { spawn, spawnSync } from "node:child_process";
+import { accessSync, constants, realpathSync, statSync } from "node:fs";
+import { constants as system } from "node:os";
+import { delimiter, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  BRIDGE_NONCE_ENVIRONMENT,
+  BRIDGE_SOCKET_ENVIRONMENT,
+  WORKING_COPY_INDEX_METHOD,
+  WORKING_COPY_RECEIVED_REF,
+} from "./contract.js";
+import { bridgeCall } from "./mcp.js";
+import { formatCommandError, KitRefusal } from "./refusal.js";
+
+const SHIM = realpathSync(fileURLToPath(new URL("session-bin/git", import.meta.url)));
+const VALUED = new Set(["-C", "-c", "--git-dir", "--work-tree", "--namespace", "--config-env", "--attr-source", "--super-prefix"]);
+const RELAYED = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
+
+function nativeGit() {
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    if (directory === "") continue;
+    const candidate = join(directory, "git");
+    try {
+      if (!statSync(candidate).isFile() || realpathSync(candidate) === SHIM) continue;
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {}
+  }
+  return null;
+}
+
+function command(args) {
+  let index = 0;
+  while (index < args.length && args[index].startsWith("-")) index += VALUED.has(args[index]) ? 2 : 1;
+  return { globals: args.slice(0, index), name: args[index], rest: args.slice(index + 1) };
+}
+
+function delegated(git, args) {
+  return new Promise((resolve) => {
+    const child = spawn(git, args, { stdio: "inherit" });
+    const relay = (signal) => child.kill(signal);
+    for (const signal of RELAYED) process.on(signal, relay);
+    const settle = (outcome) => {
+      for (const signal of RELAYED) process.off(signal, relay);
+      resolve(outcome);
+    };
+    child.once("error", (error) => {
+      process.stderr.write(`kit_git_unavailable: ${error.message}\n`);
+      settle({ status: 127, signal: null });
+    });
+    child.once("close", (status, signal) => settle({ status, signal }));
+  });
+}
+
+function captured(git, args, env = process.env) {
+  const run = spawnSync(git, args, { stdio: ["ignore", "pipe", "ignore"], maxBuffer: Infinity, env });
+  return run.status === 0 ? run.stdout.toString("utf8") : null;
+}
+
+function indexed(listing) {
+  const entries = new Map();
+  for (const record of listing.split("\0")) {
+    const tab = record.indexOf("\t");
+    if (tab < 0) continue;
+    const [mode, object, stage] = record.slice(0, tab).split(" ");
+    entries.set(record.slice(tab + 1), stage === "0" ? `${mode} ${object}` : null);
+  }
+  return entries;
+}
+
+function renamings(output) {
+  return (output ?? "").split("\n").filter((line) => line.startsWith("Renaming ")).map((line) => line.slice(9));
+}
+
+function movedPaths(renaming, before, after) {
+  for (let at = renaming.indexOf(" to "); at >= 0; at = renaming.indexOf(" to ", at + 1)) {
+    const from = renaming.slice(0, at);
+    const to = renaming.slice(at + 4);
+    if (before.has(from) && !after.has(from) && after.get(to) === before.get(from)) return [{ from, to }];
+  }
+  return [];
+}
+
+async function recorded(cwd, change) {
+  const socket = process.env[BRIDGE_SOCKET_ENVIRONMENT];
+  const nonce = process.env[BRIDGE_NONCE_ENVIRONMENT];
+  if (socket === undefined || nonce === undefined) return;
+  try {
+    const frame = await bridgeCall({ socket, nonce }, { method: WORKING_COPY_INDEX_METHOD, params: { cwd, ...change } });
+    if (frame.error !== undefined) throw new KitRefusal(frame.error.message ?? "kit_house_refused");
+  } catch (refusal) {
+    process.stderr.write(`${formatCommandError(refusal)}: house git push will not see this index change\n`);
+  }
+}
+
+async function observed(git, { globals, name, rest }, args) {
+  const located = captured(git, [...globals, "rev-parse", "--show-toplevel", "--show-cdup", WORKING_COPY_RECEIVED_REF, "HEAD"]);
+  if (located === null) return delegated(git, args);
+  const [top, cdup, , head] = located.split("\n");
+  const listing = [...globals, "ls-files", "--stage", "-z", "--full-name", "--", cdup === "" ? "." : cdup];
+  const before = captured(git, listing);
+  const rehearsal = [...globals, "mv", "--dry-run", ...rest];
+  const planned = name === "mv" ? renamings(captured(git, rehearsal, { ...process.env, LC_ALL: "C" })) : [];
+  const outcome = await delegated(git, args);
+  const after = before === null ? null : captured(git, listing);
+  if (after === null) return outcome;
+  const [prior, next] = [indexed(before), indexed(after)];
+  const moves = outcome.status === 0 ? planned.flatMap((renaming) => movedPaths(renaming, prior, next)) : [];
+  const sources = new Set(moves.map((move) => move.from));
+  const destinations = new Set(moves.map((move) => move.to));
+  const gone = [...prior.keys()].filter((path) => !next.has(path) && !sources.has(path));
+  const arrived = [...next.keys()].filter((path) => !prior.has(path) && !destinations.has(path));
+  const heads = captured(git, [...globals, "rev-parse", "HEAD", ...(name === "rebase" ? ["ORIG_HEAD"] : [])]);
+  const [current, tip = head] = heads?.trim().split("\n") ?? [];
+  const commit = current === undefined || current === head ? [] : [tip, current];
+  if (moves.length > 0 || gone.length > 0 || arrived.length > 0 || commit.length > 0) {
+    await recorded(top, { moves, gone, arrived, commit, command: name });
+  }
+  return outcome;
+}
+
+async function run(args) {
+  const git = nativeGit();
+  if (git === null) {
+    process.stderr.write("kit_git_unavailable\n");
+    return { status: 127, signal: null };
+  }
+  return observed(git, command(args), args);
+}
+
+run(process.argv.slice(2)).then(({ status, signal }) => {
+  if (signal === null) {
+    process.exitCode = status;
+    return;
+  }
+  process.exitCode = 128 + system.signals[signal];
+  process.kill(process.pid, signal);
+});

package/src/session-bin/git

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../git-main.js";

package/src/worker.js

@@ -19,7 +19,7 @@ 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, workingCopyPaths } from "./working-copy.js";
+import { applyWorkingCopies, ownerCaller, pushWorkingCopy, recordIndexChange, workingCopyPaths } from "./working-copy.js";
 import { readConfiguration } from "./configuration.js";
 import { launchBase, readyLaunchDirectory } from "./directory.js";
 import {
@@ -33,6 +33,7 @@ import {
   WORKER_HEARTBEAT_MS,
   WORKER_INHERITED_ENVIRONMENT,
   WORKER_SUPERVISION_POLL_MS,
+  WORKING_COPY_INDEX_METHOD,
   WORKING_COPY_PUSH_METHOD,
 } from "./contract.js";
 import { EpochReportRequired, formatCommandError, houseFailed, KitRefusal } from "./refusal.js";
@@ -283,10 +284,12 @@ function refusedWith(text) {
 }
 
 function acceptedWith(text) {
-  const written = answerYaml(text).results.map(({ path, op, revision }) =>
-    op === "remove" ? { path, revision: null, content: null } : { path, revision },
-  );
-  return { refused: null, written };
+  const written = new Map();
+  for (const { path, op, revision, from } of answerYaml(text).results) {
+    if (from !== undefined) written.set(from, { path: from, revision: null, content: null });
+    written.set(path, op === "remove" ? { path, revision: null, content: null } : { path, revision });
+  }
+  return { refused: null, written: [...written.values()] };
 }
 
 async function sessionPush(context, bound, authority, frame, signal) {
@@ -341,6 +344,8 @@ async function openRunBridge(context, bound, authority, start) {
     settle: handed((interaction, outcome) => settleInteraction(context, interaction, outcome)),
     forward: handed((frame, signal) => frame.method === WORKING_COPY_PUSH_METHOD
       ? sessionPush(context, bound, authority, frame, signal)
+      : frame.method === WORKING_COPY_INDEX_METHOD
+      ? recordIndexChange(context, frame.params, signal).then(() => ({ jsonrpc: "2.0", id: frame.id, result: {} }))
       : localFiles(async (sent) =>
         callHouseMcp(
           context.session,

package/src/working-copy.js

@@ -5,6 +5,7 @@ import { readBindings } from "./binding.js";
 import {
   KIT_DOOR_BATCH_PATH,
   KIT_DOOR_DISCOVER_PATH,
+  KIT_DOOR_ENUMERATE_PATH,
   KIT_DOOR_REVISIONS_PATH,
   KIT_WORKING_COPY_SELECTION_PATH,
   ROOM_REFERENCE,
@@ -510,11 +511,17 @@ async function located(cwd, signal) {
   return { repository: await realpath(dirname(common)), worktree };
 }
 
-async function copyAt(directory, repository) {
+async function heldAt(directory, repository) {
   for (const copy of await heldCopies(directory)) {
     if ((await realpath(copy.repository).catch(() => null)) === repository) return copy;
   }
-  throw new KitRefusal("kit_working_copy_not_found", repository);
+  return null;
+}
+
+async function copyAt(directory, repository) {
+  const copy = await heldAt(directory, repository);
+  if (copy === null) throw new KitRefusal("kit_working_copy_not_found", repository);
+  return copy;
 }
 
 async function treeOf(repository, commit, signal) {
@@ -563,13 +570,152 @@ async function trustedBase(copy, commit, signal) {
   );
 }
 
+function withMoves(copy, moves) {
+  const { moves: held, ...rest } = copy;
+  return moves.length === 0 ? rest : { ...rest, moves };
+}
+
+function carries(before, after, from, to) {
+  return before.has(from) && !after.has(from) && after.has(to) && !before.has(to);
+}
+
+function retainedMoves(chains, worktree, moves, touched) {
+  const kept = chains.flatMap((chain) => {
+    if (chain.at(-1).worktree !== worktree || !touched.has(chain.at(-1).path)) return [chain];
+    const committed = chain
+      .filter((position, at) => at === 0 || position.commits !== undefined)
+      .map(({ path, commits }) => (commits === undefined ? { path } : { path, commits }));
+    return committed.length > 1 ? [committed] : [];
+  });
+  return moves.reduce((held, { from, to }) => {
+    const extended =
+      held.find((chain) => chain.at(-1).path === from && [undefined, worktree].includes(chain.at(-1).worktree)) ?? [{ path: from }];
+    return [...held.filter((chain) => chain !== extended), [...extended, { path: to, worktree }]];
+  }, kept);
+}
+
+async function reachedFrom(repository, chains, commit, signal) {
+  const reached = new Set();
+  for (const candidate of new Set(chains.flat().flatMap((position) => position.commits ?? []))) {
+    if (await contains(repository, candidate, commit, signal)) reached.add(candidate);
+  }
+  return reached;
+}
+
+function reaches(position, reached) {
+  return (position.commits ?? []).some((commit) => reached.has(commit));
+}
+
+async function rewrittenMoves(repository, chains, worktree, [tip, next], { tying, touched }, signal) {
+  const held = await reachedFrom(repository, chains, tip, signal);
+  const kept = await reachedFrom(repository, chains, next, signal);
+  const left = (position) => reaches(position, held) && !reaches(position, kept);
+  if (!tying) {
+    return chains.map((chain) =>
+      touched.has(chain.at(-1).path) ? chain : chain.map((position) => (left(position) ? { ...position, worktree } : position)),
+    );
+  }
+  const starts = chains.map((chain) =>
+    chain.findLastIndex((position, at) => at === 0 || reaches(position, kept) || (position.worktree !== worktree && !left(position))),
+  );
+  if (chains.every((chain, index) => starts[index] === chain.length - 1)) return chains;
+  const base = await runGit(repository, ["merge-base", tip, next], { capture: true, signal, failure: GIT_FAILED }).then(lines, () => []);
+  const before = base.length === 0 ? new Map() : await treeOf(repository, base[0], signal);
+  const after = await treeOf(repository, next, signal);
+  return chains.map((chain, index) => {
+    const start = starts[index];
+    if (start === chain.length - 1 || !carries(before, after, chain[start].path, chain.at(-1).path)) return chain;
+    const tied = chain.slice(start + 1).map(({ path, commits = [] }) => ({ path, commits: [...commits, next] }));
+    return [...chain.slice(0, start + 1), ...tied];
+  });
+}
+
+function reachedPart(chain, reached) {
+  const at = chain.findIndex((position, index) => index > 0 && !reaches(position, reached));
+  return at < 0 ? chain : chain.slice(0, at);
+}
+
+function remainingMoves(chains, reached) {
+  return chains.flatMap((chain) => {
+    const [{ path }, ...rest] = chain.slice(reachedPart(chain, reached).length - 1);
+    return rest.length > 0 ? [[{ path }, ...rest]] : [];
+  });
+}
+
+function reportedMoves(moves) {
+  if (
+    !Array.isArray(moves) ||
+    moves.some((move) => typeof move?.from !== "string" || typeof move.to !== "string" || move.from === move.to)
+  ) {
+    throw new KitRefusal("kit_house_arguments_invalid", "moves");
+  }
+  return moves.map(({ from, to }) => ({ from, to }));
+}
+
+function reportedStrings(values, name) {
+  if (!Array.isArray(values) || values.some((value) => typeof value !== "string")) {
+    throw new KitRefusal("kit_house_arguments_invalid", name);
+  }
+  return values;
+}
+
+export async function recordIndexChange(context, request, signal) {
+  if (typeof request?.cwd !== "string") throw new KitRefusal("kit_house_arguments_invalid", "cwd");
+  const moves = reportedMoves(request.moves);
+  const touched = new Set([
+    ...reportedStrings(request.gone, "gone"),
+    ...reportedStrings(request.arrived, "arrived"),
+    ...moves.map((move) => move.to),
+  ]);
+  const commit = reportedStrings(request.commit, "commit");
+  const rewrite = commit.length === 2 && ["commit", "rebase", "reset"].includes(request.command);
+  const at = await located(request.cwd, signal);
+  const held = await heldAt(context.directory, at.repository);
+  if (held === null) return;
+  const path = copyPath(context.directory, held);
+  await exclusively(path, async () => {
+    const copy = await readCopy(path);
+    if (copy === null || (copy.moves === undefined && moves.length === 0)) return;
+    const retained = retainedMoves(copy.moves ?? [], at.worktree, moves, touched);
+    const kept = rewrite
+      ? await rewrittenMoves(copy.repository, retained, at.worktree, commit, { tying: request.command !== "reset", touched }, signal)
+      : retained;
+    await writeCopy(context.directory, withMoves(copy, kept), signal);
+  });
+}
+
+function renamed(chains, reached, before, after) {
+  const pairs = chains.flatMap((chain) => {
+    const paths = reachedPart(chain, reached).map(({ path }) => path);
+    const from = paths.findIndex((path) => before.has(path));
+    const to = paths.findLastIndex((path) => after.has(path));
+    return to > from && carries(before, after, paths[from], paths[to]) ? [[paths[from], paths[to]]] : [];
+  });
+  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];
+  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) }];
+}
+
 async function derived(copy, base, commit, signal) {
   const root = housePath(scopeOf(copy));
   const before = await treeOf(copy.repository, base, signal);
   const after = await treeOf(copy.repository, commit, signal);
+  const moved = renamed(copy.moves ?? [], await reachedFrom(copy.repository, copy.moves ?? [], commit, signal), before, after);
+  const arrived = new Set(moved.values());
   const changes = [];
   for (const path of [...new Set([...before.keys(), ...after.keys()])].sort()) {
+    if (arrived.has(path)) continue;
     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)));
+      continue;
+    }
     const next = after.get(path);
     if (prior?.object === next?.object) continue;
     const target = `${root}/${path}`;
@@ -622,9 +768,65 @@ async function recorded(copy, files, message, acknowledging, signal) {
   };
 }
 
-function submittedPaths(copy) {
+function pushedPaths(changes) {
+  return new Set(changes.flatMap((change) => (change.op === "rename" ? [change.path, change.to] : [change.path])));
+}
+
+async function enumerated(context, copy, since, signal) {
+  const answer = await door(
+    context.session,
+    KIT_DOOR_ENUMERATE_PATH,
+    { prefixes: selectedPrefixes(scopeOf(copy)), positions: [{ authority: copy.room_ref, ...since }] },
+    signal,
+  );
+  const view = answer?.authorities?.find((entry) => entry?.authority === copy.room_ref);
+  if (
+    !Array.isArray(view?.changes) ||
+    typeof view.position !== "string" ||
+    typeof view.log_epoch !== "string" ||
+    view.changes.some(
+      (change) =>
+        typeof change?.path !== "string" ||
+        (change.removed !== true && (typeof change.content !== "string" || typeof change.revision !== "string")),
+    )
+  ) {
+    throw rejected("enumerate");
+  }
+  return view;
+}
+
+async function referrers(context, copy, selected, signal) {
+  const { push } = copy;
   const root = housePath(scopeOf(copy));
-  return new Set(copy.push.changes.map((change) => change.path.slice(root.length + 1)));
+  const destinations = push.changes.filter((change) => change.op === "rename").map((change) => change.to);
+  if (destinations.length === 0) return [];
+  const changed = new Map();
+  let since = push.since;
+  while (!destinations.every((path) => changed.has(path))) {
+    const view = await enumerated(context, copy, since, signal);
+    for (const change of view.changes) changed.set(`${root}/${change.path}`, change);
+    if (view.position === since.position) {
+      throw new KitRefusal("kit_working_copy_result_unreadable", destinations.filter((path) => !changed.has(path)).join(", "));
+    }
+    since = { position: view.position, log_epoch: view.log_epoch };
+  }
+  const pushed = pushedPaths(push.changes);
+  return [...changed.entries()]
+    .filter(([path, change]) => !pushed.has(path) && selected.has(change.path))
+    .map(([path, change]) =>
+      change.removed === true
+        ? { path, revision: null, content: null }
+        : { path, revision: change.revision, content: change.content },
+    );
+}
+
+async function housePosition(context, copy, signal) {
+  const discovery = discoveryOf(
+    await door(context.session, KIT_DOOR_DISCOVER_PATH, { prefixes: selectedPrefixes(scopeOf(copy)) }, signal),
+  );
+  const authority = discovery.authorities.find((entry) => entry?.room_ref === copy.room_ref);
+  if (typeof authority?.position !== "string" || typeof authority.log_epoch !== "string") throw rejected("discover");
+  return { position: authority.position, log_epoch: authority.log_epoch };
 }
 
 function short(commit) {
@@ -633,8 +835,8 @@ function short(commit) {
 
 async function acknowledge(context, copy, signal) {
   const { push } = copy;
-  const files = await materials(context, copy, push.written, signal);
   const selected = await treeOf(copy.repository, push.commit, signal);
+  const files = await materials(context, copy, [...push.written, ...(await referrers(context, copy, selected, signal))], signal);
   const edits = [];
   for (const file of files) {
     if ((await blobText(copy.repository, selected.get(file.path), file.path, signal)) !== file.content) edits.push(file);
@@ -646,7 +848,8 @@ async function acknowledge(context, copy, signal) {
     { commit: push.commit, edits },
     signal,
   );
-  return { ...next, push: { ...push, acknowledged } };
+  const remaining = remainingMoves(copy.moves ?? [], await reachedFrom(copy.repository, copy.moves ?? [], push.commit, signal));
+  return { ...withMoves(next, remaining), push: { ...push, acknowledged } };
 }
 
 async function integrated(copy, signal) {
@@ -680,7 +883,9 @@ async function integrated(copy, signal) {
     await git(["rebase", "--abort"]).catch(() => undefined);
     return pending("a conflict");
   }
-  return { done: true, text: `${accepted}; ${name} is at ${short(lines(await git(["rev-parse", "HEAD"]))[0])}.` };
+  const current = lines(await git(["rev-parse", "HEAD"]))[0];
+  const moves = await rewrittenMoves(copy.repository, copy.moves ?? [], worktree, [tip, current], { tying: true }, signal);
+  return { done: true, text: `${accepted}; ${name} is at ${short(current)}.`, moves };
 }
 
 async function finish(context, copy, signal) {
@@ -691,7 +896,8 @@ async function finish(context, copy, signal) {
       await writeCopy(context.directory, acknowledged, signal);
     }
     const outcome = await integrated(acknowledged, signal);
-    if (outcome.done) await writeCopy(context.directory, without(acknowledged), signal);
+    const moves = outcome.moves ?? acknowledged.moves ?? [];
+    if (outcome.done) await writeCopy(context.directory, without(withMoves(acknowledged, moves)), signal);
     return { refused: false, text: outcome.text };
   } catch (error) {
     return {
@@ -733,7 +939,7 @@ async function expired(context, copy, text, signal) {
   const confirmed = await receive(context, without(copy), scopeOf(copy), signal);
   const house = await treeOf(copy.repository, confirmed.received.commit, signal);
   const selected = await treeOf(copy.repository, push.commit, signal);
-  const paths = [...submittedPaths(copy)];
+  const paths = [...pushedPaths(push.changes)].map((path) => path.slice(root.length + 1));
   if (paths.some((path) => house.get(path)?.object !== selected.get(path)?.object)) {
     await writeCopy(context.directory, confirmed, signal);
     return {
@@ -771,8 +977,8 @@ async function settle(context, copy, caller, signal) {
   const { refused } = answer;
   if (refused?.code === "operation_expired") return expired(context, copy, refused.text, signal);
   if (refused === null) {
-    const submitted = new Set(push.changes.map((change) => change.path));
-    const written = answer.written.filter((entry) => submitted.has(entry.path));
+    const pushed = pushedPaths(push.changes);
+    const written = answer.written.filter((entry) => pushed.has(entry.path));
     const accepted = { ...copy, push: { ...push, state: "accepted", written } };
     await writeCopy(context.directory, accepted, signal);
     return finish(context, accepted, signal);
@@ -815,6 +1021,7 @@ async function pushed(context, path, at, selector, caller, signal) {
   if (changes.length === 0) return { refused: false, text: `Nothing to submit: ${short(commit)} matches House.` };
   const branch = await runGit(at.worktree, ["symbolic-ref", "-q", "HEAD"], { capture: true, signal, failure: GIT_FAILED })
     .then((output) => lines(output)[0], () => null);
+  const since = changes.some((change) => change.op === "rename") ? await housePosition(context, copy, signal) : null;
   const submitted = {
     ...copy,
     push: {
@@ -825,6 +1032,7 @@ async function pushed(context, path, at, selector, caller, signal) {
       commit,
       worktree: at.worktree,
       branch,
+      ...(since === null ? {} : { since }),
     },
   };
   await writeCopy(context.directory, submitted, signal);