@kitman-sh/cli 0.0.0-stage → 0.6.0

package/dist/chunk-3j7sewn0.js

@@ -0,0 +1,4618 @@
+// @bun
+import {
+  pipeArguments,
+  dual,
+  identity,
+  toJsonValue,
+  isBoolean,
+  isFunction,
+  isNumber,
+  isObject,
+  isJsonObject,
+  isString2,
+  none,
+  isNone,
+  isSome,
+  getOrUndefined,
+  Service2,
+  get,
+  merge,
+  succeed,
+  fail,
+  isResult,
+  isFailure,
+  isSuccess,
+  ensure,
+  map2,
+  millis,
+  seconds,
+  TaggedError,
+  die,
+  findErrorOption,
+  pretty,
+  succeed2,
+  void_,
+  isSuccess2,
+  isFailure2,
+  makeUnsafe2,
+  _await,
+  isDoneUnsafe,
+  doneUnsafe,
+  Scope,
+  make9,
+  provide,
+  addFinalizer,
+  close,
+  succeed4,
+  effect,
+  currentTimeMillis,
+  exponential,
+  jittered,
+  all,
+  forEach,
+  succeed5,
+  suspend,
+  sync,
+  void_2,
+  callback,
+  never,
+  gen,
+  fail4,
+  die3,
+  withFiber,
+  flatMap,
+  andThen,
+  tap,
+  result,
+  option,
+  exit,
+  map3,
+  as,
+  asSome,
+  asVoid,
+  catch_,
+  catchReason,
+  catchDefect,
+  catchIf,
+  mapError,
+  orDie,
+  tapError,
+  retry,
+  ignore,
+  orElseSucceed,
+  timeout,
+  timeoutOrElse,
+  sleep,
+  raceFirst,
+  matchEffect,
+  context,
+  contextWith,
+  provideContext,
+  updateContext,
+  provideService,
+  scope,
+  scoped,
+  acquireRelease,
+  ensuring,
+  uninterruptible,
+  forever,
+  repeat,
+  forkIn,
+  forkScoped,
+  fnUntraced,
+  fn,
+  logWarning,
+  logError,
+  interrupt3,
+  makeUnsafe4,
+  makeUnsafe5,
+  make13,
+  map4,
+  filter,
+  decodeText,
+  splitLines,
+  runHead,
+  FileSystem,
+  Path,
+  ChildProcessSpawner,
+  make15,
+  Crypto,
+  value,
+  is,
+  optionalKey,
+  Literal,
+  String2,
+  Boolean2,
+  Struct,
+  ArraySchema,
+  Union,
+  Literals,
+  Int,
+  Date2,
+  TaggedError2,
+  toDate,
+  wallClockMillis,
+  findForbiddenRepoBindingSecretPath,
+  runnerAgentSandboxPolicy,
+  agentNetworkAllowlist,
+  findForbiddenAgentEnvironmentSecretPath,
+  redactedOutputTail,
+  canonicalSha256,
+  createId,
+  isSyncKitHashValid,
+  isSyncKitSafe,
+  decodeJsonStringOption,
+  encodeJsonStringSync,
+  encodePrettyJsonString,
+  decodeJsonStringSync,
+  encodeUnknownJsonStringSync,
+  option2,
+  String3,
+  digestSha256,
+  CommandFailed2,
+  runCommand2,
+  shellOutputTailChars2,
+  runShell2,
+  herdrExecutionExtension2,
+  herdrNativeExtensionIds2,
+  herdrPiRunnerCapabilitiesForRepoBinding2,
+  herdrPiRunnerCapabilities2,
+  assertHerdrRunnerCapability2
+} from "./chunk-txyq8r41.js";
+import {
+  make4,
+  readerString,
+  isCloseEvent,
+  SocketReadError,
+  SocketWriteError,
+  SocketOpenError,
+  SocketUpgradeError,
+  SocketCloseError,
+  SocketError
+} from "./chunk-hw7qkap1.js";
+import"./chunk-hrvcz0m4.js";
+import {
+  RunSettled
+} from "./chunk-xdk488qp.js";
+import"./chunk-n32jhswz.js";
+import {
+  programLease
+} from "./chunk-fc0v325q.js";
+import {
+  nextInt
+} from "./chunk-brp7cekg.js";
+
+// packages/core/src/runner-trust.ts
+import { createHash } from "crypto";
+class RunnerArtifactTrustError extends TaggedError("RunnerArtifactTrustError") {
+  constructor(code) {
+    super({ code, message: code });
+  }
+}
+function sha256(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+
+// packages/agent-runtime/src/agent-environment.ts
+class AgentEnvironmentResolutionError extends TaggedError("AgentEnvironmentResolutionError") {
+  get message() {
+    return `AgentEnvironment resolution failed: ${this.issues.join("; ")}`;
+  }
+}
+function resolveAgentEnvironment(input) {
+  const core = resolveAgentEnvironmentCore({
+    harness: input.harness,
+    fragments: input.fragments,
+    ...availableCredentialReferences(input)
+  });
+  if (core.issues.length > 0)
+    throw new AgentEnvironmentResolutionError({ issues: core.issues });
+  return {
+    harness: input.harness,
+    skills: core.skills,
+    plugins: core.plugins,
+    mcpServers: core.mcpServers,
+    harnessSettings: core.harnessSettings,
+    providerAuthRefs: core.providerAuthRefs,
+    runnerSecretRefs: core.runnerSecretRefs,
+    permissions: core.permissions,
+    hooks: core.hooks,
+    runtimeConstraints: core.runtimeConstraints,
+    sandboxPolicyRequirements: core.sandboxPolicyRequirements,
+    warnings: []
+  };
+}
+function availableCredentialReferences(input) {
+  return {
+    ...input.availableProviderAuthRefs === undefined ? undefined : { availableProviderAuthRefs: input.availableProviderAuthRefs },
+    ...input.availableRunnerSecretRefs === undefined ? undefined : { availableRunnerSecretRefs: input.availableRunnerSecretRefs }
+  };
+}
+function resolveAgentEnvironmentCore(input) {
+  const issues = [];
+  const skills = [];
+  const plugins = [];
+  const mcpServers = [];
+  const harnessSettings = [];
+  const pendingHarnessSettings = [];
+  const providerAuthRefs = [];
+  const runnerSecretRefs = [];
+  const permissions = [];
+  const hooks = [];
+  const runtimeConstraints = [];
+  const sandboxPolicyRequirements = [];
+  for (const entry of input.fragments) {
+    const secretPath = findForbiddenAgentEnvironmentSecretPath(entry.fragment);
+    if (secretPath !== undefined) {
+      issues.push(`AgentEnvironment fragment from ${sourceLabel(entry.source)} contains forbidden secret-like value at ${secretPath}`);
+      continue;
+    }
+    mergeItems(skills, entry.fragment.skills ?? [], entry.source, (item) => item.name, "skill", issues);
+    mergeItems(plugins, entry.fragment.plugins ?? [], entry.source, (item) => item.name, "plugin", issues);
+    mergeItems(mcpServers, entry.fragment.mcpServers ?? [], entry.source, (item) => item.name, "MCP server", issues);
+    for (const setting of entry.fragment.harnessSettings ?? []) {
+      const applied = input.harness === undefined ? false : setting.harness === input.harness;
+      const target = applied ? harnessSettings : pendingHarnessSettings;
+      mergeItems(target, [setting], entry.source, (item) => `${item.harness}:${item.key}`, "harness setting", issues);
+    }
+    mergeItems(providerAuthRefs, entry.fragment.providerAuthRefs ?? [], entry.source, providerAuthRefKey, "ProviderAuthRef", issues);
+    mergeItems(runnerSecretRefs, entry.fragment.runnerSecretRefs ?? [], entry.source, (item) => item.name, "RunnerSecretRef", issues);
+    mergeItems(permissions, entry.fragment.permissions ?? [], entry.source, (item) => item.key, "permission", issues);
+    mergeItems(hooks, entry.fragment.hooks ?? [], entry.source, (item) => `${item.name}:${item.event}`, "hook", issues);
+    mergeItems(runtimeConstraints, entry.fragment.runtimeConstraints ?? [], entry.source, (item) => item.key, "runtime constraint", issues);
+    mergeItems(sandboxPolicyRequirements, entry.fragment.sandboxPolicyRequirements ?? [], entry.source, (item) => item.key, "sandbox policy requirement", issues);
+  }
+  validateAvailableProviderAuthRefs(providerAuthRefs, input.availableProviderAuthRefs, issues);
+  validateAvailableRunnerSecretRefs(runnerSecretRefs, input.availableRunnerSecretRefs, issues);
+  return {
+    skills,
+    plugins,
+    mcpServers,
+    harnessSettings,
+    pendingHarnessSettings,
+    providerAuthRefs,
+    runnerSecretRefs,
+    permissions,
+    hooks,
+    runtimeConstraints,
+    sandboxPolicyRequirements,
+    issues
+  };
+}
+function resolveAgentEnvironmentFromSources(input) {
+  const harness = input.harness ?? input.userPreferences?.defaultHarness ?? firstSyncProfileHarness(input.syncProfile) ?? "opencode";
+  const syncProfileSources = input.syncProfile?.sources ?? [];
+  const selectedFragments = orderedSourceKinds.flatMap((sourceKind) => input.fragments.filter((entry) => entry.sourceKind === sourceKind && fragmentMatchesHarness(entry, harness) && fragmentMatchesProjectContext(entry, input.projectContext) && fragmentSelectedByUserPreferences(entry, input.userPreferences, harness) && fragmentSelectedBySyncProfile(entry, syncProfileSources, input.projectContext)));
+  const preferenceFragments = userPreferenceFragments(input.userId, input.userPreferences, harness);
+  const resolveInput = {
+    harness,
+    fragments: [
+      ...selectedFragments.filter((entry) => entry.sourceKind !== "device_local" && entry.sourceKind !== "step_attempt_override" && entry.sourceKind !== "command_override"),
+      ...preferenceFragments,
+      ...selectedFragments.filter((entry) => entry.sourceKind === "device_local" || entry.sourceKind === "step_attempt_override" || entry.sourceKind === "command_override")
+    ],
+    ...input.availableProviderAuthRefs === undefined ? undefined : { availableProviderAuthRefs: input.availableProviderAuthRefs },
+    ...input.availableRunnerSecretRefs === undefined ? undefined : { availableRunnerSecretRefs: input.availableRunnerSecretRefs }
+  };
+  return resolveAgentEnvironment(resolveInput);
+}
+var orderedSourceKinds = [
+  "built_in",
+  "personal_kit_default",
+  "workspace_assignment",
+  "team_default",
+  "project_kit",
+  "device_local",
+  "step_attempt_override",
+  "command_override"
+];
+function firstSyncProfileHarness(syncProfile) {
+  return syncProfile?.harnesses?.[0];
+}
+function userPreferenceFragments(userId, preferences, harness) {
+  const fragments = [];
+  const preferenceSource = { kind: "user_preferences", userId };
+  if (preferences?.agentEnvironment !== undefined) {
+    fragments.push({ source: preferenceSource, fragment: preferences.agentEnvironment });
+  }
+  const providerAuthRefs = preferences?.providerAuthRefs ?? [];
+  const modelPreference = preferences?.modelPreferences?.find((item) => item.harness === harness);
+  if (providerAuthRefs.length > 0 || modelPreference !== undefined) {
+    fragments.push({
+      source: preferenceSource,
+      fragment: {
+        providerAuthRefs,
+        harnessSettings: modelPreference === undefined ? [] : [{ harness, key: "modelProfile", policy: "recommended", value: modelPreference }]
+      }
+    });
+  }
+  return fragments;
+}
+function fragmentMatchesHarness(entry, harness) {
+  return entry.harness === undefined || entry.harness === harness;
+}
+function fragmentMatchesProjectContext(entry, projectContext) {
+  if (projectContext === undefined)
+    return true;
+  if (entry.workspaceId !== undefined && projectContext?.workspaceId !== entry.workspaceId)
+    return false;
+  if (entry.projectId !== undefined && projectContext?.projectId !== entry.projectId)
+    return false;
+  if (entry.teamId !== undefined && !(projectContext?.teamIds ?? []).includes(entry.teamId))
+    return false;
+  return true;
+}
+function fragmentSelectedByUserPreferences(entry, preferences, harness) {
+  if (entry.sourceKind !== "personal_kit_default")
+    return true;
+  const activations = preferences?.perHarnessKitActivations;
+  if (activations === undefined)
+    return false;
+  const kitId = entry.source.kind === "user_kit" ? entry.source.kitId : undefined;
+  if (kitId === undefined)
+    return true;
+  const activation = activations.find((item) => item.harness === harness && item.kitId === kitId);
+  return activation?.enabled ?? false;
+}
+function fragmentSelectedBySyncProfile(entry, sources, projectContext) {
+  const enabledSources = sources.filter((source) => source.enabled);
+  if (entry.sourceKind === "built_in" || entry.sourceKind === "device_local" || entry.sourceKind === "step_attempt_override" || entry.sourceKind === "command_override")
+    return true;
+  if (entry.sourceKind === "project_kit") {
+    const projectSources = sources.filter((source) => source.kind === "project_kits" && source.projectId === entry.projectId);
+    if (projectSources.length > 0)
+      return projectSources.some((source) => source.enabled);
+    return projectContext !== undefined;
+  }
+  if (projectContext !== undefined && entry.sourceKind === "workspace_assignment") {
+    const workspaceSources = sources.filter((source) => source.kind === "workspace_assignments" && source.workspaceId === entry.workspaceId);
+    if (workspaceSources.length > 0)
+      return workspaceSources.some((source) => source.enabled);
+    return true;
+  }
+  if (projectContext !== undefined && entry.sourceKind === "team_default") {
+    const teamSources = sources.filter((source) => source.kind === "team_defaults" && source.workspaceId === entry.workspaceId && (source.teamId === undefined || source.teamId === entry.teamId));
+    if (teamSources.length > 0)
+      return teamSources.some((source) => source.enabled);
+    return true;
+  }
+  if (entry.sourceKind === "personal_kit_default")
+    return sources.length === 0 || enabledSources.some((source) => source.kind === "personal_kit_defaults" && (source.harness === undefined || source.harness === entry.harness));
+  if (entry.sourceKind === "workspace_assignment")
+    return enabledSources.some((source) => source.kind === "workspace_assignments" && source.workspaceId === entry.workspaceId);
+  if (entry.sourceKind === "team_default")
+    return enabledSources.some((source) => source.kind === "team_defaults" && source.workspaceId === entry.workspaceId && (source.teamId === undefined || source.teamId === entry.teamId));
+  return false;
+}
+function mergeItems(target, items, source, keyOf, label, issues) {
+  for (const item of items) {
+    const key = keyOf(item);
+    const index = target.findIndex((candidate) => keyOf(candidate.item) === key);
+    if (index === -1) {
+      target.push({ item, source });
+      continue;
+    }
+    const existing = target[index];
+    if (existing === undefined) {
+      target.push({ item, source });
+      continue;
+    }
+    if (existing.item.policy === "required" && item.policy === "required" && stableStringify(existing.item) !== stableStringify(item)) {
+      issues.push(`Conflicting required ${label} ${key} from ${sourceLabel(existing.source)} and ${sourceLabel(source)}`);
+      continue;
+    }
+    if (existing.item.policy === "required" && item.policy === "recommended")
+      continue;
+    if (existing.item.policy === "required" && item.policy === "required")
+      continue;
+    target[index] = { item, source };
+  }
+}
+function validateAvailableProviderAuthRefs(resolved, available, issues) {
+  if (available === undefined)
+    return;
+  const keys = new Set(available.map(providerAuthRefKey));
+  for (const ref of resolved) {
+    if (ref.item.policy === "required" && !keys.has(providerAuthRefKey(ref.item))) {
+      issues.push(`Missing required ProviderAuthRef ${providerAuthRefKey(ref.item)} from ${sourceLabel(ref.source)}`);
+    }
+  }
+}
+function validateAvailableRunnerSecretRefs(resolved, available, issues) {
+  if (available === undefined)
+    return;
+  const names = new Set(available.map((item) => item.name));
+  for (const ref of resolved) {
+    if (ref.item.policy === "required" && !names.has(ref.item.name)) {
+      issues.push(`Missing required RunnerSecretRef ${ref.item.name} from ${sourceLabel(ref.source)}`);
+    }
+  }
+}
+function providerAuthRefKey(ref) {
+  if (ref.kind === "existing_harness_login")
+    return `${ref.provider}:existing_harness_login:${ref.accountHint ?? "default"}`;
+  if (ref.kind === "local_env")
+    return `${ref.provider}:local_env:${ref.envName}`;
+  if (ref.kind === "runner_secret")
+    return `${ref.provider}:runner_secret:${ref.runnerSecretName}`;
+  return `${ref.provider}:managed_oauth:${ref.grantId ?? "managed"}`;
+}
+function sourceLabel(source) {
+  if (source.label !== undefined)
+    return source.label;
+  if (source.kind === "workspace_kit" || source.kind === "project_kit")
+    return `${source.kind}:${source.kitId}`;
+  if (source.kind === "team_default_kit")
+    return `${source.kind}:${source.teamId}:${source.kitId}`;
+  if (source.kind === "user_kit")
+    return `${source.kind}:${source.userId}:${source.kitId}`;
+  if (source.kind === "agent_sync_profile")
+    return `${source.kind}:${source.profileId ?? source.userId}`;
+  if (source.kind === "user_preferences")
+    return `${source.kind}:${source.userId}`;
+  if (source.kind === "step_attempt_override")
+    return `${source.kind}:${source.stepAttemptId}`;
+  return source.kind;
+}
+function stableStringify(value) {
+  return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+  if (Array.isArray(value))
+    return value.map(sortValue);
+  if (!isObject(value) || value === null)
+    return toJsonValue(value);
+  const result = {};
+  for (const key of Object.keys(value).sort()) {
+    result[key] = sortValue(Object.getOwnPropertyDescriptor(value, key)?.value);
+  }
+  return result;
+}
+// packages/agent-runtime/src/env.ts
+var optionalEnv = (name) => gen(function* () {
+  const value = getOrUndefined(yield* option2(String3(name)))?.trim();
+  return value === undefined || value.length === 0 ? undefined : value;
+}).pipe(orElseSucceed(() => {
+  return;
+}));
+
+// packages/agent-runtime/src/config.ts
+class AgentRuntimeConfigError extends TaggedError("AgentRuntimeConfigError") {
+}
+var loadAgentRuntimeConfig = fnUntraced(function* (input = {}) {
+  const path = yield* Path;
+  const user = yield* readJsonObject(input.userConfigPath ?? (yield* defaultAgentRuntimeUserConfigPath));
+  const project = yield* readJsonObject(input.projectConfigPath ?? path.join(input.projectRoot ?? path.resolve("."), ".kitman", "config.json"));
+  const agentRuntime = project?.agentRuntime;
+  if (agentRuntime !== undefined && !isJsonObject(agentRuntime))
+    return yield* invalid("Project agentRuntime config must be an object");
+  const projectProfileId = yield* optionalString(agentRuntime?.profileId, "agentRuntime.profileId");
+  const userProfileId = yield* optionalString(user?.defaultProfileId, "defaultProfileId");
+  return {
+    profileId: projectProfileId ?? userProfileId ?? "opencode",
+    source: projectProfileId !== undefined ? "project" : userProfileId !== undefined ? "user" : "default"
+  };
+});
+var setDefaultAgentRuntimeProfile = fnUntraced(function* (profileId, file) {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const target = file ?? (yield* defaultAgentRuntimeUserConfigPath);
+  const current = yield* readJsonObject(target);
+  yield* fs.makeDirectory(path.dirname(target), { recursive: true });
+  const text = yield* encodePrettyJsonString({ ...current, defaultProfileId: profileId });
+  yield* fs.writeFileString(target, `${text}
+`);
+});
+var defaultAgentRuntimeUserConfigPath = gen(function* () {
+  const path = yield* Path;
+  const home = yield* optionalEnv("HOME");
+  const base = (yield* optionalEnv("XDG_CONFIG_HOME")) ?? (home === undefined ? path.resolve(".") : path.join(home, ".config"));
+  return path.join(base, "kitman", "agent-runtime.json");
+});
+var invalid = (message) => fail4(new AgentRuntimeConfigError({ message }));
+var readJsonObject = (file) => gen(function* () {
+  const fs = yield* FileSystem;
+  const text = yield* fs.readFileString(file).pipe(asSome, catchReason("PlatformError", "NotFound", () => succeed5(none())));
+  if (isNone(text))
+    return;
+  const value = getOrUndefined(decodeJsonStringOption(text.value));
+  if (value === undefined)
+    return yield* invalid(`Invalid JSON in ${file}`);
+  if (!isJsonObject(value))
+    return yield* invalid(`${file} must contain a JSON object`);
+  return value;
+});
+var optionalString = (value, label) => gen(function* () {
+  if (value === undefined)
+    return;
+  if (isString2(value) && value.trim().length > 0)
+    return value;
+  return yield* invalid(`${label} must be a non-empty string when provided`);
+});
+// packages/agent-runtime/src/config-convergence.ts
+var writeAgentEnvironmentConfigFile = fnUntraced(function* (file, content) {
+  const fs = yield* FileSystem;
+  const paths = {
+    path: yield* Path,
+    home: yield* optionalEnv("HOME")
+  };
+  yield* fs.makeDirectory(paths.path.dirname(file), { recursive: true });
+  const existing = yield* readExistingText(file);
+  const merged = yield* gen(function* () {
+    if (file.endsWith("AGENTS.md"))
+      return mergeCodexAgents(existing, content);
+    if (file.endsWith("opencode.json")) {
+      const managed = yield* readManagedNamesForConfig(paths, file);
+      return mergeOpenCodeConfig(existing, content, managed.mcpNames, managed.pluginNames);
+    }
+    if (file.endsWith(".codex/config.toml")) {
+      const managed = yield* readManagedNamesForConfig(paths, file);
+      return mergeCodexConfig(existing, content, managed.mcpNames, managed.skillPaths);
+    }
+    if (isPiConfigPath(paths.path, file, "settings.json"))
+      return mergePiSettingsConfig(existing, content);
+    if (isPiConfigPath(paths.path, file, "mcp.json")) {
+      const managed = yield* readManagedNamesForConfig(paths, file);
+      return mergePiMcpConfig(existing, content, managed.mcpNames);
+    }
+    return content;
+  });
+  yield* fs.writeFileString(file, merged);
+});
+var KitmanAgentsStartMarker = "<!-- KITMAN_AGENT_ENVIRONMENT_START -->";
+var KitmanAgentsEndMarker = "<!-- KITMAN_AGENT_ENVIRONMENT_END -->";
+var KitmanGeneratedAgentsPrefix = "# Kitman AgentEnvironment\n\nThis file is generated by `kitman sync`";
+function mergeCodexAgents(existingText, generatedText) {
+  const block = `${KitmanAgentsStartMarker}
+${generatedText.trimEnd()}
+${KitmanAgentsEndMarker}`;
+  const trimmedExisting = existingText.trim();
+  if (trimmedExisting.length === 0 || existingText.startsWith(KitmanGeneratedAgentsPrefix))
+    return `${block}
+`;
+  const start = existingText.indexOf(KitmanAgentsStartMarker);
+  const end = existingText.indexOf(KitmanAgentsEndMarker);
+  if (start !== -1 && end !== -1 && end > start) {
+    return `${existingText.slice(0, start)}${block}${existingText.slice(end + KitmanAgentsEndMarker.length).replace(/^\n?/, `
+`)}`;
+  }
+  return `${existingText.trimEnd()}
+
+${block}
+`;
+}
+var readExistingText = (file) => flatMap(FileSystem, (fs) => fs.readFileString(file).pipe(catchReason("PlatformError", "NotFound", () => succeed5(""))));
+var readManagedNamesForConfig = (paths, file) => gen(function* () {
+  const manifest = parseJsonObject(yield* readExistingText(yield* managedManifestPathForConfig(paths, file)));
+  const servers = Array.isArray(manifest.mcpServers) ? manifest.mcpServers : [];
+  const plugins = Array.isArray(manifest.plugins) ? manifest.plugins : [];
+  const materializedSkills = Array.isArray(manifest.materializedSkills) ? manifest.materializedSkills : [];
+  return {
+    mcpNames: new Set(servers.flatMap((entry) => {
+      const item = objectValue(objectValue(entry).item);
+      return isString2(item.name) ? [item.name] : [];
+    })),
+    pluginNames: new Set(plugins.flatMap((entry) => {
+      const item = objectValue(objectValue(entry).item);
+      return isString2(item.name) ? [item.name] : [];
+    })),
+    skillPaths: new Set(materializedSkills.flatMap((entry) => {
+      const item = objectValue(entry);
+      return isString2(item.skillPath) ? [item.skillPath] : [];
+    }))
+  };
+});
+var managedManifestPathForConfig = (paths, file) => gen(function* () {
+  const fs = yield* FileSystem;
+  const manifestRoot = managedManifestRootPath(paths, file);
+  const manifestPath = paths.path.join(manifestRoot, ".kitman", manifestFileForHarness(managedHarnessForConfigPath(paths, file)));
+  const legacyPath = paths.path.join(manifestRoot, ".kitman/agent-environment.manifest.json");
+  if (yield* fs.exists(manifestPath))
+    return manifestPath;
+  return (yield* fs.exists(legacyPath)) ? legacyPath : manifestPath;
+});
+var HomeConfigFiles = [
+  [".config/opencode/opencode.json", "opencode"],
+  [".codex/AGENTS.md", "codex"],
+  [".codex/config.toml", "codex"],
+  [".claude/.mcp.json", "claude-code"],
+  [".pi/agent/settings.json", "pi"],
+  [".pi/agent/mcp.json", "pi"]
+];
+function homeConfigHarness({ path, home }, file) {
+  if (home === undefined)
+    return;
+  const resolved = path.resolve(file);
+  return HomeConfigFiles.find(([relative]) => path.resolve(home, relative) === resolved)?.[1];
+}
+function managedManifestRootPath(paths, file) {
+  const { path, home } = paths;
+  const resolved = path.resolve(file);
+  if (home !== undefined && homeConfigHarness(paths, file) !== undefined)
+    return home;
+  const harness = managedHarnessForConfigPath(paths, file);
+  const configDirectory = path.dirname(resolved);
+  const configFile = path.basename(resolved);
+  if (harness === "codex" && configFile === "config.toml" && path.basename(configDirectory) === ".codex")
+    return path.dirname(configDirectory);
+  if (harness === "pi" && (configFile === "settings.json" || configFile === "mcp.json") && path.basename(configDirectory) === ".pi")
+    return path.dirname(configDirectory);
+  return configDirectory;
+}
+function managedHarnessForConfigPath(paths, file) {
+  const homeHarness = homeConfigHarness(paths, file);
+  if (homeHarness !== undefined)
+    return homeHarness;
+  const { path } = paths;
+  const resolved = path.resolve(file);
+  const configFile = path.basename(resolved);
+  if (configFile === "opencode.json")
+    return "opencode";
+  if (configFile === ".mcp.json")
+    return "claude-code";
+  if ((configFile === "settings.json" || configFile === "mcp.json") && path.basename(path.dirname(resolved)) === ".pi")
+    return "pi";
+  if (configFile === "AGENTS.md" || configFile === "config.toml")
+    return "codex";
+  return;
+}
+function manifestFileForHarness(harness) {
+  if (harness === undefined)
+    return "agent-environment.manifest.json";
+  return `agent-environment.${harness}.manifest.json`;
+}
+function mergeOpenCodeConfig(existingText, generatedText, managedMcpNames, managedPluginNames) {
+  const existing = parseJsonObject(existingText);
+  const generated = parseJsonObject(generatedText);
+  const existingMcp = { ...objectValue(existing.mcp) };
+  for (const name of managedMcpNames)
+    delete existingMcp[name];
+  const existingPlugins = uniqueStrings(arrayValue(existing.plugin).filter((entry) => !pluginReferenceMatchesManaged(entry, managedPluginNames)));
+  const merged = {
+    ...existing,
+    ...generated,
+    mcp: { ...existingMcp, ...objectValue(generated.mcp) },
+    plugin: uniqueStrings([...existingPlugins, ...arrayValue(generated.plugin)]),
+    skills: {
+      ...objectValue(existing.skills),
+      ...objectValue(generated.skills),
+      paths: uniqueStrings([
+        ...arrayValue(objectValue(existing.skills).paths),
+        ...arrayValue(objectValue(generated.skills).paths)
+      ])
+    }
+  };
+  return `${JSON.stringify(merged, null, 2)}
+`;
+}
+function pluginReferenceMatchesManaged(entry, managedPluginNames) {
+  if (!isString2(entry))
+    return false;
+  for (const name of managedPluginNames) {
+    if (entry === name || entry.startsWith(`${name}@`))
+      return true;
+  }
+  return false;
+}
+function mergePiSettingsConfig(existingText, generatedText) {
+  const existing = parseJsonObject(existingText);
+  const generated = parseJsonObject(generatedText);
+  const merged = {
+    ...existing,
+    ...generated,
+    packages: uniquePackageEntries([...packageEntries(existing.packages), ...packageEntries(generated.packages)])
+  };
+  return `${JSON.stringify(merged, null, 2)}
+`;
+}
+function mergePiMcpConfig(existingText, generatedText, managedMcpNames) {
+  const existing = parseJsonObject(existingText);
+  const generated = parseJsonObject(generatedText);
+  const existingMcp = { ...objectValue(existing.mcpServers) };
+  for (const name of managedMcpNames)
+    delete existingMcp[name];
+  const merged = {
+    ...existing,
+    ...generated,
+    mcpServers: { ...existingMcp, ...objectValue(generated.mcpServers) }
+  };
+  return `${JSON.stringify(merged, null, 2)}
+`;
+}
+function packageEntries(value) {
+  return Array.isArray(value) ? value : [];
+}
+function uniquePackageEntries(values) {
+  const seen = new Set;
+  const result = [];
+  for (const value of values) {
+    const key = isString2(value) ? `string:${value}` : `json:${JSON.stringify(value)}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    result.push(value);
+  }
+  return result;
+}
+function isPiConfigPath(path, file, name) {
+  const parent = path.dirname(file);
+  return path.basename(file) === name && (path.basename(parent) === ".pi" || path.basename(parent) === "agent" && path.basename(path.dirname(parent)) === ".pi");
+}
+function mergeCodexConfig(existingText, generatedText, managedMcpNames, managedSkillPaths = new Set) {
+  const preserved = stripTomlTables(existingText, new Set([...managedMcpNames, ...mcpServerNames(generatedText)]), new Set([...managedSkillPaths, ...codexSkillPaths(generatedText)])).trimEnd();
+  const generated = generatedText.trim();
+  if (preserved.length === 0)
+    return `${generated}
+`;
+  if (generated.length === 0)
+    return `${preserved}
+`;
+  return `${preserved}
+
+${generated}
+`;
+}
+function stripTomlTables(text, removeMcpServerNames, removeSkillPaths) {
+  const lines = text.split(`
+`);
+  const kept = [];
+  for (let index = 0;index < lines.length; ) {
+    const line = lines[index] ?? "";
+    const table = /^(\[\[?)([^\]]+)\]\]?/.exec(line)?.[2];
+    if (table === undefined) {
+      kept.push(line);
+      index += 1;
+      continue;
+    }
+    const block = [line];
+    index += 1;
+    while (index < lines.length && !/^\[\[?[^\]]+\]\]?/.test(lines[index] ?? "")) {
+      block.push(lines[index] ?? "");
+      index += 1;
+    }
+    const skillPath = table === "skills.config" ? codexSkillPathFromBlock(block) : undefined;
+    const drop = codexMcpServerName(table, removeMcpServerNames) !== undefined || skillPath !== undefined && removeSkillPaths.has(skillPath);
+    if (!drop)
+      kept.push(...block);
+  }
+  return kept.join(`
+`);
+}
+function mcpServerNames(toml) {
+  const names = new Set;
+  for (const line of toml.split(`
+`)) {
+    const table = /^\[([^\]]+)\]/.exec(line)?.[1];
+    if (table === undefined)
+      continue;
+    const name = codexMcpServerTableName(table);
+    if (name !== undefined)
+      names.add(name);
+  }
+  return names;
+}
+function codexSkillPaths(toml) {
+  const paths = new Set;
+  const lines = toml.split(`
+`);
+  for (let index = 0;index < lines.length; ) {
+    const line = lines[index] ?? "";
+    if (!line.startsWith("[[skills.config]]")) {
+      index += 1;
+      continue;
+    }
+    const block = [line];
+    index += 1;
+    while (index < lines.length && !/^\[\[?[^\]]+\]\]?/.test(lines[index] ?? "")) {
+      block.push(lines[index] ?? "");
+      index += 1;
+    }
+    const path = codexSkillPathFromBlock(block);
+    if (path !== undefined)
+      paths.add(path);
+  }
+  return paths;
+}
+function codexSkillPathFromBlock(block) {
+  for (const line of block) {
+    const match = /^path\s*=\s*"((?:\\"|[^"])*)"/.exec(line.trim());
+    const value = match === null ? undefined : decodeJsonStringSync(`"${match[1]}"`);
+    if (isString2(value))
+      return value;
+  }
+}
+function codexMcpServerName(table, names) {
+  const name = codexMcpServerTableName(table);
+  return name !== undefined && names.has(name) ? name : undefined;
+}
+function codexMcpServerTableName(table) {
+  const match = /^mcp_servers\.([^.]+)(?:\.|$)/.exec(table);
+  if (match === null)
+    return;
+  return match[1];
+}
+function parseJsonObject(text) {
+  return text.trim().length === 0 ? {} : objectValue(decodeJsonStringSync(text));
+}
+function objectValue(value) {
+  return isJsonObject(value) ? value : {};
+}
+function arrayValue(value) {
+  return Array.isArray(value) ? value.filter((item) => isString2(item)) : [];
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+
+// packages/agent-runtime/src/config-writer.ts
+var Sources = {
+  opencodeMcp: "https://opencode.ai/docs/mcp-servers/",
+  opencodeSkills: "https://opencode.ai/docs/skills/",
+  opencodePlugins: "https://opencode.ai/docs/plugins/",
+  codexMcp: "https://developers.openai.com/codex/mcp",
+  codexSkills: "https://developers.openai.com/codex/skills",
+  codexPlugins: "https://developers.openai.com/codex/plugins",
+  claudeMcp: "https://docs.anthropic.com/en/docs/claude-code/mcp",
+  claudePlugins: "https://docs.anthropic.com/en/docs/claude-code/plugins",
+  skillsSh: "https://skills.sh",
+  piReadme: "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/README.md",
+  piMcpAdapter: "https://github.com/nicobailon/pi-mcp-adapter"
+};
+
+class AgentEnvironmentConfigSyncError extends TaggedError("AgentEnvironmentConfigSyncError") {
+  get message() {
+    return `AgentEnvironment config sync failed: ${this.issues.map((issue) => issue.message).join("; ")}`;
+  }
+}
+var previewAgentEnvironmentConfigSync = fnUntraced(function* (previewInput) {
+  const input = { ...previewInput, path: yield* Path, home: yield* optionalEnv("HOME") };
+  const plan = { operations: [], warnings: [], issues: [] };
+  const secretPath = findForbiddenAgentEnvironmentSecretPath(input.environment);
+  if (secretPath !== undefined) {
+    plan.issues.push({ message: `AgentEnvironment output contains forbidden secret-like value at ${secretPath}` });
+  }
+  if (input.syncKit?.status === "blocked" || (input.syncKit?.blockers.length ?? 0) > 0) {
+    plan.issues.push({
+      message: `Sync Kit is blocked; repair its pinned bindings before writing ${input.environment.harness} config.`,
+      ...input.syncKit?.blockers[0] === undefined ? undefined : { source: input.syncKit.blockers[0] }
+    });
+  }
+  if (input.syncKit !== undefined && !isSyncKitHashValid(input.syncKit)) {
+    plan.issues.push({
+      message: "Sync Kit hash does not match its resolved bindings; discard the stale preview before writing config."
+    });
+  }
+  if (input.syncKit !== undefined && !isSyncKitSafe(input.syncKit)) {
+    plan.issues.push({ message: "Sync Kit contains unsafe durable values; discard the preview before writing config." });
+  }
+  const syncKitPath = input.syncKit === undefined ? undefined : findForbiddenAgentEnvironmentSecretPath(input.syncKit);
+  if (syncKitPath !== undefined)
+    plan.issues.push({ message: `Sync Kit contains forbidden secret-like value at ${syncKitPath}` });
+  if (input.environment.harness === "opencode")
+    renderOpenCode(input, plan);
+  else if (input.environment.harness === "codex")
+    renderCodex(input, plan);
+  else if (input.environment.harness === "claude-code")
+    renderClaudeCode(input, plan);
+  else if (input.environment.harness === "pi")
+    renderPi(input, plan);
+  renderSkillFiles(input, plan);
+  renderManifest(input, plan);
+  if (plan.operations.some((operation) => isUnsafeConfigWritePath(operation.path))) {
+    plan.issues.push({ message: "AgentEnvironment config sync produced an unsafe relative write path." });
+  }
+  if (plan.issues.length > 0)
+    return yield* new AgentEnvironmentConfigSyncError({ issues: plan.issues });
+  return {
+    harness: input.environment.harness,
+    operations: plan.operations,
+    warnings: plan.warnings,
+    ...input.syncKit === undefined ? undefined : { syncKitHash: input.syncKit.syncKitHash, kitRefs: input.syncKit.kitRefs }
+  };
+});
+var applyAgentEnvironmentConfigSync = fnUntraced(function* (plan) {
+  if (plan.operations.some((operation) => isUnsafeConfigWritePath(operation.path)))
+    return yield* new AgentEnvironmentConfigSyncError({
+      issues: [{ message: "AgentEnvironment config apply rejected an unsafe relative write path." }]
+    });
+  for (const operation of plan.operations)
+    yield* writeAgentEnvironmentConfigFile(operation.path, operation.content);
+  return plan;
+});
+var SafeModelReference = /^(?!.*(?:https?:\/\/|ftp:\/\/|file:\/\/|Bearer\s|secret|token|password))(?!.*(?:^|[\s])(?:\/|~\/|[A-Za-z]:\\\\))[A-Za-z0-9][A-Za-z0-9_.:/@-]{0,239}$/iu;
+function renderModelSetting(input, plan) {
+  const candidates = [];
+  for (const entry of input.environment.harnessSettings) {
+    const key = entry.item.key.toLowerCase();
+    if (key !== "model" && key !== "modelprofile" && key !== "model_profile") {
+      reportUnsupported(plan, entry.item.policy, `harness setting ${entry.item.key}`, input.environment.harness, "this writer only renders the non-secret model profile setting natively", undefined);
+      continue;
+    }
+    const value = entry.item.value;
+    let candidate;
+    if (isString2(value))
+      candidate = value.trim();
+    else if (isObject(value) && value !== null) {
+      candidate = readStringProperty(value, "model") ?? readStringProperty(value, "modelRef") ?? readStringProperty(value, "profileRef");
+    }
+    if (candidate === undefined || !SafeModelReference.test(candidate)) {
+      reportUnsupported(plan, entry.item.policy, `harness setting ${entry.item.key}`, input.environment.harness, "model settings must use a non-secret model or profile reference", undefined);
+      continue;
+    }
+    candidates.push({ value: candidate, policy: entry.item.policy });
+  }
+  for (const binding of input.syncKit?.bindings ?? []) {
+    if (binding.model === undefined)
+      continue;
+    if (binding.harness !== undefined && binding.harness.id !== input.environment.harness)
+      continue;
+    const candidate = binding.model.modelRef;
+    if (!SafeModelReference.test(candidate)) {
+      reportUnsupported(plan, binding.model.policy, `Sync Kit model ${candidate}`, input.environment.harness, "model settings must use a non-secret model or profile reference", binding.model.contributedBy[0]?.kitRef);
+      continue;
+    }
+    const source = binding.model.contributedBy[0]?.kitRef;
+    candidates.push({
+      value: candidate,
+      policy: binding.model.policy,
+      ...source === undefined ? undefined : { source }
+    });
+  }
+  const distinct = [...new Set(candidates.map((candidate) => candidate.value))];
+  if (distinct.length > 1) {
+    const required = candidates.some((candidate) => candidate.policy === "required");
+    reportUnsupported(plan, required ? "required" : "recommended", `model profiles for ${input.environment.harness}`, input.environment.harness, "multiple model profiles cannot be represented in one harness config; choose a model per Step in the Loop", candidates.find((candidate) => candidate.source !== undefined)?.source);
+    return;
+  }
+  return distinct[0];
+}
+function readStringProperty(value, key) {
+  const candidate = Object.getOwnPropertyDescriptor(value, key)?.value;
+  return isString2(candidate) && candidate.trim().length > 0 ? candidate.trim() : undefined;
+}
+function renderOpenCode(input, plan) {
+  const mcp = objectMap(input.environment.mcpServers, (server) => renderOpenCodeMcpServer(input, server, plan));
+  const plugins = renderOpenCodePlugins(input.environment.plugins, plan);
+  const model = renderModelSetting(input, plan);
+  const skillPermission = Object.fromEntries((input.materializedSkills ?? []).map((skill) => [skill.name, "allow"]));
+  plan.operations.push({
+    kind: "write_file",
+    path: targetPath(input, "opencode.json"),
+    description: "OpenCode project config for Kitman AgentEnvironment MCP servers and package plugins.",
+    content: json({
+      $schema: "https://opencode.ai/config.json",
+      ...model === undefined ? undefined : { model },
+      ...Object.keys(mcp).length === 0 ? undefined : { mcp },
+      ...plugins.length === 0 ? undefined : { plugin: plugins },
+      ...Object.keys(skillPermission).length === 0 ? undefined : { permission: { skill: skillPermission } }
+    }),
+    sources: [Sources.opencodeMcp, Sources.opencodePlugins]
+  });
+}
+function renderCodex(input, plan) {
+  const serverBlocks = [];
+  const model = renderModelSetting(input, plan);
+  const credentialName = input.mcpCredentialName?.trim() || "OpenCode";
+  for (const server of input.environment.mcpServers) {
+    const block = renderCodexMcpServer(input, server, plan, credentialName);
+    if (block !== undefined)
+      serverBlocks.push(block);
+  }
+  renderUnsupportedPlugins(input.environment.plugins, input.environment.harness, plan);
+  renderCodexInstructions(input, plan);
+  plan.operations.push({
+    kind: "write_file",
+    path: targetPath(input, ".codex/config.toml"),
+    description: "Codex project config.toml MCP server entries for Kitman AgentEnvironment.",
+    content: serverBlocks.length === 0 && model === undefined ? `# Kitman Codex MCP config generated by kitman sync
+` : `${[...model === undefined ? [] : [`model = ${tomlString(model)}`], ...serverBlocks].join(`
+
+`)}
+`,
+    sources: [Sources.codexMcp, Sources.codexPlugins]
+  });
+}
+function renderCodexInstructions(input, plan) {
+  const lines = [
+    "# Kitman AgentEnvironment",
+    "",
+    "This file is generated by `kitman sync` from non-secret Kitman AgentEnvironment configuration. Do not paste secrets here.",
+    "",
+    "## Synced Harness",
+    "",
+    "- Harness: codex",
+    "- Secrets: not synced; use the referenced local environment variables or existing harness login.",
+    "",
+    "## MCP Servers",
+    "",
+    ...markdownList(input.environment.mcpServers.map((entry) => `${entry.item.name} (${entry.item.policy}, ${entry.item.transport.kind})`)),
+    "",
+    "## Skills",
+    "",
+    ...markdownList(input.environment.skills.map((entry) => `${entry.item.name} (${entry.item.policy})`)),
+    "",
+    "## Plugins",
+    "",
+    ...markdownList(input.environment.plugins.map((entry) => `${entry.item.name} (${entry.item.policy}, ${entry.item.source.kind})`)),
+    "",
+    "## Harness Settings",
+    "",
+    ...markdownList(input.environment.harnessSettings.map((entry) => `${entry.item.key}: ${safeInstructionValue(entry.item.value)} (${entry.item.policy})`)),
+    "",
+    "## Permissions",
+    "",
+    ...markdownList(input.environment.permissions.map((entry) => `${entry.item.key}: ${markdownValue(entry.item.value)} (${entry.item.policy})`)),
+    "",
+    "## Hooks",
+    "",
+    ...markdownList(input.environment.hooks.map((entry) => `${entry.item.name}: ${entry.item.event} -> ${safeCommandValue(entry.item.command, entry.item.args)} (${entry.item.policy})`)),
+    "",
+    "## Runtime Constraints",
+    "",
+    ...markdownList(input.environment.runtimeConstraints.map((entry) => `${entry.item.key}: ${markdownValue(entry.item.value)} (${entry.item.policy})`)),
+    "",
+    "## Sandbox Policy Requirements",
+    "",
+    ...markdownList(input.environment.sandboxPolicyRequirements.map((entry) => `${entry.item.key}: ${markdownValue(entry.item.value)} (${entry.item.policy})`)),
+    "",
+    "## Provider Auth References",
+    "",
+    ...markdownList(input.environment.providerAuthRefs.map((entry) => `${entry.item.provider}: ${entry.item.kind} (${entry.item.policy})`)),
+    "",
+    "## Runner Secret References",
+    "",
+    ...markdownList(input.environment.runnerSecretRefs.map((entry) => `${entry.item.name} (${entry.item.policy}, ${entry.item.source.kind})`)),
+    ""
+  ];
+  plan.operations.push({
+    kind: "write_file",
+    path: targetPath(input, "AGENTS.md"),
+    description: "Codex project instructions summarizing the Kitman-managed AgentEnvironment.",
+    content: `${lines.join(`
+`).trimEnd()}
+`,
+    sources: [Sources.codexSkills, Sources.codexMcp, Sources.codexPlugins]
+  });
+}
+function renderClaudeCode(input, plan) {
+  const mcpServers = objectMap(input.environment.mcpServers, (server) => renderClaudeMcpServer(input, server, plan));
+  renderUnsupportedPlugins(input.environment.plugins, input.environment.harness, plan);
+  const model = renderModelSetting(input, plan);
+  const skillOverrides = Object.fromEntries((input.materializedSkills ?? []).map((skill) => [skill.name, "on"]));
+  if (Object.keys(mcpServers).length > 0 || Object.keys(skillOverrides).length > 0) {
+    plan.operations.push({
+      kind: "write_file",
+      path: targetPath(input, ".mcp.json"),
+      description: "Claude Code project-scoped MCP server config for Kitman AgentEnvironment.",
+      content: json({
+        ...Object.keys(mcpServers).length === 0 ? undefined : { mcpServers },
+        ...Object.keys(skillOverrides).length === 0 ? undefined : { skillOverrides }
+      }),
+      sources: [Sources.claudeMcp, Sources.claudePlugins]
+    });
+  }
+  if (model !== undefined) {
+    plan.operations.push({
+      kind: "write_file",
+      path: targetPath(input, ".claude/settings.json"),
+      description: "Claude Code settings generated from the resolved non-secret model profile.",
+      content: json({ model }),
+      sources: [Sources.claudeMcp]
+    });
+  }
+}
+function renderPi(input, plan) {
+  const credentialName = input.mcpCredentialName?.trim() || "Pi";
+  const model = renderModelSetting(input, plan);
+  const mcpServers = objectMap(input.environment.mcpServers, (server) => renderPiMcpServer(input, server, plan, credentialName));
+  const packages = [
+    ...Object.keys(mcpServers).length === 0 ? [] : ["npm:pi-mcp-adapter"],
+    ...renderPiPlugins(input.environment.plugins, plan)
+  ];
+  if (packages.length > 0 || model !== undefined) {
+    plan.operations.push({
+      kind: "write_file",
+      path: targetPath(input, ".pi/settings.json"),
+      description: "Pi project settings generated from resolved non-secret MCP and model intent.",
+      content: json({
+        ...packages.length === 0 ? undefined : { packages },
+        ...model === undefined ? undefined : { model }
+      }),
+      sources: [Sources.piReadme, Sources.piMcpAdapter]
+    });
+  }
+  plan.operations.push({
+    kind: "write_file",
+    path: targetPath(input, ".pi/mcp.json"),
+    description: "Pi MCP adapter config for Kitman AgentEnvironment MCP servers.",
+    content: json({ mcpServers }),
+    sources: [Sources.piMcpAdapter]
+  });
+}
+function renderPiPlugins(plugins, plan) {
+  const packages = [];
+  for (const plugin of plugins) {
+    if (plugin.item.source.kind === "package") {
+      packages.push(`npm:${packageReference(plugin.item.source.packageName, plugin.item.source.version)}`);
+      continue;
+    }
+    reportUnsupported(plan, plugin.item.policy, `plugin ${plugin.item.name}`, "pi", "Pi package plugins require an npm package source", sourceLabel2(plugin.source));
+  }
+  return [...new Set(packages)];
+}
+function renderOpenCodeMcpServer(input, server, plan) {
+  const transport = server.item.transport;
+  if (transport.kind === "stdio") {
+    const environment = renderJsonEnvMap(transport.env, server.item, "opencode", plan);
+    return {
+      type: "local",
+      command: [
+        resolveKitmanCliMcpCommand(input, server, transport.command),
+        ...resolveKitmanCliMcpArgs(input, server, transport.args ?? [])
+      ],
+      enabled: true,
+      ...environment === undefined ? undefined : { environment }
+    };
+  }
+  const headers = renderJsonHeaders(transport.headers, server.item, "opencode", plan);
+  return {
+    type: "remote",
+    url: transport.url,
+    enabled: true,
+    ...headers === undefined ? undefined : { headers }
+  };
+}
+function renderClaudeMcpServer(input, server, plan) {
+  const transport = server.item.transport;
+  if (transport.kind === "stdio") {
+    const env = renderJsonEnvMap(transport.env, server.item, "claude-code", plan);
+    const args = resolveKitmanCliMcpArgs(input, server, transport.args ?? []);
+    return {
+      type: "stdio",
+      command: transport.command,
+      ...args.length === 0 ? undefined : { args },
+      ...env === undefined ? undefined : { env }
+    };
+  }
+  const headers = renderJsonHeaders(transport.headers, server.item, "claude-code", plan);
+  return {
+    type: "http",
+    url: transport.url,
+    ...headers === undefined ? undefined : { headers }
+  };
+}
+function renderPiMcpServer(input, server, plan, credentialName) {
+  const transport = server.item.transport;
+  if (transport.kind === "stdio") {
+    const env = renderPiEnvMap(transport.env, server.item, plan);
+    const args = resolvePiMcpArgs(input, server, transport.args ?? [], credentialName);
+    return {
+      command: resolveKitmanCliMcpCommand(input, server, transport.command),
+      ...args.length === 0 ? undefined : { args },
+      ...env === undefined ? undefined : { env }
+    };
+  }
+  const headers = renderPiHeaders(transport.headers, server.item, plan);
+  return {
+    url: transport.url,
+    ...headers === undefined ? undefined : { headers }
+  };
+}
+function renderCodexMcpServer(input, server, plan, credentialName) {
+  const key = tomlTableKey(server.item.name);
+  const transport = server.item.transport;
+  const lines = [`[mcp_servers.${key}]`];
+  if (transport.kind === "stdio") {
+    lines.push(`command = ${tomlString(resolveKitmanCliMcpCommand(input, server, transport.command))}`);
+    const args = resolveCodexMcpArgs(input, server, transport.args ?? []);
+    if (server.item.name === "kitman" && !hasNameArgument(args) && credentialName.length > 0) {
+      args.push("--name", credentialName);
+    }
+    if (args.length > 0)
+      lines.push(`args = ${tomlArray(args)}`);
+    const env = renderCodexEnv(transport.env, server.item, plan);
+    if (env.length > 0)
+      lines.push(...env);
+  } else {
+    lines.push(`url = ${tomlString(transport.url)}`);
+    const auth = renderCodexHeaders(transport.headers, server.item, plan);
+    if (auth.length > 0)
+      lines.push(...auth);
+  }
+  lines.push("enabled = true");
+  if (server.item.policy === "required")
+    lines.push("required = true");
+  return lines.join(`
+`);
+}
+function resolveCodexMcpArgs(input, server, args) {
+  return resolveKitmanCliMcpArgs(input, server, args);
+}
+function resolvePiMcpArgs(input, server, args, credentialName) {
+  const resolved = resolveKitmanCliMcpArgs(input, server, args);
+  if (isKitmanCliMcpServer(server) && !hasNameArgument(resolved) && credentialName.length > 0) {
+    resolved.push("--name", credentialName);
+  }
+  return resolved;
+}
+function resolveKitmanCliMcpArgs(input, server, args) {
+  if (!isKitmanCliMcpServer(server))
+    return [...args];
+  return args.map((arg) => arg === "apps/cli/src/index.ts" ? resolveLocalPath(input, arg) : arg);
+}
+function resolveKitmanCliMcpCommand(input, server, command) {
+  if (!isKitmanCliMcpServer(server) || command !== "kitman")
+    return command;
+  if (input.scope !== "user")
+    return command;
+  return input.path.join(input.rootDir ?? input.home ?? ".", ".local", "bin", "kitman");
+}
+function resolveLocalPath(input, path) {
+  return input.path.resolve(input.rootDir ?? ".", path);
+}
+function hasNameArgument(args) {
+  return args.some((item, index) => item === "--name" && args[index + 1] !== undefined);
+}
+function renderOpenCodePlugins(plugins, plan) {
+  const packages = [];
+  for (const plugin of plugins) {
+    if (plugin.item.source.kind === "package") {
+      packages.push(packageReference(plugin.item.source.packageName, plugin.item.source.version));
+      continue;
+    }
+    reportUnsupported(plan, plugin.item.policy, `plugin ${plugin.item.name}`, "opencode", "this writer only has source-verified OpenCode plugin config for package sources", sourceLabel2(plugin.source));
+  }
+  return packages;
+}
+function renderUnsupportedPlugins(plugins, harness, plan) {
+  for (const plugin of plugins) {
+    const sourceKind = plugin.item.source.kind === "package" ? "package sources" : `${plugin.item.source.kind} sources`;
+    reportUnsupported(plan, plugin.item.policy, `plugin ${plugin.item.name}`, harness, `this writer has no source-verified plugin installer for ${sourceKind}`, sourceLabel2(plugin.source));
+  }
+}
+function renderSkillFiles(input, plan) {
+  const materializedSkillNames = new Set((input.materializedSkills ?? []).map((skill) => skill.name));
+  for (const skill of input.environment.skills) {
+    if (materializedSkillNames.has(skill.item.name))
+      continue;
+    const content = skillFileContent(skill, input.environment.harness, plan);
+    if (content === undefined)
+      continue;
+    const path = `${skillBasePath(input.environment.harness)}/${skillSlug(skill.item.name)}/SKILL.md`;
+    plan.operations.push({
+      kind: "write_file",
+      path: targetPath(input, path),
+      description: `Agent skill ${skill.item.name} rendered from Kitman content.`,
+      content,
+      sources: skillSources(skill, input.environment.harness)
+    });
+  }
+}
+function skillFileContent(skill, harness, plan) {
+  if (skill.item.source.kind !== "kitman") {
+    return;
+  }
+  if (skill.item.source.contentMarkdown === undefined) {
+    reportUnsupported(plan, skill.item.policy, `skill ${skill.item.name}`, harness, "this writer can only render Kitman-stored skill content without fetching external registries", sourceLabel2(skill.source));
+    return;
+  }
+  const content = skill.item.source.contentMarkdown.trimEnd();
+  if (content.trimStart().startsWith("---"))
+    return `${content}
+`;
+  return `---
+name: ${skillSlug(skill.item.name)}
+description: ${JSON.stringify(skill.item.name)}
+---
+
+${content}
+`;
+}
+function renderManifest(input, plan) {
+  plan.operations.push({
+    kind: "write_file",
+    path: targetPath(input, manifestFilePathForHarness(input.environment.harness)),
+    description: "Kitman manifest preserving the resolved AgentEnvironment intent and source attribution.",
+    content: json({
+      schemaVersion: 1,
+      generatedBy: "kitman",
+      harness: input.environment.harness,
+      skills: input.environment.skills,
+      plugins: input.environment.plugins,
+      mcpServers: input.environment.mcpServers,
+      harnessSettings: input.environment.harnessSettings,
+      providerAuthRefs: input.environment.providerAuthRefs,
+      runnerSecretRefs: input.environment.runnerSecretRefs,
+      permissions: input.environment.permissions,
+      hooks: input.environment.hooks,
+      runtimeConstraints: input.environment.runtimeConstraints,
+      sandboxPolicyRequirements: input.environment.sandboxPolicyRequirements,
+      materializedSkills: input.materializedSkills ?? [],
+      ...input.syncKit === undefined ? undefined : { syncKitHash: input.syncKit.syncKitHash, kitRefs: input.syncKit.kitRefs },
+      warnings: [...input.environment.warnings, ...plan.warnings.map((warning) => warning.message)]
+    }),
+    sources: [Sources.opencodeMcp, Sources.codexMcp, Sources.claudeMcp, Sources.piReadme]
+  });
+}
+function manifestFilePathForHarness(harness) {
+  return `.kitman/agent-environment.${harness}.manifest.json`;
+}
+function renderJsonEnvMap(env, requirement, harness, plan) {
+  if (env === undefined)
+    return;
+  const rendered = {};
+  for (const [name, value] of Object.entries(env)) {
+    const envName = exactEnvRef(value);
+    if (envName === undefined) {
+      reportUnsupported(plan, requirement.policy, `MCP server ${requirement.name} environment ${name}`, harness, "environment values must use non-secret {env:NAME} references", undefined);
+      continue;
+    }
+    rendered[name] = harness === "claude-code" ? `\${${envName}}` : `{env:${envName}}`;
+  }
+  return Object.keys(rendered).length === 0 ? undefined : rendered;
+}
+function renderJsonHeaders(headers, requirement, harness, plan) {
+  if (headers === undefined)
+    return;
+  const rendered = {};
+  for (const [name, value] of Object.entries(headers)) {
+    const exact = exactEnvRef(value);
+    const bearer = bearerEnvRef(value);
+    if (exact !== undefined) {
+      rendered[name] = harness === "claude-code" ? `\${${exact}}` : `{env:${exact}}`;
+    } else if (bearer !== undefined) {
+      rendered[name] = harness === "claude-code" ? `Bearer \${${bearer}}` : `Bearer {env:${bearer}}`;
+    } else {
+      reportUnsupported(plan, requirement.policy, `MCP server ${requirement.name} header ${name}`, harness, "headers must use non-secret {env:NAME} references", undefined);
+    }
+  }
+  return Object.keys(rendered).length === 0 ? undefined : rendered;
+}
+function renderCodexEnv(env, requirement, plan) {
+  if (env === undefined)
+    return [];
+  const envVars = [];
+  for (const [name, value] of Object.entries(env)) {
+    const envName = exactEnvRef(value);
+    if (envName === undefined || envName !== name) {
+      reportUnsupported(plan, requirement.policy, `MCP server ${requirement.name} environment ${name}`, "codex", "stdio environment values must forward same-named non-secret {env:NAME} references", undefined);
+      continue;
+    }
+    envVars.push(envName);
+  }
+  return envVars.length === 0 ? [] : [`env_vars = ${tomlArray(envVars)}`];
+}
+function renderPiEnvMap(env, requirement, plan) {
+  if (env === undefined)
+    return;
+  const rendered = {};
+  for (const [name, value] of Object.entries(env)) {
+    const envName = exactEnvRef(value);
+    if (envName === undefined) {
+      reportUnsupported(plan, requirement.policy, `MCP server ${requirement.name} environment ${name}`, "pi", "environment values must use non-secret {env:NAME} references", undefined);
+      continue;
+    }
+    rendered[name] = `\${${envName}}`;
+  }
+  return Object.keys(rendered).length === 0 ? undefined : rendered;
+}
+function renderPiHeaders(headers, requirement, plan) {
+  if (headers === undefined)
+    return;
+  const rendered = {};
+  for (const [name, value] of Object.entries(headers)) {
+    const exact = exactEnvRef(value);
+    const bearer = bearerEnvRef(value);
+    if (exact !== undefined) {
+      rendered[name] = `\${${exact}}`;
+    } else if (bearer !== undefined) {
+      rendered[name] = `Bearer \${${bearer}}`;
+    } else {
+      reportUnsupported(plan, requirement.policy, `MCP server ${requirement.name} header ${name}`, "pi", "headers must use non-secret {env:NAME} references", undefined);
+    }
+  }
+  return Object.keys(rendered).length === 0 ? undefined : rendered;
+}
+function renderCodexHeaders(headers, requirement, plan) {
+  if (headers === undefined)
+    return [];
+  const envHeaders = [];
+  let bearerTokenEnvVar;
+  for (const [name, value] of Object.entries(headers)) {
+    const exact = exactEnvRef(value);
+    const bearer = bearerEnvRef(value);
+    if (name.toLowerCase() === "authorization" && bearer !== undefined) {
+      bearerTokenEnvVar = bearer;
+    } else if (exact !== undefined) {
+      envHeaders.push(`${tomlKeyValue(name)} = ${tomlString(exact)}`);
+    } else {
+      reportUnsupported(plan, requirement.policy, `MCP server ${requirement.name} header ${name}`, "codex", "headers must use non-secret {env:NAME} references", undefined);
+    }
+  }
+  const lines = [];
+  if (bearerTokenEnvVar !== undefined)
+    lines.push(`bearer_token_env_var = ${tomlString(bearerTokenEnvVar)}`);
+  if (envHeaders.length > 0)
+    lines.push(`env_http_headers = { ${envHeaders.join(", ")} }`);
+  return lines;
+}
+function reportUnsupported(plan, policy, label, harness, reason, source) {
+  const issue = {
+    message: `${policy === "required" ? "Unsupported required" : "Skipping recommended"} ${label} for ${harness} because ${reason}.`,
+    ...source === undefined ? undefined : { source }
+  };
+  if (policy === "required")
+    plan.issues.push(issue);
+  else
+    plan.warnings.push(issue);
+}
+function objectMap(items, render) {
+  return Object.fromEntries(items.flatMap((item) => {
+    const rendered = render(item);
+    return rendered === undefined ? [] : [[item.item.name, rendered]];
+  }));
+}
+function skillBasePath(harness) {
+  if (harness === "claude-code")
+    return ".claude/skills";
+  if (harness === "codex")
+    return ".codex/skills";
+  if (harness === "pi")
+    return ".pi/skills";
+  return ".agents/skills";
+}
+function packageReference(packageName, version) {
+  return version === undefined ? packageName : `${packageName}@${version}`;
+}
+function skillSourcesForHarness(harness) {
+  if (harness === "opencode")
+    return [Sources.opencodeSkills];
+  if (harness === "codex")
+    return [Sources.codexSkills];
+  if (harness === "claude-code")
+    return [Sources.claudePlugins];
+  if (harness === "pi")
+    return [Sources.piReadme];
+  return [];
+}
+function skillSources(skill, harness) {
+  if (skill.item.source.kind === "skills_sh")
+    return [Sources.skillsSh];
+  return skillSourcesForHarness(harness);
+}
+function skillSlug(name) {
+  const slug = name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return slug.length === 0 ? "kitman-skill" : slug;
+}
+function isUnsafeConfigWritePath(path) {
+  if (path.length === 0 || path.includes("\x00"))
+    return true;
+  if (path.startsWith("/") || /^[A-Za-z]:[\\/]/u.test(path))
+    return false;
+  return path.split(/[\\/]/u).some((segment) => segment === "..");
+}
+function targetPath(input, relativePath) {
+  if (input.scope === "user")
+    return userTargetPath(input, relativePath);
+  return input.rootDir === undefined ? relativePath : input.path.join(input.rootDir, relativePath);
+}
+function userTargetPath(input, relativePath) {
+  const home = input.rootDir ?? input.home;
+  if (home === undefined)
+    return relativePath;
+  if (input.environment.harness === "opencode" && relativePath === "opencode.json")
+    return input.path.join(home, ".config/opencode/opencode.json");
+  if (input.environment.harness === "codex" && relativePath === ".codex/config.toml")
+    return input.path.join(home, ".codex/config.toml");
+  if (input.environment.harness === "codex" && relativePath === "AGENTS.md")
+    return input.path.join(home, ".codex/AGENTS.md");
+  if (input.environment.harness === "claude-code" && relativePath === ".mcp.json")
+    return input.path.join(home, ".claude/.mcp.json");
+  if (input.environment.harness === "pi" && relativePath === ".pi/settings.json")
+    return input.path.join(home, ".pi/agent/settings.json");
+  if (input.environment.harness === "pi" && relativePath === ".pi/mcp.json")
+    return input.path.join(home, ".pi/agent/mcp.json");
+  if (input.environment.harness === "pi" && relativePath.startsWith(".pi/skills/"))
+    return input.path.join(home, ".pi/agent/skills", relativePath.slice(".pi/skills/".length));
+  return input.path.join(home, relativePath);
+}
+function exactEnvRef(value) {
+  const match = /^\{env:([A-Z_][A-Z0-9_]*)\}$/.exec(value);
+  return match?.[1];
+}
+function bearerEnvRef(value) {
+  const match = /^Bearer \{env:([A-Z_][A-Z0-9_]*)\}$/.exec(value);
+  return match?.[1];
+}
+function tomlTableKey(value) {
+  return /^[A-Za-z0-9_-]+$/.test(value) ? value : tomlString(value);
+}
+function tomlKeyValue(value) {
+  return /^[A-Za-z0-9_-]+$/.test(value) ? value : tomlString(value);
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function tomlArray(values) {
+  return `[${values.map(tomlString).join(", ")}]`;
+}
+function json(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function markdownList(items) {
+  if (items.length === 0)
+    return ["- None."];
+  return items.map((item) => `- ${item}`);
+}
+var UnsafeInstructionText = /(?:Bearer\s|(?:sk-|ghp_|glpat-)|secret|token|password|api[_ -]?key|(?:^|[\s])(?:\/|~\/|[A-Za-z]:\\\\))/iu;
+function safeInstructionValue(value) {
+  const text = isString2(value) ? value : JSON.stringify(value);
+  if (text === undefined || UnsafeInstructionText.test(text))
+    return "[REDACTED]";
+  return text.slice(0, 240);
+}
+function safeCommandValue(command, args) {
+  return safeInstructionValue([command, ...args ?? []].join(" "));
+}
+function markdownValue(value) {
+  return safeInstructionValue(value);
+}
+function isKitmanCliMcpServer(server) {
+  const transport = server.item.transport;
+  if (server.item.name !== "kitman" || transport.kind !== "stdio")
+    return false;
+  if (transport.command === "kitman")
+    return transport.args?.[0] === "mcp";
+  if (transport.command !== "bun")
+    return false;
+  const args = transport.args ?? [];
+  return args.some((arg) => arg.endsWith("apps/cli/src/index.ts") || arg.endsWith("kitman")) && args.includes("mcp");
+}
+function sourceLabel2(source) {
+  if (source.label !== undefined)
+    return source.label;
+  if (source.kind === "workspace_kit" || source.kind === "project_kit")
+    return `${source.kind}:${source.kitId}`;
+  if (source.kind === "user_preferences")
+    return `${source.kind}:${source.userId}`;
+  if (source.kind === "step_attempt_override")
+    return `${source.kind}:${source.stepAttemptId}`;
+  return source.kind;
+}
+// packages/agent-runtime/src/profile.ts
+var BuiltInLaunchProfiles = [
+  { id: "opencode", name: "OpenCode", command: "opencode", verification: { invocation: "verified", mcp: "verified" } },
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    command: "claude",
+    verification: { invocation: "verified", mcp: "verified" }
+  },
+  { id: "codex", name: "Codex", command: "codex", verification: { invocation: "verified", mcp: "verified" } },
+  { id: "pi", name: "Pi", command: "pi", verification: { invocation: "unverified", mcp: "unverified" } }
+];
+function listBuiltInLaunchProfiles() {
+  return BuiltInLaunchProfiles;
+}
+// packages/agent-runtime/src/repo-materializer.ts
+class RepoMaterializationError extends TaggedError("RepoMaterializationError") {
+}
+function repositoryUrl(repoBinding) {
+  return repoBinding.repositoryUrl ?? `https://${repoBinding.host}/${repoBinding.owner}/${repoBinding.name}.git`;
+}
+// packages/agent-runtime/src/skill-materializer.ts
+class AgentEnvironmentMaterializationError extends TaggedError("AgentEnvironmentMaterializationError") {
+  get message() {
+    return `AgentEnvironment materialization failed: ${this.issues.map((issue) => issue.message).join("; ")}`;
+  }
+}
+
+class SkillMaterializationRefused extends TaggedError("SkillMaterializationRefused") {
+}
+var previewAgentEnvironmentMaterialization = fnUntraced(function* (input) {
+  const path = yield* Path;
+  const home = input.rootDir ?? (yield* optionalEnv("HOME")) ?? ".";
+  const harness = input.environment.harness;
+  const sourceRoot = input.cacheRoot ?? path.join(home, ".kitman", "agent-environment", "skills");
+  const targetRoot = skillBasePath2(path, harness, input.scope, input.rootDir, home);
+  const operations = [];
+  const materializedSkills = [];
+  const warnings = [];
+  for (const skill of input.environment.skills) {
+    const skillKey = skillIdentity(skill.item);
+    const source = skill.item.source;
+    const skip = (message) => {
+      const issue = { message, skillName: skill.item.name, skillKey };
+      if (skill.item.policy === "required")
+        return new AgentEnvironmentMaterializationError({ issues: [issue] });
+      warnings.push(issue);
+      return;
+    };
+    const refusal = source.kind !== "kitman" ? skip(input.noInstall === true ? `Skipping materialization for ${skill.item.name} because sync was run with noInstall.` : `Materializing ${skill.item.name} from ${source.kind} is not supported; only Kitman skills are materialized.`) : source.contentMarkdown === undefined ? skip(`Kitman skill ${skill.item.name} has no contentMarkdown to materialize.`) : undefined;
+    if (refusal !== undefined)
+      return yield* refusal;
+    if (source.kind !== "kitman" || source.contentMarkdown === undefined)
+      continue;
+    const skillPath = path.join(sourceRoot, "kitman", hashSegment(source.skillId ?? source.name ?? skill.item.name), skillSlug2(skill.item.name));
+    operations.push({
+      kind: "write_skill",
+      skillName: skill.item.name,
+      skillKey,
+      path: path.join(skillPath, "SKILL.md"),
+      content: skillMarkdown(skill.item.name, source.contentMarkdown)
+    }, {
+      kind: "symlink_skill",
+      skillName: skill.item.name,
+      skillKey,
+      sourcePath: skillPath,
+      targetPath: path.join(targetRoot, `${skillSlug2(skill.item.name)}-${hashSegment(skillKey)}`),
+      sourceRoot,
+      targetRoot
+    });
+    materializedSkills.push({ name: skill.item.name, key: skillKey, harness, source, skillPath, managed: true });
+  }
+  return { harness, operations, materializedSkills, warnings };
+});
+var applyAgentEnvironmentMaterialization = fnUntraced(function* (plan) {
+  for (const operation of plan.operations) {
+    if (operation.kind === "write_skill")
+      yield* writeSkill(plan, operation);
+    else
+      yield* exposeSkill(operation);
+  }
+  return plan;
+});
+var refuse = (message) => fail4(new SkillMaterializationRefused({ message }));
+var writeSkill = (plan, operation) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const boundary = plan.operations.find((candidate) => candidate.kind === "symlink_skill" && candidate.skillKey === operation.skillKey);
+  if (boundary === undefined)
+    return yield* refuse("SKILL_SYMLINK_BOUNDARY_MISSING");
+  const root = path.resolve(boundary.sourceRoot);
+  const target = path.resolve(operation.path);
+  if (!isPathWithin(path, root, target) || target === root)
+    return yield* refuse("SKILL_WRITE_OUTSIDE_ROOT");
+  yield* assertNoSymlinkComponents(path.dirname(target), "SKILL_WRITE_OUTSIDE_ROOT");
+  if (yield* isSymbolicLink(target))
+    return yield* refuse("SKILL_WRITE_SYMLINK");
+  yield* fs.makeDirectory(path.dirname(target), { recursive: true });
+  yield* fs.writeFileString(target, operation.content);
+});
+var exposeSkill = (operation) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  if (operation.sourceRoot.length === 0 || operation.targetRoot.length === 0)
+    return yield* refuse("SKILL_SYMLINK_BOUNDARY_MISSING");
+  yield* assertNoSymlinkComponents(operation.sourceRoot, "SKILL_SOURCE_SYMLINK_PARENT");
+  const sourceRoot = yield* realPathOr(operation.sourceRoot, "SKILL_SOURCE_ROOT_UNAVAILABLE");
+  const sourcePath = yield* realPathOr(operation.sourcePath, "SKILL_SOURCE_UNAVAILABLE");
+  if (!isPathWithin(path, sourceRoot, sourcePath))
+    return yield* refuse("SKILL_SOURCE_OUTSIDE_ROOT");
+  const skillDocument = path.join(sourcePath, "SKILL.md");
+  if ((yield* fs.exists(skillDocument)) && !isPathWithin(path, sourcePath, yield* fs.realPath(skillDocument)))
+    return yield* refuse("SKILL_SOURCE_OUTSIDE_ROOT");
+  const targetRoot = path.resolve(operation.targetRoot);
+  const targetPath = path.resolve(operation.targetPath);
+  const targetParent = path.dirname(targetPath);
+  if (!isPathWithin(path, targetRoot, targetPath) || !isPathWithin(path, targetRoot, targetParent))
+    return yield* refuse("SKILL_TARGET_OUTSIDE_ROOT");
+  yield* assertNoSymlinkComponents(targetParent, "SKILL_TARGET_SYMLINK_PARENT");
+  yield* fs.makeDirectory(targetParent, { recursive: true });
+  if (yield* isSymbolicLink(targetPath)) {
+    const linkTarget = yield* fs.readLink(targetPath);
+    const resolvedLink = path.resolve(targetParent, linkTarget);
+    if ((yield* fs.exists(resolvedLink)) && (yield* fs.realPath(resolvedLink)) === sourcePath)
+      return;
+    if (!linkTarget.includes("/.kitman/agent-environment/skills/"))
+      return yield* refuse(`Refusing to replace non-Kitman skill symlink: ${targetPath}`);
+    yield* fs.remove(targetPath);
+  } else if (yield* fs.exists(targetPath)) {
+    return yield* refuse(`Refusing to replace user-owned skill path: ${targetPath}`);
+  }
+  yield* fs.symlink(path.resolve(operation.sourcePath), targetPath);
+});
+var isSymbolicLink = (file) => flatMap(FileSystem, (fs) => fs.readLink(file).pipe(as(true), orElseSucceed(() => false)));
+var realPathOr = (file, reason) => flatMap(FileSystem, (fs) => fs.realPath(file).pipe(mapError(() => new SkillMaterializationRefused({ message: reason }))));
+var assertNoSymlinkComponents = (file, reason) => gen(function* () {
+  const path = yield* Path;
+  for (let current = path.resolve(file);; current = path.dirname(current)) {
+    if (yield* isSymbolicLink(current))
+      return yield* refuse(reason);
+    if (path.dirname(current) === current)
+      return;
+  }
+});
+function isPathWithin(path, root, candidate) {
+  const remainder = path.relative(path.resolve(root), path.resolve(candidate));
+  return remainder === "" || remainder !== ".." && !remainder.startsWith(`..${path.sep}`) && !path.isAbsolute(remainder);
+}
+function skillIdentity(skill) {
+  const source = skill.source;
+  if (source.kind === "skills_sh")
+    return `skills_sh:${source.slug}${source.version === undefined ? "" : `@${source.version}`}:${skill.name}`;
+  if (source.kind === "kitman")
+    return `kitman:${source.skillId ?? source.name ?? skill.name}:${skill.name}`;
+  if (source.kind === "git")
+    return `git:${source.url}#${source.ref}:${source.path ?? ""}:${skill.name}`;
+  if (source.kind === "package")
+    return `package:${source.packageName}@${source.version}:${source.path ?? ""}:${skill.name}`;
+  if (source.kind === "url")
+    return `url:${source.sha256}:${skill.name}`;
+  return `local_path:${source.path}:${skill.name}`;
+}
+var ProjectSkillDirectories = {
+  "claude-code": ".claude/skills",
+  codex: ".agents/skills",
+  opencode: ".agents/skills",
+  pi: ".pi/skills"
+};
+function skillBasePath2(path, harness, scope, rootDir, home) {
+  return scope === "user" ? path.join(home, ".agents", "skills") : path.join(rootDir ?? ".", ProjectSkillDirectories[harness]);
+}
+function skillMarkdown(name, contentMarkdown) {
+  const content = contentMarkdown.trimEnd();
+  if (content.trimStart().startsWith("---"))
+    return `${content}
+`;
+  return `---
+name: ${skillSlug2(name)}
+description: ${JSON.stringify(name)}
+---
+
+${content}
+`;
+}
+function skillSlug2(name) {
+  const slug = name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return slug.length === 0 ? "kitman-skill" : slug;
+}
+function hashSegment(value) {
+  return sha256(value).slice(0, 16);
+}
+// node_modules/.bun/@effect+platform-node-shared@4.0.4+b8cbb99ebc524863/node_modules/@effect/platform-node-shared/dist/NodeSocket.js
+import { Buffer as Buffer2 } from "buffer";
+import * as Net from "net";
+import * as Tls from "tls";
+import * as NodeWS from "ws";
+var isDeno = "Deno" in globalThis;
+var readAvailable = (conn) => {
+  const first = conn.read();
+  if (first === null)
+    return;
+  const second = conn.read();
+  if (second === null)
+    return [first];
+  const out = [first, second];
+  let chunk;
+  while ((chunk = conn.read()) !== null) {
+    out.push(chunk);
+  }
+  return out;
+};
+var toBuffers = (input) => map2(ensure(input), (value) => Buffer2.from(value));
+var closeSocket = (conn, isOpen) => {
+  if (conn.closed !== false)
+    return;
+  if (!isOpen || !("destroySoon" in conn)) {
+    conn.destroy();
+  } else {
+    conn.destroySoon();
+  }
+};
+var makeNet = (options) => fromDuplex(contextWith((context) => {
+  let conn;
+  let isOpen = false;
+  return flatMap(addFinalizer(get(context, Scope), sync(() => {
+    if (!conn)
+      return;
+    closeSocket(conn, isOpen);
+  })), () => callback((resume) => {
+    conn = Net.createConnection(options);
+    conn.once("connect", () => {
+      isOpen = true;
+      resume(succeed5(conn));
+    });
+    conn.on("error", (cause) => {
+      resume(fail4(new SocketError({
+        reason: new SocketOpenError({
+          kind: "Unknown",
+          cause
+        })
+      })));
+    });
+  }));
+}), options);
+var fromDuplex = (open, options) => withFiber((fiber) => {
+  let currentSocket;
+  const latch = makeUnsafe4(false);
+  const openServices = fiber.context;
+  const isServer = options?.tlsServer === true;
+  const secureEvent = isServer ? "secure" : "secureConnect";
+  const reader = gen(function* () {
+    const scope2 = yield* scope;
+    let conn = yield* provide(open, scope2).pipe(options?.openTimeout !== undefined ? timeoutOrElse({
+      duration: options.openTimeout,
+      orElse: () => fail4(new SocketError({
+        reason: new SocketOpenError({
+          kind: "Timeout",
+          cause: new Error("Connection timed out")
+        })
+      }))
+    }) : identity);
+    let error;
+    let waiter;
+    let pending;
+    let reading = false;
+    let closed = false;
+    let upgradeAvailable = true;
+    function drain() {
+      if (waiter === undefined || reading)
+        return;
+      let chunk = pending;
+      pending = undefined;
+      if (chunk === undefined && !closed) {
+        reading = true;
+        try {
+          chunk = readAvailable(conn);
+        } finally {
+          reading = false;
+        }
+      }
+      if (closed)
+        chunk = undefined;
+      if (waiter === undefined) {
+        pending = chunk;
+        return;
+      }
+      const result = chunk !== undefined ? succeed5(chunk) : error !== undefined ? fail4(error) : undefined;
+      if (result === undefined)
+        return;
+      const resume = waiter;
+      waiter = undefined;
+      resume(result);
+    }
+    function end(err) {
+      error ??= err;
+      drain();
+    }
+    function close(err) {
+      error ??= err;
+      closed = true;
+      pending = undefined;
+      drain();
+    }
+    function onEnd() {
+      end(new SocketError({
+        reason: new SocketCloseError({
+          code: 1000
+        })
+      }));
+    }
+    function onError(cause) {
+      close(new SocketError({
+        reason: new SocketReadError({
+          cause
+        })
+      }));
+    }
+    function onClose(hadError) {
+      const err = new SocketError({
+        reason: new SocketCloseError({
+          code: hadError ? 1006 : 1000
+        })
+      });
+      if (hadError)
+        close(err);
+      else
+        end(err);
+    }
+    function attachReadListeners(conn) {
+      conn.on("readable", drain);
+      conn.on("end", onEnd);
+      conn.on("error", onError);
+      conn.on("close", onClose);
+    }
+    function detachReadListeners(conn) {
+      conn.off("readable", drain);
+      conn.off("end", onEnd);
+      conn.off("error", onError);
+      conn.off("close", onClose);
+    }
+    if (!isDeno)
+      conn.pause();
+    attachReadListeners(conn);
+    yield* addFinalizer(scope2, sync(() => {
+      close(new SocketError({
+        reason: new SocketCloseError({
+          code: 1006
+        })
+      }));
+      detachReadListeners(conn);
+      latch.closeUnsafe();
+      currentSocket = undefined;
+      upgradeAvailable = false;
+    }));
+    currentSocket = conn;
+    latch.openUnsafe();
+    const pull = callback((resume) => {
+      waiter = resume;
+      drain();
+      if (waiter !== resume)
+        return;
+      return sync(() => {
+        if (waiter === resume)
+          waiter = undefined;
+      });
+    });
+    const upgrade = (upgradeOptions = {}) => suspend(() => {
+      if (!upgradeAvailable) {
+        return fail4(new SocketError({
+          reason: new SocketUpgradeError({
+            cause: new Error("socket is already upgraded or closed")
+          })
+        }));
+      }
+      const hasKey = upgradeOptions.key !== undefined;
+      const hasCert = upgradeOptions.cert !== undefined;
+      if (isServer && (!hasKey || !hasCert) || hasKey !== hasCert) {
+        return fail4(new SocketError({
+          reason: new SocketUpgradeError({
+            cause: new Error(isServer ? "server TLS upgrade requires both key and cert" : "TLS upgrade credentials must include both key and cert")
+          })
+        }));
+      }
+      return callback((resume) => {
+        const raw = conn;
+        detachReadListeners(raw);
+        let tls;
+        try {
+          const secureContext = Tls.createSecureContext({
+            key: upgradeOptions.key === undefined ? undefined : map2(ensure(upgradeOptions.key), (value2) => Buffer2.from(value(value2))),
+            cert: upgradeOptions.cert === undefined ? undefined : toBuffers(upgradeOptions.cert),
+            ca: upgradeOptions.ca === undefined ? undefined : toBuffers(upgradeOptions.ca),
+            passphrase: upgradeOptions.passphrase === undefined ? undefined : value(upgradeOptions.passphrase)
+          });
+          const tlsOptions = {
+            secureContext,
+            ALPNProtocols: upgradeOptions.alpnProtocols === undefined ? undefined : [...upgradeOptions.alpnProtocols],
+            requestCert: upgradeOptions.requestCert,
+            rejectUnauthorized: upgradeOptions.rejectUnauthorized
+          };
+          tls = isServer ? new Tls.TLSSocket(raw, {
+            ...tlsOptions,
+            isServer: true
+          }) : Tls.connect({
+            ...tlsOptions,
+            servername: upgradeOptions.servername,
+            socket: raw
+          });
+        } catch (cause) {
+          attachReadListeners(raw);
+          resume(fail4(new SocketError({
+            reason: new SocketUpgradeError({
+              cause
+            })
+          })));
+          return;
+        }
+        conn = tls;
+        currentSocket = tls;
+        tls.pause();
+        function cleanup() {
+          tls.off(secureEvent, succeed);
+          tls.off("error", failUpgrade);
+          tls.off("close", onUpgradeClose);
+        }
+        function succeed() {
+          cleanup();
+          upgradeAvailable = false;
+          attachReadListeners(tls);
+          resume(void_2);
+        }
+        function failUpgrade(cause) {
+          cleanup();
+          const upgradeError = new SocketError({
+            reason: new SocketUpgradeError({
+              cause
+            })
+          });
+          close(upgradeError);
+          resume(fail4(upgradeError));
+        }
+        function onUpgradeClose() {
+          failUpgrade(new Error("socket closed during TLS upgrade"));
+        }
+        tls.once(secureEvent, succeed);
+        tls.once("error", failUpgrade);
+        tls.once("close", onUpgradeClose);
+        return sync(() => {
+          cleanup();
+          close(new SocketError({
+            reason: new SocketCloseError({
+              code: 1006
+            })
+          }));
+          tls.destroy();
+        });
+      });
+    });
+    return {
+      pull,
+      upgrade
+    };
+  }).pipe(updateContext((input) => merge(openServices, input)));
+  const awaitDrain = (conn) => callback((resume) => {
+    function cleanup() {
+      conn.off("drain", onDrain);
+      conn.off("error", onError);
+      conn.off("close", onClose);
+    }
+    function onDrain() {
+      cleanup();
+      resume(void_2);
+    }
+    function onError(cause) {
+      cleanup();
+      resume(fail4(new SocketError({
+        reason: new SocketWriteError({
+          cause
+        })
+      })));
+    }
+    function onClose() {
+      cleanup();
+      resume(fail4(new SocketError({
+        reason: new SocketWriteError({
+          cause: new Error("socket closed")
+        })
+      })));
+    }
+    conn.on("drain", onDrain);
+    conn.on("error", onError);
+    conn.on("close", onClose);
+    return sync(cleanup);
+  });
+  const write = (chunk) => suspend(() => {
+    const conn = currentSocket;
+    if (conn === undefined)
+      return latch.whenOpen(write(chunk));
+    if (isCloseEvent(chunk)) {
+      conn.destroy(chunk.code > 1000 ? new Error(`closed with code ${chunk.code}`) : undefined);
+      return void_2;
+    }
+    try {
+      return conn.write(chunk) ? void_2 : awaitDrain(conn);
+    } catch (cause) {
+      return fail4(new SocketError({
+        reason: new SocketWriteError({
+          cause
+        })
+      }));
+    }
+  });
+  const writeAll = (chunks) => suspend(() => {
+    const conn = currentSocket;
+    if (conn === undefined)
+      return latch.whenOpen(writeAll(chunks));
+    let needsDrain = false;
+    try {
+      if (chunks.length === 1) {
+        needsDrain = !conn.write(chunks[0]);
+      } else {
+        conn.cork();
+        try {
+          for (let i = 0;i < chunks.length; i++) {
+            needsDrain = !conn.write(chunks[i]) || needsDrain;
+          }
+        } finally {
+          conn.uncork();
+        }
+      }
+    } catch (cause) {
+      return fail4(new SocketError({
+        reason: new SocketWriteError({
+          cause
+        })
+      }));
+    }
+    return needsDrain ? awaitDrain(conn) : void_2;
+  });
+  const writer = acquireRelease(succeed5({
+    write,
+    writeAll
+  }), () => sync(() => {
+    if (!currentSocket || currentSocket.writableEnded)
+      return;
+    currentSocket.end();
+  }));
+  return succeed5(make4({
+    reader,
+    writer
+  }));
+});
+// packages/agent-runtime/src/herdr-socket-client.ts
+var HERDR_SOCKET_PROTOCOL = 22;
+var HERDR_SOCKET_MAX_FRAME_BYTES = 64 * 1024;
+var HerdrSocketMethods = [
+  "session.snapshot",
+  "agent.list",
+  "pane.list",
+  "workspace.list",
+  "workspace.create",
+  "tab.list",
+  "tab.create",
+  "agent.start",
+  "agent.prompt",
+  "agent.wait",
+  "pane.read",
+  "pane.send_text",
+  "pane.send_keys",
+  "agent.send_keys",
+  "pane.close"
+];
+var ExpectedResultTypes = {
+  "session.snapshot": ["session_snapshot"],
+  "agent.list": ["agent_list"],
+  "pane.list": ["pane_list"],
+  "workspace.list": ["workspace_list"],
+  "workspace.create": ["workspace_created"],
+  "tab.list": ["tab_list"],
+  "tab.create": ["tab_created"],
+  "agent.start": ["agent_started"],
+  "agent.prompt": ["agent_prompted"],
+  "agent.wait": ["agent_info"],
+  "pane.read": ["pane_read"],
+  "pane.send_text": ["ok"],
+  "pane.send_keys": ["ok"],
+  "agent.send_keys": ["ok"],
+  "pane.close": ["ok"]
+};
+var isHerdrSocketMethod = (method) => HerdrSocketMethods.some((candidate) => candidate === method);
+
+class HerdrSocketError extends TaggedError("HerdrSocketError") {
+}
+var fail2 = (message) => new HerdrSocketError({ message });
+
+class HerdrSocketClient {
+  socketPath;
+  requestTimeoutMs;
+  maxFrameBytes;
+  closed = false;
+  constructor(options) {
+    if (options.socketPath.length === 0)
+      throw new TypeError("herdr_socket_path_invalid");
+    this.socketPath = options.socketPath;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 30000;
+    this.maxFrameBytes = options.maxFrameBytes ?? HERDR_SOCKET_MAX_FRAME_BYTES;
+    if (!Number.isInteger(this.requestTimeoutMs) || this.requestTimeoutMs < 1)
+      throw new TypeError("herdr_request_timeout_invalid");
+    if (!Number.isInteger(this.maxFrameBytes) || this.maxFrameBytes < 128)
+      throw new TypeError("herdr_frame_limit_invalid");
+  }
+  request(method, params) {
+    return suspend(() => {
+      if (!isHerdrSocketMethod(method))
+        return fail4(fail2(`herdr_method_not_allowed:${method}`));
+      if (!isRecord(params))
+        return fail4(fail2("herdr_request_params_invalid"));
+      const unbounded = boundedValueViolation(params, this.maxFrameBytes);
+      if (unbounded !== undefined)
+        return fail4(fail2(unbounded));
+      if (this.closed)
+        return fail4(fail2("herdr_client_closed"));
+      return this.exchange(method, params);
+    });
+  }
+  sessionSnapshot() {
+    return flatMap(this.request("session.snapshot", {}), (result) => {
+      const snapshot = isRecord(result) && result.type === "session_snapshot" ? result.snapshot : undefined;
+      if (!isRecord(snapshot) || !isString2(snapshot.version) || !isNumber(snapshot.protocol) || !Number.isInteger(snapshot.protocol) || !Array.isArray(snapshot.workspaces) || !Array.isArray(snapshot.tabs) || !Array.isArray(snapshot.panes) || !Array.isArray(snapshot.layouts) || !Array.isArray(snapshot.agents))
+        return fail4(fail2("herdr_session_snapshot_invalid"));
+      if (snapshot.protocol !== HERDR_SOCKET_PROTOCOL)
+        return fail4(fail2("herdr_protocol_mismatch"));
+      return succeed5({
+        version: snapshot.version,
+        protocol: snapshot.protocol,
+        workspaces: snapshot.workspaces,
+        tabs: snapshot.tabs,
+        panes: snapshot.panes,
+        layouts: snapshot.layouts,
+        agents: snapshot.agents
+      });
+    });
+  }
+  close() {
+    return sync(() => {
+      this.closed = true;
+    });
+  }
+  exchange(method, params) {
+    const id = createId();
+    const frame = `${encodeUnknownJsonStringSync({ id, method, params })}
+`;
+    const maxFrameBytes = this.maxFrameBytes;
+    const socketPath = this.socketPath;
+    if (Buffer.byteLength(frame, "utf8") > maxFrameBytes)
+      return fail4(fail2("herdr_request_too_large"));
+    return gen(function* () {
+      const socket = yield* makeNet({ path: socketPath });
+      const pull = yield* readerString(socket).pipe(mapError(() => fail2("herdr_socket_connect_failed")));
+      const writer = yield* socket.writer;
+      yield* writer.write(frame).pipe(mapError(() => fail2("herdr_socket_write_failed")));
+      let buffer = "";
+      for (;; ) {
+        const chunks = yield* pull.pipe(mapError(() => fail2("herdr_socket_closed")));
+        buffer += chunks.join("");
+        for (let newline = buffer.indexOf(`
+`);newline >= 0; newline = buffer.indexOf(`
+`)) {
+          const line = buffer.slice(0, newline);
+          buffer = buffer.slice(newline + 1);
+          const response = parseResponseLine(line, id, method, maxFrameBytes);
+          if (response instanceof HerdrSocketError)
+            return yield* response;
+          if (response !== undefined)
+            return response;
+        }
+        if (Buffer.byteLength(buffer, "utf8") > maxFrameBytes)
+          return yield* fail2("herdr_response_too_large");
+      }
+    }).pipe(scoped, timeoutOrElse({
+      duration: millis(this.requestTimeoutMs),
+      orElse: () => fail4(fail2("herdr_request_timeout"))
+    }));
+  }
+}
+function parseResponseLine(line, id, method, maxFrameBytes) {
+  if (Buffer.byteLength(line, "utf8") > maxFrameBytes)
+    return fail2("herdr_response_too_large");
+  const value = getOrUndefined(decodeJsonStringOption(line));
+  if (value === undefined || !isRecord(value) || boundedValueViolation(value, maxFrameBytes) !== undefined)
+    return fail2("herdr_response_invalid");
+  if (isString2(value.event) || value.id !== id)
+    return;
+  if (isRecord(value.error)) {
+    const code = isString2(value.error.code) && /^[A-Za-z0-9_.-]{1,80}$/u.test(value.error.code) ? value.error.code : "unknown";
+    return fail2(`herdr_remote_error:${code}`);
+  }
+  const result = value.result;
+  if (result === undefined || !isRecord(result) || !isString2(result.type))
+    return fail2("herdr_response_invalid");
+  return ExpectedResultTypes[method].some((type) => type === result.type) ? result : fail2("herdr_response_invalid");
+}
+function boundedValueViolation(value, maxBytes, depth = 0) {
+  if (depth > 16)
+    return "herdr_value_too_deep";
+  if (isString2(value))
+    return Buffer.byteLength(value, "utf8") > maxBytes ? "herdr_value_too_large" : undefined;
+  if (value === null || isBoolean(value))
+    return;
+  if (isNumber(value))
+    return Number.isFinite(value) ? undefined : "herdr_value_invalid";
+  if (Array.isArray(value)) {
+    if (value.length > 1000)
+      return "herdr_value_too_large";
+    for (const item of value) {
+      const violation = boundedValueViolation(item, maxBytes, depth + 1);
+      if (violation !== undefined)
+        return violation;
+    }
+    return;
+  }
+  if (!isRecord(value))
+    return "herdr_value_invalid";
+  const keys = Object.keys(value);
+  if (keys.length > 200)
+    return "herdr_value_too_large";
+  for (const key of keys) {
+    if (Buffer.byteLength(key, "utf8") > 240)
+      return "herdr_value_invalid";
+    const violation = boundedValueViolation(value[key], maxBytes, depth + 1);
+    if (violation !== undefined)
+      return violation;
+  }
+  return;
+}
+function isRecord(value) {
+  return isObject(value) && value !== null && !Array.isArray(value);
+}
+// packages/agent-runtime/src/herdr-server-supervisor.ts
+class HerdrServerError extends TaggedError("HerdrServerError") {
+}
+var fail3 = (message) => new HerdrServerError({ message });
+
+class HerdrServerSupervisor {
+  runnerId;
+  options;
+  readinessTimeoutMs;
+  runtimeValue;
+  owned;
+  client;
+  started = false;
+  attachedToExistingServer = false;
+  constructor(options) {
+    if (!/^[A-Za-z0-9._:-]{1,240}$/u.test(options.runnerId))
+      throw new TypeError("herdr_runner_id_invalid");
+    this.runnerId = options.runnerId;
+    this.options = options;
+    this.readinessTimeoutMs = options.readinessTimeoutMs ?? 30000;
+    if (!Number.isInteger(this.readinessTimeoutMs) || this.readinessTimeoutMs < 1 || this.readinessTimeoutMs > 30000)
+      throw new TypeError("herdr_readiness_timeout_invalid");
+  }
+  get runtime() {
+    if (this.runtimeValue === undefined)
+      throw new TypeError("herdr_runtime_not_prepared");
+    return { ...this.runtimeValue };
+  }
+  get executionClient() {
+    return {
+      request: (method, params) => suspend(() => this.started && this.client?.request !== undefined ? this.client.request(method, params) : fail4(new HerdrSocketError({ message: "herdr_client_not_ready" })))
+    };
+  }
+  start = fnUntraced(function* () {
+    if (this.started && this.client !== undefined)
+      return yield* this.client.sessionSnapshot().pipe(mapError((error) => fail3(error.message)));
+    if ((this.options.platform ?? process.platform) !== "linux")
+      return yield* fail3("herdr_linux_required");
+    const defaultSession = this.options.session === "default";
+    const runtime = defaultSession ? undefined : yield* this.prepareRuntime();
+    if (!(yield* (this.options.executableAvailable ?? executableAvailable)(this.options.piCommand ?? "pi")))
+      return yield* fail3("herdr_pi_unavailable");
+    const socketClientOptions = this.options.socketClientOptions ?? {};
+    const socketPath = runtime?.socketPath ?? (yield* defaultSessionSocketPath);
+    const clientOptions = {
+      socketPath,
+      ...socketClientOptions,
+      requestTimeoutMs: Math.min(socketClientOptions.requestTimeoutMs ?? this.readinessTimeoutMs, this.readinessTimeoutMs)
+    };
+    const socketClient = (this.options.clientFactory ?? ((options) => new HerdrSocketClient(options)))(clientOptions);
+    const snapshot = yield* (runtime === undefined ? this.attachToDefaultSession(socketPath, socketClient) : this.spawnAndAwaitReadiness(runtime, socketClient)).pipe(tapError(() => andThen(socketClient.close(), this.cleanupOwnedServer())));
+    this.client = socketClient;
+    this.started = true;
+    return snapshot;
+  });
+  stop = fnUntraced(function* () {
+    this.started = false;
+    const client = this.client;
+    this.client = undefined;
+    if (client !== undefined)
+      yield* client.close();
+    yield* this.cleanupOwnedServer();
+  });
+  spawnAndAwaitReadiness = fnUntraced(function* (runtime, socketClient) {
+    if (!this.attachedToExistingServer) {
+      const owned = yield* (this.options.spawnServer ?? spawnServer)({
+        command: this.options.herdrCommand ?? "herdr",
+        args: ["--session", runtime.sessionName, "server"],
+        socketPath: runtime.socketPath
+      });
+      this.owned = owned;
+      yield* writeOwnerMarker(runtime.ownerFile, {
+        runnerId: this.runnerId,
+        socketPath: runtime.socketPath,
+        sessionName: runtime.sessionName,
+        pid: owned.pid
+      });
+    }
+    const snapshot = yield* awaitReadiness(socketClient, this.readinessTimeoutMs);
+    if (snapshot.protocol !== HERDR_SOCKET_PROTOCOL)
+      return yield* fail3("herdr_protocol_mismatch");
+    return snapshot;
+  });
+  attachToDefaultSession = fnUntraced(function* (socketPath, socketClient) {
+    const running = yield* result(socketClient.sessionSnapshot());
+    if (isFailure(running)) {
+      const message = running.failure.message;
+      if (message !== "herdr_socket_connect_failed" && message !== "herdr_socket_closed")
+        return yield* fail3(message);
+      yield* (this.options.spawnServer ?? spawnServer)({
+        command: this.options.herdrCommand ?? "herdr",
+        args: ["server"],
+        socketPath
+      });
+    }
+    const snapshot = isSuccess(running) ? running.success : yield* awaitReadiness(socketClient, this.readinessTimeoutMs);
+    if (snapshot.protocol !== HERDR_SOCKET_PROTOCOL)
+      return yield* fail3("herdr_protocol_mismatch");
+    return snapshot;
+  });
+  prepareRuntime = fnUntraced(function* () {
+    const fs = yield* FileSystem;
+    const path = yield* Path;
+    const runtimeRoot = this.options.runtimeRoot ?? path.join(yield* temporaryDirectory, "kitman-herdr");
+    const directory = this.options.runtimeDirectory ?? path.join(runtimeRoot, `runner-${digest(this.runnerId)}`);
+    yield* mapError(all([
+      fs.makeDirectory(path.dirname(directory), { recursive: true, mode: 448 }),
+      fs.makeDirectory(directory, { recursive: true, mode: 448 }),
+      fs.chmod(directory, 448)
+    ]), () => fail3("herdr_runtime_unavailable"));
+    const sessionName = `kitman-herdr-${digest(this.runnerId)}`;
+    const runtime = {
+      directory,
+      socketPath: yield* herdrSessionSocketPath(sessionName),
+      ownerFile: path.join(directory, ".kitman-herdr-owner.json"),
+      sessionName
+    };
+    this.runtimeValue = runtime;
+    this.attachedToExistingServer = yield* reclaimStaleRuntime(runtime, this.runnerId, this.options.processAlive ?? processAlive);
+    return runtime;
+  });
+  cleanupOwnedServer() {
+    return suspend(() => {
+      const owned = this.owned;
+      const runtime = this.runtimeValue;
+      this.owned = undefined;
+      if (owned === undefined)
+        return void_2;
+      return andThen(owned.stop, runtime === undefined ? void_2 : removeOwnedRuntimeFiles(runtime, this.runnerId));
+    });
+  }
+}
+var reclaimStaleRuntime = (runtime, runnerId, isAlive) => gen(function* () {
+  let socketExists = yield* pathExists(runtime.socketPath);
+  let owner = yield* readOwnerMarker(runtime.ownerFile);
+  if (socketExists && owner === undefined) {
+    yield* sleep(250);
+    socketExists = yield* pathExists(runtime.socketPath);
+    owner = yield* readOwnerMarker(runtime.ownerFile);
+  }
+  if (!socketExists && owner === undefined)
+    return false;
+  if (owner === undefined || owner.runnerId !== runnerId || owner.socketPath !== runtime.socketPath)
+    return yield* fail3(`herdr_socket_ownership_unknown:${socketExists ? "socket_present" : "socket_missing"}:${owner === undefined ? "owner_missing" : "owner_mismatch"}`);
+  if (yield* isAlive(owner.pid))
+    return true;
+  yield* removeRuntimeFiles(runtime);
+  return false;
+});
+var awaitReadiness = (client, readinessTimeoutMs) => gen(function* () {
+  const deadline = (yield* currentTimeMillis) + readinessTimeoutMs;
+  for (;; ) {
+    const remaining = deadline - (yield* currentTimeMillis);
+    if (remaining <= 0)
+      return yield* fail3("herdr_socket_connect_failed");
+    const attempt = yield* result(client.sessionSnapshot().pipe(mapError((error) => fail3(error.message)), timeoutOrElse({ duration: remaining, orElse: () => fail4(fail3("herdr_readiness_timeout")) })));
+    if (isSuccess(attempt))
+      return attempt.success;
+    const message = attempt.failure.message;
+    if (message !== "herdr_socket_connect_failed" && message !== "herdr_socket_closed")
+      return yield* attempt.failure;
+    yield* sleep(Math.min(250, remaining));
+  }
+});
+var removeOwnedRuntimeFiles = (runtime, runnerId) => gen(function* () {
+  const owner = yield* readOwnerMarker(runtime.ownerFile);
+  if (owner !== undefined && owner.runnerId === runnerId && owner.socketPath === runtime.socketPath)
+    yield* removeRuntimeFiles(runtime);
+});
+var herdrSessionSocketPath = (sessionName) => gen(function* () {
+  const path = yield* Path;
+  const base = (yield* optionalEnv("XDG_CONFIG_HOME")) ?? path.join(yield* homeDirectory, ".config");
+  return path.join(base, "herdr", "sessions", sessionName, "herdr.sock");
+});
+var defaultSessionSocketPath = gen(function* () {
+  const path = yield* Path;
+  const base = (yield* optionalEnv("XDG_CONFIG_HOME")) ?? path.join(yield* homeDirectory, ".config");
+  return path.join(base, "herdr", "herdr.sock");
+});
+var homeDirectory = map3(optionalEnv("HOME"), (home) => home ?? "/");
+var temporaryDirectory = map3(optionalEnv("TMPDIR"), (tmp) => tmp ?? "/tmp");
+var executableAvailable = (command) => gen(function* () {
+  const spawner = yield* ChildProcessSpawner;
+  const exitCode = yield* spawner.exitCode(make15("which", [command], { stdin: "ignore", stdout: "ignore", stderr: "ignore" }));
+  return exitCode === 0;
+}).pipe(orElseSucceed(() => false));
+var spawnServer = (input) => gen(function* () {
+  const spawner = yield* ChildProcessSpawner;
+  const scope = yield* make9();
+  const handle = yield* spawner.spawn(make15(input.command, [...input.args], {
+    env: { HERDR_SOCKET_PATH: input.socketPath },
+    extendEnv: true,
+    detached: true,
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "ignore"
+  })).pipe(provide(scope), mapError(() => fail3("herdr_server_start_failed")));
+  yield* ignore(handle.unref);
+  return {
+    pid: handle.pid,
+    stop: handle.kill({ killSignal: "SIGTERM", forceKillAfter: "1 second" }).pipe(ignore, andThen(close(scope, void_)))
+  };
+});
+var processAlive = (pid) => sync(() => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !(isObject(error) && error !== null && ("code" in error) && error.code === "ESRCH");
+  }
+});
+var writeOwnerMarker = (path, marker) => gen(function* () {
+  const fs = yield* FileSystem;
+  yield* fs.writeFileString(path, `${encodeJsonStringSync(marker)}
+`, { mode: 384 });
+  yield* fs.chmod(path, 384);
+}).pipe(mapError(() => fail3("herdr_runtime_unavailable")));
+var readOwnerMarker = (path) => gen(function* () {
+  const fs = yield* FileSystem;
+  const text = yield* fs.readFileString(path);
+  const value = getOrUndefined(decodeJsonStringOption(text));
+  if (!isJsonObject(value) || !isString2(value.runnerId) || !isString2(value.socketPath) || !isString2(value.sessionName) || !isNumber(value.pid) || !Number.isInteger(value.pid))
+    return;
+  return { runnerId: value.runnerId, socketPath: value.socketPath, sessionName: value.sessionName, pid: value.pid };
+}).pipe(orElseSucceed(() => {
+  return;
+}));
+var pathExists = (path) => gen(function* () {
+  const fs = yield* FileSystem;
+  const info = yield* fs.stat(path);
+  return info.type === "Socket" || info.type === "File";
+}).pipe(orElseSucceed(() => false));
+var removeRuntimeFiles = (runtime) => gen(function* () {
+  const fs = yield* FileSystem;
+  yield* ignore(fs.remove(runtime.socketPath, { force: true }));
+  yield* ignore(fs.remove(runtime.ownerFile, { force: true }));
+});
+function digest(value) {
+  return sha256(value).slice(0, 16);
+}
+// packages/agent-runtime/src/agent-harness-service.ts
+class HarnessError extends TaggedError("HarnessError") {
+}
+
+class Harness extends Service2()("Harness") {
+}
+// packages/agent-runtime/src/herdr-execution-primitives.ts
+class HerdrHarnessError extends TaggedError("HerdrHarnessError") {
+}
+
+class HerdrCanceledError extends TaggedError("HerdrCanceledError") {
+}
+var HerdrInterruptByte = "\x03";
+var stopOwnedHarness = (client, paneId, delayMs) => gen(function* () {
+  yield* ignore(client.request("pane.send_text", { pane_id: paneId, text: HerdrInterruptByte }));
+  if (delayMs > 0)
+    yield* sleep(delayMs);
+  yield* ignore(client.request("pane.send_text", { pane_id: paneId, text: `${HerdrInterruptByte}${HerdrInterruptByte}` }));
+});
+function shortId(value) {
+  return value.replace(/[^A-Za-z0-9]/gu, "").slice(-16) || "run";
+}
+function isRecord2(value) {
+  return isObject(value) && value !== null && !Array.isArray(value);
+}
+var requestRecord = (client, method, params, expectedType) => flatMap(client.request(method, params), (response) => {
+  const result = recordValue(response);
+  return result === undefined || result.type !== expectedType ? fail4(new HerdrHarnessError({ message: `${method}_response_invalid` })) : succeed5(result);
+});
+function recordValue(value) {
+  return isRecord2(value) ? value : undefined;
+}
+function recordList(value, key) {
+  const list = recordValue(value)?.[key];
+  return Array.isArray(list) ? list.filter((item) => isRecord2(item)) : [];
+}
+function stringValue(value) {
+  return isString2(value) && value.length > 0 ? value : undefined;
+}
+function numberValue(value) {
+  return isNumber(value) && Number.isInteger(value) && value >= 0 ? value : undefined;
+}
+function nestedString(value, path) {
+  let current = recordValue(value);
+  for (const segment of path)
+    current = recordValue(current)?.[segment];
+  return stringValue(current);
+}
+var abortable = (effect, signal) => signal === undefined ? effect : raceFirst(effect, callback((resume) => {
+  const abort = () => resume(fail4(new HerdrCanceledError));
+  if (signal.aborted) {
+    abort();
+    return;
+  }
+  signal.addEventListener("abort", abort, { once: true });
+  return sync(() => signal.removeEventListener("abort", abort));
+}));
+// packages/agent-runtime/src/herdr-harness.ts
+var harnessFailure = (reason) => (cause) => new HarnessError({ reason, message: cause.message, cause });
+var makeHerdrHarness = (options) => {
+  const client = {
+    request: (method, params) => (isFunction(options.client) ? options.client() : options.client).request(method, params)
+  };
+  const launch = (input) => gen(function* () {
+    const agentStart = yield* requestRecord(client, "agent.start", { pane_id: input.surfaceId, kind: input.binary, name: input.name, timeout_ms: 120000, args: [...input.args] }, "agent_started");
+    const agent = recordValue(agentStart.agent);
+    const target = stringValue(agent?.pane_id);
+    const baselineSequence = numberValue(agent?.state_change_seq);
+    const expectedTabId = input.native?.["herdr.tabId"];
+    const expectedWorkspaceId = input.native?.["herdr.workspaceId"];
+    if (target !== input.surfaceId || expectedTabId !== undefined && nestedString(agentStart, ["agent", "tab_id"]) !== expectedTabId || expectedWorkspaceId !== undefined && nestedString(agentStart, ["agent", "workspace_id"]) !== expectedWorkspaceId || target === undefined || baselineSequence === undefined)
+      return yield* new HerdrHarnessError({ message: "agent_identity_mismatch" });
+    const deadline = (yield* currentTimeMillis) + 600000;
+    let readySequence;
+    while ((yield* currentTimeMillis) < deadline) {
+      const ready = yield* result(requestRecord(client, "agent.wait", { target, until: ["idle", "blocked", "done"], timeout_ms: 5000 }, "agent_info"));
+      if (isFailure(ready)) {
+        if (ready.failure.message !== "herdr_remote_error:timeout")
+          return yield* ready.failure;
+      } else {
+        const readyAgent = recordValue(ready.success.agent);
+        readySequence = numberValue(readyAgent?.state_change_seq);
+        if (readyAgent?.interactive_ready === true && readyAgent.launch_pending !== true)
+          break;
+      }
+      yield* sleep(200);
+    }
+    if (readySequence === undefined || (yield* currentTimeMillis) >= deadline)
+      return yield* new HerdrHarnessError({ message: "agent_readiness_invalid" });
+    return { targetId: target, baselineSequence: readySequence };
+  }).pipe(mapError(harnessFailure("harness_launch_failed")));
+  const prompt = (input) => client.request("agent.prompt", { target: input.targetId, text: input.text }).pipe(asVoid, mapError(harnessFailure("harness_prompt_failed")));
+  const observe = (input) => gen(function* () {
+    const deadline = (yield* currentTimeMillis) + input.timeoutMs;
+    let active = false;
+    const markActivity = gen(function* () {
+      if (active)
+        return;
+      active = true;
+      yield* sync(() => input.onActivity?.()).pipe(catchDefect(() => void_2));
+    });
+    while ((yield* currentTimeMillis) < deadline) {
+      if (input.signal?.aborted === true)
+        return { kind: "canceled" };
+      const recovered = yield* result(agentStatus(client, input.targetId, input.signal));
+      if (isFailure(recovered)) {
+        const error = recovered.failure;
+        if (error instanceof HerdrCanceledError)
+          return { kind: "canceled" };
+        if (error.message !== "herdr_remote_error:timeout") {
+          yield* logError("herdr_observation_error", error.message);
+          return { kind: "unreported" };
+        }
+        yield* markActivity;
+        yield* sleep(100);
+        continue;
+      }
+      const { status, sequence } = recovered.success;
+      if (status === "working" || sequence !== undefined && sequence > input.baselineSequence)
+        yield* markActivity;
+      if (status === "blocked")
+        return { kind: "blocked" };
+      if ((status === "done" || status === "idle") && active)
+        return { kind: "terminal" };
+      yield* sleep(100);
+    }
+    return { kind: "timeout" };
+  });
+  return {
+    launch,
+    prompt,
+    observe,
+    cancel: (input) => stopOwnedHarness(client, input.surfaceId, input.delayMs ?? 0)
+  };
+};
+var herdrHarnessLayer = (options) => succeed4(Harness, Harness.of(makeHerdrHarness(options)));
+var agentStatus = (client, target, signal) => gen(function* () {
+  const result = yield* abortable(client.request("agent.wait", { target, timeout_ms: 250 }), signal);
+  const resultRecord = recordValue(result);
+  const agent = recordValue(resultRecord?.agent) ?? resultRecord;
+  const status = stringValue(agent?.agent_status);
+  if (status !== "working" && status !== "blocked" && status !== "done" && status !== "idle")
+    return yield* new HerdrHarnessError({ message: "agent_status_invalid" });
+  return { status, sequence: numberValue(agent?.state_change_seq) };
+});
+// packages/agent-runtime/src/harness-adapters.ts
+var HarnessAdapters = [
+  {
+    id: "claude",
+    binary: "claude",
+    form: "interactive",
+    modelFlag: "--model",
+    auth: ["~/.claude", "~/.claude.json"],
+    providerHosts: ["api.anthropic.com", "console.anthropic.com", "claude.ai"],
+    effortArgs: ["--effort", "{effort}"],
+    autoPermissionArgs: ["--dangerously-skip-permissions"],
+    toolless: { args: ["--tools", "", "--strict-mcp-config"] },
+    firstMessage: "herdr_prompt",
+    mcp: { kind: "json_arg", flag: "--mcp-config" },
+    skills: { kind: "add_dir", flag: "--add-dir", root: ".claude/skills" },
+    mcpToolTimeout: { kind: "env", variables: ["MCP_TOOL_TIMEOUT", "CLAUDE_CODE_MCP_TOOL_IDLE_TIMEOUT"], unit: "ms" },
+    session: {
+      location: { root: ".claude/projects", layout: "per_directory" },
+      start: ["--session-id", "{session}"],
+      resume: ["--resume", "{transcript}"]
+    }
+  },
+  {
+    id: "codex",
+    binary: "codex",
+    form: "interactive",
+    modelFlag: "--model",
+    auth: ["~/.codex"],
+    providerHosts: ["api.openai.com", "auth.openai.com", "chatgpt.com"],
+    effortArgs: ["-c", 'model_reasoning_effort="{effort}"'],
+    autoPermissionArgs: ["--dangerously-bypass-approvals-and-sandbox"],
+    firstMessage: "herdr_prompt",
+    mcp: { kind: "toml_overrides", flag: "-c" },
+    skills: { kind: "skills_config", root: "skills" },
+    mcpToolTimeout: { kind: "server_field", field: "tool_timeout_sec", unit: "s" },
+    session: {
+      location: { root: ".codex/sessions", layout: "by_date" },
+      resume: ["resume", "{session}", "-c", 'tui.resume_cwd="current"']
+    }
+  },
+  {
+    id: "pi",
+    binary: "pi",
+    form: "interactive",
+    modelFlag: "--model",
+    auth: ["~/.pi"],
+    providerHosts: ["api.anthropic.com", "api.openai.com", "generativelanguage.googleapis.com", "openrouter.ai"],
+    effortArgs: ["--thinking", "{effort}"],
+    autoPermissionArgs: ["--approve"],
+    toolless: {
+      args: ["--tools", "mcp__kitman__*", "--no-extensions", "-e", "builtin:mcp", "--no-skills"],
+      serverFields: { exposure: "direct" },
+      mcp: { kind: "workspace_file", path: ".pi/mcp.json" }
+    },
+    firstMessage: "herdr_prompt",
+    mcp: { kind: "config_file_arg", flag: "--mcp-config" },
+    skills: { kind: "flag", flag: "--skill", root: "skills" },
+    mcpToolTimeout: { kind: "server_field", field: "timeout", unit: "s" }
+  },
+  {
+    id: "opencode",
+    binary: "opencode",
+    form: "interactive",
+    modelFlag: "--model",
+    auth: ["~/.local/share/opencode", "~/.config/opencode"],
+    providerHosts: [
+      "api.anthropic.com",
+      "api.openai.com",
+      "generativelanguage.googleapis.com",
+      "openrouter.ai",
+      "opencode.ai",
+      "models.dev"
+    ],
+    autoPermissionArgs: ["--auto"],
+    firstMessage: "herdr_prompt",
+    mcp: { kind: "config_env", variable: "OPENCODE_CONFIG_CONTENT" },
+    skills: { kind: "config_paths", root: "skills" },
+    mcpToolTimeout: { kind: "server_field", field: "timeout", unit: "ms" }
+  }
+];
+var sessionArgs = (adapter, session) => {
+  if (adapter.session === undefined || session === undefined)
+    return [];
+  const args = session.transcript === undefined ? adapter.session.start ?? [] : adapter.session.resume;
+  return args.map((arg) => arg.replace("{session}", session.id).replace("{transcript}", session.transcript ?? ""));
+};
+var kitmanMcpToolTimeoutSeconds = 24 * 60 * 60;
+function kitmanMcpToolTimeout(adapter, seconds) {
+  const timeout = adapter.mcpToolTimeout;
+  if (timeout === undefined)
+    return;
+  const value = timeout.unit === "ms" ? seconds * 1000 : seconds;
+  return timeout.kind === "env" ? { env: Object.fromEntries(timeout.variables.map((variable) => [variable, String(value)])) } : { server: { [timeout.field]: value } };
+}
+function harnessAdapter(id) {
+  return HarnessAdapters.find((adapter) => adapter.id === id);
+}
+function resolveHarnessLaunch(input) {
+  const launch = skillsLaunch(input);
+  const effort = input.effort;
+  return effort === undefined || input.adapter.effortArgs === undefined ? launch : { ...launch, args: [...launch.args, ...input.adapter.effortArgs.map((arg) => arg.replace("{effort}", effort))] };
+}
+function skillsLaunch(input) {
+  const skills = input.skills ?? [];
+  if (skills.length === 0)
+    return mcpLaunch(input, undefined);
+  const { skills: loading } = input.adapter;
+  const root = `${input.configDir}/${loading.root}`;
+  const launch = mcpLaunch(input, loading.kind === "config_paths" ? root : undefined);
+  const args = (() => {
+    switch (loading.kind) {
+      case "add_dir":
+        return [loading.flag, input.configDir];
+      case "skills_config":
+        return [
+          "-c",
+          `skills.config=[${skills.map((skill) => `{ path = ${JSON.stringify(`${root}/${skill.name}/SKILL.md`)}, enabled = true }`).join(", ")}]`
+        ];
+      case "flag":
+        return skills.flatMap((skill) => [loading.flag, `${root}/${skill.name}`]);
+      case "config_paths":
+        return [];
+    }
+  })();
+  return {
+    ...launch,
+    args: [...launch.args, ...args],
+    files: [
+      ...launch.files,
+      ...skills.flatMap((skill) => Object.entries(skill.files).map(([path, content]) => ({ path: `${root}/${skill.name}/${path}`, content })))
+    ]
+  };
+}
+function mcpLaunch(input, skillsDir) {
+  const { adapter, mcp } = input;
+  const model = input.model === undefined ? [] : [adapter.modelFlag, input.model];
+  const session = sessionArgs(adapter, input.session);
+  const server = { command: mcp.command, args: [...mcp.args] };
+  const timeout = kitmanMcpToolTimeout(adapter, kitmanMcpToolTimeoutSeconds);
+  const timeoutEnv = timeout !== undefined && "env" in timeout ? timeout.env : {};
+  const toolless = input.toolless === true ? adapter.toolless : undefined;
+  const timeoutFields = timeout !== undefined && "server" in timeout ? timeout.server : {};
+  const serverFields = toolless?.serverFields === undefined ? timeoutFields : { ...timeoutFields, ...toolless.serverFields };
+  const accessArgs = [...adapter.autoPermissionArgs, ...toolless?.args ?? []];
+  const delivery = toolless?.mcp ?? adapter.mcp;
+  const fileConfig = () => JSON.stringify({
+    mcpServers: {
+      kitman: {
+        ...server,
+        env: Object.fromEntries(mcp.environment.map((name) => [name, `\${${name}}`])),
+        ...serverFields
+      }
+    }
+  });
+  switch (delivery.kind) {
+    case "json_arg":
+      return {
+        binary: adapter.binary,
+        args: [
+          ...session,
+          ...accessArgs,
+          ...model,
+          delivery.flag,
+          JSON.stringify({ mcpServers: { kitman: { ...server, ...serverFields } } })
+        ],
+        env: timeoutEnv,
+        files: []
+      };
+    case "toml_overrides": {
+      const { flag } = delivery;
+      return {
+        binary: adapter.binary,
+        args: [
+          ...session,
+          ...accessArgs,
+          ...model,
+          delivery.flag,
+          `mcp_servers.kitman.command=${JSON.stringify(mcp.command)}`,
+          delivery.flag,
+          `mcp_servers.kitman.args=${JSON.stringify(mcp.args)}`,
+          delivery.flag,
+          `mcp_servers.kitman.env_vars=${JSON.stringify(mcp.environment)}`,
+          ...Object.entries(serverFields).flatMap(([field, value]) => [flag, `mcp_servers.kitman.${field}=${value}`])
+        ],
+        env: timeoutEnv,
+        files: []
+      };
+    }
+    case "config_file_arg": {
+      const path = `${input.configDir}/kitman-mcp.json`;
+      return {
+        binary: adapter.binary,
+        args: [...session, ...accessArgs, ...model, delivery.flag, path],
+        env: timeoutEnv,
+        files: [{ path, content: fileConfig() }]
+      };
+    }
+    case "workspace_file":
+      return {
+        binary: adapter.binary,
+        args: [...session, ...accessArgs, ...model],
+        env: timeoutEnv,
+        files: [{ path: delivery.path, content: fileConfig(), inWorkspace: true }]
+      };
+    case "config_env":
+      return {
+        binary: adapter.binary,
+        args: [...session, ...accessArgs, ...model],
+        env: {
+          ...timeoutEnv,
+          [delivery.variable]: JSON.stringify({
+            mcp: {
+              kitman: {
+                type: "local",
+                command: [mcp.command, ...mcp.args],
+                environment: Object.fromEntries(mcp.environment.map((name) => [name, `{env:${name}}`])),
+                ...serverFields
+              }
+            },
+            ...skillsDir === undefined ? undefined : { skills: { paths: [skillsDir] } }
+          })
+        },
+        files: []
+      };
+  }
+}
+// packages/agent-runtime/src/herdr-execution-surface.ts
+var invalid2 = (message) => new HerdrHarnessError({ message });
+var prepareHerdrExecutionSurface = fn("prepareHerdrExecutionSurface")(function* (input) {
+  const workspaceId = yield* ensureTaskWorkspace(input.client, input.taskId);
+  const tab = yield* ensureStepTab(input.client, workspaceId, input.stepKey, input.worktreePath, input);
+  return { workspaceId, ...tab };
+});
+var ensureTaskWorkspace = fnUntraced(function* (client, taskId) {
+  const label = `kitman-task-${shortId(taskId)}`;
+  const workspaces = yield* requestRecord(client, "workspace.list", {}, "workspace_list");
+  const found = recordList(workspaces, "workspaces").find((candidate) => stringValue(candidate.label) === label);
+  if (found !== undefined) {
+    const workspaceId = stringValue(found.workspace_id);
+    if (workspaceId !== undefined)
+      return workspaceId;
+    return yield* invalid2("workspace_identity_invalid");
+  }
+  const created = yield* requestRecord(client, "workspace.create", { label, focus: false }, "workspace_created");
+  const workspaceId = nestedString(created, ["workspace", "workspace_id"]);
+  if (workspaceId === undefined)
+    return yield* invalid2("workspace_identity_invalid");
+  return workspaceId;
+});
+var ensureStepTab = fnUntraced(function* (client, workspaceId, stepKey, worktreePath, input) {
+  const label = `step-${stepKey}`;
+  const tabs = yield* requestRecord(client, "tab.list", {}, "tab_list");
+  const found = recordList(tabs, "tabs").find((candidate) => stringValue(candidate.workspace_id) === workspaceId && stringValue(candidate.label) === label);
+  const tabId = found === undefined ? undefined : stringValue(found.tab_id);
+  if (tabId !== undefined) {
+    const panes = yield* requestRecord(client, "pane.list", {}, "pane_list");
+    const pane = recordList(panes, "panes").find((candidate) => stringValue(candidate.tab_id) === tabId);
+    const paneId = pane === undefined ? undefined : stringValue(pane.pane_id);
+    if (paneId !== undefined)
+      yield* requestRecord(client, "pane.close", { pane_id: paneId }, "ok");
+  }
+  return yield* createStepTab(client, workspaceId, label, worktreePath, input);
+});
+var createStepTab = fnUntraced(function* (client, workspaceId, label, worktreePath, input) {
+  const shellEnv = input.tabShellEnv ?? {};
+  const created = yield* requestRecord(client, "tab.create", {
+    workspace_id: workspaceId,
+    cwd: worktreePath,
+    label,
+    focus: false,
+    ...Object.keys(shellEnv).length > 0 ? { env: shellEnv } : undefined
+  }, "tab_created");
+  const tabId = nestedString(created, ["tab", "tab_id"]);
+  const paneId = nestedString(created, ["root_pane", "pane_id"]);
+  if (tabId === undefined || paneId === undefined)
+    return yield* invalid2("tab_identity_invalid");
+  const tabWorkspaceId = nestedString(created, ["tab", "workspace_id"]);
+  if (tabWorkspaceId !== undefined && tabWorkspaceId !== workspaceId)
+    return yield* invalid2("tab_workspace_mismatch");
+  const paneWorkspaceId = nestedString(created, ["root_pane", "workspace_id"]);
+  if (paneWorkspaceId !== undefined && paneWorkspaceId !== workspaceId)
+    return yield* invalid2("pane_workspace_mismatch");
+  return { tabId, paneId };
+});
+
+// packages/agent-runtime/src/srt-sandbox.ts
+import { fileURLToPath } from "url";
+var pinnedSrtCommand = () => [
+  process.execPath,
+  fileURLToPath(import.meta.resolve("@anthropic-ai/sandbox-runtime/dist/cli.js"))
+];
+var srtSettings = (policy) => policy.network === "open" ? undefined : {
+  network: { allowedDomains: [...policy.network.hosts], deniedDomains: [], strictAllowlist: true },
+  filesystem: {
+    denyRead: [...policy.readDeniedPaths],
+    allowWrite: [...policy.writablePaths],
+    denyWrite: []
+  }
+};
+var srtCacheEnvironment = (dir) => ({
+  XDG_CACHE_HOME: dir,
+  npm_config_cache: `${dir}/npm`,
+  BUN_INSTALL_CACHE_DIR: `${dir}/bun`
+});
+var quote = (value) => `'${value.replaceAll("'", `'\\''`)}'`;
+var prepareSrtPane = (input) => gen(function* () {
+  const settings = srtSettings(input.policy);
+  if (settings === undefined)
+    return yield* die3(new Error("srt cannot run a Step with an open network"));
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const dir = yield* fs.makeTempDirectoryScoped({ prefix: "kitman-srt-" });
+  const settingsFile = path.join(dir, "srt-settings.json");
+  yield* fs.writeFileString(settingsFile, encodeUnknownJsonStringSync(settings));
+  yield* fs.writeFileString(path.join(dir, input.binary), [
+    "#!/bin/sh",
+    `PATH=$(printf %s "$PATH" | tr ':' '\\n' | grep -vxF ${quote(dir)} | paste -sd: -)`,
+    "export PATH",
+    `exec ${[...input.srtCommand, "--settings", settingsFile, "--", input.binary].map(quote).join(" ")} "$@"`,
+    ""
+  ].join(`
+`), { mode: 493 });
+  return { dir, settingsFile, env: { PATH: `${dir}:${input.path}` } };
+});
+
+// packages/agent-runtime/src/docker-sandbox.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+var RunnerLabel = "kitman.runner";
+var StepAttemptLabel = "kitman.step-attempt";
+var EgressProxyImage = "oven/bun@sha256:d2bc1fbc3afcd3d70afc2bb2544235bf559caae2a3084e9abed126e233797511";
+var egressProxyAddress = "http://kitman-egress:3128";
+
+class ContainerError extends TaggedError("ContainerError") {
+}
+var imagePull = { timeout: "30 minutes" };
+var dockerContainerRunner = map3(ChildProcessSpawner, (spawner) => {
+  const docker = (args, options = {}) => runCommand2("docker", args, options).pipe(mapError((error) => new ContainerError({ message: error.message })), provideService(ChildProcessSpawner, spawner));
+  const labelArgs = (labels) => labels.flatMap(([key, value]) => ["--label", `${key}=${value}`]);
+  const ids = (output) => output.split(`
+`).filter((id) => id.trim().length > 0);
+  return {
+    createInternalNetwork: (input) => asVoid(docker(["network", "create", "--internal", ...labelArgs(input.labels), input.name])),
+    run: (input) => asVoid(docker([
+      "run",
+      "--detach",
+      "--name",
+      input.name,
+      ...labelArgs(input.labels),
+      ...input.network === undefined ? [] : ["--network", input.network],
+      ...input.user === undefined ? [] : ["--user", input.user],
+      ...input.mounts.flatMap((mount) => [
+        "--volume",
+        `${mount.source}:${mount.target}${mount.readOnly === true ? ":ro" : ""}`
+      ]),
+      ...input.workdir === undefined ? [] : ["--workdir", input.workdir],
+      ...Object.entries(input.env).flatMap(([key, value]) => ["--env", `${key}=${value}`]),
+      input.image,
+      ...input.command
+    ], imagePull)),
+    connect: (input) => asVoid(docker(["network", "connect", "--alias", input.alias, input.network, input.container])),
+    removeLabelled: ([key, value]) => gen(function* () {
+      const filter = ["--filter", `label=${key}=${value}`];
+      const containers = ids(yield* docker(["ps", "--all", "--quiet", ...filter]));
+      if (containers.length > 0)
+        yield* docker(["rm", "--force", ...containers]);
+      const networks = ids(yield* docker(["network", "ls", "--quiet", ...filter]));
+      if (networks.length > 0)
+        yield* docker(["network", "rm", ...networks]);
+    }).pipe(catch_((error) => logWarning("runner_container_removal_failed", error.message)))
+  };
+});
+var quote2 = (value) => `'${value.replaceAll("'", `'\\''`)}'`;
+var dockerName = (id) => id.replaceAll(/[^a-zA-Z0-9_.-]/g, "-");
+var prepareDockerPane = (input) => gen(function* () {
+  const { containers } = input.docker;
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const id = dockerName(input.attemptId);
+  const labels = [
+    [RunnerLabel, input.runnerId],
+    [StepAttemptLabel, input.attemptId]
+  ];
+  const agent = `kitman-agent-${id}`;
+  const network = input.policy.network === "open" ? undefined : `kitman-agent-net-${id}`;
+  yield* acquireRelease(void_2, () => containers.removeLabelled([StepAttemptLabel, input.attemptId]));
+  if (input.policy.network !== "open" && network !== undefined) {
+    const proxy = `kitman-egress-${id}`;
+    yield* containers.createInternalNetwork({ name: network, labels });
+    yield* containers.run({
+      name: proxy,
+      image: input.docker.proxyImage ?? EgressProxyImage,
+      labels,
+      mounts: [
+        {
+          source: fileURLToPath2(import.meta.resolve("./egress-proxy.ts")),
+          target: "/kitman/egress-proxy.ts",
+          readOnly: true
+        }
+      ],
+      env: {},
+      command: ["bun", "/kitman/egress-proxy.ts", input.policy.network.hosts.join(",")]
+    });
+    yield* containers.connect({ network, container: proxy, alias: "kitman-egress" });
+  }
+  yield* containers.run({
+    name: agent,
+    image: input.docker.image,
+    labels,
+    ...network === undefined ? undefined : { network },
+    ...input.docker.user === undefined ? undefined : { user: input.docker.user },
+    mounts: input.policy.writablePaths.map((writable) => ({ source: writable, target: writable })),
+    workdir: input.workspace,
+    env: {
+      HOME: path.join(input.configDir, "home"),
+      ...srtCacheEnvironment(`${input.configDir}/cache`),
+      ...network === undefined ? undefined : {
+        HTTPS_PROXY: egressProxyAddress,
+        HTTP_PROXY: egressProxyAddress,
+        https_proxy: egressProxyAddress,
+        http_proxy: egressProxyAddress,
+        NO_PROXY: "localhost,127.0.0.1",
+        no_proxy: "localhost,127.0.0.1"
+      }
+    },
+    command: ["sleep", "infinity"]
+  });
+  yield* fs.makeDirectory(path.join(input.configDir, "home"), { recursive: true });
+  const dir = yield* fs.makeTempDirectoryScoped({ prefix: "kitman-docker-" });
+  const shell = path.join(dir, "shell");
+  const forwarded = ["TERM", ...Object.keys(input.policy.environment)].flatMap((name) => ["-e", name]);
+  yield* fs.writeFileString(shell, [
+    "#!/bin/sh",
+    `exec docker exec -it -w ${quote2(input.workspace)} ${forwarded.map(quote2).join(" ")} ${quote2(agent)} /bin/sh "$@"`,
+    ""
+  ].join(`
+`), { mode: 493 });
+  return { container: agent, env: { SHELL: shell } };
+});
+var removeRunnerContainers = (containers, runnerId) => containers.removeLabelled([RunnerLabel, runnerId]);
+
+// packages/agent-runtime/src/herdr-step-attempt-executor.ts
+var firstMessage = (agent, worktree) => {
+  if (agent.session?.transcript !== undefined)
+    return `Kitman moved this Step to another machine after the last one stopped. Your conversation and your workspace are restored to the last checkpoint, and the workspace is now ${worktree}. Continue where you left off; read the brief again with step_brief if you need it.`;
+  if (agent.session?.workspaceRestored === true)
+    return `${agent.brief.prompt}
+
+An earlier attempt of this Step stopped; your workspace holds its work up to its last checkpoint.`;
+  return agent.brief.prompt;
+};
+var failed = (reason, summary) => ({ status: "failed", reason, summary });
+var stepSandboxPolicy = (input) => ({
+  ...input.policy,
+  writablePaths: [...input.policy.writablePaths, input.workspace, input.configDir],
+  readDeniedPaths: [
+    ...input.policy.readDeniedPaths,
+    ...HarnessAdapters.filter((other) => other.id !== input.adapter.id).flatMap((other) => other.auth)
+  ],
+  environment: { ...input.policy.environment, ...input.environment }
+});
+var executeHerdrStepAttempt = (input) => gen(function* () {
+  const lease = input.parentAttempt.attempt.lease;
+  if (lease === undefined || input.parentAttempt.step.implementation.kind !== "agent" || input.parentAttempt.step.implementation.runtimeKind !== "herdr" && input.parentAttempt.step.implementation.runtimeKind !== undefined || input.parentAttempt.attempt.status !== "waiting" && input.parentAttempt.attempt.status !== "running" || lease.ownerId !== input.runnerId)
+    return failed("lease_invalid", "Parent LoopStep lease or runtime was invalid.");
+  const taskId = input.parentAttempt.attempt.taskId;
+  if (taskId === undefined)
+    return failed("task_required", "Herdr execution requires a Task.");
+  if (input.signal?.aborted === true)
+    return { status: "canceled", reason: "canceled" };
+  const adapter = harnessAdapter(input.agent.brief.harness);
+  if (adapter === undefined)
+    return failed("harness_unsupported", `This Runner has no adapter for the ${input.agent.brief.harness} harness.`);
+  const toolless = input.agent.brief.toolless === true;
+  if (toolless && adapter.toolless === undefined)
+    return failed("harness_not_toolless", `The ${adapter.id} harness cannot run an agent without its own tools, so this tool-less Step was not started.`);
+  const fs = yield* FileSystem;
+  const model = input.agent.brief.model ?? input.parentAttempt.attempt.execution.metadata.model;
+  const effort = input.agent.brief.effort;
+  const mcp = {
+    ...input.agent.kitmanMcp,
+    env: {
+      KITMAN_STEP_CREDENTIAL: input.agent.stepCredential,
+      KITMAN_API_URL: input.agent.apiUrl,
+      ...toolless ? { KITMAN_STEP_TOOLS: "output" } : undefined
+    }
+  };
+  const configDir = yield* fs.makeTempDirectoryScoped({ prefix: "kitman-harness-" }).pipe(orDie);
+  const launch = resolveHarnessLaunch({
+    adapter,
+    ...isString2(model) ? { model } : undefined,
+    ...effort === undefined ? undefined : { effort },
+    mcp: { ...mcp, environment: Object.keys(mcp.env) },
+    configDir,
+    ...input.agent.brief.skills === undefined ? undefined : { skills: input.agent.brief.skills },
+    toolless,
+    ...input.agent.session === undefined ? undefined : {
+      session: {
+        id: input.agent.session.id,
+        ...input.agent.session.transcript === undefined ? undefined : { transcript: input.agent.session.transcript }
+      }
+    }
+  });
+  const reachable = yield* exit(input.agent.preflight(mcp));
+  if (isFailure2(reachable))
+    return failed("kitman_mcp_unreachable", "Kitman MCP was not reachable from the harness; the agent was not started.");
+  const state = { agentStarted: false };
+  const execute = gen(function* () {
+    const worktreePath = input.workspace.path;
+    if (worktreePath.trim().length === 0)
+      return yield* new HerdrHarnessError({ message: "task_workspace_unavailable" });
+    const policy = stepSandboxPolicy({
+      policy: input.sandbox.policy,
+      adapter,
+      workspace: worktreePath,
+      configDir,
+      environment: { ...input.agent.secrets, ...launch.env, ...mcp.env }
+    });
+    const srt = input.sandbox.backend === "srt" ? yield* prepareSrtPane({
+      policy,
+      binary: launch.binary,
+      srtCommand: input.sandbox.srtCommand ?? pinnedSrtCommand(),
+      path: (yield* optionalEnv("PATH")) ?? ""
+    }).pipe(mapError(() => new HerdrHarnessError({ message: "sandbox_settings_unwritable" }))) : undefined;
+    const docker = input.sandbox.backend !== "docker" ? undefined : input.sandbox.docker === undefined ? yield* new HerdrHarnessError({ message: "sandbox_unavailable" }) : yield* prepareDockerPane({
+      docker: input.sandbox.docker,
+      runnerId: input.runnerId,
+      attemptId: input.parentAttempt.attempt.id,
+      policy,
+      workspace: worktreePath,
+      configDir
+    }).pipe(mapError(() => new HerdrHarnessError({ message: "sandbox_container_unavailable" })));
+    const path = yield* Path;
+    const files = launch.files.map((file) => ({
+      ...file,
+      root: file.inWorkspace === true ? worktreePath : configDir,
+      path: file.inWorkspace === true ? `${worktreePath}/${file.path}` : file.path
+    }));
+    if (files.some((file) => !isPathWithin(path, file.root, file.path)))
+      return yield* new HerdrHarnessError({ message: "harness_config_unwritable" });
+    for (const file of files) {
+      const { path } = file;
+      yield* fs.makeDirectory(path.slice(0, path.lastIndexOf("/")), { recursive: true }).pipe(andThen(fs.writeFileString(path, file.content)), mapError(() => new HerdrHarnessError({ message: "harness_config_unwritable" })));
+    }
+    const surface = yield* prepareHerdrExecutionSurface({
+      client: input.client,
+      taskId,
+      stepKey: input.parentAttempt.attempt.stepKey,
+      worktreePath,
+      tabShellEnv: {
+        ...policy.environment,
+        ...srt === undefined ? undefined : { ...srtCacheEnvironment(`${configDir}/cache`), ...srt.env },
+        ...docker?.env
+      }
+    });
+    state.paneId = surface.paneId;
+    state.agentStarted = true;
+    const launched = yield* input.harness.launch({
+      surfaceId: surface.paneId,
+      name: `kitman-agent-${shortId(input.parentAttempt.attempt.id)}`,
+      binary: launch.binary,
+      args: launch.args,
+      native: { "herdr.workspaceId": surface.workspaceId, "herdr.tabId": surface.tabId }
+    });
+    yield* input.harness.prompt({ targetId: launched.targetId, text: firstMessage(input.agent, worktreePath) });
+    const steering = input.control.steering;
+    const deliveries = steering === undefined ? undefined : yield* forkScoped(forever(flatMap(steering.next, (note) => input.harness.prompt({ targetId: launched.targetId, text: note.text }).pipe(matchEffect({
+      onSuccess: () => steering.report(note, true),
+      onFailure: () => steering.report(note, false)
+    })))));
+    const observation = yield* input.harness.observe({
+      targetId: launched.targetId,
+      surfaceId: surface.paneId,
+      baselineSequence: launched.baselineSequence,
+      timeoutMs: input.executionTimeoutMs ?? 30 * 60000,
+      ...input.signal === undefined ? undefined : { signal: input.signal }
+    });
+    if (steering !== undefined && deliveries !== undefined) {
+      yield* interrupt3(deliveries);
+      yield* forEach(yield* steering.undelivered, (note) => steering.report(note, false), { discard: true });
+    }
+    if (observation.kind === "canceled")
+      return { status: "canceled", reason: "canceled" };
+    if (observation.kind === "unreported")
+      return { status: "unreported", reason: "herdr_unavailable" };
+    if (yield* input.control.settled.pipe(orElseSucceed(() => false)))
+      return { status: "settled" };
+    switch (observation.kind) {
+      case "blocked":
+        return { status: "blocked", summary: "The agent stopped for input before submitting its Output." };
+      case "timeout":
+        return failed("timeout", "The agent did not submit its Output before the Step timed out.");
+      case "terminal":
+        return failed("output_missing", "The agent finished without submitting its Output.");
+    }
+  });
+  const teardown = gen(function* () {
+    if (state.paneId !== undefined && state.agentStarted) {
+      yield* input.harness.cancel({ surfaceId: state.paneId, delayMs: input.teardownDelayMs ?? 250 });
+    }
+    if (input.workspace.cleanup !== undefined)
+      yield* ignore(input.workspace.cleanup);
+  });
+  return yield* execute.pipe(catch_(classifyFailure), ensuring(teardown));
+}).pipe(scoped);
+var classifyFailure = (error) => {
+  const cause = error instanceof HarnessError ? error.cause : error;
+  if (cause instanceof HerdrCanceledError)
+    return succeed5({ status: "canceled", reason: "canceled" });
+  if (!(cause instanceof HerdrHarnessError))
+    return as(logError("herdr_executor_error", error.message), {
+      status: "unreported",
+      reason: "herdr_unavailable"
+    });
+  return succeed5(failed(cause.message, "Herdr agent execution failed closed."));
+};
+// packages/agent-runtime/src/agent-backend.ts
+class AgentBackendRefusal extends TaggedError("AgentBackendRefusal") {
+}
+
+class AgentBackend extends Service2()("AgentBackend") {
+}
+var herdrSandboxBackends = ["host"];
+var refuseAgentRequest = (request, enforceable) => {
+  const { attempt } = request;
+  const backend = request.sandbox.backend;
+  if (!enforceable.includes(backend))
+    return new AgentBackendRefusal({
+      reason: "sandbox_unavailable",
+      summary: `\`${backend}\` is not available on this host.`
+    });
+  if (request.sharedRunner && backend === "host")
+    return new AgentBackendRefusal({
+      reason: "sandbox_required",
+      summary: "A shared Runner runs agents only in `srt` or `docker`, never on `host`."
+    });
+  if (backend === "srt" && request.sandbox.policy.network === "open")
+    return new AgentBackendRefusal({
+      reason: "sandbox_network_unsupported",
+      summary: "The Agent opens the network, which `srt` cannot do; it needs `docker`."
+    });
+  if (attempt.step.implementation.kind !== "agent")
+    return new AgentBackendRefusal({ reason: "step_not_agent", summary: "The request is not an agent Step." });
+  if (attempt.attempt.status !== "waiting" && attempt.attempt.status !== "running")
+    return new AgentBackendRefusal({
+      reason: "attempt_not_claimable",
+      summary: `StepAttempt ${attempt.attempt.id} is not claimable.`
+    });
+  if (attempt.attempt.lease === undefined)
+    return new AgentBackendRefusal({
+      reason: "lease_missing",
+      summary: `StepAttempt ${attempt.attempt.id} has no active lease.`
+    });
+  if (attempt.attempt.lease.ownerId !== request.runnerId)
+    return new AgentBackendRefusal({
+      reason: "lease_owner_mismatch",
+      summary: `StepAttempt ${attempt.attempt.id} is leased to another Runner.`
+    });
+  return;
+};
+var herdrAgentBackendLayer = (options) => effect(AgentBackend, gen(function* () {
+  const harness = yield* Harness;
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const sandboxBackends = (options.sandboxBackends ?? herdrSandboxBackends).filter((backend) => backend !== "docker" || options.docker !== undefined);
+  if (options.docker !== undefined)
+    yield* removeRunnerContainers(options.docker.containers, options.docker.runnerId);
+  const client = {
+    request: (method, params) => options.client().request(method, params)
+  };
+  return AgentBackend.of({
+    sandboxBackends,
+    execute: (request) => {
+      const refused = refuseAgentRequest(request, sandboxBackends);
+      if (refused !== undefined)
+        return fail4(refused);
+      return executeHerdrStepAttempt({
+        runnerId: request.runnerId,
+        parentAttempt: request.attempt,
+        workspace: request.workspace,
+        client,
+        harness,
+        agent: request.launch,
+        sandbox: {
+          ...request.sandbox,
+          ...options.srtCommand === undefined ? undefined : { srtCommand: options.srtCommand },
+          ...options.docker === undefined ? undefined : { docker: options.docker }
+        },
+        control: {
+          settled: request.settled,
+          ...request.steering === undefined ? undefined : { steering: request.steering }
+        },
+        ...request.signal === undefined ? undefined : { signal: request.signal },
+        ...options.teardownDelayMs === undefined ? undefined : { teardownDelayMs: options.teardownDelayMs },
+        ...request.executionTimeoutMs === undefined ? undefined : { executionTimeoutMs: request.executionTimeoutMs }
+      }).pipe(provideService(FileSystem, fs), provideService(Path, path));
+    }
+  });
+}));
+// packages/agent-runtime/src/sandbox-host.ts
+var installed = (probe, command, label) => map3(probe("sh", ["-c", `command -v ${command}`]), (found) => found ? [] : [`${label} is not installed`]);
+var srtMissing = (probe, platform) => gen(function* () {
+  if (platform === "darwin")
+    return [
+      ...yield* installed(probe, "sandbox-exec", "Seatbelt (sandbox-exec)"),
+      ...yield* installed(probe, "rg", "ripgrep (rg)")
+    ];
+  if (platform !== "linux")
+    return [`srt does not run on ${platform}`];
+  const tools = [
+    ...yield* installed(probe, "bwrap", "bubblewrap (bwrap)"),
+    ...yield* installed(probe, "socat", "socat"),
+    ...yield* installed(probe, "rg", "ripgrep (rg)")
+  ];
+  if (tools.some((missing) => missing.startsWith("bubblewrap")))
+    return tools;
+  const namespaces = yield* probe("bwrap", ["--unshare-user", "--ro-bind", "/", "/", "true"]);
+  return namespaces ? tools : [
+    ...tools,
+    "unprivileged user namespaces are not allowed (on Ubuntu: sysctl kernel.apparmor_restrict_unprivileged_userns=0)"
+  ];
+});
+var dockerMissing = (probe, image) => map3(probe("docker", ["info"]), (reachable) => [
+  ...reachable ? [] : ["the docker daemon is not reachable"],
+  ...image === undefined ? ["KITMAN_RUNNER_DOCKER_IMAGE is not set"] : /@sha256:[a-f0-9]{64}$/.test(image) ? [] : ["KITMAN_RUNNER_DOCKER_IMAGE is not pinned by digest (image@sha256:...)"]
+]);
+var probeSandboxHost = (probe, platform = process.platform, options = {}) => gen(function* () {
+  const srt = yield* srtMissing(probe, platform);
+  const docker = yield* dockerMissing(probe, options.dockerImage);
+  return {
+    backends: [
+      "host",
+      ...srt.length === 0 ? ["srt"] : [],
+      ...docker.length === 0 ? ["docker"] : []
+    ],
+    unavailable: [
+      ...srt.length === 0 ? [] : [{ backend: "srt", missing: srt }],
+      ...docker.length === 0 ? [] : [{ backend: "docker", missing: docker }]
+    ]
+  };
+});
+var commandHostProbe = map3(ChildProcessSpawner, (spawner) => (command, args) => runCommand2(command, args, { timeout: "10 seconds" }).pipe(as(true), orElseSucceed(() => false), provideService(ChildProcessSpawner, spawner)));
+// packages/agent-runtime/src/herdr-executor.ts
+var agentStepSandboxPolicy = (work, apiUrl, authStore) => ({
+  ...runnerAgentSandboxPolicy(),
+  readDeniedPaths: [...new Set([...runnerAgentSandboxPolicy().readDeniedPaths, authStore])],
+  network: agentNetworkAllowlist({
+    apiUrl,
+    providerHosts: harnessAdapter(work.brief.harness)?.providerHosts ?? [],
+    ...work.repoBinding === undefined ? undefined : { repoBindingHost: work.repoBinding.host },
+    ...work.network === undefined ? undefined : { agent: work.network }
+  })
+});
+function runnerStepAttemptFromAgentStep(work) {
+  return {
+    kind: "step_attempt",
+    attempt: {
+      id: work.id,
+      workspaceId: "",
+      ...work.projectId === undefined ? undefined : { projectId: work.projectId },
+      runId: work.runId,
+      taskId: work.runId,
+      stepKey: work.stepKey,
+      sequence: 0,
+      required: true,
+      attempt: work.attempt,
+      status: "running",
+      inputManifest: { manifestVersion: 1, assembledAt: work.lease.lastHeartbeatAt, entries: [] },
+      execution: { metadata: {} },
+      reviewEvidence: [],
+      lease: {
+        ownerId: work.lease.leaseOwnerId,
+        runnerReplicaId: work.lease.runnerReplicaId,
+        leaseId: work.lease.leaseId,
+        fencingToken: work.lease.fencingToken,
+        capacitySlot: work.lease.capacitySlot,
+        expiresAt: work.lease.leaseExpiresAt,
+        lastHeartbeatAt: work.lease.lastHeartbeatAt
+      },
+      createdAt: work.lease.lastHeartbeatAt,
+      updatedAt: work.lease.lastHeartbeatAt
+    },
+    step: {
+      title: work.stepKey,
+      implementation: { kind: "agent", taskIdRef: work.runId, agentId: work.id, runtimeKind: "herdr" },
+      inputSchemaRef: { kind: "typebox_ref", name: "WorkUnitInput" },
+      outputSchemaRef: { kind: "typebox_ref", name: "WorkUnitOutput" },
+      allowedCapabilities: [],
+      retryPolicy: { maxAttempts: 1, backoff: "none" },
+      timeoutPolicy: { timeoutSeconds: 1800 },
+      metadata: {}
+    }
+  };
+}
+// packages/agent-runtime/src/materialization-plan.ts
+class AgentEnvironmentPlanApplyError extends TaggedError("AgentEnvironmentPlanApplyError") {
+  get message() {
+    return `AgentEnvironment plan apply failed during ${this.phase}: ${this.cause.message}`;
+  }
+}
+var previewAgentEnvironmentPlan = fnUntraced(function* (input) {
+  const skills = yield* previewAgentEnvironmentMaterialization({
+    environment: input.environment,
+    ...input.rootDir === undefined ? undefined : { rootDir: input.rootDir },
+    ...input.scope === undefined ? undefined : { scope: input.scope },
+    ...input.cacheRoot === undefined ? undefined : { cacheRoot: input.cacheRoot },
+    ...input.noInstall === undefined ? undefined : { noInstall: input.noInstall }
+  });
+  const harnessConfig = yield* previewAgentEnvironmentConfigSync({
+    environment: input.environment,
+    materializedSkills: skills.materializedSkills,
+    ...input.syncKit === undefined ? undefined : { syncKit: input.syncKit },
+    ...input.rootDir === undefined ? undefined : { rootDir: input.rootDir },
+    ...input.scope === undefined ? undefined : { scope: input.scope },
+    ...input.mcpCredentialName === undefined ? undefined : { mcpCredentialName: input.mcpCredentialName }
+  });
+  return {
+    harness: input.environment.harness,
+    ...input.syncKit === undefined ? undefined : { syncKitHash: input.syncKit.syncKitHash },
+    skills,
+    harnessConfig,
+    operationCount: skills.operations.length + harnessConfig.operations.length,
+    warnings: [...skills.warnings, ...harnessConfig.warnings].map((item) => item.message)
+  };
+});
+function composeAgentEnvironmentSyncPlan(targets) {
+  return { version: 1, planId: canonicalSha256(targets), targets };
+}
+var applyAgentEnvironmentPlans = fnUntraced(function* (plan) {
+  for (const target of plan.targets)
+    yield* applyAgentEnvironmentMaterialization(target.skills).pipe(mapError((cause) => new AgentEnvironmentPlanApplyError({ phase: "skills", cause })));
+  for (const target of plan.targets)
+    yield* applyAgentEnvironmentConfigSync(target.harnessConfig).pipe(mapError((cause) => new AgentEnvironmentPlanApplyError({ phase: "harness_config", cause })));
+  return plan;
+});
+// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/internal/matcher.js
+var TypeId = "~effect/Match/Matcher";
+var TypeMatcherProto = {
+  [TypeId]: {
+    _input: identity,
+    _filters: identity,
+    _remaining: identity,
+    _result: identity,
+    _return: identity,
+    _args: identity
+  },
+  _tag: "TypeMatcher",
+  add(_case) {
+    return makeTypeMatcher(this.select, [...this.cases, _case]);
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+function makeTypeMatcher(select, cases) {
+  const matcher = Object.create(TypeMatcherProto);
+  matcher.select = select;
+  matcher.cases = cases;
+  return matcher;
+}
+var ValueMatcherProto = {
+  [TypeId]: {
+    _input: identity,
+    _filters: identity,
+    _result: identity,
+    _return: identity,
+    _flavor: identity
+  },
+  _tag: "ValueMatcher",
+  add(_case) {
+    if (isSuccess(this.value)) {
+      return this;
+    }
+    if (_case._tag === "When" && _case.guard(this.provided) === true) {
+      return makeValueMatcher(this.provided, succeed(_case.evaluate(this.provided)));
+    } else if (_case._tag === "Not" && _case.guard(this.provided) === false) {
+      return makeValueMatcher(this.provided, succeed(_case.evaluate(this.provided)));
+    }
+    return this;
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+function makeValueMatcher(provided, value) {
+  const matcher = Object.create(ValueMatcherProto);
+  matcher.provided = provided;
+  matcher.value = value;
+  return matcher;
+}
+var makeWhen = (guard, evaluate) => ({
+  _tag: "When",
+  guard,
+  evaluate
+});
+var valueTags = /* @__PURE__ */ dual(2, (input, fields) => {
+  const match = tagsExhaustive(fields)(makeTypeMatcher(identity, []));
+  return match(input);
+});
+var discriminators = (field) => (fields) => {
+  const predicate = makeWhen((arg) => arg != null && Object.hasOwn(fields, arg[field]), (data) => fields[data[field]](data));
+  return (self) => self.add(predicate);
+};
+var discriminatorsExhaustive = (field) => (fields) => {
+  const addCases = discriminators(field)(fields);
+  return (matcher) => exhaustive(addCases(matcher));
+};
+var tagsExhaustive = /* @__PURE__ */ discriminatorsExhaustive("_tag");
+var result2 = (self) => {
+  if (self._tag === "ValueMatcher") {
+    return self.value;
+  }
+  const len = self.cases.length;
+  if (len === 1) {
+    const _case = self.cases[0];
+    return (...args) => {
+      const input = self.select(...args);
+      if (_case._tag === "When" && _case.guard(input) === true) {
+        return succeed(_case.evaluate(input, ...args));
+      } else if (_case._tag === "Not" && _case.guard(input) === false) {
+        return succeed(_case.evaluate(input, ...args));
+      }
+      return fail(input);
+    };
+  }
+  return (...args) => {
+    const input = self.select(...args);
+    for (let i = 0;i < len; i++) {
+      const _case = self.cases[i];
+      if (_case._tag === "When" && _case.guard(input) === true) {
+        return succeed(_case.evaluate(input, ...args));
+      } else if (_case._tag === "Not" && _case.guard(input) === false) {
+        return succeed(_case.evaluate(input, ...args));
+      }
+    }
+    return fail(input);
+  };
+};
+var getExhaustiveAbsurdErrorMessage = "effect/match/Match/exhaustive: absurd";
+var exhaustive = (self) => {
+  const toResult = result2(self);
+  if (isResult(toResult)) {
+    if (isSuccess(toResult)) {
+      return toResult.success;
+    }
+    throw new Error(getExhaustiveAbsurdErrorMessage);
+  }
+  return (...args) => {
+    const result = toResult(...args);
+    if (isSuccess(result)) {
+      return result.success;
+    }
+    throw new Error(getExhaustiveAbsurdErrorMessage);
+  };
+};
+
+// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/Match.js
+var valueTags2 = valueTags;
+
+// packages/agent-runtime/src/runner-replica.ts
+function controlFailureKind(error) {
+  const status = "status" in error ? error.status : undefined;
+  const code = "code" in error ? error.code : undefined;
+  if (code === "stale_lease" || status === 409)
+    return "stale_lease";
+  if (status === 401 || status === 403)
+    return "unauthorized";
+  if (!isNumber(status) || status === 408 || status === 429 || status >= 500)
+    return "transient";
+  return "rejected";
+}
+
+class RunnerReplicaError extends TaggedError("RunnerReplicaError") {
+  get message() {
+    return `${this.operation} failed (${this.kind})`;
+  }
+}
+
+class RunnerReplicaCancellation extends TaggedError("RunnerReplicaCancellation") {
+  get message() {
+    return "Cancellation requested";
+  }
+}
+var makeReplicaSignals = sync(() => {
+  let generation = 0;
+  let nextWork = makeUnsafe2();
+  const stops = new Map;
+  const mailboxes = new Map;
+  const mailboxFor = (workUnitId) => {
+    const existing = mailboxes.get(workUnitId);
+    if (existing !== undefined)
+      return existing;
+    const created = {
+      notes: [],
+      seen: new Set,
+      arrived: makeUnsafe2(),
+      updated: makeUnsafe2()
+    };
+    mailboxes.set(workUnitId, created);
+    return created;
+  };
+  const nextSteer = (workUnitId) => suspend(() => {
+    const mailbox = mailboxFor(workUnitId);
+    const note = mailbox.notes.shift();
+    if (note !== undefined)
+      return succeed5(note);
+    if (isDoneUnsafe(mailbox.arrived))
+      mailbox.arrived = makeUnsafe2();
+    return andThen(_await(mailbox.arrived), nextSteer(workUnitId));
+  });
+  const stopFor = (workUnitId) => {
+    const existing = stops.get(workUnitId);
+    if (existing !== undefined)
+      return existing;
+    const created = makeUnsafe2();
+    stops.set(workUnitId, created);
+    return created;
+  };
+  const workSignalledAfter = (seen) => suspend(() => generation > seen ? void_2 : _await(nextWork));
+  return {
+    push: (signal) => sync(() => {
+      const stop = (workUnitId, kind) => doneUnsafe(stopFor(workUnitId), succeed2(kind));
+      valueTags2(signal, {
+        WorkAvailable: () => {
+          generation += 1;
+          const signalled = nextWork;
+          nextWork = makeUnsafe2();
+          doneUnsafe(signalled, void_);
+        },
+        LeaseRevoked: ({ workUnitId }) => stop(workUnitId, "lost"),
+        Settled: ({ workUnitId }) => stop(workUnitId, "lost"),
+        Canceled: ({ workUnitId }) => stop(workUnitId, "canceled"),
+        RunSettled: () => {
+          return;
+        },
+        Steer: ({ workUnitId, messageId, text }) => {
+          const mailbox = mailboxFor(workUnitId);
+          if (mailbox.seen.has(messageId))
+            return;
+          mailbox.seen.add(messageId);
+          mailbox.notes.push({ messageId, text });
+          doneUnsafe(mailbox.arrived, void_);
+        },
+        SessionUpdated: ({ workUnitId }) => doneUnsafe(mailboxFor(workUnitId).updated, void_)
+      });
+    }),
+    generation: sync(() => generation),
+    workSignalledAfter,
+    stopped: (workUnitId) => suspend(() => _await(stopFor(workUnitId))),
+    steers: (workUnitId) => ({
+      next: nextSteer(workUnitId),
+      undelivered: sync(() => mailboxFor(workUnitId).notes.splice(0))
+    }),
+    sessionUpdated: (workUnitId) => suspend(() => {
+      const mailbox = mailboxFor(workUnitId);
+      return andThen(_await(mailbox.updated), sync(() => {
+        mailbox.updated = makeUnsafe2();
+      }));
+    }),
+    forget: (workUnitId) => sync(() => {
+      stops.delete(workUnitId);
+      mailboxes.delete(workUnitId);
+    })
+  };
+});
+var leaseInput = (work) => ({
+  leaseOwnerId: work.lease.leaseOwnerId,
+  runnerReplicaId: work.lease.runnerReplicaId,
+  leaseId: work.lease.leaseId,
+  attempt: work.lease.attempt,
+  fencingToken: work.lease.fencingToken,
+  capacitySlot: work.lease.capacitySlot
+});
+function heartbeatInterval(work) {
+  const leasedFor = Date.parse(work.lease.leaseExpiresAt) - Date.parse(work.lease.lastHeartbeatAt);
+  return millis(Math.max(1000, Math.floor(leasedFor / 2)));
+}
+var releaseTimeout = "5 seconds";
+var retryTransient = (effect) => effect.pipe(retry({
+  times: 3,
+  while: (error) => error instanceof RunnerReplicaError && error.kind === "transient",
+  schedule: exponential(millis(100)).pipe(jittered)
+}));
+function runReplica(control, executor, signals) {
+  const call = (operation, effect) => retryTransient(suspend(effect).pipe(mapError((cause) => cause instanceof RunnerReplicaCancellation ? cause : new RunnerReplicaError({ operation, kind: controlFailureKind(cause), cause }))));
+  return scoped(gen(function* () {
+    const claimed = yield* call("claim", control.claim);
+    const work = claimed.workUnit;
+    if (work === undefined)
+      return { status: "idle" };
+    const lease = leaseInput(work);
+    const workHeartbeat = sleep(heartbeatInterval(work)).pipe(flatMap(() => call("heartbeatWork", () => control.heartbeatWork(work.id, lease))), repeat({ until: (heartbeat) => heartbeat?.settled === true }), as({ status: "settled" }));
+    const pushedStop = signals === undefined ? never : signals.stopped(work.id).pipe(flatMap((stop) => stop === "canceled" ? fail4(new RunnerReplicaCancellation) : succeed5({ status: "settled" })), ensuring(signals.forget(work.id)));
+    let completed = false;
+    let leaseLost = false;
+    return yield* gen(function* () {
+      const execution = executor.execute(work).pipe(mapError((cause) => new RunnerReplicaError({ operation: "execute", kind: "rejected", cause })));
+      const outcome = yield* raceFirst(execution, raceFirst(workHeartbeat, pushedStop)).pipe(catchIf((error) => error instanceof RunnerReplicaCancellation, () => succeed5({ status: "canceled", failureSummary: "Cancellation requested" })));
+      if (outcome.status === "deferred")
+        return { status: "idle" };
+      if (outcome.status === "settled") {
+        completed = true;
+        return { status: "completed", workUnitId: work.id };
+      }
+      yield* call("complete", () => control.complete({
+        workUnitId: work.id,
+        lease,
+        idempotencyKey: `${work.id}:${lease.fencingToken}`,
+        outcome
+      }));
+      completed = true;
+      return { status: "completed", workUnitId: work.id };
+    }).pipe(tapError((error) => sync(() => {
+      leaseLost = error instanceof RunnerReplicaError && error.operation !== "execute" && error.kind !== "transient";
+    })), ensuring(suspend(() => completed || leaseLost ? void_2 : call("release", () => control.release(work.id, lease)).pipe(timeout(releaseTimeout), catch_((error) => logWarning("runner_release_failed", error.message))))));
+  }));
+}
+var idleBackoff = (idleIterations) => millis(Math.min(1000 * 2 ** idleIterations, 30000));
+function superviseReplica(input) {
+  const { signals } = input;
+  const claimTurn = makeUnsafe5(1);
+  let emptyAt = -1;
+  const wokenControl = (control, signals) => ({
+    ...control,
+    claim: () => claimTurn.withPermit(gen(function* () {
+      const generation = yield* signals.generation;
+      if (generation <= emptyAt)
+        return {};
+      const claimed = yield* control.claim();
+      if (claimed.workUnit === undefined)
+        emptyAt = Math.max(emptyAt, generation);
+      return claimed;
+    }))
+  });
+  const runSlot = (capacitySlot) => gen(function* () {
+    let idleIterations = 0;
+    let woken = true;
+    while (true) {
+      const seen = signals === undefined ? 0 : yield* signals.generation;
+      const control = input.control(capacitySlot);
+      const exit2 = yield* exit(runReplica(signals !== undefined && woken ? wokenControl(control, signals) : control, input.executor, signals));
+      if (isSuccess2(exit2) && exit2.value.status === "completed") {
+        idleIterations = 0;
+        woken = false;
+        continue;
+      }
+      if (isSuccess2(exit2) && signals !== undefined) {
+        yield* signals.workSignalledAfter(seen);
+        woken = true;
+        continue;
+      }
+      if (isFailure2(exit2)) {
+        const error = findErrorOption(exit2.cause);
+        if (isSome(error) && error.value instanceof RunnerReplicaError && error.value.kind === "unauthorized")
+          return yield* error.value;
+        yield* logError("runner_slot_recoverable_error", capacitySlot, pretty(exit2.cause));
+      }
+      yield* sleep(idleBackoff(idleIterations++));
+    }
+  });
+  const heartbeat = input.control(input.slots[0] ?? "slot-1").heartbeatReplica;
+  const replicaHeartbeat = gen(function* () {
+    while (true) {
+      const exit2 = yield* exit(retryTransient(heartbeatCall(heartbeat)));
+      if (isFailure2(exit2)) {
+        const error = findErrorOption(exit2.cause);
+        if (isSome(error) && error.value.kind === "unauthorized")
+          return yield* error.value;
+        yield* logError("runner_replica_heartbeat_failed", pretty(exit2.cause));
+      }
+      yield* sleep(ReplicaHeartbeatInterval);
+    }
+  });
+  return all([replicaHeartbeat, forEach(input.slots, runSlot, { concurrency: "unbounded", discard: true })], {
+    concurrency: "unbounded",
+    discard: true
+  }).pipe(andThen(never));
+}
+var ReplicaHeartbeatInterval = seconds(10);
+var ReplicaHeartbeatTimeout = seconds(15);
+var heartbeatCall = (heartbeat) => suspend(heartbeat).pipe(timeout(ReplicaHeartbeatTimeout), mapError((cause) => new RunnerReplicaError({ operation: "heartbeatReplica", kind: controlFailureKind(cause), cause })));
+// packages/agent-runtime/src/herdr-executor-surface.ts
+class HerdrExecutorSurfaceError extends TaggedError("HerdrExecutorSurfaceError") {
+}
+function herdrExecutorSurface(input) {
+  const supervisor = input.supervisor ?? new HerdrServerSupervisor({
+    runnerId: input.runnerId,
+    ...input.session === undefined ? undefined : { session: input.session }
+  });
+  const createdWorkspaces = new Set;
+  const createdTabs = new Map;
+  const record = (method, response) => sync(() => {
+    const workspaceId = nestedString(response, ["workspace", "workspace_id"]);
+    const tabId = nestedString(response, ["tab", "tab_id"]);
+    const tabWorkspaceId = nestedString(response, ["tab", "workspace_id"]);
+    if (method === "workspace.create" && workspaceId !== undefined)
+      createdWorkspaces.add(workspaceId);
+    if (method === "tab.create" && tabId !== undefined && tabWorkspaceId !== undefined)
+      createdTabs.set(tabId, tabWorkspaceId);
+  });
+  const prune = suspend(() => {
+    const client = supervisor.executionClient;
+    const workspaces = [...createdWorkspaces];
+    const tabs = [...createdTabs].flatMap(([tabId, workspaceId]) => createdWorkspaces.has(workspaceId) ? [] : [tabId]);
+    createdWorkspaces.clear();
+    createdTabs.clear();
+    return all([
+      ...workspaces.map((workspaceId) => ignore(client.request("workspace.close", { workspace_id: workspaceId }))),
+      ...tabs.map((tabId) => ignore(client.request("tab.close", { tab_id: tabId })))
+    ], { discard: true });
+  });
+  return {
+    executionClient: {
+      request: (method, params) => supervisor.executionClient.request(method, params).pipe(tap((response) => record(method, response)))
+    },
+    start: () => supervisor.start().pipe(mapError((error) => new HerdrExecutorSurfaceError({ reason: "start_failed", message: error.message })), flatMap((readiness) => readiness.protocol === HERDR_SOCKET_PROTOCOL ? void_2 : fail4(new HerdrExecutorSurfaceError({ reason: "start_failed", message: "herdr_protocol_mismatch" })))),
+    stop: () => andThen(prune, supervisor.stop())
+  };
+}
+// packages/agent-runtime/src/kitman-mcp-preflight.ts
+class KitmanMcpUnreachable extends TaggedError("KitmanMcpUnreachable") {
+}
+var handshake = [
+  {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "kitman-runner", version: "1" } }
+  },
+  { jsonrpc: "2.0", method: "notifications/initialized" },
+  { jsonrpc: "2.0", id: 2, method: "tools/call", params: { name: "step_brief", arguments: {} } }
+].map((message) => `${JSON.stringify(message)}
+`).join("");
+var kitmanMcpPreflight = (mcp) => gen(function* () {
+  const spawner = yield* ChildProcessSpawner;
+  const server = yield* spawner.spawn(make15(mcp.command, [...mcp.args], {
+    extendEnv: true,
+    env: mcp.env,
+    stdin: { stream: make13(new TextEncoder().encode(handshake)), endOnDone: false },
+    stderr: "ignore"
+  }));
+  const reply = yield* server.stdout.pipe(decodeText, splitLines, map4((line) => recordValue(getOrUndefined(decodeJsonStringOption(line)))), filter((message) => message?.id === 2), runHead);
+  const result = isSome(reply) ? recordValue(reply.value?.result) : undefined;
+  if (result === undefined || result.isError === true)
+    return yield* new KitmanMcpUnreachable({ message: "Kitman MCP did not return the StepAttempt brief" });
+}).pipe(scoped, timeoutOrElse({
+  duration: "20 seconds",
+  orElse: () => fail4(new KitmanMcpUnreachable({ message: "Kitman MCP did not answer in time" }))
+}), mapError((error) => error instanceof KitmanMcpUnreachable ? error : new KitmanMcpUnreachable({ message: error.message })));
+// packages/agent-runtime/src/loop-bundles.ts
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+class BundleRefused extends TaggedError("BundleRefused") {
+  get message() {
+    return `Loop bundle ${this.digest} refused: ${this.reason}`;
+  }
+}
+var sha2562 = (bytes) => digestSha256(bytes, "hex");
+var bundleCacheDir = fileURLToPath3(new URL("../.bundles/", import.meta.url));
+var kitmanBundles = (input) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const cacheDir = input.cacheDir ?? bundleCacheDir;
+  const fileOf = (digest) => path.join(cacheDir, `${digest}.js`);
+  const refused = (digest, reason) => new BundleRefused({ digest, reason });
+  const verified = (digest, bytes) => sha2562(bytes) === digest ? void_2 : fail4(refused(digest, "its content does not match its digest"));
+  const write = (digest, bytes) => gen(function* () {
+    const written = `${fileOf(digest)}.${yield* nextInt}.partial`;
+    yield* fs.makeDirectory(cacheDir, { recursive: true });
+    yield* fs.writeFile(written, bytes);
+    yield* fs.rename(written, fileOf(digest));
+  }).pipe(mapError((error) => refused(digest, `not cached: ${error.message}`)));
+  const file = (digest) => gen(function* () {
+    const cached = yield* fs.readFile(fileOf(digest)).pipe(option);
+    if (isSome(cached) && sha2562(cached.value) === digest)
+      return fileOf(digest);
+    const fetched = yield* input.fetch(digest).pipe(mapError((error) => refused(digest, `not fetched: ${error.message}`)));
+    const bytes = new TextEncoder().encode(fetched);
+    yield* verified(digest, bytes);
+    yield* write(digest, bytes);
+    return fileOf(digest);
+  });
+  return {
+    file
+  };
+});
+// packages/agent-runtime/src/program-process.ts
+var inheritedEnv = ["PATH", "HOME", "TMPDIR", "LANG", "LC_ALL", "TZ"];
+var programProcessExecutor = (input) => (work) => gen(function* () {
+  const file = yield* input.bundles.file(work.loopDigest);
+  const spawner = yield* ChildProcessSpawner;
+  const { program, ...unit } = work;
+  const inherited = yield* forEach(inheritedEnv, (name) => map3(optionalEnv(name), (value) => value === undefined ? [] : [[name, value]]));
+  const handle = yield* spawner.spawn(make15(input.bun ?? process.execPath, [file], {
+    stdin: make13(new TextEncoder().encode(encodeUnknownJsonStringSync(unit))),
+    stdout: "inherit",
+    stderr: "inherit",
+    extendEnv: false,
+    env: {
+      ...Object.fromEntries(inherited.flat()),
+      KITMAN_LOOP_ID: program.loopId,
+      KITMAN_API_URL: input.apiUrl,
+      KITMAN_PROGRAM_CREDENTIAL: program.credential
+    },
+    forceKillAfter: "5 seconds"
+  }));
+  const exitCode = yield* handle.exitCode;
+  if (exitCode === 0)
+    return { status: "settled" };
+  yield* logWarning("runner_program_exited_unsettled", { workUnitId: work.id, exitCode });
+  return { status: "deferred" };
+}).pipe(scoped, catch_((error) => as(logWarning("runner_program_not_started", error.message), { status: "deferred" })));
+// packages/oversight/src/domain/intent.ts
+var ConstraintKind = Literals(["rule", "semantic"]);
+var ConstraintSeverity = Literals(["block", "warn"]);
+var ConstraintSource = Literals(["launch", "repository", "plan", "parent", "human"]);
+var ProtectedPathsRule = Struct({
+  kind: Literal("protected_paths"),
+  globs: ArraySchema(String2)
+});
+var Constraint = Struct({
+  id: String2,
+  text: String2,
+  kind: ConstraintKind,
+  severity: ConstraintSeverity,
+  source: ConstraintSource,
+  rule: optionalKey(ProtectedPathsRule)
+});
+var Intent = Struct({
+  version: Int,
+  goal: String2,
+  doneWhen: ArraySchema(String2),
+  constraints: ArraySchema(Constraint),
+  corrections: Boolean2,
+  removedConstraintIds: ArraySchema(String2)
+});
+
+class ConstraintSpellingInvalid extends TaggedError2()("ConstraintSpellingInvalid", { message: String2 }) {
+}
+
+class ConstraintNotFound extends TaggedError2()("ConstraintNotFound", {
+  message: String2
+}) {
+}
+// packages/oversight/src/domain/drift.ts
+var EvidenceLimits = { files: 20, linesPerFile: 200, changedPaths: 1000, lineLength: 1000 };
+var outputLines = EvidenceLimits.files * EvidenceLimits.linesPerFile;
+var EvidenceFile = Struct({
+  path: String2,
+  excerpt: String2,
+  redacted: Boolean2,
+  truncated: Boolean2
+});
+var ChangeEvidence = Struct({
+  kind: Literal("change"),
+  changedPaths: ArraySchema(String2),
+  omittedPaths: Int,
+  files: ArraySchema(EvidenceFile),
+  truncated: Boolean2
+});
+var OutputEvidence = Struct({
+  kind: Literal("output"),
+  text: String2,
+  truncated: Boolean2
+});
+var Evidence = Union([ChangeEvidence, OutputEvidence]);
+var globParts = new Map([
+  ["**/", "(?:.*/)?"],
+  ["**", ".*"],
+  ["*", "[^/]*"],
+  ["?", "[^/]"]
+]);
+var secretName = /^\.env(\..*)?$|^\.?credentials(\..*)?$|^\.(netrc|npmrc|pgpass)$|\.(pem|key|p12|pfx|jks|keystore)$|^id_(rsa|dsa|ecdsa|ed25519)|secret/i;
+var looksSecret = (path) => secretName.test(path.split("/").at(-1) ?? path);
+var capLines = (text, limit) => {
+  const lines = text.split(`
+`);
+  const capped = lines.slice(0, limit).map((line) => line.length > EvidenceLimits.lineLength ? line.slice(0, EvidenceLimits.lineLength) : line);
+  return {
+    text: capped.join(`
+`),
+    truncated: lines.length > limit || lines.some((line) => line.length > EvidenceLimits.lineLength)
+  };
+};
+var boundChange = (change) => {
+  const changedPaths = change.changedPaths.slice(0, EvidenceLimits.changedPaths);
+  const omittedPaths = (change.omittedPaths ?? 0) + change.changedPaths.length - changedPaths.length;
+  const files = changedPaths.slice(0, EvidenceLimits.files).map((path) => {
+    if (looksSecret(path))
+      return { path, excerpt: "", redacted: true, truncated: false };
+    const given = change.files.find((file) => file.path === path);
+    const capped = capLines(given?.diff ?? "", EvidenceLimits.linesPerFile);
+    return { path, excerpt: capped.text, redacted: false, truncated: capped.truncated || given?.truncated === true };
+  });
+  return {
+    kind: "change",
+    changedPaths,
+    omittedPaths,
+    files,
+    truncated: omittedPaths > 0 || changedPaths.length > files.length || files.some((file) => file.truncated)
+  };
+};
+var DriftStatus = Literals(["open", "correction_sent", "escalated", "verified", "dismissed"]);
+var DriftActor = Struct({ actorType: String2, actorId: String2 });
+var DriftResolution = Struct({
+  status: DriftStatus,
+  intentVersion: Int,
+  at: Date2,
+  reason: optionalKey(String2),
+  actor: optionalKey(DriftActor)
+});
+var DriftReport = Struct({
+  constraintId: String2,
+  constraintText: String2,
+  kind: ConstraintKind,
+  severity: ConstraintSeverity,
+  intentVersion: Int,
+  citedPaths: ArraySchema(String2),
+  truncated: Boolean2,
+  status: DriftStatus,
+  history: ArraySchema(DriftResolution)
+});
+
+class DriftReportNotOpen extends TaggedError2()("DriftReportNotOpen", {
+  message: String2
+}) {
+}
+// packages/oversight/src/domain/judgement.ts
+var ConstraintVerdict = Literals(["holds", "breached", "unverified"]);
+var OutcomeVerdict = Literals(["met", "not_met", "unverified"]);
+var Citation = Struct({ path: String2, line: optionalKey(Int) });
+var JudgeOutput = Struct({
+  constraints: ArraySchema(Struct({ id: String2, verdict: ConstraintVerdict, citations: ArraySchema(Citation) })),
+  goal: optionalKey(OutcomeVerdict),
+  doneWhen: optionalKey(ArraySchema(Struct({ item: Int, verdict: OutcomeVerdict })))
+});
+var JudgementReading = Struct({
+  constraints: ArraySchema(Struct({ constraintId: String2, verdict: ConstraintVerdict, citations: ArraySchema(Citation) })),
+  goal: optionalKey(OutcomeVerdict),
+  doneWhen: optionalKey(ArraySchema(OutcomeVerdict))
+});
+var verdictEnum = (values) => ({ type: "string", enum: values });
+var closedObject = (properties, required) => ({
+  type: "object",
+  additionalProperties: false,
+  required,
+  properties
+});
+var constraintsSchema = {
+  type: "array",
+  items: closedObject({
+    id: { type: "string" },
+    verdict: verdictEnum(ConstraintVerdict.literals),
+    citations: {
+      type: "array",
+      items: closedObject({ path: { type: "string" }, line: { type: "integer", minimum: 1 } }, ["path"])
+    }
+  }, ["id", "verdict", "citations"])
+};
+// packages/oversight/src/domain/alignment.ts
+var AlignmentVerdict = Literals(["aligned", "not_aligned", "unverified"]);
+var Alignment = Struct({
+  verdict: AlignmentVerdict,
+  reasons: ArraySchema(String2),
+  intentVersion: Int,
+  judgedAt: Date2
+});
+// packages/agent-runtime/src/agent-step-executor.ts
+import { homedir } from "os";
+
+// packages/agent-runtime/src/harness-sessions.ts
+import { gunzipSync, gzipSync } from "zlib";
+var projectDirectory = (worktree) => worktree.replace(/[^a-zA-Z0-9]/g, "-");
+var rolloutId = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
+var filesUnder = (directory) => gen(function* () {
+  const fs = yield* FileSystem;
+  if (!(yield* fs.exists(directory)))
+    return [];
+  return (yield* fs.readDirectory(directory, { recursive: true })).map((file) => `${directory}/${file}`);
+});
+var rolloutDirectory = (path) => gen(function* () {
+  const fs = yield* FileSystem;
+  const firstLine = (yield* fs.readFileString(path)).split(`
+`, 1)[0] ?? "";
+  const line = getOrUndefined(decodeJsonStringOption(firstLine));
+  const payload = isJsonObject(line) ? line.payload : undefined;
+  return isJsonObject(payload) && isString2(payload.cwd) ? payload.cwd : undefined;
+});
+var findSession = (adapter, place) => gen(function* () {
+  const location = adapter.session?.location;
+  if (location === undefined)
+    return;
+  const root = `${place.home}/${location.root}`;
+  if (location.layout === "per_directory") {
+    if (place.id === undefined)
+      return;
+    const name = `${place.id}.jsonl`;
+    const own = `${root}/${projectDirectory(place.worktree)}/${name}`;
+    const fs = yield* FileSystem;
+    const path = (yield* fs.exists(own)) ? own : (yield* filesUnder(root)).find((file) => file.endsWith(`/${name}`));
+    return path === undefined ? undefined : { id: place.id, name, path };
+  }
+  for (const path of (yield* filesUnder(root)).filter((file) => rolloutId.test(file)).sort().reverse()) {
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    const id = rolloutId.exec(name)?.[1];
+    if (id === undefined)
+      continue;
+    if (place.id === undefined ? (yield* rolloutDirectory(path)) === place.worktree : id === place.id)
+      return { id, name, path };
+  }
+  return;
+}).pipe(orElseSucceed(() => {
+  return;
+}));
+var packSession = (path) => map3(flatMap(FileSystem, (fs) => fs.readFile(path)), (content) => new Uint8Array(gzipSync(content)));
+var restoreSession = (adapter, place) => gen(function* () {
+  const fs = yield* FileSystem;
+  const location = adapter.session?.location;
+  if (location === undefined)
+    return yield* die3(`${adapter.id} keeps no session to restore`);
+  const root = `${place.home}/${location.root}`;
+  const today = toDate(wallClockMillis()).toISOString().slice(0, 10).replaceAll("-", "/");
+  const directory = location.layout === "per_directory" ? `${root}/${projectDirectory(place.worktree)}` : `${root}/${today}`;
+  const path = `${directory}/${place.session.name}`;
+  yield* fs.makeDirectory(directory, { recursive: true });
+  yield* fs.writeFile(path, new Uint8Array(gunzipSync(place.session.content)));
+  return { id: place.session.id, name: place.session.name, path };
+});
+
+// packages/agent-runtime/src/agent-step-executor.ts
+var transfer = { timeout: "30 minutes" };
+var stallLimit = ["-c", "http.lowSpeedLimit=1000", "-c", "http.lowSpeedTime=60"];
+var checkpointTransfer = { timeout: "5 minutes" };
+var clonePermits = new Map;
+var inClone = (directory) => (effect) => {
+  const permit = clonePermits.get(directory) ?? makeUnsafe5(1);
+  clonePermits.set(directory, permit);
+  return permit.withPermits(1)(effect);
+};
+var runCheckouts = (rootDir) => {
+  const runsDir = `${rootDir}/runs`;
+  const reposDir = `${rootDir}/repos`;
+  const cloned = (repoBinding) => gen(function* () {
+    const fs = yield* FileSystem;
+    const path = yield* Path;
+    const forbidden = findForbiddenRepoBindingSecretPath(repoBinding);
+    if (forbidden !== undefined)
+      return yield* new RepoMaterializationError({
+        message: `RepoBinding contains forbidden secret-like value at ${forbidden}`
+      });
+    const directory = path.join(reposDir, repoBinding.id);
+    const url = repositoryUrl(repoBinding);
+    if (yield* fs.exists(directory)) {
+      const origin = yield* runCommand2("git", ["-C", directory, "remote", "get-url", "origin"]);
+      if (origin.trim() !== url)
+        return yield* new RepoMaterializationError({
+          message: "Existing runner-managed repository cache failed validation."
+        });
+    } else
+      yield* runCommand2("git", [...stallLimit, "clone", "--origin", "origin", "--no-checkout", url, directory], transfer);
+    return directory;
+  });
+  const fetch = (directory) => runCommand2("git", ["-C", directory, ...stallLimit, "fetch", "--prune", "origin"], transfer);
+  const inCloneOf = (repoBinding) => inClone(`${reposDir}/${repoBinding.id}`);
+  const clone = (repoBinding) => inCloneOf(repoBinding)(cloned(repoBinding));
+  const holds = (directory, revision) => revision === undefined || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(revision) ? succeed5(false) : map3(exit(runCommand2("git", ["-C", directory, "cat-file", "-e", `${revision}^{commit}`])), isSuccess2);
+  const checkout = (work, repoBinding, checkpoint) => gen(function* () {
+    const fs = yield* FileSystem;
+    const path = yield* Path;
+    const repository = yield* cloned(repoBinding);
+    const worktree = path.join(runsDir, work.runId, work.id);
+    if (checkpoint === undefined && !(yield* holds(repository, work.baseRevision)))
+      yield* fetch(repository);
+    if (yield* fs.exists(worktree))
+      yield* fs.remove(worktree, { recursive: true });
+    yield* runCommand2("git", ["-C", repository, "worktree", "prune"]);
+    if (checkpoint === undefined) {
+      yield* runCommand2("git", [
+        "-C",
+        repository,
+        "worktree",
+        "add",
+        "--detach",
+        worktree,
+        work.baseRevision ?? `origin/${repoBinding.defaultTargetBranch}`
+      ]);
+      return worktree;
+    }
+    yield* runCommand2("git", ["-C", repository, ...stallLimit, "fetch", "origin", checkpoint.ref], transfer);
+    yield* runCommand2("git", ["-C", repository, "worktree", "add", "--detach", worktree, `${checkpoint.revision}^`]);
+    yield* runCommand2("git", ["-C", worktree, "read-tree", "-u", "--reset", checkpoint.revision]);
+    yield* runCommand2("git", ["-C", worktree, "reset", "--quiet"]);
+    return worktree;
+  }).pipe(inCloneOf(repoBinding));
+  const scratch = (work) => gen(function* () {
+    const fs = yield* FileSystem;
+    const directory = `${rootDir}/scratch/${work.id}`;
+    return yield* acquireRelease(as(fs.makeDirectory(directory, { recursive: true }), directory), () => ignore(fs.remove(directory, { recursive: true, force: true })));
+  });
+  return {
+    clone,
+    checkout,
+    scratch,
+    held: gen(function* () {
+      const fs = yield* FileSystem;
+      return (yield* fs.exists(runsDir)) ? [...yield* fs.readDirectory(runsDir)].sort() : [];
+    }),
+    drop: (runId) => gen(function* () {
+      const fs = yield* FileSystem;
+      yield* fs.remove(`${runsDir}/${runId}`, { recursive: true, force: true });
+      for (const repo of (yield* fs.exists(reposDir)) ? yield* fs.readDirectory(reposDir) : [])
+        yield* ignore(runCommand2("git", ["-C", `${reposDir}/${repo}`, "worktree", "prune"])).pipe(inClone(`${reposDir}/${repo}`));
+    })
+  };
+};
+var isRunSettled = is(RunSettled);
+var clearSettledCheckpoints = (rpc, checkouts) => gen(function* () {
+  const deleted = yield* forEach(yield* rpc.settledCheckpoints, (checkpoint) => checkpoint.ref === undefined || checkpoint.repoBinding === undefined ? succeed5([checkpoint.stepAttemptId]) : deleteRef(checkouts, checkpoint.repoBinding, checkpoint.ref).pipe(as([checkpoint.stepAttemptId]), catch_((error) => as(logWarning("runner_checkpoint_ref_kept", error.message), []))));
+  if (deleted.flat().length > 0)
+    yield* rpc.forgetCheckpoints(deleted.flat());
+});
+var deleteRef = (checkouts, repoBinding, ref) => gen(function* () {
+  const repository = yield* checkouts.clone(repoBinding);
+  if ((yield* runCommand2("git", ["-C", repository, "ls-remote", "origin", ref])).trim() !== "")
+    yield* runCommand2("git", ["-C", repository, ...stallLimit, "push", "origin", "--delete", ref], transfer);
+});
+var listenForSignals = (input) => gen(function* () {
+  const services = yield* context();
+  const clearCheckpoints = clearSettledCheckpoints(input.rpc, input.checkouts).pipe(catch_((error) => logWarning("runner_checkpoints_not_cleared", error.message)), provideContext(services));
+  const held = yield* input.checkouts.held;
+  const settled = held.length === 0 ? [] : yield* input.rpc.settledRuns(held);
+  yield* forEach(settled, input.checkouts.drop, { discard: true });
+  const scope2 = yield* scope;
+  yield* forkIn(clearCheckpoints, scope2);
+  yield* input.rpc.listen(input.runnerReplicaId, (signal) => isRunSettled(signal) ? ignore(input.checkouts.drop(signal.runId)).pipe(provideContext(services), andThen(forkIn(clearCheckpoints, scope2)), asVoid) : input.signals.push(signal));
+}).pipe(scoped, catch_((error) => logWarning("runner_signals_disconnected", error.message)), catchDefect((defect) => logError("runner_signals_failed", pretty(die(defect)))), andThen(sleep(input.reconnectAfter)), forever);
+var pushWork = (worktree, branch, step) => gen(function* () {
+  const git = (...args) => runCommand2("git", ["-C", worktree, ...args]);
+  yield* git("add", "--all");
+  if (isFailure2(yield* exit(git("diff", "--cached", "--quiet"))))
+    yield* git("-c", "user.name=Kitman", "-c", "user.email=runner@kitman.invalid", "commit", "-m", `Step ${step}`);
+  yield* runCommand2("git", ["-C", worktree, ...stallLimit, "push", "--force", "origin", `HEAD:refs/heads/${branch}`], transfer);
+  return (yield* git("rev-parse", "HEAD")).trim();
+});
+var runChange = (worktree, runBase) => gen(function* () {
+  const git = (...args) => runCommand2("git", ["-C", worktree, ...args]);
+  const base = (yield* git("merge-base", "HEAD", runBase)).trim();
+  const changedPaths = (yield* git("diff", "--name-only", "-z", "--no-renames", base, "HEAD")).split("\x00").filter((path) => path !== "");
+  const files = yield* forEach(changedPaths.slice(0, EvidenceLimits.files).filter((path) => !looksSecret(path)), (path) => map3(git("diff", "--no-color", "--no-renames", base, "HEAD", "--", `:(literal)${path}`), (diff) => ({
+    path,
+    diff
+  })));
+  const change = boundChange({ changedPaths, files });
+  return { ...change, changedPaths: [...change.changedPaths], files: [...change.files] };
+});
+var rpcStepCheckpoints = (rpc, signals) => ({
+  resume: (work) => rpc.resumeCheckpoint({ lease: stepLease(work) }),
+  save: (work, checkpoint) => rpc.saveCheckpoint({ lease: stepLease(work), checkpoint }),
+  sessionUpdated: (work) => signals.sessionUpdated(work.id)
+});
+var stepLease = (work) => ({
+  workUnitId: work.id,
+  leaseOwnerId: work.lease.leaseOwnerId,
+  runnerReplicaId: work.lease.runnerReplicaId,
+  leaseId: work.lease.leaseId,
+  attempt: work.lease.attempt,
+  fencingToken: work.lease.fencingToken,
+  capacitySlot: work.lease.capacitySlot
+});
+var gitIdentity = ["-c", "user.name=Kitman", "-c", "user.email=runner@kitman.invalid"];
+var pushCheckpoint = (worktree, ref, previousTree) => gen(function* () {
+  const fs = yield* FileSystem;
+  const index = (yield* runCommand2("git", [
+    "-C",
+    worktree,
+    "rev-parse",
+    "--path-format=absolute",
+    "--git-path",
+    "index"
+  ])).trim();
+  const scratchIndex = `${index}.kitman-checkpoint`;
+  const git = (...args) => runCommand2("git", ["-C", worktree, ...args], { env: { GIT_INDEX_FILE: scratchIndex } });
+  yield* fs.copyFile(index, scratchIndex);
+  yield* git("add", "--all");
+  const tree = (yield* git("write-tree")).trim();
+  if (tree === previousTree)
+    return;
+  const revision = (yield* git(...gitIdentity, "commit-tree", tree, "-p", "HEAD", "-m", "Kitman checkpoint")).trim();
+  yield* runCommand2("git", ["-C", worktree, ...stallLimit, "push", "--force", "origin", `${revision}:${ref}`], checkpointTransfer);
+  return { tree, ref, revision };
+});
+var restoreCheckpointRef = (worktree, ref, recorded) => runCommand2("git", recorded.revision === undefined ? ["-C", worktree, ...stallLimit, "push", "origin", "--delete", ref] : ["-C", worktree, ...stallLimit, "push", "--force", "origin", `${recorded.revision}:${ref}`], checkpointTransfer);
+var sameBytes = (left, right) => left !== undefined && left.length === right.length && left.every((byte, index) => byte === right[index]);
+var agentStepExecutor = (input) => (work) => gen(function* () {
+  const checkouts = runCheckouts(input.rootDir);
+  const repoBinding = work.checkout === "none" ? undefined : work.repoBinding;
+  const writable = work.checkout === "write" && repoBinding !== undefined;
+  const adapter = harnessAdapter(work.brief.harness);
+  const home = input.home ?? homedir();
+  const point = input.checkpoints === undefined ? undefined : yield* input.checkpoints.resume(work).pipe(catch_((error) => as(logWarning("runner_checkpoint_unavailable", error.message), undefined)));
+  const saved = point?.ref === undefined || point.revision === undefined ? undefined : { ref: point.ref, revision: point.revision };
+  const restored = repoBinding === undefined || saved === undefined ? undefined : yield* checkouts.checkout(work, repoBinding, saved).pipe(catch_((error) => as(logWarning("runner_checkpoint_not_restored", error.message), undefined)));
+  const worktree = restored ?? (repoBinding === undefined ? yield* checkouts.scratch(work) : yield* checkouts.checkout(work, repoBinding));
+  const storedSession = point?.session;
+  const transcript = storedSession === undefined || adapter?.session === undefined || storedSession.harness !== adapter.id ? undefined : yield* restoreSession(adapter, { home, worktree, session: storedSession }).pipe(catch_((error) => as(logWarning("runner_session_not_restored", error.message), undefined)));
+  const session = {
+    id: transcript?.id ?? (yield* (yield* Crypto).randomUUIDv4()),
+    ...transcript === undefined ? undefined : { transcript: transcript.path },
+    workspaceRestored: restored !== undefined
+  };
+  const sessionId = transcript !== undefined || adapter?.session?.start !== undefined ? session.id : undefined;
+  let last = {};
+  const checkpoint = gen(function* () {
+    if (input.checkpoints === undefined)
+      return;
+    const workspace = writable ? yield* pushCheckpoint(worktree, checkpointRef(work), last.tree) : undefined;
+    const file = adapter === undefined ? undefined : yield* findSession(adapter, {
+      home,
+      worktree,
+      ...sessionId === undefined ? undefined : { id: sessionId }
+    });
+    const content = file === undefined ? undefined : yield* packSession(file.path);
+    const sessionChanged = content !== undefined && !sameBytes(last.session, content);
+    if (workspace === undefined && !sessionChanged)
+      return;
+    const next = {
+      ...last,
+      ...workspace,
+      ...content === undefined ? undefined : { session: content }
+    };
+    yield* input.checkpoints.save(work, {
+      ...next.ref === undefined || next.revision === undefined ? undefined : { ref: next.ref, revision: next.revision },
+      ...file === undefined || content === undefined || adapter === undefined ? undefined : { session: { harness: adapter.id, id: file.id, name: file.name, content } }
+    }).pipe(tapError(() => workspace === undefined ? void_2 : ignore(restoreCheckpointRef(worktree, workspace.ref, last))));
+    last = next;
+  }).pipe(catchIf((error) => controlFailureKind(error) !== "stale_lease", (error) => logWarning("runner_checkpoint_failed", error.message)));
+  const checkpoints = input.checkpoints;
+  const checkpointing = checkpoints === undefined ? undefined : yield* forkScoped(forever(andThen(checkpoints.sessionUpdated(work).pipe(timeoutOrElse({ duration: input.checkpointEvery ?? "1 minute", orElse: () => void_2 })), uninterruptible(checkpoint))).pipe(catch_((error) => logWarning("runner_checkpoints_stopped", error.message))));
+  const ran = yield* input.runAgent(work, worktree, session);
+  if (checkpointing !== undefined)
+    yield* interrupt3(checkpointing);
+  if (ran.status !== "finished")
+    return { status: ran.status, failureSummary: ran.summary };
+  const state = yield* input.heartbeat(work);
+  if (state.settled)
+    return { status: "settled" };
+  if (state.outputSubmitted !== true)
+    return {
+      status: "failed",
+      failureSummary: "The agent finished without submitting its Output"
+    };
+  if (work.checkout !== "write" || work.branch === undefined)
+    return { status: "completed" };
+  const revision = yield* pushWork(worktree, work.branch, work.stepKey);
+  const boundary = yield* runChange(worktree, work.runBaseRevision ?? work.baseRevision ?? `origin/${repoBinding?.defaultTargetBranch ?? "HEAD"}`).pipe(catch_((error) => as(logWarning("runner_boundary_unread", error.message), undefined)));
+  return boundary === undefined ? { status: "completed", revision } : { status: "completed", revision, boundary };
+}).pipe(scoped);
+var checkpointRef = (work) => `refs/kitman/checkpoints/${work.runId}/${work.id}`;
+// packages/agent-runtime/src/verification-executor.ts
+var checkTimeout = "30 minutes";
+var runChecks = (worktree, checks, tree, known) => gen(function* () {
+  const path = yield* Path;
+  const due = checks.filter((check) => !known.some((entry) => entry.tree === tree && entry.name === check.name && entry.command === check.command));
+  return yield* forEach(due, (check) => gen(function* () {
+    const startedAt = yield* currentTimeMillis;
+    const ran = yield* runShell2(check.command, {
+      cwd: path.join(worktree, check.workingDirectory ?? "."),
+      timeout: checkTimeout
+    });
+    return {
+      name: check.name,
+      command: check.command,
+      status: ran.exitCode === 0 ? "passed" : "failed",
+      ...ran.exitCode === undefined ? undefined : { exitCode: ran.exitCode },
+      durationMs: (yield* currentTimeMillis) - startedAt,
+      outputTail: redactedOutputTail(ran.output)
+    };
+  }));
+});
+var treeOf = (worktree) => map3(runCommand2("git", ["-C", worktree, "rev-parse", "HEAD^{tree}"]), (tree) => tree.trim());
+var verificationExecutor = (input) => (work) => gen(function* () {
+  const checkouts = runCheckouts(input.rootDir);
+  const head = yield* checkouts.checkout({ runId: work.runId, id: work.id, baseRevision: work.revision }, work.repoBinding);
+  const baseline = yield* checkouts.checkout({ runId: work.runId, id: `${work.id}-baseline` }, work.repoBinding);
+  const headTree = yield* treeOf(head);
+  const baselineTree = yield* treeOf(baseline);
+  const trees = headTree === baselineTree ? [headTree] : [headTree, baselineTree];
+  const known = yield* input.known(work, trees);
+  const headChecks = yield* runChecks(head, work.checks, headTree, known);
+  return {
+    status: "completed",
+    evidence: {
+      head: { revision: work.revision, tree: headTree, checks: headChecks },
+      ...headTree === baselineTree ? undefined : {
+        baseline: {
+          revision: (yield* runCommand2("git", ["-C", baseline, "rev-parse", "HEAD"])).trim(),
+          tree: baselineTree,
+          checks: yield* runChecks(baseline, work.checks, baselineTree, known)
+        }
+      }
+    }
+  };
+});
+var rpcKnownEvidence = (rpc) => (work, trees) => rpc.knownEvidence({ lease: programLease(work), trees: [...trees] });
+
+// packages/agent-runtime/src/index.ts
+var AgentRuntimePackageName = "@kitman/agent-runtime";
+export {
+  AgentBackend,
+  AgentBackendRefusal,
+  AgentEnvironmentConfigSyncError,
+  AgentEnvironmentMaterializationError,
+  AgentEnvironmentPlanApplyError,
+  AgentEnvironmentResolutionError,
+  AgentRuntimeConfigError,
+  AgentRuntimePackageName,
+  BundleRefused,
+  CommandFailed2 as CommandFailed,
+  ContainerError,
+  EgressProxyImage,
+  HERDR_SOCKET_PROTOCOL,
+  Harness,
+  HarnessAdapters,
+  HarnessError,
+  HerdrCanceledError,
+  HerdrExecutorSurfaceError,
+  HerdrHarnessError,
+  HerdrServerError,
+  HerdrServerSupervisor,
+  HerdrSocketClient,
+  HerdrSocketError,
+  KitmanMcpUnreachable,
+  RepoMaterializationError,
+  RunnerLabel,
+  RunnerReplicaCancellation,
+  SkillMaterializationRefused,
+  StepAttemptLabel,
+  abortable,
+  agentStepExecutor,
+  agentStepSandboxPolicy,
+  applyAgentEnvironmentConfigSync,
+  applyAgentEnvironmentMaterialization,
+  applyAgentEnvironmentPlans,
+  assertHerdrRunnerCapability2 as assertHerdrRunnerCapability,
+  bundleCacheDir,
+  clearSettledCheckpoints,
+  commandHostProbe,
+  composeAgentEnvironmentSyncPlan,
+  controlFailureKind,
+  defaultAgentRuntimeUserConfigPath,
+  dockerContainerRunner,
+  dockerMissing,
+  executeHerdrStepAttempt,
+  harnessAdapter,
+  herdrAgentBackendLayer,
+  herdrExecutionExtension2 as herdrExecutionExtension,
+  herdrExecutorSurface,
+  herdrHarnessLayer,
+  herdrNativeExtensionIds2 as herdrNativeExtensionIds,
+  herdrPiRunnerCapabilities2 as herdrPiRunnerCapabilities,
+  herdrPiRunnerCapabilitiesForRepoBinding2 as herdrPiRunnerCapabilitiesForRepoBinding,
+  herdrSandboxBackends,
+  isPathWithin,
+  isRecord2 as isRecord,
+  kitmanBundles,
+  kitmanMcpPreflight,
+  kitmanMcpToolTimeout,
+  kitmanMcpToolTimeoutSeconds,
+  listBuiltInLaunchProfiles,
+  listenForSignals,
+  loadAgentRuntimeConfig,
+  makeHerdrHarness,
+  makeReplicaSignals,
+  nestedString,
+  numberValue,
+  pinnedSrtCommand,
+  prepareDockerPane,
+  prepareSrtPane,
+  previewAgentEnvironmentConfigSync,
+  previewAgentEnvironmentMaterialization,
+  previewAgentEnvironmentPlan,
+  probeSandboxHost,
+  programProcessExecutor,
+  recordList,
+  recordValue,
+  refuseAgentRequest,
+  removeRunnerContainers,
+  repositoryUrl,
+  requestRecord,
+  resolveAgentEnvironment,
+  resolveAgentEnvironmentFromSources,
+  resolveHarnessLaunch,
+  rpcKnownEvidence,
+  rpcStepCheckpoints,
+  runCheckouts,
+  runCommand2 as runCommand,
+  runReplica,
+  runShell2 as runShell,
+  runnerStepAttemptFromAgentStep,
+  setDefaultAgentRuntimeProfile,
+  sha2562 as sha256,
+  shellOutputTailChars2 as shellOutputTailChars,
+  shortId,
+  skillIdentity,
+  srtCacheEnvironment,
+  srtMissing,
+  srtSettings,
+  stepSandboxPolicy,
+  stopOwnedHarness,
+  stringValue,
+  superviseReplica,
+  verificationExecutor,
+  writeAgentEnvironmentConfigFile
+};