terminal-pilot 0.0.5 → 0.0.7

package/dist/commands/index.js

@@ -0,0 +1,3973 @@
+// ../cmdkit/src/index.ts
+import { fileURLToPath } from "node:url";
+
+// ../cmdkit-schema/src/index.ts
+function assertValidEnumValues(values) {
+  if (values.length === 0) {
+    throw new Error("Enum schema requires at least one value");
+  }
+  const uniqueValues = new Set(values);
+  if (uniqueValues.size !== values.length) {
+    throw new Error("Enum schema values must be unique");
+  }
+}
+var S = {
+  String(options = {}) {
+    return {
+      kind: "string",
+      ...options
+    };
+  },
+  Number(options = {}) {
+    return {
+      kind: "number",
+      ...options
+    };
+  },
+  Boolean(options = {}) {
+    return {
+      kind: "boolean",
+      ...options
+    };
+  },
+  Enum(values, options = {}) {
+    assertValidEnumValues(values);
+    return {
+      kind: "enum",
+      values,
+      ...options
+    };
+  },
+  Array(item, options = {}) {
+    return {
+      kind: "array",
+      item,
+      ...options
+    };
+  },
+  Object(shape) {
+    return {
+      kind: "object",
+      shape
+    };
+  },
+  Optional(inner) {
+    return {
+      kind: "optional",
+      inner
+    };
+  }
+};
+
+// ../cmdkit/src/index.ts
+var commandConfigSymbol = /* @__PURE__ */ Symbol("cmdkit.command.config");
+var groupConfigSymbol = /* @__PURE__ */ Symbol("cmdkit.group.config");
+var commandSourcePathSymbol = /* @__PURE__ */ Symbol("cmdkit.command.sourcePath");
+var UserError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UserError";
+  }
+};
+function cloneScope(scope) {
+  return scope === void 0 ? void 0 : [...scope];
+}
+function cloneSecretDefinition(secret) {
+  return {
+    env: secret.env,
+    description: secret.description,
+    optional: secret.optional
+  };
+}
+function cloneSecrets(secrets) {
+  if (secrets === void 0) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(secrets).map(([key, secret]) => [key, cloneSecretDefinition(secret)])
+  );
+}
+function cloneRequires(requires) {
+  if (requires === void 0) {
+    return void 0;
+  }
+  return {
+    auth: requires.auth,
+    apiVersion: requires.apiVersion,
+    check: requires.check
+  };
+}
+function parseStackPath(candidate) {
+  if (candidate.startsWith("file://")) {
+    try {
+      return fileURLToPath(candidate);
+    } catch {
+      return void 0;
+    }
+  }
+  if (candidate.startsWith("/")) {
+    return candidate;
+  }
+  return void 0;
+}
+function extractStackPath(line) {
+  const trimmed = line.trim();
+  const fileIndex = trimmed.indexOf("file://");
+  if (fileIndex >= 0) {
+    const location2 = trimmed.slice(fileIndex);
+    const separatorIndex2 = location2.lastIndexOf(":");
+    const previousSeparatorIndex2 = separatorIndex2 >= 0 ? location2.lastIndexOf(":", separatorIndex2 - 1) : -1;
+    const candidate2 = separatorIndex2 >= 0 && previousSeparatorIndex2 >= 0 ? location2.slice(0, previousSeparatorIndex2) : location2;
+    return parseStackPath(candidate2);
+  }
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex < 0) {
+    return void 0;
+  }
+  const location = trimmed.slice(slashIndex);
+  const separatorIndex = location.lastIndexOf(":");
+  const previousSeparatorIndex = separatorIndex >= 0 ? location.lastIndexOf(":", separatorIndex - 1) : -1;
+  const candidate = separatorIndex >= 0 && previousSeparatorIndex >= 0 ? location.slice(0, previousSeparatorIndex) : location;
+  return parseStackPath(candidate);
+}
+function inferCommandSourcePath() {
+  const stack = new Error().stack;
+  if (typeof stack !== "string") {
+    return void 0;
+  }
+  for (const line of stack.split("\n").slice(1)) {
+    const candidate = extractStackPath(line);
+    if (candidate === void 0) {
+      continue;
+    }
+    if (candidate.includes("/packages/cmdkit/src/index.ts") || candidate.includes("/packages/cmdkit/dist/index.js")) {
+      continue;
+    }
+    return candidate;
+  }
+  return void 0;
+}
+function composeChecks(parentCheck, childCheck) {
+  if (parentCheck === void 0) {
+    return childCheck;
+  }
+  if (childCheck === void 0) {
+    return parentCheck;
+  }
+  return async (ctx) => {
+    const parentResult = await parentCheck(ctx);
+    if (!parentResult.ok) {
+      return parentResult;
+    }
+    return childCheck(ctx);
+  };
+}
+function mergeRequires(parent, child) {
+  if (parent === void 0 && child === void 0) {
+    return void 0;
+  }
+  const merged = {
+    auth: child?.auth ?? parent?.auth,
+    apiVersion: child?.apiVersion ?? parent?.apiVersion,
+    check: composeChecks(parent?.check, child?.check)
+  };
+  if (merged.auth === void 0 && merged.apiVersion === void 0 && merged.check === void 0) {
+    return void 0;
+  }
+  return merged;
+}
+function mergeSecrets(parent, child) {
+  return cloneSecrets({
+    ...parent,
+    ...child
+  });
+}
+function resolveCommandScope(ownScope, inheritedScope) {
+  return cloneScope(ownScope ?? inheritedScope) ?? ["cli", "sdk"];
+}
+function resolveGroupScope(ownScope, inheritedScope) {
+  return cloneScope(ownScope ?? inheritedScope);
+}
+function createBaseCommand(config) {
+  const command = {
+    kind: "command",
+    name: config.name,
+    description: config.description,
+    aliases: [...config.aliases ?? []],
+    positional: [...config.positional ?? []],
+    params: config.params,
+    secrets: cloneSecrets(config.secrets),
+    scope: resolveCommandScope(config.scope, void 0),
+    confirm: config.confirm ?? false,
+    requires: cloneRequires(config.requires),
+    handler: config.handler,
+    render: config.render
+  };
+  Object.defineProperty(command, commandConfigSymbol, {
+    value: {
+      scope: cloneScope(config.scope),
+      secrets: cloneSecrets(config.secrets),
+      requires: cloneRequires(config.requires),
+      sourcePath: inferCommandSourcePath()
+    }
+  });
+  return command;
+}
+function createBaseGroup(config) {
+  const group = {
+    kind: "group",
+    name: config.name,
+    description: config.description,
+    aliases: [...config.aliases ?? []],
+    scope: resolveGroupScope(config.scope, void 0),
+    secrets: cloneSecrets(config.secrets),
+    requires: cloneRequires(config.requires),
+    children: [],
+    default: void 0
+  };
+  Object.defineProperty(group, groupConfigSymbol, {
+    value: {
+      scope: cloneScope(config.scope),
+      secrets: cloneSecrets(config.secrets),
+      requires: cloneRequires(config.requires),
+      children: [...config.children],
+      default: config.default
+    }
+  });
+  return group;
+}
+function getInternalCommandConfig(command) {
+  return command[commandConfigSymbol];
+}
+function getInternalGroupConfig(group) {
+  return group[groupConfigSymbol];
+}
+function materializeCommand(command, inherited) {
+  const internal = getInternalCommandConfig(command);
+  const materialized = {
+    kind: "command",
+    name: command.name,
+    description: command.description,
+    aliases: [...command.aliases],
+    positional: [...command.positional],
+    params: command.params,
+    secrets: mergeSecrets(inherited.secrets, internal.secrets),
+    scope: resolveCommandScope(internal.scope, inherited.scope),
+    confirm: command.confirm,
+    requires: mergeRequires(inherited.requires, internal.requires),
+    handler: command.handler,
+    render: command.render
+  };
+  Object.defineProperty(materialized, commandConfigSymbol, {
+    value: {
+      scope: cloneScope(internal.scope),
+      secrets: cloneSecrets(internal.secrets),
+      requires: cloneRequires(internal.requires),
+      sourcePath: internal.sourcePath
+    }
+  });
+  Object.defineProperty(materialized, commandSourcePathSymbol, {
+    value: internal.sourcePath
+  });
+  return materialized;
+}
+function materializeGroup(group, inherited) {
+  const internal = getInternalGroupConfig(group);
+  const scope = resolveGroupScope(internal.scope, inherited.scope);
+  const secrets = mergeSecrets(inherited.secrets, internal.secrets);
+  const requires = mergeRequires(inherited.requires, internal.requires);
+  const materializedChildren = internal.children.map(
+    (child) => materializeNode(child, {
+      scope,
+      secrets,
+      requires
+    })
+  );
+  let defaultChild;
+  if (internal.default !== void 0) {
+    const defaultIndex = internal.children.indexOf(internal.default);
+    if (defaultIndex === -1) {
+      throw new UserError(`Default command "${internal.default.name}" must be listed in children.`);
+    }
+    const resolvedDefault = materializedChildren[defaultIndex];
+    if (resolvedDefault?.kind !== "command") {
+      throw new UserError(`Default child "${internal.default.name}" must be a command.`);
+    }
+    defaultChild = resolvedDefault;
+  }
+  const materialized = {
+    kind: "group",
+    name: group.name,
+    description: group.description,
+    aliases: [...group.aliases],
+    scope,
+    secrets,
+    requires,
+    children: materializedChildren,
+    default: defaultChild
+  };
+  Object.defineProperty(materialized, groupConfigSymbol, {
+    value: {
+      scope: cloneScope(internal.scope),
+      secrets: cloneSecrets(internal.secrets),
+      requires: cloneRequires(internal.requires),
+      children: [...internal.children],
+      default: internal.default
+    }
+  });
+  return materialized;
+}
+function materializeNode(node, inherited) {
+  if (node.kind === "command") {
+    return materializeCommand(node, inherited);
+  }
+  return materializeGroup(node, inherited);
+}
+function defineCommand(config) {
+  return materializeCommand(createBaseCommand(config), {
+    scope: void 0,
+    secrets: {},
+    requires: void 0
+  });
+}
+function defineGroup(config) {
+  return materializeGroup(createBaseGroup(config), {
+    scope: void 0,
+    secrets: {},
+    requires: void 0
+  });
+}
+
+// src/terminal-pilot.ts
+import { randomUUID } from "node:crypto";
+
+// src/terminal-session.ts
+import { spawn as spawnChildProcess } from "node:child_process";
+import { EventEmitter } from "node:events";
+import * as nodePty from "node-pty";
+
+// src/ansi.ts
+var ESC = 27;
+var BEL = 7;
+var ST = 156;
+var CSI = 155;
+var OSC = 157;
+var DCS = 144;
+var SOS = 152;
+var PM = 158;
+var APC = 159;
+function stripAnsi(input) {
+  let output = "";
+  for (let index = 0; index < input.length; index += 1) {
+    const code = input.charCodeAt(index);
+    if (code === ESC) {
+      const nextCode = input.charCodeAt(index + 1);
+      if (nextCode === 91) {
+        index = consumeCsi(input, index + 2);
+        continue;
+      }
+      if (nextCode === 93) {
+        index = consumeTerminatedString(input, index + 2, true);
+        continue;
+      }
+      if (nextCode === 80 || nextCode === 88 || nextCode === 94 || nextCode === 95) {
+        index = consumeTerminatedString(input, index + 2, false);
+        continue;
+      }
+      if (!Number.isNaN(nextCode)) {
+        index += 1;
+      }
+      continue;
+    }
+    if (code === CSI) {
+      index = consumeCsi(input, index + 1);
+      continue;
+    }
+    if (code === OSC) {
+      index = consumeTerminatedString(input, index + 1, true);
+      continue;
+    }
+    if (code === DCS || code === SOS || code === PM || code === APC) {
+      index = consumeTerminatedString(input, index + 1, false);
+      continue;
+    }
+    output += input[index];
+  }
+  return output;
+}
+function consumeCsi(input, index) {
+  while (index < input.length) {
+    const code = input.charCodeAt(index);
+    if (code >= 64 && code <= 126) {
+      return index;
+    }
+    index += 1;
+  }
+  return input.length;
+}
+function consumeTerminatedString(input, index, allowBellTerminator) {
+  while (index < input.length) {
+    const code = input.charCodeAt(index);
+    if (code === ST || allowBellTerminator && code === BEL) {
+      return index;
+    }
+    if (code === ESC && input.charCodeAt(index + 1) === 92) {
+      return index + 1;
+    }
+    index += 1;
+  }
+  return input.length;
+}
+
+// src/terminal-buffer.ts
+var RESET_SGR = "\x1B[0m";
+var TerminalBuffer = class {
+  _cols;
+  _rows;
+  _screen;
+  _cursorX = 0;
+  _cursorY = 0;
+  _savedCursor = { x: 0, y: 0 };
+  _scrollTop = 0;
+  _scrollBottom;
+  _state = 0 /* Normal */;
+  _csiParams = "";
+  _csiPrivate = "";
+  _style = createDefaultStyleState();
+  _styleSequence = "";
+  displayBuffer;
+  constructor(cols, rows) {
+    this._cols = cols;
+    this._rows = rows;
+    this._scrollBottom = rows - 1;
+    this._screen = this._makeScreen(cols, rows);
+    this.displayBuffer = Object.defineProperties(
+      {},
+      {
+        cursorX: { get: () => this._cursorX, enumerable: true },
+        cursorY: { get: () => this._cursorY, enumerable: true },
+        data: { get: () => this._screen, enumerable: true }
+      }
+    );
+  }
+  write(data) {
+    for (const ch of data) {
+      this._feed(ch);
+    }
+  }
+  renderLine(row) {
+    const cells = this._screen[row] ?? [];
+    let lastVisibleCell = -1;
+    for (let index = cells.length - 1; index >= 0; index -= 1) {
+      if (cells[index] !== null) {
+        lastVisibleCell = index;
+        break;
+      }
+    }
+    if (lastVisibleCell === -1) {
+      return "";
+    }
+    let line = "";
+    let activeStyle = "";
+    for (let index = 0; index <= lastVisibleCell; index += 1) {
+      const cell = cells[index];
+      const cellStyle = cell?.style ?? "";
+      if (cellStyle !== activeStyle) {
+        line += cellStyle.length > 0 ? cellStyle : RESET_SGR;
+        activeStyle = cellStyle;
+      }
+      line += cell?.[1] ?? " ";
+    }
+    if (activeStyle.length > 0) {
+      line += RESET_SGR;
+    }
+    return line;
+  }
+  resize(cols, rows) {
+    while (this._screen.length < rows) {
+      this._screen.push(this._makeRow(cols));
+    }
+    this._screen.length = rows;
+    for (let y = 0; y < rows; y++) {
+      const row = this._screen[y] ?? this._makeRow(cols);
+      while (row.length < cols) row.push(null);
+      row.length = cols;
+      this._screen[y] = row;
+    }
+    this._cols = cols;
+    this._rows = rows;
+    this._scrollTop = 0;
+    this._scrollBottom = rows - 1;
+    this._cursorX = this._clamp(this._cursorX, 0, cols - 1);
+    this._cursorY = this._clamp(this._cursorY, 0, rows - 1);
+  }
+  _makeScreen(cols, rows) {
+    return Array.from({ length: rows }, () => this._makeRow(cols));
+  }
+  _makeRow(cols) {
+    return Array(cols).fill(null);
+  }
+  _clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+  }
+  _setChar(y, x, ch) {
+    const row = this._screen[y];
+    if (row && x >= 0 && x < this._cols) {
+      const cell = [ch.charCodeAt(0), ch];
+      if (this._styleSequence.length > 0) {
+        Object.defineProperty(cell, "style", {
+          value: this._styleSequence,
+          writable: true,
+          configurable: true
+        });
+      }
+      row[x] = cell;
+    }
+  }
+  _eraseLine(y, fromX, toX) {
+    const row = this._screen[y];
+    if (!row) return;
+    for (let x = fromX; x <= toX && x < this._cols; x++) {
+      row[x] = null;
+    }
+  }
+  _scrollUp(count) {
+    for (let i = 0; i < count; i++) {
+      this._screen.splice(this._scrollTop, 1);
+      this._screen.splice(this._scrollBottom, 0, this._makeRow(this._cols));
+    }
+  }
+  _scrollDown(count) {
+    for (let i = 0; i < count; i++) {
+      this._screen.splice(this._scrollBottom, 1);
+      this._screen.splice(this._scrollTop, 0, this._makeRow(this._cols));
+    }
+  }
+  _newline() {
+    if (this._cursorY === this._scrollBottom) {
+      this._scrollUp(1);
+    } else {
+      this._cursorY = Math.min(this._cursorY + 1, this._rows - 1);
+    }
+  }
+  _parseCsiParams() {
+    if (!this._csiParams) return [];
+    return this._csiParams.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+  }
+  _execCsi(final) {
+    const params17 = this._parseCsiParams();
+    const p0 = params17[0] ?? 0;
+    const p1 = params17[1] ?? 0;
+    if (this._csiPrivate === "?") {
+      if (final === "h" || final === "l") {
+        if (params17.includes(1049)) {
+          if (final === "h") {
+            this._screen = this._makeScreen(this._cols, this._rows);
+            this._cursorX = 0;
+            this._cursorY = 0;
+          } else {
+            this._screen = this._makeScreen(this._cols, this._rows);
+            this._cursorX = 0;
+            this._cursorY = 0;
+          }
+          this._resetStyle();
+        }
+      }
+      return;
+    }
+    switch (final) {
+      case "A":
+        this._cursorY = this._clamp(this._cursorY - Math.max(1, p0), 0, this._rows - 1);
+        break;
+      case "B":
+        this._cursorY = this._clamp(this._cursorY + Math.max(1, p0), 0, this._rows - 1);
+        break;
+      case "C":
+      // cursor forward
+      case "a":
+        this._cursorX = this._clamp(this._cursorX + Math.max(1, p0), 0, this._cols - 1);
+        break;
+      case "D":
+        this._cursorX = this._clamp(this._cursorX - Math.max(1, p0), 0, this._cols - 1);
+        break;
+      case "E":
+        this._cursorY = this._clamp(this._cursorY + Math.max(1, p0), 0, this._rows - 1);
+        this._cursorX = 0;
+        break;
+      case "F":
+        this._cursorY = this._clamp(this._cursorY - Math.max(1, p0), 0, this._rows - 1);
+        this._cursorX = 0;
+        break;
+      case "G":
+      // cursor horizontal absolute
+      case "`":
+        this._cursorX = this._clamp(Math.max(1, p0) - 1, 0, this._cols - 1);
+        break;
+      case "H":
+      // cursor position
+      case "f":
+        this._cursorY = this._clamp(Math.max(1, p0) - 1, 0, this._rows - 1);
+        this._cursorX = this._clamp(Math.max(1, p1) - 1, 0, this._cols - 1);
+        break;
+      case "I":
+        for (let i = 0; i < Math.max(1, p0); i++) {
+          this._cursorX = Math.min(this._cols - 1, (Math.floor(this._cursorX / 8) + 1) * 8);
+        }
+        break;
+      case "J":
+        if (p0 === 0) {
+          this._eraseLine(this._cursorY, this._cursorX, this._cols - 1);
+          for (let y = this._cursorY + 1; y < this._rows; y++) this._eraseLine(y, 0, this._cols - 1);
+        } else if (p0 === 1) {
+          for (let y = 0; y < this._cursorY; y++) this._eraseLine(y, 0, this._cols - 1);
+          this._eraseLine(this._cursorY, 0, this._cursorX);
+        } else if (p0 === 2 || p0 === 3) {
+          for (let y = 0; y < this._rows; y++) this._eraseLine(y, 0, this._cols - 1);
+        }
+        break;
+      case "K":
+        if (p0 === 0) this._eraseLine(this._cursorY, this._cursorX, this._cols - 1);
+        else if (p0 === 1) this._eraseLine(this._cursorY, 0, this._cursorX);
+        else if (p0 === 2) this._eraseLine(this._cursorY, 0, this._cols - 1);
+        break;
+      case "X":
+        this._eraseLine(this._cursorY, this._cursorX, this._cursorX + Math.max(1, p0) - 1);
+        break;
+      case "L": {
+        const n = Math.max(1, p0);
+        for (let i = 0; i < n; i++) {
+          this._screen.splice(this._scrollBottom, 1);
+          this._screen.splice(this._cursorY, 0, this._makeRow(this._cols));
+        }
+        break;
+      }
+      case "M": {
+        const n = Math.max(1, p0);
+        for (let i = 0; i < n; i++) {
+          this._screen.splice(this._cursorY, 1);
+          this._screen.splice(this._scrollBottom, 0, this._makeRow(this._cols));
+        }
+        break;
+      }
+      case "P": {
+        const row = this._screen[this._cursorY];
+        if (row) {
+          const n = Math.max(1, p0);
+          row.splice(this._cursorX, n);
+          while (row.length < this._cols) row.push(null);
+        }
+        break;
+      }
+      case "@": {
+        const row = this._screen[this._cursorY];
+        if (row) {
+          const n = Math.max(1, p0);
+          for (let i = 0; i < n; i++) row.splice(this._cursorX, 0, null);
+          row.splice(this._cols);
+        }
+        break;
+      }
+      case "S":
+        this._scrollUp(Math.max(1, p0));
+        break;
+      case "T":
+        if (params17.length <= 1) this._scrollDown(Math.max(1, p0));
+        break;
+      case "Z": {
+        const n = Math.max(1, p0);
+        for (let i = 0; i < n; i++) {
+          this._cursorX = Math.max(0, (Math.ceil(this._cursorX / 8) - 1) * 8);
+        }
+        break;
+      }
+      case "d":
+        this._cursorY = this._clamp(Math.max(1, p0) - 1, 0, this._rows - 1);
+        break;
+      case "e":
+        this._cursorY = this._clamp(this._cursorY + Math.max(1, p0), 0, this._rows - 1);
+        break;
+      case "r": {
+        const top = this._clamp(Math.max(1, p0) - 1, 0, this._rows - 1);
+        const bottom = this._clamp((p1 === 0 ? this._rows : p1) - 1, 0, this._rows - 1);
+        if (top < bottom) {
+          this._scrollTop = top;
+          this._scrollBottom = bottom;
+        }
+        this._cursorX = 0;
+        this._cursorY = 0;
+        break;
+      }
+      case "s":
+        this._savedCursor = { x: this._cursorX, y: this._cursorY };
+        break;
+      case "u":
+        this._cursorX = this._clamp(this._savedCursor.x, 0, this._cols - 1);
+        this._cursorY = this._clamp(this._savedCursor.y, 0, this._rows - 1);
+        break;
+      case "m":
+        this._applySgr(params17);
+        break;
+      default:
+        break;
+    }
+  }
+  _feed(ch) {
+    const code = ch.charCodeAt(0);
+    switch (this._state) {
+      case 0 /* Normal */:
+        this._feedNormal(ch, code);
+        break;
+      case 1 /* Escape */:
+        this._feedEscape(ch, code);
+        break;
+      case 2 /* Csi */:
+        this._feedCsi(ch, code);
+        break;
+      case 3 /* Osc */:
+        if (code === 7 || code === 156) {
+          this._state = 0 /* Normal */;
+        } else if (code === 27) {
+          this._state = 0 /* Normal */;
+        }
+        break;
+      case 4 /* Str */:
+        if (code === 156 || code === 7) {
+          this._state = 0 /* Normal */;
+        } else if (code === 27) {
+          this._state = 0 /* Normal */;
+        }
+        break;
+      case 5 /* EscCharset */:
+        this._state = 0 /* Normal */;
+        break;
+      case 6 /* EscHash */:
+        this._state = 0 /* Normal */;
+        break;
+    }
+  }
+  _feedNormal(ch, code) {
+    if (code === 27) {
+      this._state = 1 /* Escape */;
+    } else if (code === 155) {
+      this._csiParams = "";
+      this._csiPrivate = "";
+      this._state = 2 /* Csi */;
+    } else if (code === 157) {
+      this._state = 3 /* Osc */;
+    } else if (code === 144 || code === 152 || code === 158 || code === 159) {
+      this._state = 4 /* Str */;
+    } else if (code === 7 || code === 5 || code === 6) {
+    } else if (code === 8) {
+      if (this._cursorX > 0) this._cursorX--;
+    } else if (code === 127) {
+      if (this._cursorX > 0) {
+        this._cursorX--;
+        this._setChar(this._cursorY, this._cursorX, " ");
+      }
+    } else if (code === 9) {
+      this._cursorX = Math.min(this._cols - 1, (Math.floor(this._cursorX / 8) + 1) * 8);
+    } else if (code === 10 || code === 11 || code === 12) {
+      this._newline();
+    } else if (code === 13) {
+      this._cursorX = 0;
+    } else if (code === 14 || code === 15) {
+    } else if (code >= 32 && code !== 127) {
+      this._setChar(this._cursorY, this._cursorX, ch);
+      this._cursorX++;
+      if (this._cursorX >= this._cols) {
+        this._cursorX = 0;
+        this._newline();
+      }
+    }
+  }
+  _feedEscape(ch, code) {
+    this._state = 0 /* Normal */;
+    if (code === 91) {
+      this._csiParams = "";
+      this._csiPrivate = "";
+      this._state = 2 /* Csi */;
+    } else if (code === 93) {
+      this._state = 3 /* Osc */;
+    } else if (code === 80 || code === 88 || code === 94 || code === 95) {
+      this._state = 4 /* Str */;
+    } else if (code === 40 || code === 41 || code === 42 || code === 43 || code === 45 || code === 46) {
+      this._state = 5 /* EscCharset */;
+    } else if (code === 35) {
+      this._state = 6 /* EscHash */;
+    } else if (code === 55) {
+      this._savedCursor = { x: this._cursorX, y: this._cursorY };
+    } else if (code === 56) {
+      this._cursorX = this._clamp(this._savedCursor.x, 0, this._cols - 1);
+      this._cursorY = this._clamp(this._savedCursor.y, 0, this._rows - 1);
+    } else if (code === 68) {
+      this._newline();
+    } else if (code === 69) {
+      this._cursorX = 0;
+      this._newline();
+    } else if (code === 77) {
+      if (this._cursorY === this._scrollTop) {
+        this._scrollDown(1);
+      } else {
+        this._cursorY = Math.max(0, this._cursorY - 1);
+      }
+    } else if (code === 72) {
+    } else if (code === 99) {
+      this._screen = this._makeScreen(this._cols, this._rows);
+      this._cursorX = 0;
+      this._cursorY = 0;
+      this._savedCursor = { x: 0, y: 0 };
+      this._scrollTop = 0;
+      this._scrollBottom = this._rows - 1;
+      this._resetStyle();
+    }
+  }
+  _feedCsi(ch, code) {
+    if (code >= 64 && code <= 126) {
+      this._execCsi(ch);
+      this._state = 0 /* Normal */;
+    } else if (code === 63 || code === 33 || code === 62 || code === 32) {
+      this._csiPrivate = ch;
+    } else if (code >= 48 && code <= 57 || code === 59) {
+      this._csiParams += ch;
+    }
+  }
+  _resetStyle() {
+    this._style = createDefaultStyleState();
+    this._styleSequence = "";
+  }
+  _applySgr(params17) {
+    const normalizedParams = params17.length === 0 ? [0] : params17;
+    for (let index = 0; index < normalizedParams.length; index += 1) {
+      const value = normalizedParams[index] ?? 0;
+      switch (value) {
+        case 0:
+          this._resetStyle();
+          break;
+        case 1:
+          this._style.bold = true;
+          break;
+        case 2:
+          this._style.dim = true;
+          break;
+        case 3:
+          this._style.italic = true;
+          break;
+        case 4:
+          this._style.underline = true;
+          break;
+        case 7:
+          this._style.inverse = true;
+          break;
+        case 9:
+          this._style.strikethrough = true;
+          break;
+        case 21:
+        case 22:
+          this._style.bold = false;
+          this._style.dim = false;
+          break;
+        case 23:
+          this._style.italic = false;
+          break;
+        case 24:
+          this._style.underline = false;
+          break;
+        case 27:
+          this._style.inverse = false;
+          break;
+        case 29:
+          this._style.strikethrough = false;
+          break;
+        case 39:
+          this._style.fg = void 0;
+          break;
+        case 49:
+          this._style.bg = void 0;
+          break;
+        case 38:
+        case 48:
+          index = this._applyExtendedColor(value, normalizedParams, index);
+          break;
+        default:
+          if (value >= 30 && value <= 37 || value >= 90 && value <= 97) {
+            this._style.fg = [value];
+          } else if (value >= 40 && value <= 47 || value >= 100 && value <= 107) {
+            this._style.bg = [value];
+          }
+          break;
+      }
+    }
+    this._styleSequence = serializeStyleState(this._style);
+  }
+  _applyExtendedColor(control, params17, index) {
+    const mode = params17[index + 1];
+    const target = control === 38 ? "fg" : "bg";
+    if (mode === 5) {
+      const paletteIndex = params17[index + 2];
+      if (paletteIndex !== void 0) {
+        this._style[target] = [control, 5, paletteIndex];
+        return index + 2;
+      }
+      return index;
+    }
+    if (mode === 2) {
+      const red = params17[index + 2];
+      const green = params17[index + 3];
+      const blue = params17[index + 4];
+      if (red !== void 0 && green !== void 0 && blue !== void 0) {
+        this._style[target] = [control, 2, red, green, blue];
+        return index + 4;
+      }
+    }
+    return index;
+  }
+};
+function createDefaultStyleState() {
+  return {
+    bold: false,
+    dim: false,
+    italic: false,
+    underline: false,
+    inverse: false,
+    strikethrough: false
+  };
+}
+function serializeStyleState(state) {
+  const codes = [];
+  if (state.bold) {
+    codes.push(1);
+  }
+  if (state.dim) {
+    codes.push(2);
+  }
+  if (state.italic) {
+    codes.push(3);
+  }
+  if (state.underline) {
+    codes.push(4);
+  }
+  if (state.inverse) {
+    codes.push(7);
+  }
+  if (state.strikethrough) {
+    codes.push(9);
+  }
+  if (state.fg !== void 0) {
+    codes.push(...state.fg);
+  }
+  if (state.bg !== void 0) {
+    codes.push(...state.bg);
+  }
+  return codes.length === 0 ? "" : `\x1B[${codes.join(";")}m`;
+}
+
+// src/keys.ts
+var NAMED_KEY_SEQUENCES = {
+  Enter: "\r",
+  Tab: "	",
+  Escape: "\x1B",
+  Backspace: "\x7F",
+  Delete: "\x1B[3~",
+  ArrowUp: "\x1B[A",
+  ArrowDown: "\x1B[B",
+  ArrowRight: "\x1B[C",
+  ArrowLeft: "\x1B[D",
+  Home: "\x1B[H",
+  End: "\x1B[F",
+  PageUp: "\x1B[5~",
+  PageDown: "\x1B[6~",
+  Space: " "
+};
+var NAMED_KEY_LOWER = new Map(
+  Object.entries(NAMED_KEY_SEQUENCES).map(([k, v]) => [k.toLowerCase(), v])
+);
+var VALID_KEYS_HINT = `Valid keys: ${Object.keys(NAMED_KEY_SEQUENCES).join(", ")}, Control+<letter>, Alt+<key>`;
+function unknownKeyError(key) {
+  return new Error(`Unknown terminal key: ${key}. ${VALID_KEYS_HINT}`);
+}
+function keyToSequence(key) {
+  const lowerKey = key.toLowerCase();
+  const namedSequence = NAMED_KEY_LOWER.get(lowerKey);
+  if (namedSequence !== void 0) {
+    return namedSequence;
+  }
+  if (lowerKey.startsWith("control+")) {
+    return controlKeyToSequence(key.slice("control+".length));
+  }
+  if (lowerKey.startsWith("alt+")) {
+    const nestedKey = key.slice("alt+".length);
+    if (nestedKey.length === 0) {
+      throw unknownKeyError(key);
+    }
+    if (nestedKey.length === 1) {
+      return "\x1B" + nestedKey;
+    }
+    try {
+      return "\x1B" + keyToSequence(nestedKey);
+    } catch {
+      throw unknownKeyError(key);
+    }
+  }
+  if (key.length === 1) {
+    return key;
+  }
+  throw unknownKeyError(key);
+}
+function controlKeyToSequence(controlKey) {
+  if (controlKey.length !== 1) {
+    throw unknownKeyError(`Control+${controlKey}`);
+  }
+  const uppercaseLetter = controlKey.toUpperCase();
+  const charCode = uppercaseLetter.charCodeAt(0);
+  if (charCode < 65 || charCode > 90) {
+    throw unknownKeyError(`Control+${controlKey}`);
+  }
+  return String.fromCharCode(charCode - 64);
+}
+
+// src/terminal-screen.ts
+var TerminalScreen = class {
+  lines;
+  rawLines;
+  cursor;
+  size;
+  constructor({
+    lines,
+    rawLines,
+    cursor,
+    size
+  }) {
+    this.lines = Object.freeze(lines.map((line) => stripAnsi(line)));
+    this.rawLines = Object.freeze([...rawLines]);
+    this.cursor = Object.freeze({ ...cursor });
+    this.size = Object.freeze({ ...size });
+    Object.freeze(this);
+  }
+  get text() {
+    return this.lines.join("\n");
+  }
+  contains(substring) {
+    return this.text.includes(substring);
+  }
+  line(index) {
+    const normalizedIndex = index < 0 ? this.lines.length + index : index;
+    const line = this.lines[normalizedIndex];
+    if (line === void 0) {
+      throw new RangeError(`Line index out of bounds: ${index}`);
+    }
+    return line;
+  }
+};
+
+// src/terminal-session.ts
+var DEFAULT_COLS = 120;
+var DEFAULT_ROWS = 40;
+var DEFAULT_TIMEOUT_MS = 1e4;
+var WAIT_FOR_POLL_MS = 10;
+var TYPE_DELAY_MS = 15;
+var CLOSE_AFTER_SIGNAL_GRACE_MS = 250;
+var CLOSE_AFTER_SIGTERM_MS = 1e3;
+var TerminalSession = class {
+  id;
+  command;
+  pid;
+  exitCode = null;
+  pty;
+  terminal;
+  emitter = new EventEmitter();
+  exitPromise;
+  rawBuffer = "";
+  lastDataAt = Date.now();
+  currentCols;
+  currentRows;
+  closeRequested = false;
+  signalRequested = false;
+  constructor({
+    id,
+    command,
+    args = [],
+    cwd = process.cwd(),
+    env = process.env,
+    cols = DEFAULT_COLS,
+    rows = DEFAULT_ROWS,
+    observe = false
+  }) {
+    this.id = id;
+    this.command = command;
+    this.currentCols = cols;
+    this.currentRows = rows;
+    this.terminal = new TerminalBuffer(cols, rows);
+    this.pty = createPtyProcess({ command, args, cwd, env, cols, rows });
+    this.pid = this.pty.pid;
+    const dataSubscription = this.pty.onData((chunk) => {
+      this.rawBuffer += chunk;
+      this.lastDataAt = Date.now();
+      this.terminal.write(chunk);
+      if (observe) {
+        process.stderr.write(chunk);
+      }
+    });
+    let exitSubscription;
+    this.exitPromise = new Promise((resolve) => {
+      exitSubscription = this.pty.onExit(({ exitCode }) => {
+        if (this.exitCode !== null) {
+          resolve(this.exitCode);
+          return;
+        }
+        this.exitCode = exitCode;
+        dataSubscription.dispose();
+        exitSubscription?.dispose();
+        this.emitter.emit("exit", exitCode);
+        resolve(exitCode);
+      });
+    });
+  }
+  async type(text) {
+    for (const character of text) {
+      await this.send(character);
+      await sleep(TYPE_DELAY_MS);
+    }
+  }
+  async fill(text) {
+    await this.send(text.replace(/\r?\n/g, "\r"));
+  }
+  async press(key) {
+    await this.send(keyToSequence(key));
+  }
+  async send(raw) {
+    if (this.exitCode !== null) {
+      return;
+    }
+    this.pty.write(raw);
+  }
+  async signal(sig) {
+    if (this.exitCode !== null) {
+      return;
+    }
+    this.signalRequested = true;
+    this.pty.kill(sig);
+  }
+  async waitFor(pattern, opts) {
+    const timeout = opts?.timeout ?? DEFAULT_TIMEOUT_MS;
+    const startedAt = Date.now();
+    while (Date.now() - startedAt <= timeout) {
+      const matched = matchPattern(this.rawBuffer, pattern);
+      if (matched !== null) {
+        return matched;
+      }
+      await sleep(WAIT_FOR_POLL_MS);
+    }
+    throw new Error(`Timed out waiting for pattern after ${timeout}ms: ${String(pattern)}`);
+  }
+  async waitForQuiet(ms) {
+    while (true) {
+      const remaining = ms - (Date.now() - this.lastDataAt);
+      if (remaining <= 0) {
+        return;
+      }
+      await sleep(remaining);
+    }
+  }
+  async screen() {
+    const rawLines = [];
+    for (let row = 0; row < this.currentRows; row += 1) {
+      rawLines.push(this.terminal.renderLine(row));
+    }
+    return new TerminalScreen({
+      lines: rawLines,
+      rawLines,
+      cursor: {
+        row: this.terminal.displayBuffer.cursorY,
+        col: this.terminal.displayBuffer.cursorX
+      },
+      size: {
+        rows: this.currentRows,
+        cols: this.currentCols
+      }
+    });
+  }
+  async history(opts) {
+    const normalized = normalizeHistoryBuffer(stripAnsi(this.rawBuffer));
+    const lines = splitHistoryLines(normalized);
+    if (opts?.last === void 0) {
+      return lines;
+    }
+    const start = Math.max(0, lines.length - opts.last);
+    return lines.slice(start);
+  }
+  async resize(cols, rows) {
+    this.currentCols = cols;
+    this.currentRows = rows;
+    if (this.exitCode === null) {
+      this.pty.resize(cols, rows);
+    }
+    this.terminal.resize(cols, rows);
+  }
+  async waitForExit(opts) {
+    if (this.exitCode !== null) {
+      return this.exitCode;
+    }
+    if (opts?.timeout !== void 0) {
+      const result = await waitForExit(this.exitPromise, opts.timeout);
+      if (result === null) {
+        throw new Error(`Timed out waiting for process to exit after ${opts.timeout}ms`);
+      }
+      return result;
+    }
+    return this.exitPromise;
+  }
+  async close() {
+    if (this.exitCode !== null) {
+      return this.exitCode;
+    }
+    if (!this.closeRequested) {
+      this.closeRequested = true;
+      const gracefulExitCode = await waitForExit(this.exitPromise, CLOSE_AFTER_SIGNAL_GRACE_MS);
+      if (gracefulExitCode !== null) {
+        return gracefulExitCode;
+      }
+      if (this.signalRequested) {
+        return this.exitPromise;
+      }
+      if (this.exitCode === null) {
+        this.pty.kill("SIGTERM");
+        const afterSigterm = await waitForExit(this.exitPromise, CLOSE_AFTER_SIGTERM_MS);
+        if (afterSigterm !== null) {
+          return afterSigterm;
+        }
+      }
+      if (this.exitCode === null) {
+        this.pty.kill("SIGKILL");
+      }
+    }
+    return this.exitPromise;
+  }
+  on(event, cb) {
+    this.emitter.on(event, cb);
+  }
+};
+function createPtyProcess({
+  command,
+  args,
+  cwd,
+  env,
+  cols,
+  rows
+}) {
+  try {
+    return nodePty.spawn(command, args, {
+      cwd,
+      env,
+      cols,
+      rows,
+      encoding: "utf8"
+    });
+  } catch {
+    return createChildProcessFallback({ command, args, cwd, env });
+  }
+}
+function createChildProcessFallback({
+  command,
+  args,
+  cwd,
+  env
+}) {
+  const child = spawnChildProcess(command, args, {
+    cwd,
+    env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return new ChildProcessFallback(child);
+}
+var ChildProcessFallback = class {
+  pid;
+  child;
+  dataEmitter = new EventEmitter();
+  exitEmitter = new EventEmitter();
+  constructor(child) {
+    this.child = child;
+    this.pid = child.pid ?? -1;
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", this.handleData);
+    child.stderr.on("data", this.handleData);
+    child.on("exit", (exitCode, signal) => {
+      this.exitEmitter.emit("exit", {
+        exitCode: exitCode ?? signalToExitCode(signal),
+        signal: void 0
+      });
+    });
+  }
+  write(data) {
+    this.child.stdin.write(data);
+  }
+  resize() {
+  }
+  kill(signal) {
+    this.child.kill(signal);
+  }
+  onData(listener) {
+    this.dataEmitter.on("data", listener);
+    return {
+      dispose: () => {
+        this.dataEmitter.off("data", listener);
+      }
+    };
+  }
+  onExit(listener) {
+    this.exitEmitter.on("exit", listener);
+    return {
+      dispose: () => {
+        this.exitEmitter.off("exit", listener);
+      }
+    };
+  }
+  handleData = (chunk) => {
+    this.dataEmitter.emit("data", String(chunk));
+  };
+};
+function signalToExitCode(signal) {
+  if (signal === null) {
+    return 0;
+  }
+  const signalNumbers = {
+    SIGTERM: 15,
+    SIGINT: 2,
+    SIGHUP: 1,
+    SIGKILL: 9
+  };
+  const signalNumber = signalNumbers[signal];
+  if (signalNumber === void 0) {
+    return 1;
+  }
+  return 128 + signalNumber;
+}
+function matchPattern(buffer, pattern) {
+  const clean = normalizeHistoryBuffer(stripAnsi(buffer));
+  for (const line of clean.split("\n")) {
+    if (typeof pattern === "string") {
+      if (line.includes(pattern)) return line;
+    } else {
+      const flags = removeCharacter(pattern.flags, "g");
+      if (new RegExp(pattern.source, flags).test(line)) return line;
+    }
+  }
+  return null;
+}
+function removeCharacter(input, charToRemove) {
+  let output = "";
+  for (const character of input) {
+    if (character !== charToRemove) {
+      output += character;
+    }
+  }
+  return output;
+}
+function splitHistoryLines(input) {
+  const lines = input.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines;
+}
+function normalizeHistoryBuffer(input) {
+  let output = "";
+  for (const character of input) {
+    if (character === "\r" || character === "\b") {
+      continue;
+    }
+    output += character;
+  }
+  return output;
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function waitForExit(exitPromise, timeout) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve(null);
+    }, timeout);
+    void exitPromise.then((code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve(code);
+    });
+  });
+}
+
+// src/terminal-pilot.ts
+var DEFAULT_COLS2 = 120;
+var DEFAULT_ROWS2 = 40;
+var TerminalPilot = class _TerminalPilot {
+  sessionMap = /* @__PURE__ */ new Map();
+  static async launch() {
+    return new _TerminalPilot();
+  }
+  async newSession(opts) {
+    const session = new TerminalSession({
+      id: randomUUID(),
+      command: opts.command,
+      args: opts.args,
+      cwd: opts.cwd,
+      env: opts.env,
+      cols: opts.cols ?? DEFAULT_COLS2,
+      rows: opts.rows ?? DEFAULT_ROWS2,
+      observe: opts.observe ?? false
+    });
+    this.sessionMap.set(session.id, session);
+    return session;
+  }
+  getSession(id) {
+    const session = this.sessionMap.get(id);
+    if (session === void 0) {
+      throw new Error(`Session not found: ${id}`);
+    }
+    return session;
+  }
+  deleteSession(id) {
+    this.sessionMap.delete(id);
+  }
+  sessions() {
+    return [...this.sessionMap.values()].filter((s) => s.exitCode === null);
+  }
+  async close() {
+    const sessions = [...this.sessionMap.values()];
+    try {
+      await Promise.all(sessions.map((session) => session.close()));
+    } finally {
+      this.sessionMap.clear();
+    }
+  }
+};
+
+// src/commands/runtime.ts
+var SESSION_ENV_VAR = "TERMINAL_PILOT_SESSION";
+var sharedRuntime;
+function getTerminalPilotRuntime(runtime) {
+  if (runtime !== void 0) {
+    return runtime;
+  }
+  sharedRuntime ??= createTerminalPilotRuntime();
+  return sharedRuntime;
+}
+function createTerminalPilotRuntime(options = {}) {
+  const launchPilot = options.launchPilot ?? TerminalPilot.launch;
+  const nameToId = /* @__PURE__ */ new Map();
+  const idToName = /* @__PURE__ */ new Map();
+  let pilotPromise;
+  function getRequestedName(name, env) {
+    return name ?? env?.get(SESSION_ENV_VAR);
+  }
+  async function getPilot() {
+    pilotPromise ??= launchPilot();
+    return pilotPromise;
+  }
+  function nextSessionName() {
+    let index = 1;
+    while (nameToId.has(`s${index}`)) {
+      index += 1;
+    }
+    return `s${index}`;
+  }
+  function rememberSession(name, session) {
+    nameToId.set(name, session.id);
+    idToName.set(session.id, name);
+    return { name, session };
+  }
+  function forgetSession(name, sessionId) {
+    nameToId.delete(name);
+    idToName.delete(sessionId);
+  }
+  function formatAvailableSessions(names) {
+    if (names.length === 0) {
+      return "No active sessions are available.";
+    }
+    return `Available sessions: ${names.join(", ")}.`;
+  }
+  async function lookupNamedSession(name) {
+    const sessionId = nameToId.get(name);
+    if (sessionId === void 0) {
+      const active = await listSessions2();
+      throw new UserError(`Session "${name}" was not found. ${formatAvailableSessions(active.map((entry) => entry.name))}`);
+    }
+    const pilot = await getPilot();
+    try {
+      return { name, session: pilot.getSession(sessionId) };
+    } catch {
+      forgetSession(name, sessionId);
+      const active = await listSessions2();
+      throw new UserError(`Session "${name}" was not found. ${formatAvailableSessions(active.map((entry) => entry.name))}`);
+    }
+  }
+  async function listSessions2() {
+    const pilot = await getPilot();
+    return pilot.sessions().flatMap((session) => {
+      const name = idToName.get(session.id);
+      if (name === void 0) {
+        return [];
+      }
+      return [{ name, session }];
+    });
+  }
+  return {
+    async createSession(params17, env) {
+      const requestedName = getRequestedName(params17.session, env) ?? nextSessionName();
+      if (nameToId.has(requestedName)) {
+        throw new UserError(`Session "${requestedName}" already exists.`);
+      }
+      const pilot = await getPilot();
+      const session = await pilot.newSession({
+        command: params17.command,
+        args: params17.args,
+        cwd: params17.cwd,
+        cols: params17.cols,
+        rows: params17.rows,
+        observe: params17.observe
+      });
+      return rememberSession(requestedName, session);
+    },
+    async resolveSession(name, env) {
+      const requestedName = getRequestedName(name, env);
+      if (requestedName !== void 0) {
+        return lookupNamedSession(requestedName);
+      }
+      const active = await listSessions2();
+      if (active.length === 1) {
+        return active[0];
+      }
+      if (active.length === 0) {
+        throw new UserError("No active sessions. Create one with create-session.");
+      }
+      throw new UserError(
+        `Multiple active sessions require an explicit session name. Pass --session or set ${SESSION_ENV_VAR}. ${formatAvailableSessions(active.map((entry) => entry.name))}`
+      );
+    },
+    async closeSession(name, env) {
+      const namedSession = await this.resolveSession(name, env);
+      const exitCode = await namedSession.session.close();
+      const pilot = await getPilot();
+      pilot.deleteSession(namedSession.session.id);
+      forgetSession(namedSession.name, namedSession.session.id);
+      return {
+        exitCode,
+        name: namedSession.name
+      };
+    },
+    listSessions: listSessions2,
+    async close() {
+      if (pilotPromise === void 0) {
+        return;
+      }
+      const pilot = await pilotPromise;
+      await pilot.close();
+      pilotPromise = void 0;
+      nameToId.clear();
+      idToName.clear();
+    }
+  };
+}
+
+// src/commands/close-session.ts
+var params = S.Object({
+  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+});
+var closeSession = defineCommand({
+  name: "close-session",
+  description: "Close an active terminal session",
+  scope: ["cli", "mcp", "sdk"],
+  params,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const { exitCode } = await getTerminalPilotRuntime(terminalPilotRuntime).closeSession(params17.session, env);
+    return { exitCode };
+  }
+});
+
+// src/commands/create-session.ts
+var params2 = S.Object({
+  command: S.String({ description: "Command to execute" }),
+  args: S.Optional(S.Array(S.String(), { description: "Command arguments" })),
+  session: S.Optional(S.String({ short: "s", description: "Session name" })),
+  cwd: S.Optional(S.String({ description: "Working directory" })),
+  cols: S.Optional(S.Number({ description: "Terminal width in columns" })),
+  rows: S.Optional(S.Number({ description: "Terminal height in rows" })),
+  observe: S.Optional(S.Boolean({ description: "Mirror PTY output to stderr" }))
+});
+var createSession = defineCommand({
+  name: "create-session",
+  description: "Spawn an interactive CLI in a PTY",
+  scope: ["cli", "mcp", "sdk"],
+  positional: ["command", "args"],
+  params: params2,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).createSession(params17, env);
+    return { session: namedSession.name, pid: namedSession.session.pid };
+  }
+});
+
+// src/commands/fill.ts
+var params3 = S.Object({
+  text: S.String({ description: "Text to write to the session" }),
+  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+});
+var fill = defineCommand({
+  name: "fill",
+  description: "Write text to an active terminal session all at once (replaces \\n with \\r)",
+  scope: ["cli", "mcp", "sdk"],
+  positional: ["text"],
+  params: params3,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    await namedSession.session.fill(params17.text);
+    return void 0;
+  }
+});
+
+// src/commands/get-session.ts
+var params4 = S.Object({
+  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+});
+var getSession = defineCommand({
+  name: "get-session",
+  description: "Get session metadata (name, pid, command, exitCode)",
+  scope: ["cli", "mcp", "sdk"],
+  params: params4,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    return {
+      session: namedSession.name,
+      pid: namedSession.session.pid,
+      command: namedSession.session.command,
+      exitCode: namedSession.session.exitCode
+    };
+  }
+});
+
+// ../agent-skill-config/src/configs.ts
+import os from "node:os";
+import path from "node:path";
+
+// ../agent-defs/src/agents/claude-code.ts
+var claudeCodeAgent = {
+  id: "claude-code",
+  name: "claude-code",
+  label: "Claude Code",
+  summary: "Configure Claude Code to route through Poe.",
+  aliases: ["claude"],
+  binaryName: "claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#C15F3C",
+      light: "#C15F3C"
+    }
+  }
+};
+
+// ../agent-defs/src/agents/claude-desktop.ts
+var claudeDesktopAgent = {
+  id: "claude-desktop",
+  name: "claude-desktop",
+  label: "Claude Desktop",
+  summary: "Anthropic's official desktop application for Claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#D97757",
+      light: "#D97757"
+    }
+  }
+};
+
+// ../agent-defs/src/agents/codex.ts
+var codexAgent = {
+  id: "codex",
+  name: "codex",
+  label: "Codex",
+  summary: "Configure Codex to use Poe as the model provider.",
+  binaryName: "codex",
+  configPath: "~/.codex/config.toml",
+  branding: {
+    colors: {
+      dark: "#D5D9DF",
+      light: "#7A7F86"
+    }
+  }
+};
+
+// ../agent-defs/src/agents/opencode.ts
+var openCodeAgent = {
+  id: "opencode",
+  name: "opencode",
+  label: "OpenCode CLI",
+  summary: "Configure OpenCode CLI to use the Poe API.",
+  binaryName: "opencode",
+  configPath: "~/.config/opencode/config.json",
+  branding: {
+    colors: {
+      dark: "#4A4F55",
+      light: "#2F3338"
+    }
+  }
+};
+
+// ../agent-defs/src/agents/kimi.ts
+var kimiAgent = {
+  id: "kimi",
+  name: "kimi",
+  label: "Kimi",
+  summary: "Configure Kimi CLI to use Poe API",
+  aliases: ["kimi-cli"],
+  binaryName: "kimi",
+  configPath: "~/.kimi/config.toml",
+  branding: {
+    colors: {
+      dark: "#7B68EE",
+      light: "#6A5ACD"
+    }
+  }
+};
+
+// ../agent-defs/src/registry.ts
+var allAgents = [
+  claudeCodeAgent,
+  claudeDesktopAgent,
+  codexAgent,
+  openCodeAgent,
+  kimiAgent
+];
+var lookup = /* @__PURE__ */ new Map();
+for (const agent of allAgents) {
+  const values = [agent.id, agent.name, ...agent.aliases ?? []];
+  for (const value of values) {
+    const normalized = value.toLowerCase();
+    if (!lookup.has(normalized)) {
+      lookup.set(normalized, agent.id);
+    }
+  }
+}
+function resolveAgentId(input) {
+  if (!input) {
+    return void 0;
+  }
+  return lookup.get(input.toLowerCase());
+}
+
+// ../agent-skill-config/src/configs.ts
+var agentSkillConfigs = {
+  "claude-code": {
+    globalSkillDir: "~/.claude/skills",
+    localSkillDir: ".claude/skills"
+  },
+  codex: {
+    globalSkillDir: "~/.codex/skills",
+    localSkillDir: ".codex/skills"
+  },
+  opencode: {
+    globalSkillDir: "~/.config/opencode/skills",
+    localSkillDir: ".opencode/skills"
+  }
+};
+var supportedAgents = Object.keys(agentSkillConfigs);
+function resolveAgentSupport(input, registry = agentSkillConfigs) {
+  const resolvedId = resolveAgentId(input);
+  if (!resolvedId) {
+    return { status: "unknown", input };
+  }
+  const config = registry[resolvedId];
+  if (!config) {
+    return { status: "unsupported", input, id: resolvedId };
+  }
+  return { status: "supported", input, id: resolvedId, config };
+}
+function getAgentConfig(agentId) {
+  const support = resolveAgentSupport(agentId);
+  return support.status === "supported" ? support.config : void 0;
+}
+
+// ../config-mutations/src/mutations/file-mutation.ts
+function ensureDirectory(options) {
+  return {
+    kind: "ensureDirectory",
+    path: options.path,
+    label: options.label
+  };
+}
+function remove(options) {
+  return {
+    kind: "removeFile",
+    target: options.target,
+    whenEmpty: options.whenEmpty,
+    whenContentMatches: options.whenContentMatches,
+    label: options.label
+  };
+}
+function removeDirectory(options) {
+  return {
+    kind: "removeDirectory",
+    path: options.path,
+    force: options.force,
+    label: options.label
+  };
+}
+function chmod(options) {
+  return {
+    kind: "chmod",
+    target: options.target,
+    mode: options.mode,
+    label: options.label
+  };
+}
+function backup(options) {
+  return {
+    kind: "backup",
+    target: options.target,
+    label: options.label
+  };
+}
+var fileMutation = {
+  ensureDirectory,
+  remove,
+  removeDirectory,
+  chmod,
+  backup
+};
+
+// ../config-mutations/src/mutations/template-mutation.ts
+function write(options) {
+  return {
+    kind: "templateWrite",
+    target: options.target,
+    templateId: options.templateId,
+    context: options.context,
+    label: options.label
+  };
+}
+function mergeToml(options) {
+  return {
+    kind: "templateMergeToml",
+    target: options.target,
+    templateId: options.templateId,
+    context: options.context,
+    label: options.label
+  };
+}
+function mergeJson(options) {
+  return {
+    kind: "templateMergeJson",
+    target: options.target,
+    templateId: options.templateId,
+    context: options.context,
+    label: options.label
+  };
+}
+var templateMutation = {
+  write,
+  mergeToml,
+  mergeJson
+};
+
+// ../config-mutations/src/execution/apply-mutation.ts
+import Mustache from "mustache";
+
+// ../config-mutations/src/formats/json.ts
+import * as jsonc from "jsonc-parser";
+function isConfigObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse2(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const errors = [];
+  const parsed = jsonc.parse(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    throw new Error(`JSON parse error: ${jsonc.printParseErrorCode(errors[0].error)}`);
+  }
+  if (parsed === null || parsed === void 0) {
+    return {};
+  }
+  if (!isConfigObject(parsed)) {
+    throw new Error("Expected JSON object.");
+  }
+  return parsed;
+}
+function serialize(obj) {
+  return `${JSON.stringify(obj, null, 2)}
+`;
+}
+function merge(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject(existing) && isConfigObject(value)) {
+      result[key] = merge(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject(pattern) && isConfigObject(current)) {
+      const { changed: childChanged, result: childResult } = prune(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var jsonFormat = {
+  parse: parse2,
+  serialize,
+  merge,
+  prune
+};
+
+// ../config-mutations/src/formats/toml.ts
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+function isConfigObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse3(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const parsed = parseToml(content);
+  if (!isConfigObject2(parsed)) {
+    throw new Error("Expected TOML document to be a table.");
+  }
+  return parsed;
+}
+function serialize2(obj) {
+  const serialized = stringifyToml(obj);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
+}
+function merge2(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject2(existing) && isConfigObject2(value)) {
+      result[key] = merge2(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune2(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject2(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject2(pattern) && isConfigObject2(current)) {
+      const { changed: childChanged, result: childResult } = prune2(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var tomlFormat = {
+  parse: parse3,
+  serialize: serialize2,
+  merge: merge2,
+  prune: prune2
+};
+
+// ../config-mutations/src/formats/index.ts
+var formatRegistry = {
+  json: jsonFormat,
+  toml: tomlFormat
+};
+var extensionMap = {
+  ".json": "json",
+  ".toml": "toml"
+};
+function getConfigFormat(pathOrFormat) {
+  if (pathOrFormat in formatRegistry) {
+    return formatRegistry[pathOrFormat];
+  }
+  const ext = getExtension(pathOrFormat);
+  const formatName = extensionMap[ext];
+  if (!formatName) {
+    throw new Error(
+      `Unsupported config format. Cannot detect format from "${pathOrFormat}". Supported extensions: ${Object.keys(extensionMap).join(", ")}. Supported format names: ${Object.keys(formatRegistry).join(", ")}.`
+    );
+  }
+  return formatRegistry[formatName];
+}
+function detectFormat(path4) {
+  const ext = getExtension(path4);
+  return extensionMap[ext];
+}
+function getExtension(path4) {
+  const lastDot = path4.lastIndexOf(".");
+  if (lastDot === -1) {
+    return "";
+  }
+  return path4.slice(lastDot).toLowerCase();
+}
+
+// ../config-mutations/src/execution/path-utils.ts
+import path2 from "node:path";
+function expandHome(targetPath, homeDir) {
+  if (!targetPath?.startsWith("~")) {
+    return targetPath;
+  }
+  if (targetPath.startsWith("~./")) {
+    targetPath = `~/.${targetPath.slice(3)}`;
+  }
+  let remainder = targetPath.slice(1);
+  if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+    remainder = remainder.slice(1);
+  } else if (remainder.startsWith(".")) {
+    remainder = remainder.slice(1);
+    if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+      remainder = remainder.slice(1);
+    }
+  }
+  return remainder.length === 0 ? homeDir : path2.join(homeDir, remainder);
+}
+function validateHomePath(targetPath) {
+  if (typeof targetPath !== "string" || targetPath.length === 0) {
+    throw new Error("Target path must be a non-empty string.");
+  }
+  if (!targetPath.startsWith("~")) {
+    throw new Error(
+      `All target paths must be home-relative (start with ~). Received: "${targetPath}"`
+    );
+  }
+}
+function resolvePath(rawPath, homeDir, pathMapper) {
+  validateHomePath(rawPath);
+  const expanded = expandHome(rawPath, homeDir);
+  if (!pathMapper) {
+    return expanded;
+  }
+  const rawDirectory = path2.dirname(expanded);
+  const mappedDirectory = pathMapper.mapTargetDirectory({
+    targetDirectory: rawDirectory
+  });
+  const filename = path2.basename(expanded);
+  return filename.length === 0 ? mappedDirectory : path2.join(mappedDirectory, filename);
+}
+
+// ../config-mutations/src/fs-utils.ts
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function readFileIfExists(fs, target) {
+  try {
+    return await fs.readFile(target, "utf8");
+  } catch (error) {
+    if (isNotFound(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function pathExists(fs, target) {
+  try {
+    await fs.stat(target);
+    return true;
+  } catch (error) {
+    if (isNotFound(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+function createTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").replaceAll(".", "-");
+}
+
+// ../config-mutations/src/execution/apply-mutation.ts
+function resolveValue(resolver, options) {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+}
+function createInvalidDocumentBackupPath(targetPath) {
+  const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
+  return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
+}
+async function backupInvalidDocument(fs, targetPath, content) {
+  const backupPath = createInvalidDocumentBackupPath(targetPath);
+  await fs.writeFile(backupPath, content, { encoding: "utf8" });
+}
+function describeMutation(kind, targetPath) {
+  const displayPath = targetPath ?? "target";
+  switch (kind) {
+    case "ensureDirectory":
+      return `Create ${displayPath}`;
+    case "removeDirectory":
+      return `Remove directory ${displayPath}`;
+    case "backup":
+      return `Backup ${displayPath}`;
+    case "templateWrite":
+      return `Write ${displayPath}`;
+    case "chmod":
+      return `Set permissions on ${displayPath}`;
+    case "removeFile":
+      return `Remove ${displayPath}`;
+    case "configMerge":
+    case "configPrune":
+    case "configTransform":
+    case "templateMergeToml":
+    case "templateMergeJson":
+      return `Update ${displayPath}`;
+    default:
+      return "Operation";
+  }
+}
+function pruneKeysByPrefix(table, prefix) {
+  const result = {};
+  for (const [key, value] of Object.entries(table)) {
+    if (!key.startsWith(prefix)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function isConfigObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeWithPruneByPrefix(base, patch, pruneByPrefix) {
+  const result = { ...base };
+  const prefixMap = pruneByPrefix ?? {};
+  for (const [key, value] of Object.entries(patch)) {
+    const current = result[key];
+    const prefix = prefixMap[key];
+    if (isConfigObject3(current) && isConfigObject3(value)) {
+      if (prefix) {
+        const pruned = pruneKeysByPrefix(current, prefix);
+        result[key] = { ...pruned, ...value };
+      } else {
+        result[key] = mergeWithPruneByPrefix(
+          current,
+          value,
+          prefixMap
+        );
+      }
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+async function applyMutation(mutation, context, options) {
+  switch (mutation.kind) {
+    case "ensureDirectory":
+      return applyEnsureDirectory(mutation, context, options);
+    case "removeDirectory":
+      return applyRemoveDirectory(mutation, context, options);
+    case "removeFile":
+      return applyRemoveFile(mutation, context, options);
+    case "chmod":
+      return applyChmod(mutation, context, options);
+    case "backup":
+      return applyBackup(mutation, context, options);
+    case "configMerge":
+      return applyConfigMerge(mutation, context, options);
+    case "configPrune":
+      return applyConfigPrune(mutation, context, options);
+    case "configTransform":
+      return applyConfigTransform(mutation, context, options);
+    case "templateWrite":
+      return applyTemplateWrite(mutation, context, options);
+    case "templateMergeToml":
+      return applyTemplateMerge(mutation, context, options, "toml");
+    case "templateMergeJson":
+      return applyTemplateMerge(mutation, context, options, "json");
+    default: {
+      const never = mutation;
+      throw new Error(`Unknown mutation kind: ${never.kind}`);
+    }
+  }
+}
+async function applyEnsureDirectory(mutation, context, options) {
+  const rawPath = resolveValue(mutation.path, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const existed = await pathExists(context.fs, targetPath);
+  if (!context.dryRun) {
+    await context.fs.mkdir(targetPath, { recursive: true });
+  }
+  return {
+    outcome: {
+      changed: !existed,
+      effect: "mkdir",
+      detail: existed ? "noop" : "create"
+    },
+    details
+  };
+}
+async function applyRemoveDirectory(mutation, context, options) {
+  const rawPath = resolveValue(mutation.path, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const existed = await pathExists(context.fs, targetPath);
+  if (!existed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (typeof context.fs.rm !== "function") {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (mutation.force) {
+    if (!context.dryRun) {
+      await context.fs.rm(targetPath, { recursive: true, force: true });
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const entries = await context.fs.readdir(targetPath);
+  if (entries.length > 0) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    await context.fs.rm(targetPath, { recursive: true, force: true });
+  }
+  return {
+    outcome: { changed: true, effect: "delete", detail: "delete" },
+    details
+  };
+}
+async function applyRemoveFile(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  try {
+    const content = await context.fs.readFile(targetPath, "utf8");
+    const trimmed = content.trim();
+    if (mutation.whenContentMatches && !mutation.whenContentMatches.test(trimmed)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (mutation.whenEmpty && trimmed.length > 0) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  } catch (error) {
+    if (isNotFound(error)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error;
+  }
+}
+async function applyChmod(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  if (typeof context.fs.chmod !== "function") {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  try {
+    const stat = await context.fs.stat(targetPath);
+    const currentMode = typeof stat.mode === "number" ? stat.mode & 511 : null;
+    if (currentMode === mutation.mode) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.chmod(targetPath, mutation.mode);
+    }
+    return {
+      outcome: { changed: true, effect: "chmod", detail: "update" },
+      details
+    };
+  } catch (error) {
+    if (isNotFound(error)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error;
+  }
+}
+async function applyBackup(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const content = await readFileIfExists(context.fs, targetPath);
+  if (content === null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    const backupPath = `${targetPath}.backup-${createTimestamp()}`;
+    await context.fs.writeFile(backupPath, content, { encoding: "utf8" });
+  }
+  return {
+    outcome: { changed: true, effect: "copy", detail: "backup" },
+    details
+  };
+}
+async function applyConfigMerge(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const value = resolveValue(mutation.value, options);
+  let merged;
+  if (mutation.pruneByPrefix) {
+    merged = mergeWithPruneByPrefix(current, value, mutation.pruneByPrefix);
+  } else {
+    merged = format.merge(current, value);
+  }
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    },
+    details
+  };
+}
+async function applyConfigPrune(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  if (rawContent === null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  let current;
+  try {
+    current = format.parse(rawContent);
+  } catch {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (mutation.onlyIf && !mutation.onlyIf(current, options)) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const shape = resolveValue(mutation.shape, options);
+  const { changed, result } = format.prune(current, shape);
+  if (!changed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (Object.keys(result).length === 0) {
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const serialized = format.serialize(result);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: { changed: true, effect: "write", detail: "update" },
+    details
+  };
+}
+async function applyConfigTransform(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const { content: transformed, changed } = mutation.transform(current, options);
+  if (!changed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (transformed === null) {
+    if (rawContent === null) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const serialized = format.serialize(transformed);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed: true,
+      effect: "write",
+      detail: rawContent === null ? "create" : "update"
+    },
+    details
+  };
+}
+async function applyTemplateWrite(mutation, context, options) {
+  if (!context.templates) {
+    throw new Error(
+      "Template mutations require a templates loader. Provide templates function to runMutations context."
+    );
+  }
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const template = await context.templates(mutation.templateId);
+  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
+  const rendered = Mustache.render(template, templateContext);
+  const existed = await pathExists(context.fs, targetPath);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, rendered, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed: true,
+      effect: "write",
+      detail: existed ? "update" : "create"
+    },
+    details
+  };
+}
+async function applyTemplateMerge(mutation, context, options, formatName) {
+  if (!context.templates) {
+    throw new Error(
+      "Template mutations require a templates loader. Provide templates function to runMutations context."
+    );
+  }
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const format = getConfigFormat(formatName);
+  const template = await context.templates(mutation.templateId);
+  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
+  const rendered = Mustache.render(template, templateContext);
+  let templateDoc;
+  try {
+    templateDoc = format.parse(rendered);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse rendered template "${mutation.templateId}" as ${formatName.toUpperCase()}: ${error}`,
+      { cause: error }
+    );
+  }
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const merged = format.merge(current, templateDoc);
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    },
+    details
+  };
+}
+
+// ../config-mutations/src/execution/run-mutations.ts
+async function runMutations(mutations, context, options) {
+  const effects = [];
+  let anyChanged = false;
+  const resolverOptions = options ?? {};
+  for (const mutation of mutations) {
+    const { outcome } = await executeMutation(
+      mutation,
+      context,
+      resolverOptions
+    );
+    effects.push(outcome);
+    if (outcome.changed) {
+      anyChanged = true;
+    }
+  }
+  return {
+    changed: anyChanged,
+    effects
+  };
+}
+async function executeMutation(mutation, context, options) {
+  context.observers?.onStart?.({
+    kind: mutation.kind,
+    label: mutation.label ?? mutation.kind,
+    targetPath: void 0
+    // Will be resolved during apply
+  });
+  try {
+    const { outcome, details } = await applyMutation(mutation, context, options);
+    context.observers?.onComplete?.(details, outcome);
+    return { outcome, details };
+  } catch (error) {
+    context.observers?.onError?.(
+      {
+        kind: mutation.kind,
+        label: mutation.label ?? mutation.kind,
+        targetPath: void 0
+      },
+      error
+    );
+    throw error;
+  }
+}
+
+// ../config-mutations/src/template/render.ts
+import Mustache2 from "mustache";
+var originalEscape = Mustache2.escape;
+
+// ../agent-skill-config/src/templates.ts
+import { readFile } from "node:fs/promises";
+
+// ../agent-skill-config/src/apply.ts
+var UnsupportedAgentError = class extends Error {
+  constructor(agentId) {
+    super(`Unsupported agent: ${agentId}`);
+    this.name = "UnsupportedAgentError";
+  }
+};
+function toHomeRelative(localSkillDir) {
+  if (localSkillDir.startsWith("~/") || localSkillDir === "~") {
+    return localSkillDir;
+  }
+  const normalized = localSkillDir.startsWith("./") ? localSkillDir.slice(2) : localSkillDir;
+  return `~/${normalized}`;
+}
+var SKILL_TEMPLATE_ID = "__skill_content__";
+async function installSkill(agentId, skill, options) {
+  const support = resolveAgentSupport(agentId);
+  if (support.status !== "supported") {
+    throw new UnsupportedAgentError(agentId);
+  }
+  const scope = options.scope ?? "local";
+  const config = support.config;
+  const skillDir = scope === "global" ? config.globalSkillDir : toHomeRelative(config.localSkillDir);
+  const skillFolderPath = `${skillDir}/${skill.name}`;
+  const skillFilePath = `${skillFolderPath}/SKILL.md`;
+  const displayPath = `${scope === "global" ? config.globalSkillDir : config.localSkillDir}/${skill.name}/SKILL.md`;
+  await runMutations(
+    [
+      fileMutation.ensureDirectory({
+        path: skillFolderPath,
+        label: `Ensure skill directory ${skill.name}`
+      }),
+      templateMutation.write({
+        target: skillFilePath,
+        templateId: SKILL_TEMPLATE_ID,
+        label: `Write skill ${skill.name}`
+      })
+    ],
+    {
+      fs: options.fs,
+      homeDir: scope === "global" ? options.homeDir : options.cwd,
+      dryRun: options.dryRun,
+      observers: options.observers,
+      templates: async (templateId) => {
+        if (templateId === SKILL_TEMPLATE_ID) {
+          return skill.content;
+        }
+        throw new Error(`Unknown template: ${templateId}`);
+      }
+    }
+  );
+  return { skillPath: skillFilePath, displayPath };
+}
+
+// src/commands/installer.ts
+import os2 from "node:os";
+import path3 from "node:path";
+import * as nodeFs from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
+var DEFAULT_INSTALL_AGENT = "claude-code";
+var DEFAULT_INSTALL_SCOPE = "local";
+var TERMINAL_PILOT_SKILL_NAME = "terminal-pilot";
+var installableAgents = supportedAgents;
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function resolveInstallerServices(installer) {
+  return {
+    fs: installer?.fs ?? nodeFs,
+    cwd: installer?.cwd ?? process.cwd(),
+    homeDir: installer?.homeDir ?? os2.homedir(),
+    platform: installer?.platform ?? process.platform
+  };
+}
+function throwUnsupportedAgent(agent) {
+  throw new UserError(`Unsupported agent: ${agent}`);
+}
+function resolveInstallableAgent(agent) {
+  const skillSupport = resolveAgentSupport(agent);
+  if (skillSupport.status !== "supported" || !skillSupport.id) {
+    throwUnsupportedAgent(agent);
+  }
+  return skillSupport.id;
+}
+function resolveInstallScope(input) {
+  if (input.local && input.global) {
+    throw new UserError("Use either --local or --global, not both.");
+  }
+  if (input.local) {
+    return "local";
+  }
+  if (input.global) {
+    return "global";
+  }
+  return DEFAULT_INSTALL_SCOPE;
+}
+var terminalPilotTemplateCache;
+async function loadTerminalPilotTemplate() {
+  if (terminalPilotTemplateCache !== void 0) {
+    return terminalPilotTemplateCache;
+  }
+  const candidates = [
+    new URL("./templates/terminal-pilot.md", import.meta.url),
+    new URL("../templates/terminal-pilot.md", import.meta.url),
+    new URL("../../../agent-skill-config/src/templates/terminal-pilot.md", import.meta.url)
+  ];
+  for (const candidate of candidates) {
+    try {
+      terminalPilotTemplateCache = await readFile2(candidate, "utf8");
+      return terminalPilotTemplateCache;
+    } catch (error) {
+      if (!isNotFoundError(error)) {
+        throw error;
+      }
+    }
+  }
+  throw new UserError("terminal-pilot skill template is missing.");
+}
+function resolveHomeRelativePath(targetPath, homeDir) {
+  if (targetPath === "~") {
+    return homeDir;
+  }
+  if (targetPath.startsWith("~/")) {
+    return path3.join(homeDir, targetPath.slice(2));
+  }
+  return targetPath;
+}
+function getSkillFolderWithHome(agent, scope, cwd, homeDir) {
+  const config = getAgentConfig(agent);
+  if (!config) {
+    throwUnsupportedAgent(agent);
+  }
+  return {
+    displayPath: path3.join(
+      scope === "global" ? config.globalSkillDir : config.localSkillDir,
+      TERMINAL_PILOT_SKILL_NAME
+    ),
+    fullPath: path3.join(
+      scope === "global" ? resolveHomeRelativePath(config.globalSkillDir, homeDir) : path3.resolve(cwd, config.localSkillDir),
+      TERMINAL_PILOT_SKILL_NAME
+    )
+  };
+}
+async function removeSkillFolder(fs, folderPath) {
+  try {
+    await fs.stat(folderPath);
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return false;
+    }
+    throw error;
+  }
+  if (typeof fs.rm !== "function") {
+    throw new UserError("The configured filesystem does not support removing directories.");
+  }
+  await fs.rm(folderPath, { recursive: true, force: true });
+  return true;
+}
+
+// src/commands/install.ts
+var params5 = S.Object({
+  agent: S.Enum(installableAgents, {
+    description: "Agent to install terminal-pilot for",
+    default: DEFAULT_INSTALL_AGENT
+  }),
+  local: S.Optional(S.Boolean({ description: "Install the skill in the current project" })),
+  global: S.Optional(S.Boolean({ description: "Install the skill in the user home directory" }))
+});
+var install = defineCommand({
+  name: "install",
+  description: "Install the terminal-pilot CLI skill.",
+  scope: ["cli"],
+  positional: ["agent"],
+  params: params5,
+  handler: async ({ params: params17, terminalPilotInstaller }) => {
+    const services = resolveInstallerServices(terminalPilotInstaller);
+    const agent = resolveInstallableAgent(params17.agent);
+    const scope = resolveInstallScope(params17);
+    const template = await loadTerminalPilotTemplate();
+    const skillResult = await installSkill(
+      agent,
+      {
+        name: TERMINAL_PILOT_SKILL_NAME,
+        content: template
+      },
+      {
+        fs: services.fs,
+        cwd: services.cwd,
+        homeDir: services.homeDir,
+        scope
+      }
+    );
+    return {
+      agent,
+      scope,
+      skillPath: skillResult.displayPath
+    };
+  }
+});
+
+// src/commands/list-sessions.ts
+var params6 = S.Object({});
+var listSessions = defineCommand({
+  name: "list-sessions",
+  description: "List active terminal sessions",
+  scope: ["cli", "mcp", "sdk"],
+  params: params6,
+  handler: async ({ terminalPilotRuntime }) => {
+    const sessions = await getTerminalPilotRuntime(terminalPilotRuntime).listSessions();
+    return {
+      sessions: sessions.map((namedSession) => ({
+        session: namedSession.name,
+        command: namedSession.session.command,
+        pid: namedSession.session.pid
+      }))
+    };
+  }
+});
+
+// src/commands/press-key.ts
+var params7 = S.Object({
+  key: S.String({ description: "Named key to press" }),
+  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+});
+var pressKey = defineCommand({
+  name: "press-key",
+  description: "Send a named key press to an active terminal session",
+  scope: ["cli", "mcp", "sdk"],
+  positional: ["key"],
+  params: params7,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    await namedSession.session.press(params17.key);
+    return void 0;
+  }
+});
+
+// src/commands/read-history.ts
+var params8 = S.Object({
+  session: S.Optional(S.String({ short: "s", description: "Session name" })),
+  last: S.Optional(S.Number({ short: "n", description: "Return only the last N lines" }))
+});
+var readHistory = defineCommand({
+  name: "read-history",
+  description: "Read terminal output history",
+  scope: ["cli", "mcp", "sdk"],
+  params: params8,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const lines = await namedSession.session.history({ last: params17.last });
+    return { lines, exitCode: namedSession.session.exitCode };
+  }
+});
+
+// src/commands/read-screen.ts
+var params9 = S.Object({
+  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+});
+var readScreen = defineCommand({
+  name: "read-screen",
+  description: "Read the current visible terminal screen",
+  scope: ["cli", "mcp", "sdk"],
+  params: params9,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const screen = await namedSession.session.screen();
+    return {
+      lines: [...screen.lines],
+      cursor: { ...screen.cursor },
+      size: { ...screen.size },
+      exitCode: namedSession.session.exitCode
+    };
+  }
+});
+
+// src/commands/resize.ts
+var params10 = S.Object({
+  cols: S.Number({ description: "Terminal width in columns" }),
+  rows: S.Number({ description: "Terminal height in rows" }),
+  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+});
+var resize = defineCommand({
+  name: "resize",
+  description: "Resize an active terminal session",
+  scope: ["cli", "mcp", "sdk"],
+  params: params10,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    await namedSession.session.resize(params17.cols, params17.rows);
+    return void 0;
+  }
+});
+
+// ../terminal-png/src/index.ts
+import { writeFile } from "node:fs/promises";
+
+// ../terminal-png/src/ansi-parser.ts
+var ESC2 = "\x1B";
+function createDefaultStyle() {
+  return {
+    fg: null,
+    bg: null,
+    bold: false,
+    italic: false,
+    underline: false,
+    strikethrough: false,
+    dim: false
+  };
+}
+function cloneStyle(style) {
+  return { ...style };
+}
+function stylesEqual(left, right) {
+  return left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.strikethrough === right.strikethrough && left.dim === right.dim && colorsEqual(left.fg, right.fg) && colorsEqual(left.bg, right.bg);
+}
+function colorsEqual(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (!left || !right || left.type !== right.type) {
+    return false;
+  }
+  if (left.type === "rgb" && right.type === "rgb") {
+    return left.r === right.r && left.g === right.g && left.b === right.b;
+  }
+  if ((left.type === "ansi4" || left.type === "ansi8") && left.type === right.type) {
+    return left.index === right.index;
+  }
+  return false;
+}
+function pushRun(runs, style, text) {
+  if (text.length === 0) {
+    return;
+  }
+  const previous = runs.at(-1);
+  if (previous && text !== "\n" && previous.text !== "\n" && stylesEqual(previous, style)) {
+    previous.text += text;
+    return;
+  }
+  runs.push({
+    text,
+    fg: style.fg,
+    bg: style.bg,
+    bold: style.bold,
+    italic: style.italic,
+    underline: style.underline,
+    strikethrough: style.strikethrough,
+    dim: style.dim
+  });
+}
+function parseCsi(input, start) {
+  let index = start + 2;
+  while (index < input.length) {
+    const code = input.charCodeAt(index);
+    if (code >= 64 && code <= 126) {
+      return {
+        end: index + 1,
+        final: input[index],
+        params: input.slice(start + 2, index)
+      };
+    }
+    index += 1;
+  }
+  return {
+    end: input.length,
+    final: null,
+    params: input.slice(start + 2)
+  };
+}
+function toInteger(value) {
+  if (!value || value.length === 0) {
+    return null;
+  }
+  for (const char of value) {
+    if (char < "0" || char > "9") {
+      return null;
+    }
+  }
+  return Number.parseInt(value, 10);
+}
+function clampByte(value) {
+  if (value < 0) {
+    return 0;
+  }
+  if (value > 255) {
+    return 255;
+  }
+  return value;
+}
+function applyExtendedColor(params17, start) {
+  const mode = params17[start];
+  if (mode === 5) {
+    const index = params17[start + 1];
+    if (index === void 0) {
+      return null;
+    }
+    return {
+      color: { type: "ansi8", index: clampByte(index) },
+      consumed: 2
+    };
+  }
+  if (mode === 2) {
+    const r = params17[start + 1];
+    const g = params17[start + 2];
+    const b = params17[start + 3];
+    if (r === void 0 || g === void 0 || b === void 0) {
+      return null;
+    }
+    return {
+      color: { type: "rgb", r: clampByte(r), g: clampByte(g), b: clampByte(b) },
+      consumed: 4
+    };
+  }
+  return null;
+}
+function applySgr(style, paramsText) {
+  const nextStyle = cloneStyle(style);
+  const rawParams = paramsText.length === 0 ? ["0"] : paramsText.split(";");
+  const params17 = [];
+  for (const rawParam of rawParams) {
+    const value = toInteger(rawParam);
+    if (value === null) {
+      return nextStyle;
+    }
+    params17.push(value);
+  }
+  for (let index = 0; index < params17.length; index += 1) {
+    const value = params17[index];
+    if (value === 0) {
+      Object.assign(nextStyle, createDefaultStyle());
+      continue;
+    }
+    if (value === 1) {
+      nextStyle.bold = true;
+      continue;
+    }
+    if (value === 2) {
+      nextStyle.dim = true;
+      continue;
+    }
+    if (value === 22) {
+      nextStyle.bold = false;
+      nextStyle.dim = false;
+      continue;
+    }
+    if (value === 3) {
+      nextStyle.italic = true;
+      continue;
+    }
+    if (value === 23) {
+      nextStyle.italic = false;
+      continue;
+    }
+    if (value === 4) {
+      nextStyle.underline = true;
+      continue;
+    }
+    if (value === 24) {
+      nextStyle.underline = false;
+      continue;
+    }
+    if (value === 9) {
+      nextStyle.strikethrough = true;
+      continue;
+    }
+    if (value === 29) {
+      nextStyle.strikethrough = false;
+      continue;
+    }
+    if (value === 39) {
+      nextStyle.fg = null;
+      continue;
+    }
+    if (value === 49) {
+      nextStyle.bg = null;
+      continue;
+    }
+    if (value >= 30 && value <= 37) {
+      nextStyle.fg = { type: "ansi4", index: value - 30 };
+      continue;
+    }
+    if (value >= 90 && value <= 97) {
+      nextStyle.fg = { type: "ansi4", index: value - 90 + 8 };
+      continue;
+    }
+    if (value >= 40 && value <= 47) {
+      nextStyle.bg = { type: "ansi4", index: value - 40 };
+      continue;
+    }
+    if (value >= 100 && value <= 107) {
+      nextStyle.bg = { type: "ansi4", index: value - 100 + 8 };
+      continue;
+    }
+    if (value === 38 || value === 48) {
+      const extended = applyExtendedColor(params17, index + 1);
+      if (!extended) {
+        continue;
+      }
+      if (value === 38) {
+        nextStyle.fg = extended.color;
+      } else {
+        nextStyle.bg = extended.color;
+      }
+      index += extended.consumed;
+    }
+  }
+  return nextStyle;
+}
+function parseAnsi(input) {
+  const runs = [];
+  let style = createDefaultStyle();
+  let textStart = 0;
+  let index = 0;
+  while (index < input.length) {
+    const char = input[index];
+    if (char === "\n") {
+      pushRun(runs, style, input.slice(textStart, index));
+      pushRun(runs, style, "\n");
+      index += 1;
+      textStart = index;
+      continue;
+    }
+    if (char === ESC2 && input[index + 1] === "[") {
+      pushRun(runs, style, input.slice(textStart, index));
+      const sequence = parseCsi(input, index);
+      if (sequence.final === "m") {
+        style = applySgr(style, sequence.params);
+      }
+      index = sequence.end;
+      textStart = index;
+      continue;
+    }
+    index += 1;
+  }
+  pushRun(runs, style, input.slice(textStart));
+  return runs;
+}
+
+// ../terminal-png/src/png-renderer.ts
+import { Resvg } from "@resvg/resvg-js";
+
+// ../terminal-png/src/font.ts
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var require2 = createRequire(import.meta.url);
+var fontPackageRoot = dirname(require2.resolve("jetbrains-mono/package.json"));
+var webfontRoot = join(fontPackageRoot, "fonts/webfonts");
+function readWebfontBase64(filename) {
+  return readFileSync(join(webfontRoot, filename)).toString("base64");
+}
+function resolveAssetPath(filename) {
+  return fileURLToPath2(new URL(`../assets/${filename}`, import.meta.url));
+}
+function createFontFace(base64, weight, style) {
+  return `@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: ${style};
+  font-weight: ${weight};
+  src: url('data:font/woff2;base64,${base64}') format('woff2');
+}`;
+}
+var JETBRAINS_MONO_BASE64 = readWebfontBase64("JetBrainsMono-Regular.woff2");
+var JETBRAINS_MONO_FONT_FILES = [
+  resolveAssetPath("jetbrains-mono-400-normal.ttf"),
+  resolveAssetPath("jetbrains-mono-700-normal.ttf"),
+  resolveAssetPath("jetbrains-mono-400-italic.ttf"),
+  resolveAssetPath("jetbrains-mono-700-italic.ttf")
+];
+var JETBRAINS_MONO_TTF_PATH = JETBRAINS_MONO_FONT_FILES[0];
+var FONT_FACE_CSS = [
+  createFontFace(JETBRAINS_MONO_BASE64, 400, "normal"),
+  createFontFace(readWebfontBase64("JetBrainsMono-Bold.woff2"), 700, "normal"),
+  createFontFace(readWebfontBase64("JetBrainsMono-Italic.woff2"), 400, "italic"),
+  createFontFace(readWebfontBase64("JetBrainsMono-BoldItalic.woff2"), 700, "italic")
+].join("\n");
+
+// ../terminal-png/src/png-renderer.ts
+function renderPng(svg) {
+  const resvg = new Resvg(svg, {
+    font: {
+      defaultFontFamily: "JetBrains Mono",
+      fontFiles: [...JETBRAINS_MONO_FONT_FILES],
+      loadSystemFonts: false,
+      monospaceFamily: "JetBrains Mono"
+    },
+    fitTo: {
+      mode: "zoom",
+      value: 4
+    }
+  });
+  const png = resvg.render();
+  return Buffer.from(png.asPng());
+}
+
+// ../terminal-png/src/svg-renderer.ts
+var ANSI_16_PALETTE = [
+  "#282a2e",
+  "#D74E6F",
+  "#31BB71",
+  "#D3E561",
+  "#8056FF",
+  "#ED61D7",
+  "#04D7D7",
+  "#C5C8C6",
+  "#4B4B4B",
+  "#FE5F86",
+  "#00D787",
+  "#EBFF71",
+  "#8F69FF",
+  "#FF7AEA",
+  "#00FEFE",
+  "#FFFFFF"
+];
+var XTERM_256_PALETTE = [
+  "#000000",
+  "#800000",
+  "#008000",
+  "#808000",
+  "#000080",
+  "#800080",
+  "#008080",
+  "#c0c0c0",
+  "#808080",
+  "#ff0000",
+  "#00ff00",
+  "#ffff00",
+  "#0000ff",
+  "#ff00ff",
+  "#00ffff",
+  "#ffffff",
+  "#000000",
+  "#00005f",
+  "#000087",
+  "#0000af",
+  "#0000d7",
+  "#0000ff",
+  "#005f00",
+  "#005f5f",
+  "#005f87",
+  "#005faf",
+  "#005fd7",
+  "#005fff",
+  "#008700",
+  "#00875f",
+  "#008787",
+  "#0087af",
+  "#0087d7",
+  "#0087ff",
+  "#00af00",
+  "#00af5f",
+  "#00af87",
+  "#00afaf",
+  "#00afd7",
+  "#00afff",
+  "#00d700",
+  "#00d75f",
+  "#00d787",
+  "#00d7af",
+  "#00d7d7",
+  "#00d7ff",
+  "#00ff00",
+  "#00ff5f",
+  "#00ff87",
+  "#00ffaf",
+  "#00ffd7",
+  "#00ffff",
+  "#5f0000",
+  "#5f005f",
+  "#5f0087",
+  "#5f00af",
+  "#5f00d7",
+  "#5f00ff",
+  "#5f5f00",
+  "#5f5f5f",
+  "#5f5f87",
+  "#5f5faf",
+  "#5f5fd7",
+  "#5f5fff",
+  "#5f8700",
+  "#5f875f",
+  "#5f8787",
+  "#5f87af",
+  "#5f87d7",
+  "#5f87ff",
+  "#5faf00",
+  "#5faf5f",
+  "#5faf87",
+  "#5fafaf",
+  "#5fafd7",
+  "#5fafff",
+  "#5fd700",
+  "#5fd75f",
+  "#5fd787",
+  "#5fd7af",
+  "#5fd7d7",
+  "#5fd7ff",
+  "#5fff00",
+  "#5fff5f",
+  "#5fff87",
+  "#5fffaf",
+  "#5fffd7",
+  "#5fffff",
+  "#870000",
+  "#87005f",
+  "#870087",
+  "#8700af",
+  "#8700d7",
+  "#8700ff",
+  "#875f00",
+  "#875f5f",
+  "#875f87",
+  "#875faf",
+  "#875fd7",
+  "#875fff",
+  "#878700",
+  "#87875f",
+  "#878787",
+  "#8787af",
+  "#8787d7",
+  "#8787ff",
+  "#87af00",
+  "#87af5f",
+  "#87af87",
+  "#87afaf",
+  "#87afd7",
+  "#87afff",
+  "#87d700",
+  "#87d75f",
+  "#87d787",
+  "#87d7af",
+  "#87d7d7",
+  "#87d7ff",
+  "#87ff00",
+  "#87ff5f",
+  "#87ff87",
+  "#87ffaf",
+  "#87ffd7",
+  "#87ffff",
+  "#af0000",
+  "#af005f",
+  "#af0087",
+  "#af00af",
+  "#af00d7",
+  "#af00ff",
+  "#af5f00",
+  "#af5f5f",
+  "#af5f87",
+  "#af5faf",
+  "#af5fd7",
+  "#af5fff",
+  "#af8700",
+  "#af875f",
+  "#af8787",
+  "#af87af",
+  "#af87d7",
+  "#af87ff",
+  "#afaf00",
+  "#afaf5f",
+  "#afaf87",
+  "#afafaf",
+  "#afafd7",
+  "#afafff",
+  "#afd700",
+  "#afd75f",
+  "#afd787",
+  "#afd7af",
+  "#afd7d7",
+  "#afd7ff",
+  "#afff00",
+  "#afff5f",
+  "#afff87",
+  "#afffaf",
+  "#afffd7",
+  "#afffff",
+  "#d70000",
+  "#d7005f",
+  "#d70087",
+  "#d700af",
+  "#d700d7",
+  "#d700ff",
+  "#d75f00",
+  "#d75f5f",
+  "#d75f87",
+  "#d75faf",
+  "#d75fd7",
+  "#d75fff",
+  "#d78700",
+  "#d7875f",
+  "#d78787",
+  "#d787af",
+  "#d787d7",
+  "#d787ff",
+  "#d7af00",
+  "#d7af5f",
+  "#d7af87",
+  "#d7afaf",
+  "#d7afd7",
+  "#d7afff",
+  "#d7d700",
+  "#d7d75f",
+  "#d7d787",
+  "#d7d7af",
+  "#d7d7d7",
+  "#d7d7ff",
+  "#d7ff00",
+  "#d7ff5f",
+  "#d7ff87",
+  "#d7ffaf",
+  "#d7ffd7",
+  "#d7ffff",
+  "#ff0000",
+  "#ff005f",
+  "#ff0087",
+  "#ff00af",
+  "#ff00d7",
+  "#ff00ff",
+  "#ff5f00",
+  "#ff5f5f",
+  "#ff5f87",
+  "#ff5faf",
+  "#ff5fd7",
+  "#ff5fff",
+  "#ff8700",
+  "#ff875f",
+  "#ff8787",
+  "#ff87af",
+  "#ff87d7",
+  "#ff87ff",
+  "#ffaf00",
+  "#ffaf5f",
+  "#ffaf87",
+  "#ffafaf",
+  "#ffafd7",
+  "#ffafff",
+  "#ffd700",
+  "#ffd75f",
+  "#ffd787",
+  "#ffd7af",
+  "#ffd7d7",
+  "#ffd7ff",
+  "#ffff00",
+  "#ffff5f",
+  "#ffff87",
+  "#ffffaf",
+  "#ffffd7",
+  "#ffffff",
+  "#080808",
+  "#121212",
+  "#1c1c1c",
+  "#262626",
+  "#303030",
+  "#3a3a3a",
+  "#444444",
+  "#4e4e4e",
+  "#585858",
+  "#606060",
+  "#666666",
+  "#767676",
+  "#808080",
+  "#8a8a8a",
+  "#949494",
+  "#9e9e9e",
+  "#a8a8a8",
+  "#b2b2b2",
+  "#bcbcbc",
+  "#c6c6c6",
+  "#d0d0d0",
+  "#dadada",
+  "#e4e4e4",
+  "#eeeeee"
+];
+var BACKGROUND = "#171717";
+var DEFAULT_FOREGROUND = "#c4c4c4";
+var FONT_FAMILY = "JetBrains Mono";
+var FONT_SIZE = 14;
+var LINE_HEIGHT = 1.2;
+var CHARACTER_WIDTH = 8.412666666666667;
+var TEXT_BOTTOM_PADDING = 11.6;
+var DEFAULT_PADDING = {
+  top: 20,
+  right: 40,
+  bottom: 20,
+  left: 20
+};
+var WINDOW_BAR_HEIGHT = 15;
+function renderSvg(runs, options = {}) {
+  const padding = options.padding === void 0 ? DEFAULT_PADDING : {
+    top: options.padding,
+    right: options.padding,
+    bottom: options.padding,
+    left: options.padding
+  };
+  const showWindow = options.window ?? true;
+  const titleBarHeight = showWindow ? WINDOW_BAR_HEIGHT : 0;
+  const textStartX = padding.left;
+  const lineHeightPx = FONT_SIZE * LINE_HEIGHT;
+  const textStartY = titleBarHeight + padding.top + lineHeightPx;
+  const lines = splitIntoLines(runs);
+  const contentWidth = measureLines(lines);
+  const width = padding.left + contentWidth + padding.right;
+  const height = titleBarHeight + padding.top + lines.length * lineHeightPx + padding.bottom + TEXT_BOTTOM_PADDING;
+  const svgWidth = formatNumber(width);
+  const svgHeight = formatNumber(height);
+  const viewBox = `0 0 ${svgWidth} ${svgHeight}`;
+  const textElements = renderLines(lines, textStartX, textStartY, lineHeightPx);
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${svgWidth}" height="${svgHeight}" viewBox="${viewBox}">`,
+    "<defs>",
+    "<style><![CDATA[",
+    FONT_FACE_CSS,
+    "]]></style>",
+    "</defs>",
+    `<rect x="0" y="0" width="${svgWidth}" height="${svgHeight}" fill="${BACKGROUND}" />`,
+    showWindow ? renderWindowControls() : "",
+    `<g font-family="${FONT_FAMILY}" font-size="${formatNumber(FONT_SIZE)}px" fill="${DEFAULT_FOREGROUND}">`,
+    textElements,
+    "</g>",
+    "</svg>"
+  ].join("");
+}
+function splitIntoLines(runs) {
+  const lines = [[]];
+  for (const run of runs) {
+    if (run.text === "\n") {
+      lines.push([]);
+      continue;
+    }
+    lines[lines.length - 1]?.push(run);
+  }
+  return lines;
+}
+function measureLines(lines) {
+  return Math.max(
+    ...lines.map((line) => line.reduce((width, run) => width + displayWidth(run.text) * CHARACTER_WIDTH, 0)),
+    0
+  );
+}
+function displayWidth(text) {
+  const segmenter = new Intl.Segmenter();
+  let width = 0;
+  for (const { segment } of segmenter.segment(text)) {
+    const cp = segment.codePointAt(0);
+    width += cp !== void 0 && isWideCodePoint(cp) ? 2 : 1;
+  }
+  return width;
+}
+function isWideCodePoint(cp) {
+  return cp >= 4352 && cp <= 4447 || // Hangul Jamo
+  cp === 9001 || cp === 9002 || // Angle brackets
+  cp >= 11904 && cp <= 12350 || // CJK Radicals, Kangxi
+  cp >= 12353 && cp <= 13247 || // Hiragana, Katakana, CJK symbols
+  cp >= 13312 && cp <= 19903 || // CJK Extension A
+  cp >= 19968 && cp <= 42191 || // CJK Unified Ideographs
+  cp >= 43360 && cp <= 43391 || // Hangul Jamo Extended-A
+  cp >= 44032 && cp <= 55215 || // Hangul Syllables
+  cp >= 63744 && cp <= 64255 || // CJK Compatibility Ideographs
+  cp >= 65040 && cp <= 65049 || // Vertical Forms
+  cp >= 65072 && cp <= 65135 || // CJK Compatibility Forms
+  cp >= 65280 && cp <= 65376 || // Fullwidth Latin, Halfwidth Katakana
+  cp >= 65504 && cp <= 65510 || // Fullwidth Signs
+  cp >= 110592 && cp <= 110847 || // Kana Supplement
+  cp >= 126980 && cp <= 126980 || // Mahjong tile
+  cp >= 127183 && cp <= 127183 || // Playing card black joker
+  cp >= 127488 && cp <= 131069 || // Enclosed CJK + Emoji
+  cp >= 131072 && cp <= 196605 || // CJK Extension B–F
+  cp >= 196608 && cp <= 262141;
+}
+function renderLines(lines, textStartX, textStartY, lineHeightPx) {
+  return lines.map((line, index) => {
+    const y = formatNumber(textStartY + index * lineHeightPx);
+    if (line.length === 0) {
+      return `<text x="${formatNumber(textStartX)}" y="${y}" xml:space="preserve"/>`;
+    }
+    return [
+      `<text x="${formatNumber(textStartX)}" y="${y}" xml:space="preserve">`,
+      line.map(renderRun).join(""),
+      "</text>"
+    ].join("");
+  }).join("");
+}
+function renderRun(run) {
+  const attributes = ['xml:space="preserve"'];
+  const color = resolveColor(run.fg);
+  const textDecorations = [];
+  if (color !== DEFAULT_FOREGROUND) {
+    attributes.push(`fill="${escapeXmlAttribute(color)}"`);
+  }
+  if (run.bold) {
+    attributes.push('font-weight="bold"');
+  }
+  if (run.italic) {
+    attributes.push('font-style="italic"');
+  }
+  if (run.underline) {
+    textDecorations.push("underline");
+  }
+  if (run.strikethrough) {
+    textDecorations.push("line-through");
+  }
+  if (textDecorations.length > 0) {
+    attributes.push(`text-decoration="${textDecorations.join(" ")}"`);
+  }
+  if (run.dim) {
+    attributes.push('opacity="0.7"');
+  }
+  return `<tspan ${attributes.join(" ")}>${escapeXmlText(run.text)}</tspan>`;
+}
+function renderWindowControls() {
+  return [
+    '<circle cx="13.5" cy="12" r="5.5" fill="#FF5A54" />',
+    '<circle cx="32.5" cy="12" r="5.5" fill="#E6BF29" />',
+    '<circle cx="51.5" cy="12" r="5.5" fill="#52C12B" />'
+  ].join("");
+}
+function resolveColor(color) {
+  if (color === null) {
+    return DEFAULT_FOREGROUND;
+  }
+  if (color.type === "ansi4") {
+    return ANSI_16_PALETTE[color.index] ?? DEFAULT_FOREGROUND;
+  }
+  if (color.type === "ansi8") {
+    if (color.index < ANSI_16_PALETTE.length) {
+      return ANSI_16_PALETTE[color.index] ?? DEFAULT_FOREGROUND;
+    }
+    return XTERM_256_PALETTE[color.index] ?? DEFAULT_FOREGROUND;
+  }
+  return `rgb(${color.r},${color.g},${color.b})`;
+}
+function escapeXmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeXmlAttribute(value) {
+  return escapeXmlText(value).replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function formatNumber(value) {
+  return value.toFixed(2);
+}
+
+// ../terminal-png/src/index.ts
+async function renderTerminalPng(ansiText, options = {}) {
+  const runs = parseAnsi(ansiText);
+  const svg = renderSvg(runs, {
+    padding: options.padding,
+    window: options.window
+  });
+  const png = renderPng(svg);
+  if (options.output) {
+    await writeFile(options.output, png);
+  }
+  return png;
+}
+
+// src/commands/screenshot.ts
+var params11 = S.Object({
+  session: S.Optional(S.String({ short: "s", description: "Session name" })),
+  output: S.String({ short: "o", description: "Path to the output PNG file" }),
+  window: S.Optional(S.Boolean({ description: "Include terminal window chrome", default: true })),
+  padding: S.Optional(S.Number({ short: "p", description: "Padding around terminal content" }))
+});
+var screenshot = defineCommand({
+  name: "screenshot",
+  description: "Capture the current terminal screen as a PNG image",
+  scope: ["cli"],
+  params: params11,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const screen = await namedSession.session.screen();
+    await renderTerminalPng(screen.rawLines.join("\n"), {
+      output: params17.output,
+      window: params17.window,
+      padding: params17.padding
+    });
+    return void 0;
+  }
+});
+
+// src/commands/send-signal.ts
+var params12 = S.Object({
+  signal: S.String({ description: "Signal to send to the session process" }),
+  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+});
+var sendSignal = defineCommand({
+  name: "send-signal",
+  description: "Send a process signal to an active terminal session",
+  scope: ["cli", "mcp", "sdk"],
+  positional: ["signal"],
+  params: params12,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    await namedSession.session.signal(params17.signal);
+    return void 0;
+  }
+});
+
+// src/commands/type.ts
+var params13 = S.Object({
+  text: S.String({ description: "Text to write to the session" }),
+  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+});
+var type = defineCommand({
+  name: "type",
+  description: "Write text to an active terminal session character-by-character with delay",
+  scope: ["cli", "mcp", "sdk"],
+  positional: ["text"],
+  params: params13,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    await namedSession.session.type(params17.text);
+    return void 0;
+  }
+});
+
+// src/commands/uninstall.ts
+var params14 = S.Object({
+  agent: S.Enum(installableAgents, {
+    description: "Agent to uninstall terminal-pilot from",
+    default: DEFAULT_INSTALL_AGENT
+  })
+});
+var uninstall = defineCommand({
+  name: "uninstall",
+  description: "Remove the terminal-pilot CLI skill.",
+  scope: ["cli"],
+  positional: ["agent"],
+  params: params14,
+  handler: async ({ params: params17, terminalPilotInstaller }) => {
+    const services = resolveInstallerServices(terminalPilotInstaller);
+    const agent = resolveInstallableAgent(params17.agent);
+    const localSkill = getSkillFolderWithHome(
+      agent,
+      "local",
+      services.cwd,
+      services.homeDir
+    );
+    const globalSkill = getSkillFolderWithHome(
+      agent,
+      "global",
+      services.cwd,
+      services.homeDir
+    );
+    const removedSkillPaths = [];
+    if (await removeSkillFolder(services.fs, localSkill.fullPath)) {
+      removedSkillPaths.push(localSkill.displayPath);
+    }
+    if (await removeSkillFolder(services.fs, globalSkill.fullPath)) {
+      removedSkillPaths.push(globalSkill.displayPath);
+    }
+    return {
+      agent,
+      removedSkillPaths
+    };
+  }
+});
+
+// src/commands/wait-for.ts
+var params15 = S.Object({
+  pattern: S.String({ description: "Regular expression pattern to wait for" }),
+  session: S.Optional(S.String({ short: "s", description: "Session name" })),
+  timeout: S.Optional(S.Number({ short: "t", description: "Maximum wait time in milliseconds" })),
+  literal: S.Optional(
+    S.Boolean({
+      short: "l",
+      description: "When true, treat pattern as a literal string instead of a regex"
+    })
+  )
+});
+var waitFor = defineCommand({
+  name: "wait-for",
+  description: "Wait for terminal output to match a pattern",
+  scope: ["cli", "mcp", "sdk"],
+  positional: ["pattern"],
+  params: params15,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const pattern = params17.literal === true ? params17.pattern : new RegExp(params17.pattern);
+    const line = params17.timeout === void 0 ? await namedSession.session.waitFor(pattern) : await namedSession.session.waitFor(pattern, { timeout: params17.timeout });
+    return { matched: true, line };
+  }
+});
+
+// src/commands/wait-for-exit.ts
+var params16 = S.Object({
+  session: S.Optional(S.String({ short: "s", description: "Session name" })),
+  timeout: S.Optional(S.Number({ short: "t", description: "Maximum wait time in milliseconds" }))
+});
+var waitForExit2 = defineCommand({
+  name: "wait-for-exit",
+  description: "Wait for a terminal session process to finish",
+  scope: ["cli", "mcp", "sdk"],
+  params: params16,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const exitCode = await namedSession.session.waitForExit(
+      params17.timeout === void 0 ? void 0 : { timeout: params17.timeout }
+    );
+    return { exitCode };
+  }
+});
+
+// src/commands/index.ts
+var children = [
+  install,
+  uninstall,
+  createSession,
+  fill,
+  type,
+  pressKey,
+  sendSignal,
+  waitFor,
+  waitForExit2,
+  readScreen,
+  screenshot,
+  readHistory,
+  resize,
+  closeSession,
+  getSession,
+  listSessions
+];
+var terminalPilotGroup = defineGroup({
+  name: "terminal-pilot",
+  scope: ["cli", "mcp", "sdk"],
+  children
+});
+export {
+  SESSION_ENV_VAR,
+  closeSession,
+  createSession,
+  createTerminalPilotRuntime,
+  fill,
+  getSession,
+  install,
+  listSessions,
+  pressKey,
+  readHistory,
+  readScreen,
+  resize,
+  screenshot,
+  sendSignal,
+  terminalPilotGroup,
+  type,
+  uninstall,
+  waitFor,
+  waitForExit2 as waitForExit
+};
+//# sourceMappingURL=index.js.map