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

package/bootstrap.json

@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "version": "0.1.0-alpha.21",
+  "hosts": {
+    "linux": {
+      "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.21/connect-linux.sh"
+      },
+      "workspace": {
+        "argument": "--workspace",
+        "quoting": "posix"
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.21",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -9,11 +9,16 @@
   "private": false,
   "type": "module",
   "bin": {
+    "house": "src/session-bin/house",
     "kit": "bin/kit.js"
   },
+  "exports": {
+    "./bootstrap": "./bootstrap.json"
+  },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.5.0",
-    "@agentshouse/mdmodel": "0.1.0-alpha.13",
+    "@agentshouse/mdmodel": "0.1.0-alpha.15",
+    "ws": "8.22.0",
     "yaml": "2.9.1",
     "zod": "4.6.5"
   },

package/src/adapter-mcp.js

@@ -29,16 +29,3 @@ export async function commandHouseInstructions(bridge) {
   }
   return frame.result.instructions;
 }
-
-export async function commandHouseRequest(bridge) {
-  const frame = await commandHouseReply(bridge, { method: "tools/call", params: { name: "session_get_request", arguments: {} } });
-  if (frame.error !== undefined || frame.result?.isError === true) throw new KitRefusal("kit_run_input_unreadable");
-  try {
-    const content = frame.result.content;
-    const input = JSON.parse(content.find((item) => item.type === "text").text);
-    if (typeof input !== "object" || input === null || Array.isArray(input)) throw new Error();
-    return input;
-  } catch {
-    throw new KitRefusal("kit_run_input_unreadable");
-  }
-}

package/src/agents.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { readFile, rm } from "node:fs/promises";
+import { readFile, readdir, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import {
@@ -11,6 +11,7 @@ import {
 } from "./adapter.js";
 import { inheritedEnvironment } from "./command.js";
 import {
+  ADAPTER_KINDS,
   AGENT_HOME,
   AGENT_INSTALL_TIMEOUT_MS,
   AGENT_RELEASES_HOME,
@@ -261,6 +262,60 @@ export async function updateDeclaredAgents(options, configuration, dependencies
   return updated;
 }
 
+export async function removeUndeclaredAgents(directory, wanted, keep = false) {
+  const home = join(directory, AGENT_HOME);
+  let entries;
+  try {
+    entries = await readdir(home, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const retained = [];
+  for (const entry of entries) {
+    if (!wanted.includes(entry.name)) {
+      if (keep && ADAPTER_KINDS.includes(entry.name)) retained.push(entry.name);
+      else await rm(join(home, entry.name), { recursive: true, force: true });
+    }
+  }
+  return retained;
+}
+
+export async function reconcileAgentKinds(
+  options,
+  session,
+  configuration,
+  dependencies = {},
+  signal = session.signal,
+  state = {},
+) {
+  const selected = { ...configuration, agents: await desiredAgents(session, signal) };
+  state.onDesired?.(selected.agents);
+  const newlyWanted = selected.agents.filter((kind) => !state.lastDesired?.includes(kind));
+  const retained = await removeUndeclaredAgents(options.directory, selected.agents, state.busy);
+  const pointerKinds = state.busy
+    ? (
+        await Promise.all(
+          newlyWanted.map(async (kind) =>
+            (await readAgentState(options.directory, kind)).release === null ? kind : null,
+          ),
+        )
+      ).filter((kind) => kind !== null)
+    : newlyWanted;
+  const updated = await updateDeclaredAgents(
+    { directory: options.directory, at: dependencies.now?.(), forced: state.forced },
+    { ...selected, agents: state.pointer ? pointerKinds : selected.agents },
+    dependencies,
+  );
+  const readiness = await agentReadiness(
+    { directory: options.directory },
+    { ...selected, agents: [...selected.agents, ...retained] },
+    dependencies,
+  );
+  await reportAgentCapabilities(session, readiness.agents, signal);
+  return { selected, updated, reported: readiness.agents, refused: readiness.refused, retained };
+}
+
 export async function agentSignedIn(directory, kind, dependencies = {}) {
   const contract = compiledContract(kind);
   const state = await readAgentState(directory, kind);
@@ -341,15 +396,15 @@ export async function updateAgents(options, dependencies = {}) {
   return maintainControl(
     session,
     async (signal) => {
-      const selected = { ...configuration, agents: await desiredAgents(session, signal) };
-      const updated = await updateDeclaredAgents(
-        { directory: options.directory, at: dependencies.now?.(), forced: true },
-        selected,
+      const result = await reconcileAgentKinds(
+        options,
+        session,
+        configuration,
         dependencies,
+        signal,
+        { forced: true },
       );
-      const { agents } = await agentReadiness(options, selected, dependencies);
-      await reportAgentCapabilities(session, agents, signal);
-      return { updated, reported: agents };
+      return { updated: result.updated, reported: result.reported };
     },
     options.signal,
   );

package/src/binding.js

@@ -15,6 +15,18 @@ function bindingPath(directory, tmux) {
   return join(bindingDirectory(directory), `${tmux}.json`);
 }
 
+function stoppedNote(stopped) {
+  if (stopped === null || stopped === undefined) return null;
+  return {
+    turn_completed: stopped.turnCompleted,
+    capacity_exhausted: stopped.capacityExhausted,
+    provider_refused: stopped.providerRefused,
+    continuable: stopped.continuable,
+    failure: stopped.failure,
+    text_accepted: stopped.textAccepted,
+  };
+}
+
 export async function writeBinding(directory, binding) {
   const reported = binding.reported ?? null;
   await writeNote(bindingPath(directory, binding.tmux), {
@@ -29,6 +41,7 @@ export async function writeBinding(directory, binding) {
     sealed: binding.sealed === null || binding.sealed === undefined
       ? null
       : { operation: binding.sealed.operation, blocks: binding.sealed.blocks },
+    stopped: stoppedNote(binding.stopped),
     reported: reported === null ? null : reportedNote(reported),
   });
 }
@@ -45,6 +58,31 @@ function retainedSeal(stored) {
   return { operation: stored.operation, blocks: stored.blocks };
 }
 
+function retainedFailure(stored) {
+  if (stored === null) return null;
+  if (typeof stored !== "object" || Array.isArray(stored)) return undefined;
+  if (typeof stored.code !== "string" || stored.code.length === 0) return undefined;
+  if (stored.detail !== null && typeof stored.detail !== "string") return undefined;
+  return { code: stored.code, detail: stored.detail };
+}
+
+function retainedStop(stored) {
+  if (stored === null || stored === undefined) return null;
+  if (typeof stored !== "object" || Array.isArray(stored)) return undefined;
+  const flags = ["turn_completed", "capacity_exhausted", "provider_refused", "continuable", "text_accepted"];
+  if (flags.some((flag) => typeof stored[flag] !== "boolean")) return undefined;
+  const failure = retainedFailure(stored.failure);
+  if (failure === undefined) return undefined;
+  return {
+    turnCompleted: stored.turn_completed,
+    capacityExhausted: stored.capacity_exhausted,
+    providerRefused: stored.provider_refused,
+    continuable: stored.continuable,
+    failure,
+    textAccepted: stored.text_accepted,
+  };
+}
+
 function completeBinding(directory, stored) {
   if (typeof stored !== "object" || stored === null || Array.isArray(stored)) return null;
   const named = [stored.run, stored.session, stored.tmux, stored.socket, stored.nonce];
@@ -54,6 +92,8 @@ function completeBinding(directory, stored) {
   if (stored.owner_stop !== null && typeof stored.owner_stop !== "string") return null;
   const sealed = retainedSeal(stored.sealed);
   if (sealed === undefined) return null;
+  const stopped = retainedStop(stored.stopped);
+  if (stopped === undefined) return null;
   const reported = retainedReport(stored.reported);
   if (reported === undefined) return null;
   return {
@@ -65,6 +105,7 @@ function completeBinding(directory, stored) {
     conversation: stored.conversation === true,
     ownerStop: stored.owner_stop,
     sealed,
+    stopped,
     reported,
   };
 }

package/src/bridge.js

@@ -18,7 +18,7 @@ import {
 import { operationId } from "./operation.js";
 import { houseFailed } from "./refusal.js";
 
-function bridgedFrame(request, operation) {
+export function bridgedFrame(request, operation) {
   if (typeof request.method !== "string") return request;
   const params = typeof request.params === "object" && request.params !== null ? request.params : {};
   const declared = typeof params._meta === "object" && params._meta !== null ? params._meta : {};

package/src/contract.js

@@ -1,6 +1,6 @@
 import { CLAUDE_PASTED_CODE, CODEX_DEVICE_CODE, GROK_DEVICE_CODE } from "./agent-logins.js";
 
-export const KIT_CONTRACT_VERSION = "2026-09-26-house-agent-kinds";
+export const KIT_CONTRACT_VERSION = "1";
 export const KIT_CAPTURE_BATCH_MAX = 100;
 export const COMMAND_INPUT_MAX_BYTES = 4 * 1024;
 export const AUTHORIZATION_OUTPUT_MAX_BYTES = 4 * 1024;
@@ -40,6 +40,10 @@ export function runOutcomePath(run) {
   return `/kit/runs/${encodeURIComponent(run)}/outcome`;
 }
 
+export function runRequestPath(run) {
+  return `/kit/runs/${encodeURIComponent(run)}/request`;
+}
+
 export const KIT_SESSIONS_REPORT_PATH = "/kit/sessions/report";
 export const KIT_SESSIONS_REPORT_MAX = 256;
 
@@ -195,7 +199,7 @@ export const ADAPTER_CONTRACTS = Object.freeze({
     guidedLogin: CLAUDE_PASTED_CODE,
     identity: Object.freeze({ agentInfo: "@agentclientprotocol/claude-agent-acp" }),
     nativeQuestion: null,
-    sessionLoad: false,
+    sessionLoad: true,
     sessionConfig: Object.freeze({ model: "model", effort: "effort" }),
     capabilities: Object.freeze({
       field_kinds: ELICITATION_FIELD_KINDS,
@@ -288,9 +292,23 @@ export const KIT_DOOR_DISCOVER_PATH = "/kit/door/discover";
 export const KIT_DOOR_BOOTSTRAP_PATH = "/kit/door/bootstrap";
 export const KIT_DOOR_ENUMERATE_PATH = "/kit/door/enumerate";
 export const KIT_DOOR_BATCH_PATH = "/kit/door/batch";
-export const EXPLICIT_SYNC_VERSION = "explicit-sync/1";
+export const KIT_DOOR_REVISIONS_PATH = "/kit/door/revisions";
+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/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"];
+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.";
+
 export const MIGRATOR_CONTRACT = "kit-migrator/1";
 export const MIGRATOR_CATEGORY = "migrator";
 export const MIGRATOR_MANIFEST = "migrator.json";

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

@@ -0,0 +1,62 @@
+import { spawn } from "node:child_process";
+import { KitRefusal } from "./refusal.js";
+
+function cancelledOr(signal, error, code) {
+  return signal?.aborted === true || error?.name === "AbortError"
+    ? new KitRefusal("kit_command_cancelled")
+    : new KitRefusal(code);
+}
+
+function stdio(capture, input) {
+  if (input !== null) return ["pipe", capture ? "pipe" : "inherit", "inherit"];
+  return capture ? ["ignore", "pipe", "inherit"] : "inherit";
+}
+
+export function runGit(cwd, args, options = {}) {
+  const { dependencies = {}, capture = false, input = null, signal, failure } = options;
+  if (signal?.aborted === true) return Promise.reject(new KitRefusal("kit_command_cancelled"));
+  const launcher = dependencies.spawn ?? spawn;
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = launcher("git", args, {
+        cwd,
+        env: process.env,
+        stdio: stdio(capture, input),
+        signal,
+        killSignal: "SIGKILL",
+      });
+    } catch (error) {
+      reject(cancelledOr(signal, error, "kit_git_unavailable"));
+      return;
+    }
+    const output = [];
+    let settled = false;
+    const finish = (operation) => {
+      if (settled) return;
+      settled = true;
+      operation();
+    };
+    child.stdout?.on("data", (chunk) => output.push(Buffer.from(chunk)));
+    child.once("error", (error) =>
+      finish(() => reject(cancelledOr(signal, error, "kit_git_unavailable"))),
+    );
+    child.once("close", (status) => {
+      finish(() => {
+        if (signal?.aborted === true) {
+          reject(new KitRefusal("kit_command_cancelled"));
+          return;
+        }
+        if (status !== 0) {
+          reject(new KitRefusal(failure));
+          return;
+        }
+        resolve(Buffer.concat(output));
+      });
+    });
+    if (input !== null) {
+      child.stdin.on("error", () => undefined);
+      child.stdin.end(input);
+    }
+  });
+}

package/src/host.js

@@ -1,7 +1,7 @@
 import { readFile, statfs } from "node:fs/promises";
 import { readConfiguration } from "./configuration.js";
 import { HOST_CPU_SAMPLE_MS } from "./contract.js";
-import { openSession, reportHostCapacity } from "./house.js";
+import { maintainControl, openSession, reportHostCapacity } from "./house.js";
 import { KitRefusal } from "./refusal.js";
 
 const PROC_STAT = "/proc/stat";
@@ -116,6 +116,10 @@ export async function reportHost(options, dependencies = {}) {
       ? observed
       : { ...observed, maxima: declaredMaxima(configuration.host.maxima) };
   const session = await openSession(options, dependencies);
-  await reportHostCapacity(session, declaration);
+  await maintainControl(
+    session,
+    (signal) => reportHostCapacity(session, declaration, signal),
+    options.signal,
+  );
   return declaration;
 }

package/src/house-main.js

@@ -1,9 +1,19 @@
-import { resolve } from "node:path";
-import { BRIDGE_NONCE_ENVIRONMENT, BRIDGE_SOCKET_ENVIRONMENT } from "./contract.js";
-import { bridgeCall } from "./mcp.js";
-import { KitRefusal } from "./refusal.js";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import {
+  BRIDGE_NONCE_ENVIRONMENT,
+  BRIDGE_SOCKET_ENVIRONMENT,
+  WORKING_COPY_PUSH_HELP,
+  WORKING_COPY_PUSH_METHOD,
+} from "./contract.js";
+import { storedHouse } from "./login.js";
+import { answerText, bridgeCall } from "./mcp.js";
+import { formatCommandError, KitRefusal } from "./refusal.js";
+import { ownerPush } from "./working-copy.js";
 
 const HELP = ["--help", "-h"];
+const OWNER = "--owner";
+const GIT_PUSH_USAGE = `usage: house git push [commit] [${OWNER}]`;
 const usage = (verb) => `usage: house ${verb} ['<arguments as one JSON object>' | - for standard input]`;
 
 async function answered(method, params) {
@@ -49,10 +59,59 @@ function located(verb, args) {
   return args;
 }
 
+function printed(result) {
+  const text = answerText(result);
+  return result?.isError === true ? { err: text, status: 1 } : { out: text };
+}
+
+async function ownerPushed(request) {
+  const directory = process.env.HOUSE_KIT_HOME ?? join(homedir(), ".house-kit");
+  const cancellation = new AbortController();
+  const cancel = () => cancellation.abort();
+  process.once("SIGINT", cancel);
+  process.once("SIGTERM", cancel);
+  try {
+    const pushed = await ownerPush(
+      { house: await storedHouse(directory), directory, signal: cancellation.signal },
+      request,
+    );
+    return pushed.refused ? { err: pushed.text, status: 1 } : { out: pushed.text };
+  } catch (refusal) {
+    return { err: formatCommandError(refusal), status: 1 };
+  } finally {
+    process.removeListener("SIGINT", cancel);
+    process.removeListener("SIGTERM", cancel);
+  }
+}
+
+async function gitPush([action, ...rest]) {
+  if (action !== "push") throw new KitRefusal("kit_house_arguments_invalid", GIT_PUSH_USAGE);
+  if (rest.some((argument) => HELP.includes(argument))) return { out: `${GIT_PUSH_USAGE}\n\n${WORKING_COPY_PUSH_HELP}` };
+  const owner = rest.includes(OWNER);
+  const named = rest.filter((argument) => argument !== OWNER);
+  if (named.length > 1 || named.some((argument) => argument.startsWith("-"))) {
+    throw new KitRefusal("kit_house_arguments_invalid", GIT_PUSH_USAGE);
+  }
+  const request = { cwd: process.cwd(), commit: named[0] ?? "HEAD" };
+  if (process.env[BRIDGE_SOCKET_ENVIRONMENT] === undefined) {
+    if (!owner) throw new KitRefusal("kit_bridge_unavailable");
+    return ownerPushed(request);
+  }
+  if (owner) throw new KitRefusal("kit_house_arguments_invalid", `${OWNER} is only for use outside an Agent Session`);
+  return printed(await answered(WORKING_COPY_PUSH_METHOD, request));
+}
+
 async function house([verb, argument, ...rest]) {
+  if (verb === "git") return gitPush([argument, ...rest].filter((part) => part !== undefined));
   if (verb === undefined || HELP.includes(verb)) {
     const tools = await listed();
-    return { out: [usage("<verb>"), ...tools.map((tool) => `${tool.name}\n${tool.description}`)].join("\n\n") };
+    return {
+      out: [
+        usage("<verb>"),
+        ...tools.map((tool) => `${tool.name}\n${tool.description}`),
+        `git push [commit]\n${WORKING_COPY_PUSH_HELP}`,
+      ].join("\n\n"),
+    };
   }
   if (HELP.includes(argument)) {
     const tool = (await listed()).find((one) => one.name === verb);
@@ -61,9 +120,7 @@ async function house([verb, argument, ...rest]) {
   }
   if (rest.length > 0) throw new KitRefusal("kit_house_arguments_invalid", usage(verb));
   const args = located(verb, await argumentsOf(verb, argument));
-  const result = await answered("tools/call", { name: verb, arguments: args });
-  const text = (result?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("\n");
-  return result?.isError === true ? { err: text, status: 1 } : { out: text };
+  return printed(await answered("tools/call", { name: verb, arguments: args }));
 }
 
 house(process.argv.slice(2)).then(