@modootoday/pmcp 0.11.0 → 0.13.0

package/dist/harness-worker.js

@@ -0,0 +1,2737 @@
+// src/harness/application/worker.ts
+import { unlinkSync as unlinkSync4 } from "fs";
+
+// src/harness/groups/store.ts
+import { randomUUID } from "crypto";
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  fsyncSync,
+  openSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  writeFileSync
+} from "fs";
+import { dirname, join } from "path";
+
+// src/harness/validation.ts
+function object(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("invalid_object");
+  }
+  return value;
+}
+function text(value, name) {
+  if (typeof value !== "string" || value.length === 0 || value.includes("\0")) {
+    throw new Error(`invalid_${name}`);
+  }
+  return value;
+}
+function integer(value, name, min, max) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min || value > max) {
+    throw new Error(`invalid_${name}`);
+  }
+  return value;
+}
+function strings(value, name) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 64) {
+    throw new Error(`invalid_${name}`);
+  }
+  return value.map((entry) => text(entry, name));
+}
+function id(value, name) {
+  const result = text(value, name);
+  if (!/^[a-zA-Z0-9-]{1,80}$/.test(result)) throw new Error(`invalid_${name}`);
+  return result;
+}
+
+// src/harness/runtimes/docker-policy.ts
+import { isAbsolute as isAbsolute3, posix as posix3 } from "path";
+
+// src/harness/runtimes/registry.ts
+var runtimeExecutables = {
+  "codex-cli": "codex",
+  "claude-code": "claude",
+  "gemini-cli": "gemini",
+  "grok-cli": "grok",
+  antigravity: "agy"
+};
+
+// src/harness/runtimes/egress-policy.ts
+import { isAbsolute, posix } from "path";
+function egressPolicy(value) {
+  const policy = object(value);
+  const hosts = strings(policy.hosts, "egress_hosts").map(
+    (host) => host.toLowerCase()
+  );
+  if (hosts.length > 16 || new Set(hosts).size !== hosts.length)
+    throw new Error("invalid_egress_hosts");
+  for (const host of hosts) {
+    if (host.length > 253 || !host.includes(".") || /^[0-9.]+$/.test(host) || !host.split(".").every(
+      (label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label)
+    ) || /\.(local|localhost|internal|invalid|test)$/.test(host))
+      throw new Error("invalid_egress_host");
+  }
+  if (policy.bridgeExecutable === void 0) return { hosts };
+  const executable = text(policy.bridgeExecutable, "egress_bridge_executable");
+  if (!isAbsolute(executable) || posix.normalize(executable) !== executable || /[\r\n\x1b]/.test(executable))
+    throw new Error("invalid_egress_bridge_executable");
+  return { hosts, bridgeExecutable: executable };
+}
+
+// src/harness/runtimes/private-profiles.ts
+import { isAbsolute as isAbsolute2, posix as posix2 } from "path";
+function profileName(value) {
+  const name = text(value, "private_profile");
+  if (!/^[a-z][a-z0-9-]{0,31}$/.test(name))
+    throw new Error("invalid_private_profile_name");
+  return name;
+}
+function privateProfiles(value) {
+  const entries = Object.entries(object(value));
+  if (!entries.length || entries.length > 16)
+    throw new Error("invalid_private_profile_grants");
+  const result = {};
+  for (const [name, entry] of entries) {
+    profileName(name);
+    const grant = object(entry);
+    const runtime = text(grant.runtime, "private_profile_runtime");
+    const directory = absolute(grant.directory, "private_profile_directory");
+    const lockExecutable = absolute(
+      grant.lockExecutable,
+      "private_profile_lock_executable"
+    );
+    const identity = grant.identity === void 0 ? void 0 : text(grant.identity, "private_profile_identity");
+    if (identity !== void 0 && !/^\d+:\d+:\d+:\d+$/.test(identity))
+      throw new Error("invalid_private_profile_identity");
+    result[name] = {
+      runtime,
+      directory,
+      lockExecutable,
+      ...identity ? { identity } : {}
+    };
+  }
+  if (new Set(Object.values(result).map((grant) => grant.directory)).size !== entries.length)
+    throw new Error("duplicate_private_profile_directory");
+  return result;
+}
+function absolute(value, field) {
+  const path = text(value, field);
+  if (!isAbsolute2(path) || posix2.normalize(path) !== path || /[\r\n\x1b]/.test(path))
+    throw new Error("invalid_private_profile_path");
+  return path;
+}
+function selectedProfile(policy, name, runtime) {
+  if (name === void 0) return;
+  const grant = policy.privateProfiles?.[profileName(name)];
+  if (!grant || grant.runtime !== runtime || !grant.identity)
+    throw new Error("private_profile_not_granted");
+  return grant;
+}
+
+// src/harness/runtimes/docker-policy.ts
+function dockerPolicy(value) {
+  const policy = object(value);
+  if (policy.schemaVersion !== 1)
+    throw new Error("invalid_docker_policy_version");
+  if (!/^sha256:[a-f0-9]{64}$/.test(text(policy.image, "docker_image")))
+    throw new Error("docker_image_requires_digest");
+  if (policy.network !== "none")
+    throw new Error("docker_network_not_qualified");
+  if (policy.workspaceAccess !== "read-only" && policy.workspaceAccess !== "read-write")
+    throw new Error("invalid_docker_workspace_access");
+  const commands = object(policy.commands);
+  const entries = Object.entries(commands);
+  if (!entries.length || entries.length > 5)
+    throw new Error("invalid_docker_runtime_commands");
+  const parsed = {};
+  for (const [runtime, value2] of entries) {
+    if (!Object.hasOwn(runtimeExecutables, runtime))
+      throw new Error("unsupported_docker_runtime");
+    const command2 = strings(value2, "docker_runtime_command");
+    const executable = command2[0];
+    if (!isAbsolute3(executable) || posix3.normalize(executable) !== executable || command2.some((argument) => /[\r\n\x1b]/.test(argument)))
+      throw new Error("invalid_docker_runtime_command");
+    parsed[runtime] = command2;
+  }
+  return {
+    schemaVersion: 1,
+    image: text(policy.image, "docker_image"),
+    network: "none",
+    workspaceAccess: policy.workspaceAccess,
+    commands: parsed,
+    ...policy.egress === void 0 ? {} : { egress: egressPolicy(policy.egress) },
+    ...policy.privateProfiles === void 0 ? {} : { privateProfiles: privateProfiles(policy.privateProfiles) }
+  };
+}
+
+// src/harness/groups/validation.ts
+function member(value, allowed) {
+  if (!allowed.includes(value)) throw new Error("invalid_state_value");
+}
+function records(value) {
+  if (!Array.isArray(value) || value.length > 4096)
+    throw new Error("invalid_state_collection");
+  return value.map(object);
+}
+function unique(values) {
+  if (new Set(values).size !== values.length)
+    throw new Error("duplicate_state_identity");
+}
+function validateState(value) {
+  const state = object(value);
+  const group = object(state.group);
+  member(group.schemaVersion, [1]);
+  for (const field of ["owner", "id", "generation"]) id(group[field], field);
+  text(group.projectRoot, "project_root");
+  strings(group.allowedRuntimes, "allowed_runtimes");
+  member(group.profile, ["native", "docker"]);
+  if (group.profile === "docker") dockerPolicy(group.dockerPolicy);
+  if (group.profile === "native" && group.dockerPolicy !== void 0)
+    throw new Error("docker_policy_requires_docker_profile");
+  member(group.state, ["ready", "paused", "stopped"]);
+  integer(group.memoryMb, "memory_budget", 128, 4096);
+  integer(group.maxActive, "max_active", 1, 5);
+  const sessions = records(group.sessions);
+  for (const session of sessions) {
+    id(session.id, "session_id");
+    member(session.role, ["main", "worker"]);
+    member(session.stopped, [true, false]);
+  }
+  unique(sessions.map((session) => session.id));
+  if (sessions.filter((s) => s.role === "main" && !s.stopped).length > 1)
+    throw new Error("multiple_active_main_sessions");
+  const leases = records(state.leases);
+  for (const lease of leases) {
+    id(lease.token, "control_token");
+    id(lease.controller, "controller");
+    member(lease.generation, [group.generation]);
+    member(lease.mode, ["cli", "native"]);
+    member(
+      lease.sessionId,
+      sessions.map((session) => session.id)
+    );
+    if (!Number.isFinite(Date.parse(text(lease.expiresAt, "control_expiry"))))
+      throw new Error("invalid_control_expiry");
+  }
+  unique(leases.map((lease) => lease.token));
+  unique(leases.map((lease) => lease.sessionId));
+  const deliveries = records(state.deliveries);
+  for (const delivery of deliveries) {
+    if (delivery.controller !== void 0)
+      id(delivery.controller, "controller");
+    id(delivery.requestId, "request_id");
+    id(delivery.sessionId, "session_id");
+    id(delivery.generation, "generation");
+    member(delivery.operation, ["write", "submit"]);
+    member(delivery.state, ["intent", "input_written", "delivery_uncertain"]);
+    if (!/^[a-f0-9]{64}$/.test(text(delivery.digest, "delivery_digest")))
+      throw new Error("invalid_delivery_digest");
+  }
+  unique(deliveries.map((delivery) => delivery.requestId));
+  return state;
+}
+
+// src/harness/groups/store.ts
+function privateJson(path, value) {
+  const temporary = `${path}.${randomUUID()}.new`;
+  const descriptor = openSync(temporary, "wx", 384);
+  try {
+    writeFileSync(descriptor, `${JSON.stringify(value, null, 2)}
+`);
+    fsyncSync(descriptor);
+  } finally {
+    closeSync(descriptor);
+  }
+  renameSync(temporary, path);
+  const directory = openSync(dirname(path), "r");
+  try {
+    fsyncSync(directory);
+  } finally {
+    closeSync(directory);
+  }
+}
+function readPrivateJson(path) {
+  const descriptor = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const stat = fstatSync(descriptor);
+    if (!stat.isFile() || (stat.mode & 63) !== 0 || stat.size > 2097152)
+      throw new Error("unsafe_state_file");
+    if (stat.uid !== process.getuid?.()) throw new Error("foreign_state_file");
+    return JSON.parse(readFileSync(descriptor, "utf8"));
+  } finally {
+    closeSync(descriptor);
+  }
+}
+var GroupStore = class {
+  path;
+  state;
+  constructor(path) {
+    this.path = realpathSync(path);
+    this.state = validateState(readPrivateJson(path));
+    const metadata = object(
+      readPrivateJson(join(dirname(this.path), "harness.json"))
+    );
+    if (this.state.group.schemaVersion !== 1 || this.state.group.owner !== metadata.owner) {
+      throw new Error("foreign_group");
+    }
+  }
+  save() {
+    validateState(this.state);
+    privateJson(this.path, this.state);
+  }
+  session(id2) {
+    if (!this.state.group.sessions.some((entry) => entry.id === id2)) {
+      throw new Error("foreign_session");
+    }
+  }
+};
+
+// src/harness/control/leases.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { join as join12 } from "path";
+
+// src/harness/adapters/process/command.ts
+import {
+  execFileSync
+} from "child_process";
+function command(binary, args, options = {}) {
+  return execFileSync(binary, args, {
+    encoding: "utf8",
+    timeout: 1e4,
+    maxBuffer: 256 * 1024,
+    stdio: ["pipe", "pipe", "pipe"],
+    ...options
+  });
+}
+function quote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+// src/harness/adapters/process/identity.ts
+import { readFileSync as readFileSync2 } from "fs";
+function processIdentity(pid) {
+  if (!Number.isSafeInteger(pid) || pid < 1)
+    throw new Error("invalid_process_id");
+  const stat = readFileSync2(`/proc/${pid}/stat`, "utf8");
+  const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+  if (!/^\d+$/.test(fields[19] ?? ""))
+    throw new Error("process_identity_unknown");
+  return `${pid}:${fields[19]}`;
+}
+function controllerExited(identity) {
+  if (!/^\d+:\d+$/.test(identity))
+    throw new Error("invalid_controller_identity");
+  const [pid] = identity.split(":");
+  try {
+    return processIdentity(Number(pid)) !== identity;
+  } catch (error) {
+    if (error.code === "ENOENT") return true;
+    throw new Error("controller_liveness_unknown", { cause: error });
+  }
+}
+
+// src/harness/adapters/docker/claims.ts
+import { createHash } from "crypto";
+
+// src/harness/adapters/docker/identity.ts
+var containerLabels = {
+  owner: "pmcp.harness.owner",
+  nonce: "pmcp.harness.nonce",
+  role: "pmcp.harness.role"
+};
+function containerName(owner, sessionId) {
+  return `pmcp-harness-${owner.slice(0, 8)}-${sessionId}`;
+}
+
+// src/harness/adapters/docker/claims.ts
+function resourceClaim(value, owner) {
+  const record = object(value);
+  if (record.kind !== "docker" || record.owner !== owner)
+    throw new Error("foreign_container_resource");
+  if (!/^[a-f0-9]{64}$/.test(text(record.id, "container_id")))
+    throw new Error("invalid_container_id");
+  if (!/^sha256:[a-f0-9]{64}$/.test(text(record.image, "container_image")))
+    throw new Error("invalid_container_image");
+  if (!/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(
+    text(record.nonce, "container_nonce")
+  ))
+    throw new Error("invalid_container_nonce");
+  if (record.role !== "main" && record.role !== "worker")
+    throw new Error("invalid_container_role");
+  if (!/^[a-f0-9]{64}$/.test(
+    text(record.configurationDigest, "container_configuration")
+  ))
+    throw new Error("invalid_container_configuration");
+  integer(record.memoryMb, "container_memory", 32, 1472);
+  integer(record.cpuQuota, "container_cpu", 1, 5e4);
+  if (record.managed !== void 0 && record.managed !== true)
+    throw new Error("invalid_container_custody");
+  if (record.privateProfile !== void 0) {
+    profileName(record.privateProfile);
+    if (record.managed !== true)
+      throw new Error("private_profile_requires_cli_owned_creation");
+  }
+  return record;
+}
+function assertResourceOwner(resource, actual) {
+  const config = object(actual.Config);
+  const labels = object(config.Labels);
+  if (actual.Id !== resource.id || actual.Image !== resource.image || labels[containerLabels.owner] !== resource.owner || labels[containerLabels.nonce] !== resource.nonce || labels[containerLabels.role] !== resource.role)
+    throw new Error("foreign_container_identity");
+}
+function configurationDigest(actual) {
+  const host = object(actual.HostConfig);
+  if (host.OomKillDisable !== false && host.OomKillDisable !== null)
+    throw new Error("container_oom_protection_disabled");
+  if (!Array.isArray(actual.Mounts))
+    throw new Error("invalid_container_mounts");
+  const mounts = actual.Mounts.map(object).sort(
+    (left, right) => text(left.Destination, "mount_destination").localeCompare(
+      text(right.Destination, "mount_destination")
+    )
+  );
+  return createHash("sha256").update(
+    JSON.stringify(
+      canonicalValue({
+        config: actual.Config,
+        host: { ...host, OomKillDisable: false },
+        mounts
+      })
+    )
+  ).digest("hex");
+}
+function canonicalValue(value) {
+  if (Array.isArray(value)) return value.map(canonicalValue);
+  if (value === null || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, canonicalValue(entry)])
+  );
+}
+
+// src/harness/adapters/docker/observation.ts
+function inspectResource(resource, enforceConfiguration = true) {
+  const result = JSON.parse(command("docker", ["inspect", resource.id]));
+  if (!Array.isArray(result) || result.length !== 1)
+    throw new Error("invalid_container_inspection");
+  const actual = object(result[0]);
+  assertResourceOwner(resource, actual);
+  if (enforceConfiguration && configurationDigest(actual) !== resource.configurationDigest)
+    throw new Error("container_configuration_changed");
+  return actual;
+}
+function resourceAbsent(error, id2) {
+  const failure = error;
+  const message = String(failure.stderr).toLowerCase();
+  return ["object", "container"].some(
+    (kind) => message.includes(`no such ${kind}: ${id2}`)
+  );
+}
+function assertResourceFresh(resource) {
+  const state = object(inspectResource(resource).State);
+  if (state.Status !== "created" || state.Running !== false || state.Pid !== 0)
+    throw new Error("container_requires_fresh_creation");
+}
+function resourceRunning(resource) {
+  let actual;
+  try {
+    actual = inspectResource(resource);
+  } catch (error) {
+    if (resourceAbsent(error, resource.id)) return false;
+    throw error;
+  }
+  const state = object(actual.State);
+  if (typeof state.Running !== "boolean")
+    throw new Error("unknown_container_lifecycle");
+  return state.Running;
+}
+
+// src/harness/adapters/tmux/connection.ts
+var Connection = class {
+  constructor(records2) {
+    this.records = records2;
+  }
+  records;
+  tmux(args, options = {}) {
+    return command(
+      "tmux",
+      ["-S", this.records.socket, "-f", this.records.configPath, ...args],
+      options
+    );
+  }
+  alive() {
+    try {
+      this.tmux(["list-sessions"]);
+      return true;
+    } catch (error) {
+      const failure = error;
+      if (/no server running|No such file or directory|no sessions/.test(
+        String(failure.stderr ?? failure.message)
+      ))
+        return false;
+      throw error;
+    }
+  }
+  inspect(id2) {
+    const record = this.records.read(id2);
+    const target = this.tmux([
+      "display-message",
+      "-p",
+      "-t",
+      record.paneId,
+      "#{pid}|#{pane_id}|#{pane_pid}|#{pane_dead}|#{@pmcp-owner}|#{@pmcp-session}|#{pane_width}|#{pane_height}|#{session_id}|#{window_id}"
+    ]).trim().split("|");
+    const [
+      serverPid,
+      paneId,
+      panePid,
+      dead,
+      owner,
+      sessionId,
+      width,
+      height,
+      tmuxSessionId,
+      windowId
+    ] = target;
+    if (processIdentity(Number(serverPid)) !== record.serverIdentity)
+      throw new Error("stale_server");
+    if (paneId !== record.paneId || Number(panePid) !== record.panePid || tmuxSessionId !== record.tmuxSessionId || windowId !== record.windowId)
+      throw new Error("stale_pane");
+    if (owner !== this.records.owner || sessionId !== id2)
+      throw new Error("foreign_pane");
+    return {
+      ...record,
+      alive: dead === "0" && (!record.resource || resourceRunning(record.resource)),
+      width: Number(width),
+      height: Number(height)
+    };
+  }
+};
+
+// src/harness/adapters/tmux/records.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  realpathSync as realpathSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+function stateDirectory() {
+  return join2(
+    process.env.XDG_STATE_HOME ?? join2(homedir(), ".local/state"),
+    "pmcp/harness"
+  );
+}
+function runtimeUnit(id2) {
+  if (!/^[a-f0-9]{8}(-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(id2))
+    throw new Error("invalid_session_id");
+  return `pmcp-${id2}.scope`;
+}
+function budgetSlice(owner) {
+  runtimeUnit(owner);
+  return `pmcp${owner.replaceAll("-", "")}.slice`;
+}
+var RecordStore = class _RecordStore {
+  directory;
+  socket;
+  metadataPath;
+  configPath;
+  owner;
+  constructor(directory) {
+    const stat = lstatSync(directory);
+    if (!stat.isDirectory() || stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0)
+      throw new Error("unsafe_group_directory");
+    this.directory = realpathSync2(directory);
+    this.socket = join2(this.directory, "s");
+    if (Buffer.byteLength(this.socket) > 100)
+      throw new Error("socket_path_too_long");
+    this.metadataPath = join2(this.directory, "harness.json");
+    this.configPath = join2(this.directory, "tmux.conf");
+    this.owner = text(
+      object(readPrivateJson(this.metadataPath)).owner,
+      "owner"
+    );
+    runtimeUnit(this.owner);
+  }
+  static create() {
+    const root = stateDirectory();
+    mkdirSync(root, { recursive: true, mode: 448 });
+    const directory = join2(root, randomUUID2().slice(0, 16));
+    if (Buffer.byteLength(join2(directory, "s")) > 100)
+      throw new Error("socket_path_too_long");
+    mkdirSync(directory, { mode: 448 });
+    mkdirSync(join2(directory, "sessions"), { mode: 448 });
+    privateJson(join2(directory, "harness.json"), {
+      owner: randomUUID2(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    writeFileSync2(
+      join2(directory, "tmux.conf"),
+      [
+        "set -g remain-on-exit on",
+        "set -g history-limit 2000",
+        "set -g default-terminal tmux-256color",
+        "set -g status off",
+        "set -g mouse off",
+        "set -g destroy-unattached off",
+        ""
+      ].join("\n"),
+      { flag: "wx", mode: 384 }
+    );
+    return new _RecordStore(directory);
+  }
+  path(id2) {
+    runtimeUnit(id2);
+    return join2(this.directory, "sessions", `${id2}.json`);
+  }
+  read(id2) {
+    const record = object(readPrivateJson(this.path(id2)));
+    if (record.id !== id2 || record.owner !== this.owner || record.socket !== this.socket || record.unit !== runtimeUnit(id2))
+      throw new Error("foreign_backend_record");
+    for (const [field, pattern] of [
+      ["paneId", /^%\d+$/],
+      ["windowId", /^@\d+$/],
+      ["tmuxSessionId", /^\$\d+$/],
+      ["serverIdentity", /^\d+:\d+$/]
+    ]) {
+      if (!pattern.test(text(record[field], field)))
+        throw new Error("invalid_terminal_identity");
+    }
+    if (!Number.isSafeInteger(record.panePid) || Number(record.panePid) < 1)
+      throw new Error("invalid_pane_process");
+    if (record.resource !== void 0)
+      resourceClaim(record.resource, this.owner);
+    return record;
+  }
+  all() {
+    return readdirSync(join2(this.directory, "sessions")).filter((name) => name.endsWith(".json")).map((name) => this.read(name.slice(0, -5)));
+  }
+  save(record) {
+    privateJson(this.path(record.id), record);
+  }
+};
+
+// src/harness/adapters/tmux/lifecycle.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync4 } from "fs";
+import { setTimeout } from "timers/promises";
+
+// src/harness/adapters/process/artifact.ts
+import { fileURLToPath } from "url";
+var sources = {
+  worker: "../../application/worker.ts",
+  "pane-runner": "./pane-runner.ts",
+  "launch-gate": "./launch-gate.ts",
+  "egress-bridge": "../egress/bridge-runtime.ts"
+};
+function artifact(name) {
+  if (import.meta.url.endsWith(".ts"))
+    return fileURLToPath(new URL(sources[name], import.meta.url));
+  return fileURLToPath(new URL(`./harness-${name}.js`, import.meta.url));
+}
+
+// src/harness/adapters/tmux/lifecycle.ts
+import { join as join10 } from "path";
+
+// src/harness/adapters/systemd/units.ts
+function unitActive(unit) {
+  let state;
+  try {
+    state = command("systemctl", [
+      "--user",
+      "show",
+      unit,
+      "--property=ActiveState",
+      "--value"
+    ]).trim();
+  } catch (error) {
+    const failure = error;
+    if (/not found|could not be found|No such/i.test(String(failure.stderr)))
+      return false;
+    throw error;
+  }
+  return ["active", "activating", "deactivating"].includes(state);
+}
+function stopUnit(unit) {
+  if (!unitActive(unit)) return;
+  try {
+    command("systemctl", ["--user", "stop", unit]);
+  } catch (error) {
+    const stderr = String(error.stderr);
+    if (!stderr.includes(unit) || !/not loaded|not found|could not be found/i.test(stderr))
+      throw error;
+    if (unitActive(unit)) throw error;
+  }
+  if (unitActive(unit)) throw new Error("runtime_stop_unconfirmed");
+}
+
+// src/harness/adapters/tmux/launch-identity.ts
+function assertProof(connection, proof) {
+  const record = proof.session;
+  const fields = connection.tmux([
+    "display-message",
+    "-p",
+    "-t",
+    record.paneId,
+    "#{pid}|#{session_id}|#{window_id}|#{pane_id}|#{pane_pid}|#{@pmcp-owner}|#{@pmcp-session}|#{@pmcp-launch}"
+  ]).trim().split("|");
+  if (processIdentity(Number(fields[0])) !== record.serverIdentity)
+    throw new Error("stale_launch_server");
+  if (fields[1] !== record.tmuxSessionId || fields[2] !== record.windowId || fields[3] !== record.paneId || Number(fields[4]) !== record.panePid)
+    throw new Error("stale_launch_pane");
+  if (fields[5] !== record.owner || fields[6] !== record.id || fields[7] !== proof.nonce)
+    throw new Error("foreign_launch_pane");
+}
+function panePresent(connection, proof) {
+  if (!connection.alive()) return false;
+  const rows = connection.tmux(["list-panes", "-a", "-F", "#{pid}|#{pane_id}"]).trim().split("\n");
+  const server = Number(rows[0]?.split("|")[0]);
+  if (processIdentity(server) !== proof.session.serverIdentity)
+    throw new Error("stale_launch_server");
+  return rows.some((row) => row.split("|")[1] === proof.session.paneId);
+}
+
+// src/harness/launch/journal.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync, readdirSync as readdirSync2 } from "fs";
+import { join as join3 } from "path";
+var LaunchJournal = class {
+  constructor(records2, id2) {
+    this.records = records2;
+    this.id = id2;
+    runtimeUnit(id2);
+  }
+  records;
+  id;
+  path(kind) {
+    if (!["intent", "proof", "grant", "committed", "aborted"].includes(kind))
+      throw new Error("invalid_launch_artifact");
+    return join3(this.records.directory, `${this.id}.${kind}.json`);
+  }
+  intent() {
+    const value = object(readPrivateJson(this.path("intent")));
+    if (value.id !== this.id || value.owner !== this.records.owner || value.socket !== this.records.socket || value.unit !== runtimeUnit(this.id) || value.slice !== budgetSlice(this.records.owner))
+      throw new Error("foreign_launch_intent");
+    if (!/^\d+:\d+$/.test(text(value.controllerIdentity, "controller")))
+      throw new Error("invalid_launch_controller");
+    for (const field of ["groupId", "generation", "nonce"])
+      runtimeUnit(text(value[field], field));
+    if (value.role !== "main" && value.role !== "worker")
+      throw new Error("invalid_launch_role");
+    strings(value.argv, "argv");
+    text(value.cwd, "cwd");
+    text(value.runtime, "runtime");
+    text(value.createdAt, "created_at");
+    integer(value.memoryMb, "session_memory", 32, 1536);
+    if (value.resource !== void 0)
+      resourceClaim(value.resource, this.records.owner);
+    if (value.dockerCreation !== void 0) {
+      const creation = object(value.dockerCreation);
+      const config = object(creation.configuration);
+      const labels = object(config.Labels);
+      if (creation.egress !== void 0) egressPolicy(creation.egress);
+      const bridge = creation.egress === void 0 ? void 0 : egressPolicy(creation.egress).bridgeExecutable;
+      if (bridge && !/^[a-f0-9]{64}$/.test(String(creation.bridgeSha256)))
+        throw new Error("invalid_docker_bridge_digest");
+      if (!bridge && creation.bridgeSha256 !== void 0)
+        throw new Error("ungranted_docker_bridge_digest");
+      const policy = new GroupStore(join3(this.records.directory, "group.json")).state.group.dockerPolicy;
+      const profile = selectedProfile(
+        policy,
+        creation.privateProfile,
+        text(value.runtime, "runtime")
+      );
+      const expectedState = profile?.directory ?? join3(
+        this.records.directory,
+        "containers",
+        text(value.nonce, "nonce"),
+        "profile"
+      );
+      if (value.resource !== void 0 && object(value.resource).privateProfile !== creation.privateProfile)
+        throw new Error("launch_private_profile_mismatch");
+      if (creation.name !== containerName(this.records.owner, this.id) || creation.nonce !== value.nonce || creation.state !== expectedState || labels[containerLabels.owner] !== this.records.owner || labels[containerLabels.role] !== value.role || labels[containerLabels.nonce] !== value.nonce)
+        throw new Error("foreign_container_creation");
+    }
+    return value;
+  }
+  proof() {
+    const intent = this.intent();
+    const value = object(readPrivateJson(this.path("proof")));
+    const session = object(value.session);
+    if (value.nonce !== intent.nonce || session.id !== intent.id || session.owner !== intent.owner || session.socket !== intent.socket || session.unit !== intent.unit || session.cwd !== intent.cwd || session.memoryMb !== intent.memoryMb || session.runtime !== intent.runtime || session.createdAt !== intent.createdAt || JSON.stringify(session.resource) !== JSON.stringify(intent.resource))
+      throw new Error("foreign_launch_proof");
+    for (const [field, pattern] of [
+      ["paneId", /^%\d+$/],
+      ["windowId", /^@\d+$/],
+      ["tmuxSessionId", /^\$\d+$/],
+      ["serverIdentity", /^\d+:\d+$/]
+    ]) {
+      if (!pattern.test(text(session[field], field)))
+        throw new Error("invalid_launch_identity");
+    }
+    integer(session.panePid, "pane_process", 1, Number.MAX_SAFE_INTEGER);
+    if (!/^\d+:\d+$/.test(text(value.runnerIdentity, "runner")))
+      throw new Error("invalid_launch_runner");
+    return value;
+  }
+  grant() {
+    const intent = this.intent();
+    return {
+      id: intent.id,
+      owner: intent.owner,
+      groupId: intent.groupId,
+      generation: intent.generation,
+      nonce: intent.nonce,
+      proofDigest: createHash2("sha256").update(JSON.stringify(this.proof())).digest("hex")
+    };
+  }
+  assertRegistered() {
+    const intent = this.intent();
+    const group = new GroupStore(join3(this.records.directory, "group.json")).state.group;
+    if (group.id !== intent.groupId || group.generation !== intent.generation)
+      throw new Error("launch_group_generation_mismatch");
+    if (intent.dockerCreation && JSON.stringify(intent.dockerCreation.egress) !== JSON.stringify(group.dockerPolicy?.egress))
+      throw new Error("launch_egress_grant_mismatch");
+    if (group.state !== "ready" || !group.allowedRuntimes.includes(intent.runtime))
+      throw new Error("launch_group_not_ready");
+    if (!group.sessions.some(
+      (session) => session.id === intent.id && session.role === intent.role && !session.stopped
+    ))
+      throw new Error("launch_registration_missing");
+    const record = this.records.read(this.id);
+    if (JSON.stringify(record) !== JSON.stringify(this.proof().session))
+      throw new Error("launch_record_mismatch");
+  }
+  authorize() {
+    if (existsSync(this.path("aborted"))) throw new Error("launch_was_aborted");
+    this.assertRegistered();
+    privateJson(this.path("grant"), this.grant());
+  }
+  assertGrant() {
+    if (existsSync(this.path("aborted"))) throw new Error("launch_was_aborted");
+    const grant = object(readPrivateJson(this.path("grant")));
+    if (JSON.stringify(grant) !== JSON.stringify(this.grant()))
+      throw new Error("launch_grant_mismatch");
+  }
+  commit() {
+    this.assertRegistered();
+    this.assertGrant();
+    privateJson(this.path("committed"), this.grant());
+  }
+  assertCommitted() {
+    this.assertGrant();
+    const committed = object(readPrivateJson(this.path("committed")));
+    if (JSON.stringify(committed) !== JSON.stringify(this.grant()))
+      throw new Error("launch_commit_mismatch");
+  }
+  abortRecord() {
+    if (!existsSync(this.path("aborted"))) return;
+    const value = object(readPrivateJson(this.path("aborted")));
+    if (value.id !== this.id || value.owner !== this.records.owner || !["stopping", "stopped"].includes(String(value.state)))
+      throw new Error("foreign_launch_abort");
+    return value;
+  }
+};
+function launchJournals(records2) {
+  return readdirSync2(records2.directory).filter((name) => name.endsWith(".intent.json")).map((name) => new LaunchJournal(records2, name.slice(0, -12)));
+}
+function pendingLaunches(records2) {
+  return launchJournals(records2).filter((journal) => {
+    const aborted = journal.abortRecord();
+    if (aborted) return aborted.state !== "stopped";
+    if (!existsSync(journal.path("committed"))) return true;
+    journal.assertCommitted();
+    return false;
+  });
+}
+
+// src/harness/launch/recovery.ts
+import { existsSync as existsSync3 } from "fs";
+
+// src/harness/adapters/docker/lifecycle.ts
+function stopResource(resource) {
+  let actual;
+  try {
+    actual = inspectResource(resource, false);
+  } catch (error) {
+    if (resourceAbsent(error, resource.id)) return;
+    throw error;
+  }
+  const state = object(actual.State);
+  if (state.Running === true)
+    command("docker", ["stop", "--timeout", "2", resource.id]);
+  if (object(inspectResource(resource, false).State).Running !== false)
+    throw new Error("container_stop_unconfirmed");
+  if (resource.managed) {
+    command("docker", ["rm", resource.id]);
+    try {
+      inspectResource(resource, false);
+    } catch (error) {
+      if (resourceAbsent(error, resource.id)) return;
+      throw error;
+    }
+    throw new Error("container_removal_unconfirmed");
+  }
+}
+
+// src/harness/adapters/docker/creation.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { join as join9 } from "path";
+
+// src/harness/adapters/docker/admission.ts
+import { lstatSync as lstatSync5, realpathSync as realpathSync6 } from "fs";
+import { join as join6, relative as relative3 } from "path";
+
+// src/harness/adapters/docker/profile.ts
+import { homedir as homedir3 } from "os";
+import { lstatSync as lstatSync3, realpathSync as realpathSync4 } from "fs";
+import { relative as relative2 } from "path";
+
+// src/harness/adapters/docker/private-profile.ts
+import { homedir as homedir2 } from "os";
+import {
+  closeSync as closeSync2,
+  constants as constants2,
+  existsSync as existsSync2,
+  fstatSync as fstatSync2,
+  lstatSync as lstatSync2,
+  openSync as openSync2,
+  realpathSync as realpathSync3,
+  statfsSync
+} from "fs";
+import { join as join4, relative } from "path";
+var privateProfileLock = "profile.lock";
+function overlap(left, right) {
+  const scope = relative(left, right);
+  return scope === "" || scope !== ".." && !scope.startsWith("../");
+}
+function profileIdentity(directory, projectRoot) {
+  if (directory === "/" || directory === realpathSync3(homedir2()) || overlap(directory, projectRoot) || overlap(projectRoot, directory) || realpathSync3(directory) !== directory)
+    throw new Error("private_profile_scope_not_admitted");
+  const stat = lstatSync2(directory);
+  if (!stat.isDirectory() || stat.uid !== process.getuid?.() || (stat.mode & 511) !== 448)
+    throw new Error("unsafe_private_profile_directory");
+  if ([26985, 4283649346, 4266872130].includes(statfsSync(directory).type))
+    throw new Error("remote_private_profile_not_admitted");
+  const lock = openSync2(
+    join4(directory, privateProfileLock),
+    constants2.O_RDONLY | constants2.O_NOFOLLOW
+  );
+  try {
+    const value = fstatSync2(lock);
+    if (!value.isFile() || value.nlink !== 1 || value.uid !== process.getuid?.() || (value.mode & 511) !== 384)
+      throw new Error("unsafe_private_profile_lock");
+    return `${stat.dev}:${stat.ino}:${value.dev}:${value.ino}`;
+  } finally {
+    closeSync2(lock);
+  }
+}
+function assertProfileIdentity(grant, projectRoot) {
+  if (!grant.identity || profileIdentity(grant.directory, projectRoot) !== grant.identity)
+    throw new Error("private_profile_identity_changed");
+}
+function assertProfileAvailable(grant, projectRoot) {
+  assertProfileIdentity(grant, projectRoot);
+  try {
+    command("flock", [
+      "--exclusive",
+      "--nonblock",
+      "--conflict-exit-code",
+      "73",
+      join4(grant.directory, privateProfileLock),
+      "true"
+    ]);
+  } catch (error) {
+    if (error.status === 73)
+      throw new Error("private_profile_busy");
+    throw error;
+  }
+}
+
+// src/harness/adapters/docker/profile.ts
+function assertLocalDocker() {
+  if (process.env.DOCKER_HOST)
+    throw new Error("explicit_docker_host_not_admitted");
+  const endpoint = JSON.parse(
+    command("docker", [
+      "context",
+      "inspect",
+      "--format",
+      "{{json .Endpoints.docker.Host}}"
+    ])
+  );
+  if (new URL(endpoint).protocol !== "unix:")
+    throw new Error("remote_docker_context_not_admitted");
+}
+
+// src/harness/adapters/docker/mounts.ts
+import { lstatSync as lstatSync4, realpathSync as realpathSync5 } from "fs";
+import { join as join5 } from "path";
+function assertContainerMounts(actual, statePath, projectRoot, directory, nonce, policy, privateProfile, runtime) {
+  const state = text(statePath, "container_state_directory");
+  const profile = selectedProfile(policy, privateProfile, runtime ?? "");
+  if (profile) assertProfileIdentity(profile, projectRoot);
+  const expected = profile?.directory ?? join5(directory, "containers", nonce, "profile");
+  if (state !== expected || realpathSync5(state) !== expected)
+    throw new Error("foreign_container_state_directory");
+  const stat = lstatSync4(state);
+  if (!stat.isDirectory() || stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0)
+    throw new Error("unsafe_container_state_directory");
+  if (!Array.isArray(actual.Mounts) || actual.Mounts.length !== 2)
+    throw new Error("ungranted_container_mount");
+  if (new Set(actual.Mounts.map((value) => object(value).Destination)).size !== 2)
+    throw new Error("ungranted_container_mount");
+  const expectedMounts = [
+    {
+      Source: projectRoot,
+      Destination: "/workspace",
+      RW: policy.workspaceAccess === "read-write"
+    },
+    { Source: state, Destination: "/state", RW: true }
+  ];
+  for (const value of actual.Mounts) {
+    const mount = object(value);
+    if (mount.Type !== "bind" || mount.Propagation !== "rprivate" || !expectedMounts.some(
+      (expected2) => mount.Source === expected2.Source && mount.Destination === expected2.Destination && mount.RW === expected2.RW
+    ))
+      throw new Error("ungranted_container_mount");
+  }
+  const host = object(actual.HostConfig);
+  if (!Array.isArray(host.Mounts) || host.Mounts.length !== 2 || host.Mounts.some(
+    (value) => object(object(value).BindOptions).NonRecursive !== true
+  ))
+    throw new Error("recursive_container_mount_not_admitted");
+}
+
+// src/harness/adapters/docker/security.ts
+function assertContainerIsolation(host, network) {
+  if (host.ReadonlyRootfs !== true || host.Privileged !== false || host.NetworkMode !== network || host.CgroupnsMode !== "private")
+    throw new Error("invalid_container_isolation_policy");
+  if (JSON.stringify(host.CapDrop) !== '["ALL"]' || JSON.stringify(host.SecurityOpt) !== '["no-new-privileges"]' || object(host.RestartPolicy).Name !== "no")
+    throw new Error("invalid_container_execution_policy");
+  if (host.CapAdd !== null || host.PidMode !== "" || host.UTSMode !== "" || host.UsernsMode !== "" || host.CgroupParent !== "" || host.IpcMode !== "private" || hasDevices(host.Devices) || hasDevices(host.DeviceRequests) || host.AutoRemove !== false || host.VolumesFrom !== null || host.GroupAdd !== null || host.Binds !== null || Object.keys(object(host.PortBindings)).length)
+    throw new Error("ungranted_container_host_authority");
+}
+function hasDevices(value) {
+  if (value === null) return false;
+  return !Array.isArray(value) || value.length !== 0;
+}
+
+// src/harness/adapters/docker/entrypoint.ts
+function bridgeName(nonce) {
+  return `.pmcp-egress-${nonce.slice(0, 8)}.mjs`;
+}
+function containerEntrypoint(policy, runtime, nonce, privateProfile) {
+  const native = policy.commands[runtime];
+  if (!native) throw new Error("docker_runtime_command_not_granted");
+  const command2 = policy.egress?.bridgeExecutable ? [
+    policy.egress.bridgeExecutable,
+    `/state/${bridgeName(nonce)}`,
+    "--",
+    ...native
+  ] : native;
+  const profile = selectedProfile(policy, privateProfile, runtime);
+  if (!profile) return command2;
+  return [
+    profile.lockExecutable,
+    "--exclusive",
+    "--nonblock",
+    "--close",
+    "--conflict-exit-code",
+    "73",
+    `/state/${privateProfileLock}`,
+    ...command2
+  ];
+}
+
+// src/harness/adapters/docker/admission.ts
+function admitResource(path, group, role, directory, memoryMb, runtime) {
+  if (group.profile !== "docker" || !group.dockerPolicy)
+    throw new Error("container_requires_docker_profile");
+  const { projectRoot } = group;
+  assertLocalDocker();
+  const inputPath = text(path, "container_file");
+  if (lstatSync5(inputPath).isSymbolicLink())
+    throw new Error("symlink_container_file_not_admitted");
+  const source2 = realpathSync6(inputPath);
+  const scope = relative3(projectRoot, source2);
+  if (scope === ".." || scope.startsWith("../"))
+    throw new Error("container_file_outside_project");
+  const claim = object(readPrivateJson(source2));
+  if (claim.privateProfile !== void 0)
+    throw new Error("private_profile_requires_cli_owned_creation");
+  return admitClaim(claim, group, role, directory, memoryMb, runtime);
+}
+function admitClaim(value, group, role, directory, memoryMb, runtime, cwd = group.projectRoot) {
+  if (group.profile !== "docker" || !group.dockerPolicy)
+    throw new Error("container_requires_docker_profile");
+  assertLocalDocker();
+  const policy = group.dockerPolicy;
+  const { owner, projectRoot } = group;
+  const claim = object(value);
+  if (claim.owner !== owner || claim.role !== role || claim.runtime !== runtime)
+    throw new Error("foreign_container_resource");
+  const resource = {
+    kind: "docker",
+    id: text(claim.id, "container_id"),
+    owner,
+    nonce: text(claim.nonce, "container_nonce"),
+    role,
+    image: text(claim.image, "container_image"),
+    configurationDigest: "",
+    memoryMb: 0,
+    cpuQuota: 0,
+    ...claim.privateProfile === void 0 ? {} : { privateProfile: profileName(claim.privateProfile) }
+  };
+  if (!/^[a-f0-9]{64}$/.test(resource.id) || !/^sha256:[a-f0-9]{64}$/.test(resource.image) || !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(
+    resource.nonce
+  ))
+    throw new Error("invalid_container_resource");
+  const actual = inspectResource(resource, false);
+  const state = object(actual.State);
+  const config = object(actual.Config);
+  const host = object(actual.HostConfig);
+  if (resource.image !== policy.image || JSON.stringify(config.Entrypoint) !== JSON.stringify(
+    containerEntrypoint(
+      policy,
+      runtime,
+      resource.nonce,
+      resource.privateProfile
+    )
+  ))
+    throw new Error("container_runtime_image_not_granted");
+  if (config.WorkingDir !== join6("/workspace", relative3(projectRoot, cwd)))
+    throw new Error("container_cwd_not_granted");
+  assertContainerMounts(
+    actual,
+    claim.state,
+    projectRoot,
+    directory,
+    resource.nonce,
+    policy,
+    resource.privateProfile,
+    runtime
+  );
+  if (state.Status !== "created" || state.Pid !== 0 || state.Running !== false)
+    throw new Error("container_requires_fresh_creation");
+  if (config.User !== `${process.getuid?.()}:${process.getgid?.()}` || config.Tty !== true || config.OpenStdin !== true || config.StdinOnce !== false || !Array.isArray(config.Env) || JSON.stringify(
+    config.Env.filter(
+      (value2) => typeof value2 === "string" && value2.startsWith("HOME=")
+    )
+  ) !== '["HOME=/state"]')
+    throw new Error("invalid_container_terminal_policy");
+  assertContainerIsolation(host, policy.network);
+  resource.memoryMb = integer(
+    Number(host.Memory) / 1048576,
+    "container_memory",
+    32,
+    1472
+  );
+  if (host.MemorySwap !== host.Memory || memoryMb - resource.memoryMb < 64)
+    throw new Error("container_proxy_memory_unreserved");
+  integer(host.PidsLimit, "container_tasks", 1, 128);
+  if (host.CpuPeriod !== 1e5)
+    throw new Error("invalid_container_cpu_period");
+  resource.cpuQuota = integer(host.CpuQuota, "container_cpu", 1, 5e4);
+  resource.configurationDigest = configurationDigest(actual);
+  return resource;
+}
+
+// src/harness/adapters/docker/engine.ts
+import { request } from "http";
+var DockerEngine = class {
+  async create(name, configuration) {
+    assertLocalDocker();
+    const endpoint = JSON.parse(
+      command("docker", [
+        "context",
+        "inspect",
+        "--format",
+        "{{json .Endpoints.docker.Host}}"
+      ])
+    );
+    const version = command("docker", [
+      "version",
+      "--format",
+      "{{.Server.APIVersion}}"
+    ]).trim();
+    if (!/^1\.\d+$/.test(version))
+      throw new Error("invalid_docker_api_version");
+    const payload = JSON.stringify(configuration);
+    return new Promise((resolve2, reject) => {
+      const req = request(
+        {
+          socketPath: new URL(endpoint).pathname,
+          path: `/v${version}/containers/create?name=${encodeURIComponent(name)}`,
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Content-Length": Buffer.byteLength(payload)
+          }
+        },
+        (response) => {
+          const chunks = [];
+          let bytes = 0;
+          response.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > 65536) {
+              req.destroy(new Error("docker_response_too_large"));
+              return;
+            }
+            chunks.push(chunk);
+          });
+          response.once("error", reject);
+          response.once("end", () => {
+            if (response.statusCode !== 201) {
+              reject(new Error(`docker_create_status_${response.statusCode}`));
+              return;
+            }
+            try {
+              const id2 = text(
+                object(JSON.parse(Buffer.concat(chunks).toString("utf8"))).Id,
+                "container_id"
+              );
+              if (!/^[a-f0-9]{64}$/.test(id2))
+                throw new Error("invalid_container_id");
+              resolve2(id2);
+            } catch (error) {
+              reject(error);
+            }
+          });
+        }
+      );
+      req.setTimeout(
+        1e4,
+        () => req.destroy(new Error("docker_create_timeout"))
+      );
+      req.once("error", reject);
+      req.end(payload);
+    });
+  }
+};
+
+// src/harness/adapters/docker/creation-plan.ts
+import { join as join8, relative as relative4 } from "path";
+
+// src/harness/adapters/docker/bridge-artifact.ts
+import { createHash as createHash3 } from "crypto";
+import {
+  closeSync as closeSync3,
+  constants as constants3,
+  fstatSync as fstatSync3,
+  fsyncSync as fsyncSync2,
+  openSync as openSync3,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { join as join7 } from "path";
+function source() {
+  const path = artifact("egress-bridge");
+  if (!path.endsWith(".js"))
+    throw new Error("docker_bridge_requires_compiled_cli");
+  return readFileSync3(path);
+}
+function digest(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+function bridgeDigest() {
+  return digest(source());
+}
+function prepareBridge(creation) {
+  if (!creation.egress?.bridgeExecutable) return;
+  const content = source();
+  if (digest(content) !== creation.bridgeSha256)
+    throw new Error("docker_bridge_source_changed");
+  const descriptor = openSync3(
+    join7(creation.state, bridgeName(creation.nonce)),
+    "wx",
+    384
+  );
+  try {
+    writeFileSync3(descriptor, content);
+    fsyncSync2(descriptor);
+  } finally {
+    closeSync3(descriptor);
+  }
+}
+function assertBridge(creation) {
+  if (!creation.egress?.bridgeExecutable) return;
+  const descriptor = openSync3(
+    join7(creation.state, bridgeName(creation.nonce)),
+    constants3.O_RDONLY | constants3.O_NOFOLLOW
+  );
+  try {
+    const stat = fstatSync3(descriptor);
+    if (!stat.isFile() || stat.uid !== process.getuid?.() || stat.nlink !== 1 || (stat.mode & 63) !== 0 || stat.size > 2097152 || digest(readFileSync3(descriptor)) !== creation.bridgeSha256)
+      throw new Error("docker_bridge_artifact_changed");
+  } finally {
+    closeSync3(descriptor);
+  }
+}
+
+// src/harness/adapters/docker/creation-plan.ts
+function creationPlan(group, directory, id2, nonce, role, runtime, cwd, preparation) {
+  if (group.profile !== "docker" || !group.dockerPolicy)
+    throw new Error("container_requires_docker_profile");
+  assertLocalDocker();
+  const policy = group.dockerPolicy;
+  const images = JSON.parse(
+    command("docker", ["image", "inspect", policy.image])
+  );
+  if (!Array.isArray(images) || images.length !== 1 || object(images[0]).Id !== policy.image)
+    throw new Error("docker_image_not_available");
+  const imageConfig = object(object(images[0]).Config);
+  const environment = imageConfig.Env;
+  if (!Array.isArray(environment) || environment.some((entry) => typeof entry !== "string"))
+    throw new Error("invalid_container_image_environment");
+  const profile = selectedProfile(policy, preparation.privateProfile, runtime);
+  if (profile) assertProfileAvailable(profile, group.projectRoot);
+  const state = profile?.directory ?? join8(directory, "containers", nonce, "profile");
+  return {
+    name: containerName(group.owner, id2),
+    nonce,
+    state,
+    ...preparation.privateProfile ? { privateProfile: preparation.privateProfile } : {},
+    ...policy.egress ? { egress: policy.egress } : {},
+    ...policy.egress?.bridgeExecutable ? { bridgeSha256: bridgeDigest() } : {},
+    configuration: {
+      Image: policy.image,
+      Entrypoint: containerEntrypoint(
+        policy,
+        runtime,
+        nonce,
+        preparation.privateProfile
+      ),
+      Cmd: preparation.args.length ? preparation.args : null,
+      WorkingDir: join8("/workspace", relative4(group.projectRoot, cwd)),
+      User: `${process.getuid?.()}:${process.getgid?.()}`,
+      Env: [
+        ...environment.filter(
+          (entry) => !/^(HOME|TERM|PMCP_HTTPS_PROXY_SOCKET)=/.test(entry)
+        ),
+        "HOME=/state",
+        "TERM=xterm-256color",
+        ...policy.egress ? [`PMCP_HTTPS_PROXY_SOCKET=/state/e${nonce.slice(0, 8)}`] : []
+      ],
+      Tty: true,
+      OpenStdin: true,
+      StdinOnce: false,
+      AttachStdin: false,
+      AttachStdout: true,
+      AttachStderr: true,
+      Labels: {
+        ...imageConfig.Labels ?? {},
+        [containerLabels.owner]: group.owner,
+        [containerLabels.nonce]: nonce,
+        [containerLabels.role]: role
+      },
+      HostConfig: {
+        NetworkMode: policy.network,
+        CgroupnsMode: "private",
+        ReadonlyRootfs: true,
+        CapDrop: ["ALL"],
+        SecurityOpt: ["no-new-privileges"],
+        Memory: preparation.memoryMb * 1048576,
+        MemorySwap: preparation.memoryMb * 1048576,
+        PidsLimit: 64,
+        CpuPeriod: 1e5,
+        CpuQuota: preparation.cpuQuota,
+        RestartPolicy: { Name: "no" },
+        LogConfig: { Type: "none" },
+        Tmpfs: { "/tmp": "rw,nosuid,noexec,size=16m" },
+        Mounts: [
+          {
+            Type: "bind",
+            Source: group.projectRoot,
+            Target: "/workspace",
+            ...policy.workspaceAccess === "read-only" ? { ReadOnly: true } : {},
+            BindOptions: { NonRecursive: true }
+          },
+          {
+            Type: "bind",
+            Source: state,
+            Target: "/state",
+            BindOptions: { NonRecursive: true }
+          }
+        ]
+      }
+    }
+  };
+}
+function assertCreationConfiguration(actual, creation) {
+  if (actual.Name !== `/${creation.name}`)
+    throw new Error("foreign_container_creation");
+  const expected = creation.configuration;
+  const config = object(actual.Config);
+  const host = object(actual.HostConfig);
+  for (const [key, value] of Object.entries(expected)) {
+    if (key === "HostConfig" || key === "Image") continue;
+    if (!matchesFields(config[key], value))
+      throw new Error(`container_creation_configuration_changed_${key}`);
+  }
+  for (const [key, value] of Object.entries(object(expected.HostConfig))) {
+    if (!matchesFields(host[key], value))
+      throw new Error(`container_creation_configuration_changed_${key}`);
+  }
+}
+function matchesFields(actual, expected) {
+  if (Array.isArray(expected))
+    return Array.isArray(actual) && actual.length === expected.length && expected.every((value2, index) => matchesFields(actual[index], value2));
+  if (expected === null || typeof expected !== "object")
+    return actual === expected;
+  if (actual === null || typeof actual !== "object" || Array.isArray(actual))
+    return false;
+  const value = actual;
+  return Object.entries(expected).every(
+    ([key, field]) => matchesFields(value[key], field)
+  );
+}
+
+// src/harness/adapters/docker/creation.ts
+async function prepareCreation(journal) {
+  const intent = journal.intent();
+  const creation = intent.dockerCreation;
+  if (!creation) throw new Error("container_creation_missing");
+  const group = new GroupStore(join9(journal.records.directory, "group.json")).state.group;
+  const profile = selectedProfile(
+    group.dockerPolicy,
+    creation.privateProfile,
+    intent.runtime
+  );
+  if (profile) assertProfileAvailable(profile, group.projectRoot);
+  if (!profile) mkdirSync2(creation.state, { recursive: true, mode: 448 });
+  prepareBridge(creation);
+  assertBridge(creation);
+  const id2 = await new DockerEngine().create(
+    creation.name,
+    creation.configuration
+  );
+  const current = new GroupStore(join9(journal.records.directory, "group.json")).state.group;
+  if (current.id !== intent.groupId || current.generation !== intent.generation)
+    throw new Error("launch_group_generation_mismatch");
+  const resource = {
+    ...admitClaim(
+      {
+        id: id2,
+        owner: intent.owner,
+        role: intent.role,
+        runtime: intent.runtime,
+        image: current.dockerPolicy?.image,
+        nonce: creation.nonce,
+        state: creation.state,
+        ...creation.privateProfile ? { privateProfile: creation.privateProfile } : {}
+      },
+      current,
+      intent.role,
+      journal.records.directory,
+      intent.memoryMb,
+      intent.runtime,
+      intent.cwd
+    ),
+    managed: true
+  };
+  assertCreationConfiguration(
+    object(JSON.parse(command("docker", ["inspect", id2]))[0]),
+    creation
+  );
+  privateJson(journal.path("intent"), {
+    ...intent,
+    resource,
+    argv: [intent.argv[0], "start", "--attach", "--interactive", id2]
+  });
+  return resource;
+}
+function findCreation(journal) {
+  const intent = journal.intent();
+  const creation = intent.dockerCreation;
+  if (!creation) return intent.resource;
+  assertLocalDocker();
+  let actual;
+  try {
+    const values = JSON.parse(
+      command("docker", ["inspect", creation.name])
+    );
+    if (!Array.isArray(values) || values.length !== 1)
+      throw new Error("invalid_container_inspection");
+    actual = object(values[0]);
+  } catch (error) {
+    if (resourceAbsent(error, creation.name)) return;
+    throw error;
+  }
+  const resource = {
+    kind: "docker",
+    id: text(actual.Id, "container_id"),
+    owner: intent.owner,
+    nonce: creation.nonce,
+    role: intent.role,
+    image: text(creation.configuration.Image, "container_image"),
+    configurationDigest: configurationDigest(actual),
+    memoryMb: Number(object(actual.HostConfig).Memory) / 1048576,
+    cpuQuota: Number(object(actual.HostConfig).CpuQuota),
+    managed: true,
+    ...creation.privateProfile ? { privateProfile: creation.privateProfile } : {}
+  };
+  assertResourceOwner(resource, actual);
+  assertCreationConfiguration(actual, creation);
+  if (!intent.resource) {
+    const group = new GroupStore(join9(journal.records.directory, "group.json")).state.group;
+    return {
+      ...admitClaim(
+        { ...resource, runtime: intent.runtime, state: creation.state },
+        group,
+        intent.role,
+        journal.records.directory,
+        intent.memoryMb,
+        intent.runtime,
+        intent.cwd
+      ),
+      managed: true
+    };
+  }
+  if (intent.resource && (resource.id !== intent.resource.id || resource.configurationDigest !== intent.resource.configurationDigest))
+    throw new Error("container_creation_configuration_changed");
+  return resource;
+}
+
+// src/harness/launch/recovery.ts
+function abortLaunch(connection, journal) {
+  const intent = journal.intent();
+  if (!controllerExited(intent.controllerIdentity))
+    throw new Error("launch_controller_alive");
+  const previous = journal.abortRecord();
+  const resource = intent.dockerCreation ? findCreation(journal) : intent.resource;
+  if (previous?.state === "stopped") {
+    if (resource) stopResource(resource);
+    if (unitActive(intent.unit)) throw new Error("runtime_stop_unconfirmed");
+    return {
+      stopped: true,
+      alreadyStopped: true,
+      adopted: false,
+      inputReplayed: false
+    };
+  }
+  if (!existsSync3(journal.path("proof"))) {
+    const paneUnknown = connection.alive() && (!intent.dockerCreation || connection.tmux(["list-sessions", "-F", "#{session_name}"]).trim().split("\n").includes(`pmcp-${intent.id}`));
+    if (paneUnknown || unitActive(intent.unit))
+      throw new Error("launch_identity_unknown");
+    if (resource) stopResource(resource);
+    privateJson(journal.path("aborted"), {
+      id: intent.id,
+      owner: intent.owner,
+      state: "stopped",
+      noRuntimeBorn: true
+    });
+    return { stopped: true, adopted: false, inputReplayed: false };
+  }
+  const proof = journal.proof();
+  const present = panePresent(connection, proof);
+  if (present) assertProof(connection, proof);
+  if (resource) stopResource(resource);
+  privateJson(journal.path("aborted"), {
+    id: intent.id,
+    owner: intent.owner,
+    state: "stopping"
+  });
+  stopUnit(intent.unit);
+  if (present) {
+    assertProof(connection, proof);
+    connection.tmux(["kill-pane", "-t", proof.session.paneId]);
+  }
+  if (existsSync3(journal.records.path(intent.id)))
+    journal.records.save({
+      ...proof.session,
+      stoppedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  privateJson(journal.path("aborted"), {
+    id: intent.id,
+    owner: intent.owner,
+    state: "stopped"
+  });
+  return { stopped: true, adopted: false, inputReplayed: false };
+}
+
+// src/harness/adapters/tmux/lifecycle.ts
+async function start(connection, spec) {
+  const records2 = connection.records;
+  if (spec.budgetSlice !== budgetSlice(records2.owner))
+    throw new Error("foreign_budget_slice");
+  integer(spec.memoryMb, "session_memory", 32, 1536);
+  runtimeUnit(spec.groupId);
+  runtimeUnit(spec.generation);
+  if (spec.role !== "main" && spec.role !== "worker")
+    throw new Error("invalid_launch_role");
+  const id2 = randomUUID3();
+  const nonce = randomUUID3();
+  const journal = new LaunchJournal(records2, id2);
+  const dockerCreation = spec.dockerPreparation ? creationPlan(
+    new GroupStore(join10(records2.directory, "group.json")).state.group,
+    records2.directory,
+    id2,
+    nonce,
+    spec.role,
+    spec.runtime,
+    spec.cwd,
+    spec.dockerPreparation
+  ) : void 0;
+  privateJson(journal.path("intent"), {
+    id: id2,
+    owner: records2.owner,
+    controllerIdentity: processIdentity(process.pid),
+    groupId: spec.groupId,
+    generation: spec.generation,
+    role: spec.role,
+    nonce,
+    unit: runtimeUnit(id2),
+    slice: spec.budgetSlice,
+    socket: records2.socket,
+    runtime: spec.runtime,
+    memoryMb: spec.memoryMb,
+    argv: spec.argv,
+    cwd: spec.cwd,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...spec.resource ? { resource: spec.resource } : {},
+    ...dockerCreation ? { dockerCreation } : {}
+  });
+  if (dockerCreation) await prepareCreation(journal);
+  const intent = journal.intent();
+  const argv = [
+    "systemd-run",
+    "--user",
+    "--scope",
+    "--collect",
+    "--quiet",
+    `--unit=${intent.unit}`,
+    `--slice=${intent.slice}`,
+    `--property=MemoryMax=${spec.memoryMb - (intent.resource?.memoryMb ?? 0)}M`,
+    "--property=TasksMax=128",
+    "--property=CPUQuota=100%",
+    process.execPath,
+    artifact("launch-gate"),
+    records2.directory,
+    id2
+  ];
+  connection.tmux([
+    "new-session",
+    "-d",
+    "-x",
+    "160",
+    "-y",
+    "42",
+    "-s",
+    `pmcp-${id2}`,
+    "-c",
+    spec.cwd,
+    `exec ${argv.map(quote).join(" ")}`
+  ]);
+  const deadline = Date.now() + 5e3;
+  while (!existsSync4(journal.path("proof"))) {
+    if (Date.now() >= deadline) throw new Error("launch_proof_timeout");
+    await setTimeout(25);
+  }
+  const proof = journal.proof();
+  assertProof(connection, proof);
+  records2.save(proof.session);
+  return proof.session;
+}
+function stop(connection, id2) {
+  const journal = new LaunchJournal(connection.records, id2);
+  if (existsSync4(journal.path("intent"))) {
+    abortLaunch(connection, journal);
+    return;
+  }
+  const record = connection.inspect(id2);
+  if (record.resource) stopResource(record.resource);
+  stopUnit(record.unit);
+  connection.inspect(id2);
+  connection.tmux(["kill-pane", "-t", record.paneId]);
+  connection.records.save({ ...record, stoppedAt: (/* @__PURE__ */ new Date()).toISOString() });
+}
+function cleanup(connection) {
+  for (const journal of pendingLaunches(connection.records))
+    abortLaunch(connection, journal);
+  const records2 = connection.records.all();
+  if (connection.alive()) {
+    const panes = connection.tmux(["list-panes", "-a", "-F", "#{@pmcp-owner}|#{@pmcp-session}"]).trim().split("\n");
+    if (panes.some(
+      (pane) => !records2.some((record) => pane === `${record.owner}|${record.id}`)
+    ))
+      throw new Error("cleanup_foreign_pane");
+    for (const record of records2) {
+      if (!record.stoppedAt) connection.inspect(record.id);
+    }
+  }
+  for (const record of records2) {
+    if (record.resource) stopResource(record.resource);
+    if (record.stoppedAt || !existsSync4(
+      new LaunchJournal(connection.records, record.id).path("intent")
+    )) {
+      stopUnit(record.unit);
+      continue;
+    }
+    stop(connection, record.id);
+  }
+  if (connection.alive()) connection.tmux(["kill-server"]);
+}
+
+// src/harness/adapters/tmux/input.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { closeSync as closeSync4, openSync as openSync4, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
+import { join as join11 } from "path";
+function validateText(text3) {
+  if (typeof text3 !== "string" || Buffer.byteLength(text3) > 16384)
+    throw new Error("invalid_text");
+  if (/[\x00-\x08\x0b-\x1f\x7f]/.test(text3))
+    throw new Error("control_character_rejected");
+  if (/[\r\n\t]/.test(text3))
+    throw new Error("unqualified_terminal_control_input");
+}
+function guarded(connection, session, args) {
+  const owner = `#{==:#{@pmcp-owner},${session.owner}}`;
+  const identity = `#{==:#{@pmcp-session},${session.id}}`;
+  const process2 = `#{==:#{pane_pid},${session.panePid}}`;
+  const alive = "#{==:#{pane_dead},0}";
+  const condition = `#{&&:${owner},#{&&:${identity},#{&&:${process2},${alive}}}}`;
+  const output = connection.tmux([
+    "if-shell",
+    "-F",
+    "-t",
+    session.paneId,
+    condition,
+    args.map(quote).join(" "),
+    "display-message -p delivery_uncertain"
+  ]);
+  if (output.includes("delivery_uncertain"))
+    throw new Error("delivery_uncertain");
+}
+function write(connection, id2, text3, submit) {
+  validateText(text3);
+  const session = connection.inspect(id2);
+  if (!session.alive) throw new Error("runtime_exited");
+  const lock = join11(connection.records.directory, `${id2}.input.lock`);
+  const descriptor = openSync4(lock, "wx", 384);
+  const buffer = `pmcp-${randomUUID4()}`;
+  try {
+    writeFileSync4(
+      descriptor,
+      JSON.stringify({ id: id2, controller: processIdentity(process.pid) })
+    );
+    if (text3.length > 0) {
+      connection.tmux(["load-buffer", "-b", buffer, "-"], { input: text3 });
+      connection.inspect(id2);
+      guarded(connection, session, [
+        "paste-buffer",
+        "-d",
+        "-p",
+        "-r",
+        "-b",
+        buffer,
+        "-t",
+        session.paneId
+      ]);
+    }
+    if (submit) {
+      connection.inspect(id2);
+      guarded(connection, session, [
+        "send-keys",
+        "-t",
+        session.paneId,
+        "Enter"
+      ]);
+    }
+    return {
+      id: id2,
+      verdict: "input_written",
+      submitted: submit,
+      processingConfirmed: false
+    };
+  } finally {
+    try {
+      connection.tmux(["delete-buffer", "-b", buffer]);
+    } catch {
+    }
+    closeSync4(descriptor);
+    unlinkSync(lock);
+  }
+}
+function interrupt(connection, id2) {
+  const session = connection.inspect(id2);
+  if (!session.alive) throw new Error("runtime_exited");
+  guarded(connection, session, ["send-keys", "-t", session.paneId, "C-c"]);
+}
+
+// src/harness/adapters/tmux/read.ts
+function read(connection, id2, options = {}) {
+  const lines = integer(options.lines ?? 100, "lines", 1, 2e3);
+  const maxBytes = integer(options.maxBytes ?? 16384, "max_bytes", 1, 65536);
+  const session = connection.inspect(id2);
+  const flags = options.alternate === true ? ["-a"] : ["-S", `-${lines}`];
+  const output = connection.tmux([
+    "capture-pane",
+    "-p",
+    "-J",
+    "-t",
+    session.paneId,
+    ...flags
+  ]);
+  const bytes = Buffer.from(output);
+  const truncated = bytes.length > maxBytes;
+  const content = truncated ? bytes.subarray(bytes.length - maxBytes).toString("utf8").replace(/^\uFFFD+/, "") : output;
+  return { content, source: "terminal-screen", truncated };
+}
+
+// src/harness/adapters/tmux/backend.ts
+var Backend = class {
+  constructor(recordStore) {
+    this.recordStore = recordStore;
+    this.connection = new Connection(recordStore);
+    this.owner = recordStore.owner;
+    this.socket = recordStore.socket;
+    this.runDirectory = recordStore.directory;
+    this.metadataPath = recordStore.metadataPath;
+  }
+  recordStore;
+  connection;
+  owner;
+  socket;
+  runDirectory;
+  metadataPath;
+  records() {
+    return this.recordStore.all();
+  }
+  start(spec) {
+    return start(this.connection, spec);
+  }
+  inspect(id2) {
+    return this.connection.inspect(id2);
+  }
+  read(id2, options) {
+    return read(this.connection, id2, options);
+  }
+  validateText(text3) {
+    validateText(text3);
+  }
+  write(id2, text3, options = {}) {
+    return write(this.connection, id2, text3, options.submit === true);
+  }
+  interrupt(id2) {
+    interrupt(this.connection, id2);
+  }
+  stop(id2) {
+    stop(this.connection, id2);
+  }
+  cleanup() {
+    cleanup(this.connection);
+  }
+  tmux(args) {
+    return this.connection.tmux(args);
+  }
+};
+function openBackend(directory) {
+  return new Backend(new RecordStore(directory));
+}
+function assertOwnedRecords(backend) {
+  backend.records();
+}
+function writableClients(backend, sessionId) {
+  const clients = backend.tmux(["list-clients", "-F", "#{session_id}|#{client_readonly}"]).trim();
+  if (!clients) return 0;
+  return clients.split("\n").filter((line) => line === `${sessionId}|0`).length;
+}
+
+// src/harness/control/leases.ts
+function resolveLease(context, file, allowExpired = false) {
+  const credential = object(readPrivateJson(file));
+  const lease = context.store.state.leases.find(
+    (entry) => entry.token === credential.token
+  );
+  if (!lease || lease.generation !== context.store.state.group.generation)
+    throw new Error("stale_control");
+  if (!Number.isFinite(Date.parse(lease.expiresAt)))
+    throw new Error("invalid_control_expiry");
+  if (!allowExpired && Date.parse(lease.expiresAt) <= Date.now())
+    throw new Error("expired_control");
+  context.store.session(lease.sessionId);
+  context.backend.inspect(lease.sessionId);
+  return lease;
+}
+function acquireControl(context, sessionId, controller, mode) {
+  const { store, backend } = context;
+  if (store.state.group.state === "stopped") throw new Error("group_stopped");
+  store.session(sessionId);
+  const observation = backend.inspect(sessionId);
+  if (!observation.alive) throw new Error("runtime_exited");
+  const current = store.state.leases.find(
+    (entry) => entry.sessionId === sessionId
+  );
+  if (current && Date.parse(current.expiresAt) > Date.now())
+    throw new Error("control_busy");
+  if (writableClients(backend, observation.tmuxSessionId) > 0)
+    throw new Error("native_writer_active");
+  if (mode !== "cli" && mode !== "native")
+    throw new Error("invalid_control_mode");
+  const lease = {
+    token: randomUUID5(),
+    sessionId,
+    generation: store.state.group.generation,
+    controller: id(controller, "controller"),
+    mode,
+    expiresAt: new Date(Date.now() + 6e4).toISOString()
+  };
+  store.state.leases = store.state.leases.filter(
+    (entry) => entry.sessionId !== sessionId
+  );
+  store.state.leases.push(lease);
+  store.save();
+  const leaseFile = join12(backend.runDirectory, `lease-${randomUUID5()}.json`);
+  privateJson(leaseFile, { token: lease.token });
+  return { sessionId, controller, mode, expiresAt: lease.expiresAt, leaseFile };
+}
+function controlOperation(context, action, leaseFile) {
+  const lease = resolveLease(context, leaseFile, action === "release");
+  if (action === "renew") {
+    lease.expiresAt = new Date(Date.now() + 6e4).toISOString();
+    context.store.save();
+    return { sessionId: lease.sessionId, expiresAt: lease.expiresAt };
+  }
+  if (action !== "release") throw new Error("unsupported_control_operation");
+  const session = context.backend.inspect(lease.sessionId);
+  if (writableClients(context.backend, session.tmuxSessionId) > 0)
+    throw new Error("native_writer_active");
+  context.store.state.leases = context.store.state.leases.filter(
+    (entry) => entry.token !== lease.token
+  );
+  context.store.save();
+  return { sessionId: lease.sessionId, released: true, inputReplayed: false };
+}
+function attachment(context, sessionId, mode, leaseFile) {
+  context.store.session(sessionId);
+  const session = context.backend.inspect(sessionId);
+  if (!session.alive) throw new Error("runtime_exited");
+  if (mode === "observe")
+    return {
+      socket: context.backend.socket,
+      session: session.tmuxSessionId,
+      readOnly: true
+    };
+  if (mode !== "write") throw new Error("invalid_attach_mode");
+  const lease = resolveLease(context, text(leaseFile, "lease_file"));
+  if (lease.sessionId !== sessionId || lease.mode !== "native")
+    throw new Error("native_control_required");
+  if (writableClients(context.backend, session.tmuxSessionId) > 0)
+    throw new Error("native_writer_active");
+  return {
+    socket: context.backend.socket,
+    session: session.tmuxSessionId,
+    readOnly: false
+  };
+}
+
+// src/harness/delivery/service.ts
+import { createHash as createHash4 } from "crypto";
+function deliver(context, operation, leaseFile, requestId, text3) {
+  const { store, backend } = context;
+  const lease = resolveLease(context, leaseFile);
+  if (lease.mode !== "cli") throw new Error("native_control_held");
+  const session = backend.inspect(lease.sessionId);
+  if (writableClients(backend, session.tmuxSessionId) > 0)
+    throw new Error("native_writer_active");
+  if (operation !== "write" && operation !== "submit")
+    throw new Error("unsupported_input_operation");
+  if (operation === "submit" && text3 !== "")
+    throw new Error("submit_does_not_accept_text");
+  backend.validateText(text3);
+  if (/[\r\n\t]/.test(text3))
+    throw new Error("unqualified_terminal_control_input");
+  id(requestId, "request_id");
+  const digest2 = createHash4("sha256").update(
+    JSON.stringify({
+      operation,
+      text: text3,
+      sessionId: lease.sessionId,
+      generation: lease.generation
+    })
+  ).digest("hex");
+  const previous = store.state.deliveries.find(
+    (entry) => entry.requestId === requestId
+  );
+  if (previous) {
+    if (previous.digest !== digest2) throw new Error("request_conflict");
+    return {
+      ...previous,
+      ok: previous.state === "input_written",
+      duplicate: true,
+      resendAllowed: false,
+      processingConfirmed: false
+    };
+  }
+  if (store.state.deliveries.some(
+    (entry) => entry.sessionId === lease.sessionId && entry.state !== "input_written"
+  )) {
+    throw new Error("session_delivery_uncertain");
+  }
+  const delivery = {
+    controller: lease.controller,
+    requestId,
+    sessionId: lease.sessionId,
+    generation: lease.generation,
+    digest: digest2,
+    operation,
+    state: "intent"
+  };
+  store.state.deliveries.push(delivery);
+  store.save();
+  try {
+    const receipt = backend.write(lease.sessionId, text3, {
+      submit: operation === "submit"
+    });
+    delivery.state = "input_written";
+    store.save();
+    return {
+      ...receipt,
+      requestId,
+      generation: lease.generation,
+      resendAllowed: false
+    };
+  } catch (error) {
+    delivery.state = "delivery_uncertain";
+    store.save();
+    throw error;
+  }
+}
+function interrupt2(context, leaseFile) {
+  const lease = resolveLease(context, leaseFile);
+  if (lease.mode !== "cli") throw new Error("native_control_held");
+  const session = context.backend.inspect(lease.sessionId);
+  if (writableClients(context.backend, session.tmuxSessionId) > 0)
+    throw new Error("native_writer_active");
+  context.backend.interrupt(lease.sessionId);
+  return {
+    sessionId: lease.sessionId,
+    signal: "terminal-interrupt",
+    processingConfirmed: false
+  };
+}
+
+// src/harness/groups/service.ts
+import { randomUUID as randomUUID6 } from "crypto";
+import { realpathSync as realpathSync7, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join15 } from "path";
+
+// src/harness/adapters/systemd/budget.ts
+import { join as join13 } from "path";
+async function budgetOperation(directory, operation) {
+  const backend = openBackend(directory);
+  const path = join13(directory, "runtime-policy.json");
+  const metadata = object(readPrivateJson(backend.metadataPath));
+  const slice = budgetSlice(backend.owner);
+  if (operation.action === "configure") {
+    if (metadata.budgetSlice || backend.records().length)
+      throw new Error("budget_already_initialized");
+    const memoryMb2 = integer(operation.memoryMb, "memory_budget", 128, 4096);
+    const maxActive = integer(operation.maxActive, "max_active", 1, 5);
+    privateJson(backend.metadataPath, { ...metadata, budgetSlice: slice });
+    privateJson(path, { owner: backend.owner, slice, memoryMb: memoryMb2, maxActive });
+    command("systemctl", ["--user", "start", slice]);
+    command("systemctl", [
+      "--user",
+      "set-property",
+      "--runtime",
+      slice,
+      `MemoryMax=${memoryMb2}M`,
+      `MemoryHigh=${Math.floor(memoryMb2 * 0.8)}M`,
+      "TasksMax=256",
+      "CPUQuota=100%"
+    ]);
+    return { ok: true };
+  }
+  const policy = object(readPrivateJson(path));
+  if (policy.owner !== backend.owner || metadata.budgetSlice !== slice || policy.slice !== slice)
+    throw new Error("foreign_budget_policy");
+  if (operation.action === "cleanup") {
+    backend.cleanup();
+    command("systemctl", ["--user", "stop", slice]);
+    command("systemctl", ["--user", "revert", slice]);
+    return { ok: true, budgetStopped: true };
+  }
+  if (operation.action === "stop") {
+    backend.stop(text(operation.id, "session_id"));
+    return { ok: true, stopped: true };
+  }
+  if (operation.action !== "start") throw new Error("invalid_budget_operation");
+  const active = backend.records().filter((record) => {
+    if (record.resource && resourceRunning(record.resource) && !backend.inspect(record.id).alive)
+      throw new Error("container_running_without_proxy");
+    if (record.stoppedAt) {
+      if (unitActive(record.unit)) throw new Error("runtime_stop_unconfirmed");
+      return false;
+    }
+    const observation = backend.inspect(record.id);
+    if (!observation.alive && unitActive(record.unit))
+      throw new Error("runtime_lifecycle_uncertain");
+    return observation.alive;
+  });
+  if (active.length >= integer(policy.maxActive, "max_active", 1, 5))
+    throw new Error("runtime_capacity_exceeded");
+  const spec = object(operation.spec);
+  const memoryMb = integer(spec.memoryMb, "session_memory", 32, 1536);
+  const resource = spec.resource === void 0 ? void 0 : resourceClaim(spec.resource, backend.owner);
+  const dockerPreparation = spec.dockerPreparation;
+  const cpuQuota = resource?.cpuQuota ?? dockerPreparation?.cpuQuota;
+  if (cpuQuota !== void 0) {
+    const reservedCpu = backend.records().filter((record) => !record.stoppedAt).reduce((total, record) => total + (record.resource?.cpuQuota ?? 0), 0);
+    if (reservedCpu + cpuQuota > 5e4)
+      throw new Error("aggregate_container_cpu_budget_exceeded");
+  }
+  if (active.reduce((total, session2) => total + session2.memoryMb, 0) + memoryMb > integer(policy.memoryMb, "memory_budget", 128, 4096))
+    throw new Error("aggregate_memory_budget_exceeded");
+  if (resource || dockerPreparation)
+    command("systemctl", [
+      "--user",
+      "set-property",
+      "--runtime",
+      slice,
+      "CPUQuota=50%"
+    ]);
+  const session = await backend.start({
+    runtime: text(spec.runtime, "runtime"),
+    argv: spec.argv,
+    cwd: text(spec.cwd, "cwd"),
+    memoryMb,
+    budgetSlice: slice,
+    groupId: text(spec.groupId, "group_id"),
+    generation: text(spec.generation, "generation"),
+    role: spec.role,
+    ...resource ? { resource } : {},
+    ...dockerPreparation ? { dockerPreparation } : {}
+  });
+  return { ok: true, session };
+}
+
+// src/harness/adapters/systemd/configure.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { join as join14 } from "path";
+function configureBudget(context, input) {
+  const { store, backend } = context;
+  assertOwnedRecords(backend);
+  const group = store.state.group;
+  const memoryMb = integer(
+    input.memoryMb ?? group.memoryMb,
+    "memory_budget",
+    128,
+    4096
+  );
+  const maxActive = integer(
+    input.maxActive ?? group.maxActive,
+    "max_active",
+    1,
+    5
+  );
+  const active = backend.records().filter((record) => !record.stoppedAt && backend.inspect(record.id).alive);
+  if (active.length > maxActive)
+    throw new Error("capacity_below_active_sessions");
+  if (active.reduce((total, session) => total + session.memoryMb, 0) > memoryMb)
+    throw new Error("budget_below_reserved_memory");
+  const path = join14(backend.runDirectory, "runtime-policy.json");
+  const policy = object(readPrivateJson(path));
+  const metadata = object(readPrivateJson(backend.metadataPath));
+  const slice = budgetSlice(backend.owner);
+  if (policy.owner !== backend.owner || policy.slice !== slice || metadata.budgetSlice !== slice)
+    throw new Error("foreign_budget_policy");
+  execFileSync2(
+    "systemctl",
+    [
+      "--user",
+      "set-property",
+      "--runtime",
+      slice,
+      `MemoryMax=${memoryMb}M`,
+      `MemoryHigh=${Math.floor(memoryMb * 0.8)}M`
+    ],
+    { timeout: 5e3 }
+  );
+  privateJson(path, {
+    ...policy,
+    memoryMb,
+    maxActive,
+    memoryHighMb: Math.floor(memoryMb * 0.8)
+  });
+  return { memoryMb, maxActive };
+}
+
+// src/harness/adapters/process/executable.ts
+import { accessSync, constants as constants4, statSync } from "fs";
+import { delimiter, resolve } from "path";
+function locateExecutable(binary, cwd = process.cwd()) {
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    if (!directory) continue;
+    const path = resolve(cwd, directory, binary);
+    try {
+      if (!statSync(path).isFile()) continue;
+      accessSync(path, constants4.X_OK);
+      return path;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+// src/harness/groups/service.ts
+async function groupOperation(context, action, input = {}) {
+  const { store, backend } = context;
+  if (action === "inspect") return { group: store.state.group };
+  if (action === "configure") {
+    if (store.state.group.state === "stopped") throw new Error("group_stopped");
+    if (input.profile !== void 0 || input.dockerPolicyFile !== void 0)
+      throw new Error("profile_change_requires_new_group");
+    const allowedRuntimes = input.allowedRuntimes === void 0 ? store.state.group.allowedRuntimes : strings(input.allowedRuntimes, "allowed_runtimes");
+    if (allowedRuntimes.some(
+      (runtime) => !store.state.group.allowedRuntimes.includes(runtime)
+    ))
+      throw new Error("runtime_grant_expansion_requires_new_group");
+    Object.assign(store.state.group, configureBudget(context, input), {
+      allowedRuntimes
+    });
+    store.save();
+    return { group: store.state.group, nativePermissionsChanged: false };
+  }
+  if (action === "pause" || action === "resume") {
+    if (store.state.group.state === "stopped") throw new Error("group_stopped");
+    store.state.group.state = action === "pause" ? "paused" : "ready";
+    store.save();
+    return { group: store.state.group, runtimesInterrupted: false };
+  }
+  if (action !== "stop") throw new Error("unsupported_group_operation");
+  if (store.state.group.state !== "stopped") {
+    assertOwnedRecords(backend);
+    await budgetOperation(backend.runDirectory, { action: "cleanup" });
+    store.state.group.state = "stopped";
+    store.state.leases = [];
+    store.state.group.sessions.forEach((session) => {
+      session.stopped = true;
+    });
+    store.save();
+  }
+  return { group: store.state.group, inputReplayed: false };
+}
+
+// src/harness/observation/options.ts
+function readOptions(input) {
+  if (input === void 0) return {};
+  const allowed = ["lines", "maxBytes", "alternate"];
+  if (Object.keys(input).some((key) => !allowed.includes(key)))
+    throw new Error("invalid_read_option");
+  if (input.alternate !== void 0 && typeof input.alternate !== "boolean")
+    throw new Error("invalid_alternate");
+  return {
+    ...input.lines === void 0 ? {} : { lines: integer(input.lines, "lines", 1, 2e3) },
+    ...input.maxBytes === void 0 ? {} : { maxBytes: integer(input.maxBytes, "max_bytes", 1, 65536) },
+    ...input.alternate === void 0 ? {} : { alternate: input.alternate }
+  };
+}
+
+// src/harness/observation/service.ts
+function listSessions(context) {
+  const { store, backend } = context;
+  const sessions = store.state.group.sessions.map((reference) => {
+    if (reference.stopped) return { ...reference, observed: "stopped" };
+    try {
+      return {
+        ...backend.inspect(reference.id),
+        role: reference.role,
+        observed: "terminal-process"
+      };
+    } catch (error) {
+      return {
+        ...reference,
+        observed: "unavailable",
+        reason: error instanceof Error ? error.message : "observation_failed"
+      };
+    }
+  });
+  return {
+    generation: store.state.group.generation,
+    sessions,
+    providerStateInferred: false
+  };
+}
+function observeSession(context, action, sessionId, input) {
+  context.store.session(sessionId);
+  if (action === "inspect") {
+    return {
+      session: context.backend.inspect(sessionId),
+      providerStateInferred: false
+    };
+  }
+  if (action !== "read") throw new Error("unsupported_observation_operation");
+  return {
+    sessionId,
+    ...context.backend.read(sessionId, readOptions(input)),
+    providerStateInferred: false
+  };
+}
+function inspectDeliveries(context, requestId) {
+  const deliveries = context.store.state.deliveries.filter(
+    (entry) => !requestId || entry.requestId === requestId
+  );
+  if (requestId && deliveries.length === 0)
+    throw new Error("request_not_found");
+  return {
+    generation: context.store.state.group.generation,
+    deliveries,
+    processingConfirmed: false
+  };
+}
+
+// src/harness/recovery/service.ts
+import { randomUUID as randomUUID7 } from "crypto";
+
+// src/harness/adapters/process/recover-lock.ts
+import { existsSync as existsSync5, lstatSync as lstatSync6, unlinkSync as unlinkSync3 } from "fs";
+import { join as join16 } from "path";
+function recoverInputLock(backend, sessionId) {
+  backend.inspect(sessionId);
+  const path = join16(backend.runDirectory, `${sessionId}.input.lock`);
+  if (!existsSync5(path)) return;
+  const before = lstatSync6(path);
+  const record = object(readPrivateJson(path));
+  if (record.id !== sessionId) throw new Error("foreign_writer_lock");
+  if (!controllerExited(text(record.controller, "controller_identity")))
+    throw new Error("writer_still_alive");
+  if (lstatSync6(path).ino !== before.ino)
+    throw new Error("writer_lock_changed");
+  unlinkSync3(path);
+}
+
+// src/harness/sessions/service.ts
+import { realpathSync as realpathSync8 } from "fs";
+import { relative as relative5 } from "path";
+
+// src/harness/launch/service.ts
+import { existsSync as existsSync6 } from "fs";
+function assertLaunchAdmission(records2) {
+  for (const journal of launchJournals(records2)) {
+    if (journal.abortRecord()?.state === "stopped" && unitActive(journal.intent().unit))
+      throw new Error("runtime_stop_unconfirmed");
+  }
+  if (pendingLaunches(records2).length)
+    throw new Error("launch_requires_reconciliation");
+}
+function authorizeSession(context, sessionId) {
+  const journal = new LaunchJournal(context.backend.recordStore, sessionId);
+  if (journal.intent().controllerIdentity !== processIdentity(process.pid))
+    throw new Error("foreign_launch_controller");
+  assertProof(new Connection(context.backend.recordStore), journal.proof());
+  const resource = journal.intent().resource;
+  if (resource) assertResourceFresh(resource);
+  journal.authorize();
+  journal.commit();
+}
+function inspectPendingStarts(context) {
+  return pendingLaunches(context.backend.recordStore).map((journal) => ({
+    sessionId: journal.id,
+    role: journal.intent().role,
+    runtime: journal.intent().runtime,
+    controllerExited: controllerExited(journal.intent().controllerIdentity),
+    proofPresent: existsSync6(journal.path("proof")),
+    recordPresent: existsSync6(journal.records.path(journal.id)),
+    registered: context.store.state.group.sessions.some(
+      (session) => session.id === journal.id
+    ),
+    authorizationPresent: existsSync6(journal.path("grant")),
+    processingConfirmed: false,
+    inputReplayed: false
+  }));
+}
+
+// src/harness/sessions/service.ts
+async function startSession(context, input) {
+  const { store, backend } = context;
+  const group = store.state.group;
+  assertOwnedRecords(backend);
+  assertLaunchAdmission(backend.recordStore);
+  if (backend.records().some(
+    (record) => !record.stoppedAt && !group.sessions.some((session2) => session2.id === record.id)
+  )) {
+    throw new Error("unregistered_session_requires_recovery");
+  }
+  if (group.state !== "ready") throw new Error("group_not_ready");
+  const runtime = text(input.runtime, "runtime");
+  if (!group.allowedRuntimes.includes(runtime))
+    throw new Error("runtime_not_granted");
+  const role = input.role;
+  if (role !== "main" && role !== "worker") throw new Error("invalid_role");
+  if (role === "main" && group.sessions.some(
+    (session2) => session2.role === "main" && !session2.stopped
+  )) {
+    throw new Error("main_already_assigned");
+  }
+  if (role === "worker" && !group.sessions.some(
+    (session2) => session2.role === "main" && !session2.stopped
+  )) {
+    throw new Error("main_required");
+  }
+  if (role === "worker") {
+    const main = group.sessions.find(
+      (session2) => session2.role === "main" && !session2.stopped
+    );
+    if (!backend.inspect(main.id).alive) throw new Error("main_unavailable");
+  }
+  const cwd = realpathSync8(text(input.cwd ?? group.projectRoot, "cwd"));
+  const scope = relative5(group.projectRoot, cwd);
+  if (scope === ".." || scope.startsWith("../"))
+    throw new Error("cwd_outside_project");
+  const memoryMb = integer(input.memoryMb ?? 384, "session_memory", 32, 1536);
+  const executable = runtimeExecutables[runtime];
+  if (!executable) throw new Error("unsupported_runtime");
+  const args = input.args === void 0 || Array.isArray(input.args) && input.args.length === 0 ? [] : strings(input.args, "runtime_args");
+  if (group.profile === "native" && input.containerFile !== void 0)
+    throw new Error("container_requires_docker_profile");
+  if (group.dockerPolicy?.egress && input.containerFile !== void 0)
+    throw new Error("egress_requires_cli_owned_creation");
+  const privateProfile = input.privateProfile === void 0 ? void 0 : profileName(input.privateProfile);
+  if (privateProfile && (group.profile !== "docker" || input.containerFile !== void 0))
+    throw new Error("private_profile_requires_cli_owned_creation");
+  if (privateProfile) {
+    const profile = selectedProfile(
+      group.dockerPolicy,
+      privateProfile,
+      runtime
+    );
+    assertProfileAvailable(profile, group.projectRoot);
+  }
+  const resource = input.containerFile === void 0 ? void 0 : admitResource(
+    input.containerFile,
+    group,
+    role,
+    backend.runDirectory,
+    memoryMb,
+    runtime
+  );
+  if (resource && args.length)
+    throw new Error("container_args_are_fixed_at_creation");
+  if (resource && backend.records().some((record) => record.resource?.id === resource.id))
+    throw new Error("container_already_bound");
+  const dockerPreparation = group.profile === "docker" && !resource ? {
+    args,
+    memoryMb: integer(memoryMb - 64, "container_memory", 32, 1472),
+    cpuQuota: integer(
+      input.containerCpuQuota ?? Math.floor(5e4 / group.maxActive),
+      "container_cpu",
+      1,
+      5e4
+    ),
+    ...privateProfile ? { privateProfile } : {}
+  } : void 0;
+  const executablePath = locateExecutable(
+    resource || dockerPreparation ? "docker" : executable,
+    cwd
+  );
+  if (!executablePath) throw new Error("runtime_executable_unavailable");
+  const argv = resource ? [executablePath, "start", "--attach", "--interactive", resource.id] : [executablePath, ...args];
+  const result = await budgetOperation(backend.runDirectory, {
+    action: "start",
+    spec: {
+      runtime,
+      argv,
+      cwd,
+      memoryMb,
+      groupId: group.id,
+      generation: group.generation,
+      role,
+      ...resource ? { resource } : {},
+      ...dockerPreparation ? { dockerPreparation } : {}
+    }
+  });
+  const session = result.session;
+  group.sessions.push({ id: session.id, role, stopped: false });
+  store.save();
+  authorizeSession(context, session.id);
+  return { session, role, generation: group.generation };
+}
+async function stopSession(context, sessionId) {
+  const { store, backend } = context;
+  store.session(sessionId);
+  assertOwnedRecords(backend);
+  const reference = store.state.group.sessions.find(
+    (session) => session.id === sessionId
+  );
+  if (!reference.stopped) {
+    await budgetOperation(backend.runDirectory, {
+      action: "stop",
+      id: sessionId
+    });
+    reference.stopped = true;
+    store.state.leases = store.state.leases.filter(
+      (lease) => lease.sessionId !== sessionId
+    );
+    store.save();
+  }
+  return { sessionId, stopped: true };
+}
+
+// src/harness/recovery/service.ts
+function inspectRecovery(context, includeStarts = false) {
+  const pendingStarts = includeStarts ? inspectPendingStarts(context) : [];
+  return {
+    ...listSessions(context),
+    control: context.store.state.leases.map(({ token, ...lease }) => ({
+      ...lease,
+      expired: Date.parse(lease.expiresAt) <= Date.now()
+    })),
+    deliveries: context.store.state.deliveries,
+    unregisteredOwnedSessions: context.backend.records().filter(
+      (record) => !record.stoppedAt && !context.store.state.group.sessions.some(
+        (session) => session.id === record.id
+      )
+    ).map((record) => ({ id: record.id, runtime: record.runtime })),
+    inputReplayed: false,
+    ...includeStarts ? { pendingStarts } : {}
+  };
+}
+function abortStart(context, sessionId) {
+  const records2 = context.backend.recordStore;
+  const journal = new LaunchJournal(records2, sessionId);
+  if (!pendingLaunches(records2).some((entry) => entry.id === sessionId) && !journal.abortRecord())
+    throw new Error("start_already_committed");
+  const result = abortLaunch(new Connection(records2), journal);
+  const reference = context.store.state.group.sessions.find(
+    (session) => session.id === sessionId
+  );
+  if (reference) reference.stopped = true;
+  context.store.state.leases = context.store.state.leases.filter(
+    (lease) => lease.sessionId !== sessionId
+  );
+  context.store.save();
+  return { ...result, sessionId };
+}
+function reconcile(context) {
+  const { store, backend } = context;
+  for (const delivery of store.state.deliveries) {
+    if (delivery.state === "intent") delivery.state = "delivery_uncertain";
+  }
+  store.save();
+  assertOwnedRecords(backend);
+  for (const session of store.state.group.sessions) {
+    if (!session.stopped) recoverInputLock(backend, session.id);
+  }
+  const retained = [];
+  for (const lease of store.state.leases) {
+    if (Date.parse(lease.expiresAt) > Date.now()) {
+      retained.push(lease);
+      continue;
+    }
+    const session = backend.inspect(lease.sessionId);
+    if (writableClients(backend, session.tmuxSessionId) > 0) {
+      retained.push(lease);
+    }
+  }
+  store.state.leases = retained;
+  store.save();
+  return inspectRecovery(context);
+}
+async function stopOrphan(context, sessionId) {
+  if (context.store.state.group.sessions.some(
+    (session) => session.id === sessionId
+  ))
+    throw new Error("session_is_registered");
+  assertOwnedRecords(context.backend);
+  context.backend.inspect(sessionId);
+  await budgetOperation(context.backend.runDirectory, {
+    action: "stop",
+    id: sessionId
+  });
+  return { sessionId, stopped: true, adopted: false };
+}
+async function replaceMain(context, input) {
+  const { store, backend } = context;
+  const previous = store.state.group.sessions.find(
+    (session) => session.role === "main" && !session.stopped
+  );
+  if (previous) {
+    const observation = backend.inspect(previous.id);
+    if (observation.alive) throw new Error("main_still_alive");
+    previous.stopped = true;
+  }
+  store.state.group.generation = randomUUID7();
+  store.state.leases = [];
+  store.save();
+  const result = await startSession(context, { ...input, role: "main" });
+  return {
+    ...result,
+    previousMain: previous?.id ?? null,
+    inputReplayed: false
+  };
+}
+
+// src/harness/application/context.ts
+import { dirname as dirname2 } from "path";
+function openGroup(path) {
+  const store = new GroupStore(path);
+  const backend = openBackend(dirname2(store.path));
+  if (store.state.group.owner !== backend.owner)
+    throw new Error("foreign_group");
+  return { store, backend };
+}
+
+// src/harness/application/effects.ts
+var observations = /* @__PURE__ */ new Set([
+  "group:inspect",
+  "session:list",
+  "session:inspect",
+  "session:read",
+  "session:watch",
+  "delivery:list",
+  "delivery:inspect",
+  "recovery:inspect",
+  "attach:inspect"
+]);
+function isReadOnly(operation) {
+  if (operation.family === "attach" && operation.action === "open")
+    return (operation.mode ?? "observe") === "observe";
+  return observations.has(`${operation.family}:${operation.action}`);
+}
+
+// src/harness/adapters/tmux/detach.ts
+function detachClients(context, sessionId) {
+  context.store.session(sessionId);
+  const session = context.backend.inspect(sessionId);
+  context.backend.tmux(["detach-client", "-s", session.tmuxSessionId]);
+  return { sessionId, clientsDetached: true, runtimeStopRequested: false };
+}
+
+// src/harness/adapters/tmux/clients.ts
+function attachedClients(backend, sessionId) {
+  const session = backend.inspect(sessionId);
+  if (!session.alive) throw new Error("session_unavailable");
+  const output = backend.tmux([
+    "list-clients",
+    "-F",
+    "#{session_id}|#{client_pid}|#{client_readonly}|#{client_tty}"
+  ]).trim();
+  if (!output) return [];
+  return output.split("\n").flatMap((line) => {
+    const [id2, pid, readOnly, tty] = line.split("|");
+    if (id2 !== session.tmuxSessionId) return [];
+    if (!/^\d+$/.test(pid ?? "") || !tty || !["0", "1"].includes(readOnly ?? ""))
+      throw new Error("attachment_observation_unknown");
+    return [{ pid: Number(pid), tty, readOnly: readOnly === "1" }];
+  });
+}
+
+// src/harness/observation/attachments.ts
+function inspectAttachments(context, sessionId) {
+  context.store.session(sessionId);
+  return { sessionId, clients: attachedClients(context.backend, sessionId) };
+}
+
+// src/harness/application/dispatch.ts
+async function runOperation(operation) {
+  const context = openGroup(text(operation.groupFile, "group_file"));
+  if (!isReadOnly(operation) && operation.generation !== context.store.state.group.generation) {
+    throw new Error("stale_group_generation");
+  }
+  const { family, action } = operation;
+  if (family === "group")
+    return groupOperation(context, action, operation.input);
+  if (family === "session") {
+    if (action === "start")
+      return startSession(context, object(operation.input));
+    if (action === "list") return listSessions(context);
+    const sessionId = text(operation.sessionId, "session_id");
+    if (action === "stop") return stopSession(context, sessionId);
+    return observeSession(context, action, sessionId, operation.input);
+  }
+  if (family === "control") {
+    if (action === "acquire") {
+      return acquireControl(
+        context,
+        text(operation.sessionId, "session_id"),
+        text(operation.controller, "controller"),
+        operation.mode ?? "cli"
+      );
+    }
+    return controlOperation(
+      context,
+      action,
+      text(operation.leaseFile, "lease_file")
+    );
+  }
+  if (family === "input") {
+    const leaseFile = text(operation.leaseFile, "lease_file");
+    if (action === "interrupt") return interrupt2(context, leaseFile);
+    return deliver(
+      context,
+      action,
+      leaseFile,
+      text(operation.requestId, "request_id"),
+      operation.text ?? ""
+    );
+  }
+  if (family === "attach") {
+    if (action === "inspect")
+      return inspectAttachments(
+        context,
+        text(operation.sessionId, "session_id")
+      );
+    if (action === "detach")
+      return detachClients(context, text(operation.sessionId, "session_id"));
+    return attachment(
+      context,
+      text(operation.sessionId, "session_id"),
+      operation.mode ?? "observe",
+      operation.leaseFile
+    );
+  }
+  if (family === "delivery")
+    return inspectDeliveries(context, operation.requestId);
+  if (family === "recovery") {
+    if (action === "abort-start")
+      return abortStart(context, text(operation.sessionId, "session_id"));
+    if (action === "inspect")
+      return inspectRecovery(context, operation.includeStarts === true);
+    if (action === "reconcile") return reconcile(context);
+    if (action === "stop-orphan")
+      return stopOrphan(context, text(operation.sessionId, "session_id"));
+    if (action === "replace-main")
+      return replaceMain(context, object(operation.input));
+  }
+  throw new Error("unsupported_operation");
+}
+
+// src/harness/application/worker.ts
+var operationFile = process.argv[2];
+try {
+  const operation = readPrivateJson(operationFile);
+  const receipt = await runOperation(operation);
+  const group = new GroupStore(text(operation.groupFile, "group_file")).state.group;
+  console.log(
+    JSON.stringify({
+      schemaVersion: 1,
+      ok: true,
+      groupId: group.id,
+      generation: group.generation,
+      effect: `${operation.family}:${operation.action}`,
+      ...receipt
+    })
+  );
+  if (receipt.ok === false) process.exitCode = 1;
+} catch (error) {
+  console.log(
+    JSON.stringify({
+      schemaVersion: 1,
+      ok: false,
+      error: error instanceof Error ? error.message : "operation_failed",
+      resendAllowed: false
+    })
+  );
+  process.exitCode = 1;
+} finally {
+  unlinkSync4(operationFile);
+}
+//# sourceMappingURL=harness-worker.js.map