@agentshouse/kit 0.1.0-alpha.16 → 0.1.0-alpha.18

package/src/house.js

@@ -29,6 +29,7 @@ import {
   MCP_PROTOCOL_VERSION,
   WORKER_RUN_TOKEN_MARGIN_MS,
   runOutcomePath,
+  runRequestPath,
   secretInputPath,
   SECRET_VALUE_MAX,
   sessionInteractionsPath,
@@ -171,7 +172,7 @@ async function residentRelay(session, request, signal, draining) {
   }
 }
 
-export async function serveResident(session, directory, signal, drain) {
+export async function serveResident(session, directory, signal, drain, push) {
   const socket = residentSocket(directory);
   await mkdir(dirname(socket), { recursive: true, mode: 0o700 });
   await rm(socket, { force: true });
@@ -228,12 +229,15 @@ export async function serveResident(session, directory, signal, drain) {
         }
         const cancelled = new AbortController();
         relayed.set(request.id, cancelled);
-        void residentRelay(session, request, AbortSignal.any([signal, cancelled.signal]), draining).then(
-          (answer) => {
-            relayed.delete(request.id);
-            if (!connection.destroyed) writeFrame(connection, { id: request.id, ...answer });
-          },
-        );
+        const relaySignal = AbortSignal.any([signal, cancelled.signal]);
+        const answered =
+          request.push === undefined
+            ? residentRelay(session, request, relaySignal, draining)
+            : push(request.push, relaySignal).then((pushed) => ({ pushed }));
+        void answered.then((answer) => {
+          relayed.delete(request.id);
+          if (!connection.destroyed) writeFrame(connection, { id: request.id, ...answer });
+        });
       },
       onRefusal: () => connection.destroy(),
     });
@@ -301,45 +305,54 @@ async function residentDelegation(directory, fetcher) {
   }
   connection.unref();
   let next = 0;
+  function exchange(frame, signal) {
+    signal?.throwIfAborted();
+    if (connection.destroyed) return Promise.resolve(unavailable());
+    return new Promise((resolve, reject) => {
+      const id = (next += 1);
+      const cancel = () => {
+        pending.delete(id);
+        settle(id);
+        if (!connection.destroyed) writeFrame(connection, { id, cancel: true });
+        reject(signal.reason);
+      };
+      signal?.addEventListener("abort", cancel, { once: true });
+      pending.set(id, (answer) => {
+        signal?.removeEventListener("abort", cancel);
+        resolve(answer);
+      });
+      connection.ref();
+      writeFrame(connection, { id, ...frame });
+    });
+  }
+  async function push(request, signal) {
+    const answer = await exchange({ push: request }, signal);
+    if (answer.pushed === undefined) throw new KitRefusal("kit_resident_unavailable");
+    return answer.pushed;
+  }
   async function delegated(url, init = {}) {
     const { authorization, ...headers } = init.headers ?? {};
     if (authorization !== RESIDENT) return fetcher(url, init);
-    init.signal?.throwIfAborted();
     const address = new URL(url);
-    const answer = connection.destroyed
-      ? unavailable()
-      : await new Promise((resolve, reject) => {
-          const id = (next += 1);
-          const cancel = () => {
-            pending.delete(id);
-            settle(id);
-            if (!connection.destroyed) writeFrame(connection, { id, cancel: true });
-            reject(init.signal.reason);
-          };
-          init.signal?.addEventListener("abort", cancel, { once: true });
-          pending.set(id, (answer) => {
-            init.signal?.removeEventListener("abort", cancel);
-            resolve(answer);
-          });
-          connection.ref();
-          writeFrame(connection, {
-            id,
-            method: init.method ?? "GET",
-            path: `${address.pathname}${address.search}`,
-            headers,
-            ...(typeof init.body === "string"
-              ? { text: init.body }
-              : init.body === undefined
-                ? {}
-                : { bytes: Buffer.from(init.body).toString("base64") }),
-          });
-        });
+    const answer = await exchange(
+      {
+        method: init.method ?? "GET",
+        path: `${address.pathname}${address.search}`,
+        headers,
+        ...(typeof init.body === "string"
+          ? { text: init.body }
+          : init.body === undefined
+            ? {}
+            : { bytes: Buffer.from(init.body).toString("base64") }),
+      },
+      init.signal,
+    );
     return new Response(answer.body === null ? null : Buffer.from(answer.body, "base64"), {
       status: answer.status,
       headers: answer.type === null ? {} : { "content-type": answer.type },
     });
   }
-  return { connection, fetch: delegated };
+  return { connection, fetch: delegated, push };
 }
 
 export async function openSession(options, dependencies = {}) {
@@ -358,6 +371,7 @@ export async function openSession(options, dependencies = {}) {
       : await residentDelegation(options.directory, dependencies.fetch ?? fetch);
   if (resident !== null) {
     session.resident = resident.connection;
+    session.push = resident.push;
     session.dependencies = { ...dependencies, fetch: resident.fetch };
     return session;
   }
@@ -734,11 +748,7 @@ export async function reportLogin(session, login, outcome, signal = session.sign
 }
 
 const envelope = declarationReader("kit_acquire_rejected");
-
-function routineInput(value, declaration) {
-  if (typeof value !== "string" || Array.from(value).length > 20_000) envelope.refuse(declaration);
-  return value;
-}
+const input = declarationReader("kit_run_input_unreadable");
 
 function acquiredRoute(value, declaration) {
   const route = envelope.plain(value, declaration);
@@ -756,79 +766,82 @@ function acquiredRoute(value, declaration) {
 
 function conversationText(value, declaration) {
   if (value === null) return null;
-  if (typeof value !== "string" || value.length > 4096) envelope.refuse(declaration);
+  if (typeof value !== "string" || value.length > 4096) input.refuse(declaration);
   return value;
 }
 
 function conversationMessage(value, declaration) {
-  const message = envelope.plain(value, declaration);
+  const message = input.plain(value, declaration);
   const text = conversationText(message.text, `${declaration}.text`);
   const caption = conversationText(message.caption, `${declaration}.caption`);
-  if (!Array.isArray(message.files)) envelope.refuse(`${declaration}.files`);
+  if (!Array.isArray(message.files)) input.refuse(`${declaration}.files`);
   const files = message.files.map((value, index) => {
     const name = `${declaration}.files[${index}]`;
-    const file = envelope.plain(value, name);
+    const file = input.plain(value, name);
     if (file.bytes !== null && (!Number.isSafeInteger(file.bytes) || file.bytes < 0)) {
-      envelope.refuse(`${name}.bytes`);
+      input.refuse(`${name}.bytes`);
     }
     return {
-      path: envelope.text(file.path, `${name}.path`, 2048),
-      media_kind: envelope.text(file.media_kind, `${name}.media_kind`, 128),
-      media_type: file.media_type === null ? null : envelope.text(file.media_type, `${name}.media_type`, 255),
+      path: input.text(file.path, `${name}.path`, 2048),
+      media_kind: input.text(file.media_kind, `${name}.media_kind`, 128),
+      media_type: file.media_type === null ? null : input.text(file.media_type, `${name}.media_type`, 255),
       bytes: file.bytes,
     };
   });
-  if (!text && !caption && files.length === 0) envelope.refuse(declaration);
+  if (!text && !caption && files.length === 0) input.refuse(declaration);
   return {
-    message_id: envelope.text(message.message_id, `${declaration}.message_id`, 128),
+    message_id: input.text(message.message_id, `${declaration}.message_id`, 128),
     text, caption, files,
   };
 }
 
-function acquiredRequest(acquired, declaration) {
-  if (acquired.kind === "conversation") {
-    if (acquired.origin !== "user") envelope.refuse(`${declaration}.origin`);
-    const conversation = envelope.plain(acquired.conversation, `${declaration}.conversation`);
-    const turn = envelope.plain(conversation.turn, `${declaration}.conversation.turn`);
+function runRequest(answer) {
+  const request = input.plain(answer, "request");
+  if (request.kind === "conversation") {
+    if (request.origin !== "user") input.refuse("request.origin");
+    const turn = input.plain(request.turn, "request.turn");
     return {
+      kind: "conversation",
       origin: "user",
-      conversation: {
-        turn: {
-          id: envelope.text(turn.id, `${declaration}.conversation.turn.id`, 128),
-          sequence: envelope.positiveCount(turn.sequence, `${declaration}.conversation.turn.sequence`),
-          messages: envelope.filled(turn.messages, `${declaration}.conversation.turn.messages`)
-            .map((message, index) => conversationMessage(message, `${declaration}.conversation.turn.messages[${index}]`)),
-        },
+      turn: {
+        id: input.text(turn.id, "request.turn.id", 128),
+        sequence: input.positiveCount(turn.sequence, "request.turn.sequence"),
+        messages: input.filled(turn.messages, "request.turn.messages")
+          .map((message, index) => conversationMessage(message, `request.turn.messages[${index}]`)),
       },
     };
   }
-  if (acquired.kind !== "routine") envelope.refuse(`${declaration}.kind`);
-  const request = envelope.plain(acquired.request, `${declaration}.request`);
-  const routine = envelope.plain(acquired.routine, `${declaration}.routine`);
+  if (request.kind !== "routine") input.refuse("request.kind");
+  const routine = input.plain(request.routine, "request.routine");
+  if (typeof request.payload !== "string" || Array.from(request.payload).length > 20_000) input.refuse("request.payload");
+  if (!Array.isArray(request.references)) input.refuse("request.references");
   return {
-    origin: envelope.text(acquired.origin, `${declaration}.origin`, 32),
+    kind: "routine",
+    origin: input.text(request.origin, "request.origin", 32),
     routine: {
-      name: envelope.text(routine.name, `${declaration}.routine.name`, 256),
-      version: envelope.positiveCount(routine.version, `${declaration}.routine.version`),
+      name: input.text(routine.name, "request.routine.name", 256),
+      version: input.positiveCount(routine.version, "request.routine.version"),
     },
-    payload: routineInput(request.payload, `${declaration}.request.payload`),
-    requested_by: envelope.text(
-      request.requested_by,
-      `${declaration}.request.requested_by`,
-      128,
-    ),
-    requested_at: envelope.text(
-      request.requested_at,
-      `${declaration}.request.requested_at`,
-      64,
-    ),
-    deliver_at:
-      request.deliver_at === null
-        ? null
-        : envelope.text(request.deliver_at, `${declaration}.request.deliver_at`, 64),
+    instruction: input.text(request.instruction, "request.instruction", 256 * 1024),
+    payload: request.payload,
+    references: request.references.map((reference, index) => input.plain(reference, `request.references[${index}]`)),
+    requested_by: input.text(request.requested_by, "request.requested_by", 128),
+    requested_at: input.text(request.requested_at, "request.requested_at", 64),
+    deliver_at: request.deliver_at === null ? null : input.text(request.deliver_at, "request.deliver_at", 64),
   };
 }
 
+export async function readRunRequest(session, run, token, signal = session.signal) {
+  return runRequest(await houseRequest(
+    session.house,
+    `Bearer ${token}`,
+    runRequestPath(run),
+    {},
+    session.dependencies,
+    signal,
+  ));
+}
+
 function acquiredAssignment(value, declaration) {
   const acquired = envelope.plain(value, declaration);
   const bridge = envelope.plain(acquired.session, `${declaration}.session`);
@@ -857,7 +870,6 @@ function acquiredAssignment(value, declaration) {
       token: envelope.text(bridge.bridge_token, `${declaration}.session.bridge_token`, 512),
       expiresAt: Date.parse(expiresAt),
     },
-    request: acquiredRequest(acquired, declaration),
   };
 }
 

package/src/inbound.js

@@ -134,13 +134,9 @@ export async function reconcileInbound(directory, session) {
 }
 
 export async function localRequest(directory, run, request) {
-  const turn = request?.conversation?.turn ?? (request?.kind === "conversation" ? request.turn : null);
-  if (turn === null || turn === undefined) return request;
+  if (request.kind !== "conversation") return request;
   const result = structuredClone(request);
-  const localTurn = result.conversation?.turn ?? result.turn;
-  if (!Array.isArray(localTurn.messages)) throw new KitRefusal("kit_run_input_unreadable");
-  for (const message of localTurn.messages) {
-    if (!Array.isArray(message.files)) throw new KitRefusal("kit_run_input_unreadable");
+  for (const message of result.turn.messages) {
     for (const file of message.files) {
       const parts = typeof file.path === "string" ? file.path.split("/") : [];
       if (parts.length !== 4 || parts[0] !== ROOT || parts[1] !== run || !UUID.test(parts[1]) || !UUID.test(parts[2]) || !segment(parts[3])) {
@@ -161,15 +157,3 @@ export async function localRequest(directory, run, request) {
   }
   return result;
 }
-
-export async function localReply(directory, run, frame, reply) {
-  if (frame.method !== "tools/call" || frame.params?.name !== "session_get_request" || reply.error || reply.result?.isError) return reply;
-  const result = structuredClone(reply);
-  for (const item of result.result?.content ?? []) {
-    if (item.type !== "text") continue;
-    let input;
-    try { input = JSON.parse(item.text); } catch { throw new KitRefusal("kit_run_input_unreadable"); }
-    item.text = JSON.stringify(await localRequest(directory, run, input));
-  }
-  return result;
-}

package/src/launcher.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { commandHouseInstructions, commandHouseRequest } from "./adapter-mcp.js";
+import { commandHouseInstructions } from "./adapter-mcp.js";
 import {
   compiledContract,
   initializeCommandAdapter,
@@ -191,13 +191,12 @@ async function runTurn(channel, start, bridge, turn) {
       loading = false;
     }
     await configureSession(acp, contract, providerSessionId, start.adapter);
-    const request = start.request === null ? await commandHouseRequest(bridge) : start.request;
     turn.adapterSession = true;
     turn.cancel = () => acp.cancel({ sessionId: providerSessionId });
     const prompted = await acp.request("session/prompt", {
       sessionId: providerSessionId,
       prompt: [
-        { type: "text", text: JSON.stringify(request) },
+        { type: "text", text: JSON.stringify(start.request) },
         { type: "text", text: instructions },
         ...workingCopyContext(start.working_copies),
       ],

package/src/local-files.js

@@ -1,6 +1,7 @@
 import { isAbsolute } from "node:path";
-import { parse, stringify } from "yaml";
+import { stringify } from "yaml";
 import { AGENT_OPERATION_META, ATTACHMENT_FILE_META } from "./contract.js";
+import { answerText, answerYaml } from "./mcp.js";
 import { derivedOperationId } from "./operation.js";
 import { localAttachment, sendLocalConversationFile, uploadLocalAttachment } from "./original.js";
 import { KitRefusal } from "./refusal.js";
@@ -12,18 +13,9 @@ class HouseRefused extends Error {
   }
 }
 
-function parsed(text) {
-  try {
-    return parse(text);
-  } catch {
-    return null;
-  }
-}
-
 function answerOf(frame) {
   if (frame.error !== undefined || frame.result?.isError === true) throw new HouseRefused(frame);
-  const text = (frame.result?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("\n");
-  const answer = parsed(text);
+  const answer = answerYaml(answerText(frame.result));
   if (answer === null || typeof answer !== "object") throw new KitRefusal("kit_house_answer_unreadable");
   return answer;
 }

package/src/mcp.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { parse } from "yaml";
 import { bridgePeer } from "./peer.js";
 import { KitRefusal } from "./refusal.js";
 
@@ -69,3 +70,15 @@ export async function bridgeCall(bridge, request, signal = undefined) {
     await peer.end();
   }
 }
+
+export function answerText(result) {
+  return (result?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("\n");
+}
+
+export function answerYaml(text) {
+  try {
+    return parse(text);
+  } catch {
+    return null;
+  }
+}

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.js

@@ -41,7 +41,7 @@ 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);
 }

package/src/worker.js

@@ -10,15 +10,16 @@ import {
 } from "./agents.js";
 import { readBindings, removeBinding, writeBinding } from "./binding.js";
 import { readContinuation, readContinuationRuns, writeContinuation, removeContinuation } from "./continuation.js";
-import { openBridge } from "./bridge.js";
+import { bridgedFrame, openBridge } from "./bridge.js";
 import { assistantBlocks } from "./blocks.js";
 import { retryConversationFiles } from "./conversation-originals.js";
 import { openAssistantDrafts } from "./draft.js";
-import { localReply, localRequest, reconcileInbound } from "./inbound.js";
+import { localRequest, reconcileInbound } from "./inbound.js";
 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, workingCopyPaths } from "./working-copy.js";
+import { applyWorkingCopies, ownerCaller, pushWorkingCopy, workingCopyPaths } from "./working-copy.js";
 import { readConfiguration } from "./configuration.js";
 import { launchBase, readyLaunchDirectory } from "./directory.js";
 import {
@@ -32,8 +33,9 @@ import {
   WORKER_HEARTBEAT_MS,
   WORKER_INHERITED_ENVIRONMENT,
   WORKER_SUPERVISION_POLL_MS,
+  WORKING_COPY_PUSH_METHOD,
 } from "./contract.js";
-import { EpochReportRequired, houseFailed, KitRefusal } from "./refusal.js";
+import { EpochReportRequired, formatCommandError, houseFailed, KitRefusal } from "./refusal.js";
 import {
   acceptAssistantText,
   acquireCommands,
@@ -52,6 +54,7 @@ import {
   observeSessionStart,
   observeSessionStop,
   openSession,
+  readRunRequest,
   replaceSessionAuthority,
   reportContinuation,
   reportInterruptOutcome,
@@ -269,6 +272,52 @@ function endOnEpochReport(ended, act) {
   };
 }
 
+function refusedWith(text) {
+  const conflicts = answerYaml(text.slice(text.indexOf("\n") + 1))?.conflicts;
+  const current = Array.isArray(conflicts)
+    ? conflicts.map(({ path, state, revision }) =>
+        state === "absent" ? { path, revision: null, content: null } : { path, revision },
+      )
+    : null;
+  return { refused: { code: text.split(":")[0].trim(), text, current } };
+}
+
+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 };
+}
+
+async function sessionPush(context, bound, authority, frame, signal) {
+  const edit = async (body, sent) => {
+    const answer = await callHouseMcp(
+      context.session,
+      await sessionAuthority(context.session, bound.session, authority, sent),
+      bridgedFrame(
+        { jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "edit", arguments: { changes: body.changes } } },
+        body.operation_id,
+      ),
+      sent,
+    );
+    if (answer.error !== undefined) return refusedWith(answer.error.message ?? "kit_house_refused");
+    const text = answerText(answer.result);
+    return answer.result?.isError === true ? refusedWith(text) : acceptedWith(text);
+  };
+  let outcome;
+  try {
+    outcome = await pushWorkingCopy(context, frame.params, { binding: { session: bound.session }, submit: edit }, signal);
+  } catch (refusal) {
+    if (!(refusal instanceof KitRefusal)) throw refusal;
+    outcome = { refused: true, text: refusal.message };
+  }
+  return {
+    jsonrpc: "2.0",
+    id: frame.id,
+    result: { content: [{ type: "text", text: outcome.text }], ...(outcome.refused ? { isError: true } : {}) },
+  };
+}
+
 async function openRunBridge(context, bound, authority, start) {
   const ended = new AbortController();
   const handed = (act) => endOnEpochReport(ended, act);
@@ -290,14 +339,15 @@ async function openRunBridge(context, bound, authority, start) {
     ),
     secret: (interaction, ceremony) => awaitSecretInput(context.session, interaction, ceremony),
     settle: handed((interaction, outcome) => settleInteraction(context, interaction, outcome)),
-    forward: handed((frame, signal) =>
-      localFiles(async (sent) =>
-        localReply(context.directory, bound.run, sent, await callHouseMcp(
+    forward: handed((frame, signal) => frame.method === WORKING_COPY_PUSH_METHOD
+      ? sessionPush(context, bound, authority, frame, signal)
+      : localFiles(async (sent) =>
+        callHouseMcp(
           context.session,
           await sessionAuthority(context.session, bound.session, authority, signal),
           sent,
           signal,
-        )), context.session.dependencies, signal)(frame)),
+        ), context.session.dependencies, signal)(frame)),
   });
   return { bridge, drafts, ended };
 }
@@ -467,7 +517,7 @@ async function prepareAssignment(context, assignment, resumed) {
     reported: null,
   };
   const authority = { token: assignment.session.token, expiresAt: assignment.session.expiresAt };
-  const opened = await openRunBridge(context, bound, authority, {
+  const start = {
     working_directory: assignment.workingDirectory,
     working_copies: await appliedWorkingCopies(context),
     execution_authority: context.configuration.executionAuthority,
@@ -479,10 +529,16 @@ async function prepareAssignment(context, assignment, resumed) {
       effort: route.effort,
       environment: {},
     },
-    request: await localRequest(context.directory, assignment.run, assignment.request),
+    request: null,
     provider_session: assignment.providerSessionId ?? null,
-  });
-  return { bound, opened };
+  };
+  const opened = await openRunBridge(context, bound, authority, start);
+  const request = async () => {
+    const token = await sessionAuthority(context.session, bound.session, authority);
+    start.request = await localRequest(context.directory, bound.run,
+      await readRunRequest(context.session, bound.run, token));
+  };
+  return { bound, opened, request };
 }
 
 async function refuseContinuation(context, command, failure) {
@@ -523,11 +579,12 @@ async function superviseAssignment(context, assignment, resumed = false) {
     if (undecided(context, refusal)) throw refusal;
     return refuseAssignment(context, assignment, failure);
   }
-  const { bound, opened } = prepared;
+  const { bound, opened, request } = prepared;
   return superviseBound(context, bound, opened, async (spawn) => {
     if (!resumed) await commitRun(context.session, assignment.run);
     spawn.committed = true;
     await writeBinding(context.directory, bound);
+    await request();
     await createSession(context.runtime, {
       session: bound.tmux,
       workingDirectory: assignment.workingDirectory,
@@ -549,7 +606,7 @@ async function superviseResumption(context, command) {
   }
   return superviseAssignment(context, {
     ...command, agentId: held.agentId, workingDirectory: held.workingDirectory,
-    conversation: held.conversation, providerSessionId: held.providerSessionId, request: null,
+    conversation: held.conversation, providerSessionId: held.providerSessionId,
   }, true);
 }
 
@@ -952,7 +1009,16 @@ export async function runResident(options, dependencies = {}) {
   const wake = residentWake();
   const update = residentUpdate(context, wake);
   context.update = update;
-  const served = await serveResident(session, context.directory, options.signal, (serving) => update.request(serving));
+  const served = await serveResident(
+    session,
+    context.directory,
+    options.signal,
+    (serving) => update.request(serving),
+    (request, signal) =>
+      pushWorkingCopy({ directory: context.directory, session }, request, ownerCaller(session), signal).catch(
+        (error) => ({ refused: true, text: formatCommandError(error) }),
+      ),
+  );
   const serve = async (signal) => {
     context.busy = true;
     const watcher = new AbortController();