ai-whisper 0.5.0 → 0.5.1

package/dist/bin/companion-agent.js

@@ -6894,11 +6894,387 @@ function createCodexLiveSession(input) {
   };
 }
 
-// ../adapter-ai-ezio/dist/create-ai-ezio-provider.js
-import { TurnError, EngineExitedError } from "@ai-ezio/harness";
+// ../../node_modules/.pnpm/@ai-ezio+harness@file+..+ai-ezio+packages+harness/node_modules/@ai-ezio/harness/dist/resolve-hax.js
+import { existsSync as existsSync5 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname2, join as join7 } from "node:path";
+import { fileURLToPath } from "node:url";
+var HaxBinaryNotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HaxBinaryNotFoundError";
+  }
+};
+function platformPackageName(platform, arch) {
+  return `@ai-ezio/hax-${platform}-${arch}`;
+}
+function defaultResolvePackageJson(specifier) {
+  const require4 = createRequire3(import.meta.url);
+  return require4.resolve(specifier);
+}
+function findDevRoot() {
+  let dir = dirname2(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 12; i++) {
+    if (existsSync5(join7(dir, "vendor", "hax", "build", "hax"))) {
+      return dir;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return void 0;
+}
+function describeHaxBinary(options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const fileExists = options.fileExists ?? existsSync5;
+  const resolvePackageJson = options.resolvePackageJson ?? defaultResolvePackageJson;
+  const attempts = [];
+  const override = env.AI_EZIO_HAX_BIN;
+  if (override !== void 0 && override !== "") {
+    if (fileExists(override)) {
+      attempts.push(`AI_EZIO_HAX_BIN=${override} (exists)`);
+      return { ok: true, path: override, source: "env-override", attempts };
+    }
+    attempts.push(`AI_EZIO_HAX_BIN=${override} (missing)`);
+    return {
+      ok: false,
+      attempts,
+      error: `AI_EZIO_HAX_BIN is set to "${override}" but no file exists there.`
+    };
+  }
+  attempts.push("AI_EZIO_HAX_BIN (unset)");
+  const pkg = platformPackageName(platform, arch);
+  try {
+    const pkgJson = resolvePackageJson(`${pkg}/package.json`);
+    const bin = join7(dirname2(pkgJson), "bin", "hax");
+    if (fileExists(bin)) {
+      attempts.push(`${pkg} (found ${bin})`);
+      return { ok: true, path: bin, source: "platform-package", attempts };
+    }
+    attempts.push(`${pkg} (resolved, but ${bin} missing)`);
+  } catch {
+    attempts.push(`${pkg} (not installed)`);
+  }
+  const devRoot = "devRoot" in options ? options.devRoot : findDevRoot();
+  if (devRoot !== void 0) {
+    const devBin = join7(devRoot, "vendor", "hax", "build", "hax");
+    if (fileExists(devBin)) {
+      attempts.push(`${devBin} (dev fallback)`);
+      return { ok: true, path: devBin, source: "dev-fallback", attempts };
+    }
+    attempts.push(`${devBin} (dev fallback missing)`);
+  } else {
+    attempts.push("vendor/hax/build/hax (no dev root)");
+  }
+  return {
+    ok: false,
+    attempts,
+    error: `Could not locate the hax binary. Tried: ${attempts.join("; ")}.`
+  };
+}
+function resolveHaxBinary(options = {}) {
+  const result = describeHaxBinary(options);
+  if (result.ok && result.path !== void 0)
+    return result.path;
+  throw new HaxBinaryNotFoundError(`${result.error} Run "ai-ezio doctor" for help.`);
+}
+
+// ../../node_modules/.pnpm/@ai-ezio+harness@file+..+ai-ezio+packages+harness/node_modules/@ai-ezio/harness/dist/spawn.js
+import { spawn as spawn5 } from "node:child_process";
+
+// ../../node_modules/.pnpm/@ai-ezio+harness@file+..+ai-ezio+packages+harness/node_modules/@ai-ezio/harness/dist/skills-dir.js
+import { homedir } from "node:os";
+import { join as join8 } from "node:path";
+function aiEzioGlobalSkillsDir(env = process.env) {
+  const base = env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME !== "" ? env.XDG_CONFIG_HOME : join8(homedir(), ".config");
+  return join8(base, "ai-ezio", "skills");
+}
+
+// ../../node_modules/.pnpm/@ai-ezio+harness@file+..+ai-ezio+packages+harness/node_modules/@ai-ezio/harness/dist/spawn.js
+function haxSpawnArgs(extra = []) {
+  return ["--protocol-fd=3", "--control-fd=4", "--mount-mode", ...extra];
+}
+function haxSpawnEnv(base = process.env) {
+  return { ...base, HAX_EXTRA_SKILLS_DIR: aiEzioGlobalSkillsDir(base) };
+}
+function spawnHax(options = {}) {
+  const binary = options.binary ?? resolveHaxBinary();
+  const child = spawn5(binary, haxSpawnArgs(options.args), {
+    // 0,1,2 ignored; 3 = events (hax writes), 4 = controls (hax reads).
+    stdio: ["ignore", "ignore", "ignore", "pipe", "pipe"],
+    env: haxSpawnEnv(options.env ?? process.env)
+  });
+  const eventStream = child.stdio[3];
+  const controlStream = child.stdio[4];
+  return { child, eventStream, controlStream };
+}
+
+// ../../node_modules/.pnpm/@ai-ezio+protocol@file+..+ai-ezio+packages+protocol/node_modules/@ai-ezio/protocol/dist/codec.js
+import { StringDecoder } from "node:string_decoder";
+var MalformedLineError = class extends Error {
+  line;
+  constructor(line) {
+    super(`malformed JSONL line: ${JSON.stringify(line)}`);
+    this.line = line;
+    this.name = "MalformedLineError";
+  }
+};
+function encodeControl(control) {
+  return `${JSON.stringify(control)}
+`;
+}
+var JsonlDecoder = class {
+  buffer = "";
+  // fd-3 yields raw Buffer chunks at arbitrary boundaries. StringDecoder holds
+  // back the trailing bytes of a multibyte UTF-8 codepoint until the rest
+  // arrives, so a char split across reads (em-dash, bullet, smart quote, box
+  // chars) never decodes to `�`. Decoding a chunk in isolation does NOT.
+  utf8 = new StringDecoder("utf8");
+  /**
+   * Append a chunk and return every complete event it produced. A trailing
+   * partial line — or a partial multibyte char — is retained until the rest
+   * arrives. Throws MalformedLineError on a complete-but-unparseable line (the
+   * buffer past it is preserved so decoding can continue after the caller
+   * handles it).
+   */
+  push(chunk) {
+    this.buffer += typeof chunk === "string" ? chunk : this.utf8.write(Buffer.from(chunk));
+    const events = [];
+    let nl = this.buffer.indexOf("\n");
+    while (nl >= 0) {
+      const line = this.buffer.slice(0, nl);
+      this.buffer = this.buffer.slice(nl + 1);
+      const trimmed = line.trim();
+      if (trimmed.length > 0) {
+        let parsed;
+        try {
+          parsed = JSON.parse(trimmed);
+        } catch {
+          throw new MalformedLineError(line);
+        }
+        events.push(parsed);
+      }
+      nl = this.buffer.indexOf("\n");
+    }
+    return events;
+  }
+  /** Bytes buffered but not yet terminated by a newline. */
+  get pending() {
+    return this.buffer;
+  }
+};
+
+// ../../node_modules/.pnpm/@ai-ezio+protocol@file+..+ai-ezio+packages+protocol/node_modules/@ai-ezio/protocol/dist/transport-fd.js
+var FdTransport = class {
+  eventStream;
+  controlStream;
+  decoder = new JsonlDecoder();
+  constructor(eventStream, controlStream) {
+    this.eventStream = eventStream;
+    this.controlStream = controlStream;
+  }
+  async *events() {
+    for await (const chunk of this.eventStream) {
+      for (const event of this.decoder.push(chunk)) {
+        yield event;
+      }
+    }
+  }
+  send(control) {
+    this.controlStream.write(encodeControl(control));
+  }
+  close() {
+    this.controlStream.end();
+  }
+};
+
+// ../../node_modules/.pnpm/@ai-ezio+protocol@file+..+ai-ezio+packages+protocol/node_modules/@ai-ezio/protocol/dist/index.js
+var PROTOCOL_VERSION = "0.1.0";
+function semverMajor(version) {
+  const major = Number.parseInt(version.split(".", 1)[0] ?? "", 10);
+  if (Number.isNaN(major)) {
+    throw new Error(`Invalid semver version string: "${version}"`);
+  }
+  return major;
+}
+function isProtocolCompatible(theirs, ours = PROTOCOL_VERSION) {
+  return semverMajor(theirs) === semverMajor(ours);
+}
+
+// ../../node_modules/.pnpm/@ai-ezio+harness@file+..+ai-ezio+packages+harness/node_modules/@ai-ezio/harness/dist/session.js
+var ProtocolVersionError = class extends Error {
+  constructor(theirs, ours) {
+    super(`unsupported engine protocol ${theirs} (harness speaks ${ours})`);
+    this.name = "ProtocolVersionError";
+  }
+};
+var TurnError = class extends Error {
+  turnId;
+  constructor(message, turnId) {
+    super(message);
+    this.turnId = turnId;
+    this.name = "TurnError";
+  }
+};
+var EngineExitedError = class extends Error {
+  constructor(message = "engine exited (fd-3 EOF)") {
+    super(message);
+    this.name = "EngineExitedError";
+  }
+};
+var Session = class {
+  options;
+  spawned;
+  transport;
+  queue = [];
+  waiters = [];
+  ended = false;
+  closed = false;
+  exitHandlers = [];
+  ready;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /** Subscribe to engine child-exit (workflow-agnostic lifecycle signal for
+   * adapters that surface provider exit). Fires once per child exit. */
+  onExit(handler) {
+    this.exitHandlers.push(handler);
+  }
+  deliver(event) {
+    if (event && this.options.onEvent)
+      this.options.onEvent(event);
+    const w = this.waiters.shift();
+    if (w)
+      w(event);
+    else if (event)
+      this.queue.push(event);
+  }
+  next() {
+    const queued = this.queue.shift();
+    if (queued)
+      return Promise.resolve(queued);
+    if (this.ended)
+      return Promise.resolve(null);
+    return new Promise((resolve2) => this.waiters.push(resolve2));
+  }
+  /** Consume events until one of the given type arrives. Fatal EOF →
+   * EngineExitedError; a turn-scoped `error` → TurnError. */
+  async waitForEvent(type) {
+    for (; ; ) {
+      const e = await this.next();
+      if (e === null)
+        throw new EngineExitedError(`engine exited before "${type}"`);
+      if (e.type === "error" && type !== "error") {
+        throw new TurnError(e.message, e.turnId);
+      }
+      if (e.type === type)
+        return e;
+    }
+  }
+  /** Spawn hax, pump events, and gate on the `ready` protocol version. */
+  async start(options = {}) {
+    const spawned = spawnHax(options);
+    this.spawned = spawned;
+    spawned.child.on("exit", (code, signal) => {
+      for (const handler of this.exitHandlers)
+        handler({ code, signal });
+    });
+    const transport = new FdTransport(spawned.eventStream, spawned.controlStream);
+    this.transport = transport;
+    void (async () => {
+      try {
+        for await (const event of transport.events())
+          this.deliver(event);
+      } finally {
+        this.ended = true;
+        while (this.waiters.length)
+          this.deliver(null);
+      }
+    })();
+    const ready = await this.waitForEvent("ready");
+    if (!isProtocolCompatible(ready.protocol, PROTOCOL_VERSION)) {
+      this.close();
+      throw new ProtocolVersionError(ready.protocol, PROTOCOL_VERSION);
+    }
+    this.ready = ready;
+    return ready;
+  }
+  control(control) {
+    if (!this.transport)
+      throw new Error("session not started");
+    this.transport.send(control);
+  }
+  /** Send a user turn without waiting (pair with waitForEvent/interrupt). */
+  submit(text) {
+    this.control({ type: "submit", text });
+  }
+  /**
+   * Submit a user turn and resolve with its authoritative content at idle.
+   * A turn-scoped `error` is captured and the loop **drains to `idle`** (so the
+   * session settles at a clean boundary and a later submit works), then rejects
+   * with TurnError. A fatal fd-3 EOF mid-turn rejects with EngineExitedError.
+   */
+  async submitAndWait(text) {
+    this.control({ type: "submit", text });
+    let result;
+    let turnError;
+    for (; ; ) {
+      const e = await this.next();
+      if (e === null)
+        throw new EngineExitedError("engine exited mid-turn");
+      if (e.type === "assistant_turn_finished") {
+        result = { turnId: e.turnId, content: e.content };
+      } else if (e.type === "error") {
+        turnError = new TurnError(e.message, e.turnId);
+      } else if (e.type === "idle") {
+        if (turnError)
+          throw turnError;
+        return result ?? { turnId: "", content: "" };
+      }
+    }
+  }
+  /** Cancel the in-flight turn. */
+  interrupt() {
+    this.control({ type: "interrupt" });
+  }
+  /** Re-fetch the last handback without re-running a turn (no clipboard).
+   * Resolves the re-emitted content; rejects TurnError if no prior response. */
+  async copyLastResponse() {
+    this.control({ type: "copy_last_response" });
+    const e = await this.waitForEvent("assistant_turn_finished");
+    if (e.type !== "assistant_turn_finished")
+      throw new Error("unexpected event");
+    return { turnId: e.turnId, content: e.content };
+  }
+  /** Start a fresh conversation; resolves once the engine is idle again. */
+  async newConversation() {
+    this.control({ type: "new_conversation" });
+    await this.waitForEvent("idle");
+  }
+  /** Request an engine/session status event. */
+  async status() {
+    this.control({ type: "status" });
+    return await this.waitForEvent("status");
+  }
+  /** Close the control channel (shuts the engine down) and stop the child.
+   * Idempotent — safe to call from both the version-gate teardown and the
+   * caller. */
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    try {
+      this.transport?.close();
+    } catch {
+    }
+    this.spawned?.child.kill();
+  }
+};
 
 // ../adapter-ai-ezio/dist/ai-ezio-engine.js
-import { Session } from "@ai-ezio/harness";
 var defaultCreateEngineSession = ({ onEvent }) => new Session({ onEvent });
 
 // ../adapter-ai-ezio/dist/ai-ezio-prompt.js

package/dist/bin/whisper.js

@@ -9268,10 +9268,388 @@ function createCodexLiveSession(input) {
 
 // ../adapter-ai-ezio/dist/create-ai-ezio-provider.js
 init_dist();
-import { TurnError, EngineExitedError } from "@ai-ezio/harness";
+
+// ../../node_modules/.pnpm/@ai-ezio+harness@file+..+ai-ezio+packages+harness/node_modules/@ai-ezio/harness/dist/resolve-hax.js
+import { existsSync as existsSync7 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname3, join as join7 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var HaxBinaryNotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HaxBinaryNotFoundError";
+  }
+};
+function platformPackageName(platform, arch) {
+  return `@ai-ezio/hax-${platform}-${arch}`;
+}
+function defaultResolvePackageJson(specifier) {
+  const require4 = createRequire3(import.meta.url);
+  return require4.resolve(specifier);
+}
+function findDevRoot() {
+  let dir = dirname3(fileURLToPath2(import.meta.url));
+  for (let i = 0; i < 12; i++) {
+    if (existsSync7(join7(dir, "vendor", "hax", "build", "hax"))) {
+      return dir;
+    }
+    const parent = dirname3(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return void 0;
+}
+function describeHaxBinary(options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const fileExists = options.fileExists ?? existsSync7;
+  const resolvePackageJson = options.resolvePackageJson ?? defaultResolvePackageJson;
+  const attempts = [];
+  const override = env.AI_EZIO_HAX_BIN;
+  if (override !== void 0 && override !== "") {
+    if (fileExists(override)) {
+      attempts.push(`AI_EZIO_HAX_BIN=${override} (exists)`);
+      return { ok: true, path: override, source: "env-override", attempts };
+    }
+    attempts.push(`AI_EZIO_HAX_BIN=${override} (missing)`);
+    return {
+      ok: false,
+      attempts,
+      error: `AI_EZIO_HAX_BIN is set to "${override}" but no file exists there.`
+    };
+  }
+  attempts.push("AI_EZIO_HAX_BIN (unset)");
+  const pkg = platformPackageName(platform, arch);
+  try {
+    const pkgJson = resolvePackageJson(`${pkg}/package.json`);
+    const bin = join7(dirname3(pkgJson), "bin", "hax");
+    if (fileExists(bin)) {
+      attempts.push(`${pkg} (found ${bin})`);
+      return { ok: true, path: bin, source: "platform-package", attempts };
+    }
+    attempts.push(`${pkg} (resolved, but ${bin} missing)`);
+  } catch {
+    attempts.push(`${pkg} (not installed)`);
+  }
+  const devRoot = "devRoot" in options ? options.devRoot : findDevRoot();
+  if (devRoot !== void 0) {
+    const devBin = join7(devRoot, "vendor", "hax", "build", "hax");
+    if (fileExists(devBin)) {
+      attempts.push(`${devBin} (dev fallback)`);
+      return { ok: true, path: devBin, source: "dev-fallback", attempts };
+    }
+    attempts.push(`${devBin} (dev fallback missing)`);
+  } else {
+    attempts.push("vendor/hax/build/hax (no dev root)");
+  }
+  return {
+    ok: false,
+    attempts,
+    error: `Could not locate the hax binary. Tried: ${attempts.join("; ")}.`
+  };
+}
+function resolveHaxBinary(options = {}) {
+  const result = describeHaxBinary(options);
+  if (result.ok && result.path !== void 0)
+    return result.path;
+  throw new HaxBinaryNotFoundError(`${result.error} Run "ai-ezio doctor" for help.`);
+}
+
+// ../../node_modules/.pnpm/@ai-ezio+harness@file+..+ai-ezio+packages+harness/node_modules/@ai-ezio/harness/dist/spawn.js
+import { spawn as spawn6 } from "node:child_process";
+
+// ../../node_modules/.pnpm/@ai-ezio+harness@file+..+ai-ezio+packages+harness/node_modules/@ai-ezio/harness/dist/skills-dir.js
+import { homedir } from "node:os";
+import { join as join8 } from "node:path";
+function aiEzioGlobalSkillsDir(env = process.env) {
+  const base = env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME !== "" ? env.XDG_CONFIG_HOME : join8(homedir(), ".config");
+  return join8(base, "ai-ezio", "skills");
+}
+
+// ../../node_modules/.pnpm/@ai-ezio+harness@file+..+ai-ezio+packages+harness/node_modules/@ai-ezio/harness/dist/spawn.js
+function haxSpawnArgs(extra = []) {
+  return ["--protocol-fd=3", "--control-fd=4", "--mount-mode", ...extra];
+}
+function haxSpawnEnv(base = process.env) {
+  return { ...base, HAX_EXTRA_SKILLS_DIR: aiEzioGlobalSkillsDir(base) };
+}
+function spawnHax(options = {}) {
+  const binary = options.binary ?? resolveHaxBinary();
+  const child = spawn6(binary, haxSpawnArgs(options.args), {
+    // 0,1,2 ignored; 3 = events (hax writes), 4 = controls (hax reads).
+    stdio: ["ignore", "ignore", "ignore", "pipe", "pipe"],
+    env: haxSpawnEnv(options.env ?? process.env)
+  });
+  const eventStream = child.stdio[3];
+  const controlStream = child.stdio[4];
+  return { child, eventStream, controlStream };
+}
+
+// ../../node_modules/.pnpm/@ai-ezio+protocol@file+..+ai-ezio+packages+protocol/node_modules/@ai-ezio/protocol/dist/codec.js
+import { StringDecoder } from "node:string_decoder";
+var MalformedLineError = class extends Error {
+  line;
+  constructor(line) {
+    super(`malformed JSONL line: ${JSON.stringify(line)}`);
+    this.line = line;
+    this.name = "MalformedLineError";
+  }
+};
+function encodeControl(control) {
+  return `${JSON.stringify(control)}
+`;
+}
+var JsonlDecoder = class {
+  buffer = "";
+  // fd-3 yields raw Buffer chunks at arbitrary boundaries. StringDecoder holds
+  // back the trailing bytes of a multibyte UTF-8 codepoint until the rest
+  // arrives, so a char split across reads (em-dash, bullet, smart quote, box
+  // chars) never decodes to `�`. Decoding a chunk in isolation does NOT.
+  utf8 = new StringDecoder("utf8");
+  /**
+   * Append a chunk and return every complete event it produced. A trailing
+   * partial line — or a partial multibyte char — is retained until the rest
+   * arrives. Throws MalformedLineError on a complete-but-unparseable line (the
+   * buffer past it is preserved so decoding can continue after the caller
+   * handles it).
+   */
+  push(chunk) {
+    this.buffer += typeof chunk === "string" ? chunk : this.utf8.write(Buffer.from(chunk));
+    const events = [];
+    let nl = this.buffer.indexOf("\n");
+    while (nl >= 0) {
+      const line = this.buffer.slice(0, nl);
+      this.buffer = this.buffer.slice(nl + 1);
+      const trimmed = line.trim();
+      if (trimmed.length > 0) {
+        let parsed;
+        try {
+          parsed = JSON.parse(trimmed);
+        } catch {
+          throw new MalformedLineError(line);
+        }
+        events.push(parsed);
+      }
+      nl = this.buffer.indexOf("\n");
+    }
+    return events;
+  }
+  /** Bytes buffered but not yet terminated by a newline. */
+  get pending() {
+    return this.buffer;
+  }
+};
+
+// ../../node_modules/.pnpm/@ai-ezio+protocol@file+..+ai-ezio+packages+protocol/node_modules/@ai-ezio/protocol/dist/transport-fd.js
+var FdTransport = class {
+  eventStream;
+  controlStream;
+  decoder = new JsonlDecoder();
+  constructor(eventStream, controlStream) {
+    this.eventStream = eventStream;
+    this.controlStream = controlStream;
+  }
+  async *events() {
+    for await (const chunk of this.eventStream) {
+      for (const event of this.decoder.push(chunk)) {
+        yield event;
+      }
+    }
+  }
+  send(control) {
+    this.controlStream.write(encodeControl(control));
+  }
+  close() {
+    this.controlStream.end();
+  }
+};
+
+// ../../node_modules/.pnpm/@ai-ezio+protocol@file+..+ai-ezio+packages+protocol/node_modules/@ai-ezio/protocol/dist/index.js
+var PROTOCOL_VERSION = "0.1.0";
+function semverMajor(version) {
+  const major = Number.parseInt(version.split(".", 1)[0] ?? "", 10);
+  if (Number.isNaN(major)) {
+    throw new Error(`Invalid semver version string: "${version}"`);
+  }
+  return major;
+}
+function isProtocolCompatible(theirs, ours = PROTOCOL_VERSION) {
+  return semverMajor(theirs) === semverMajor(ours);
+}
+
+// ../../node_modules/.pnpm/@ai-ezio+harness@file+..+ai-ezio+packages+harness/node_modules/@ai-ezio/harness/dist/session.js
+var ProtocolVersionError = class extends Error {
+  constructor(theirs, ours) {
+    super(`unsupported engine protocol ${theirs} (harness speaks ${ours})`);
+    this.name = "ProtocolVersionError";
+  }
+};
+var TurnError = class extends Error {
+  turnId;
+  constructor(message, turnId) {
+    super(message);
+    this.turnId = turnId;
+    this.name = "TurnError";
+  }
+};
+var EngineExitedError = class extends Error {
+  constructor(message = "engine exited (fd-3 EOF)") {
+    super(message);
+    this.name = "EngineExitedError";
+  }
+};
+var Session = class {
+  options;
+  spawned;
+  transport;
+  queue = [];
+  waiters = [];
+  ended = false;
+  closed = false;
+  exitHandlers = [];
+  ready;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /** Subscribe to engine child-exit (workflow-agnostic lifecycle signal for
+   * adapters that surface provider exit). Fires once per child exit. */
+  onExit(handler) {
+    this.exitHandlers.push(handler);
+  }
+  deliver(event) {
+    if (event && this.options.onEvent)
+      this.options.onEvent(event);
+    const w = this.waiters.shift();
+    if (w)
+      w(event);
+    else if (event)
+      this.queue.push(event);
+  }
+  next() {
+    const queued = this.queue.shift();
+    if (queued)
+      return Promise.resolve(queued);
+    if (this.ended)
+      return Promise.resolve(null);
+    return new Promise((resolve5) => this.waiters.push(resolve5));
+  }
+  /** Consume events until one of the given type arrives. Fatal EOF →
+   * EngineExitedError; a turn-scoped `error` → TurnError. */
+  async waitForEvent(type) {
+    for (; ; ) {
+      const e = await this.next();
+      if (e === null)
+        throw new EngineExitedError(`engine exited before "${type}"`);
+      if (e.type === "error" && type !== "error") {
+        throw new TurnError(e.message, e.turnId);
+      }
+      if (e.type === type)
+        return e;
+    }
+  }
+  /** Spawn hax, pump events, and gate on the `ready` protocol version. */
+  async start(options = {}) {
+    const spawned = spawnHax(options);
+    this.spawned = spawned;
+    spawned.child.on("exit", (code, signal) => {
+      for (const handler of this.exitHandlers)
+        handler({ code, signal });
+    });
+    const transport = new FdTransport(spawned.eventStream, spawned.controlStream);
+    this.transport = transport;
+    void (async () => {
+      try {
+        for await (const event of transport.events())
+          this.deliver(event);
+      } finally {
+        this.ended = true;
+        while (this.waiters.length)
+          this.deliver(null);
+      }
+    })();
+    const ready = await this.waitForEvent("ready");
+    if (!isProtocolCompatible(ready.protocol, PROTOCOL_VERSION)) {
+      this.close();
+      throw new ProtocolVersionError(ready.protocol, PROTOCOL_VERSION);
+    }
+    this.ready = ready;
+    return ready;
+  }
+  control(control) {
+    if (!this.transport)
+      throw new Error("session not started");
+    this.transport.send(control);
+  }
+  /** Send a user turn without waiting (pair with waitForEvent/interrupt). */
+  submit(text) {
+    this.control({ type: "submit", text });
+  }
+  /**
+   * Submit a user turn and resolve with its authoritative content at idle.
+   * A turn-scoped `error` is captured and the loop **drains to `idle`** (so the
+   * session settles at a clean boundary and a later submit works), then rejects
+   * with TurnError. A fatal fd-3 EOF mid-turn rejects with EngineExitedError.
+   */
+  async submitAndWait(text) {
+    this.control({ type: "submit", text });
+    let result;
+    let turnError;
+    for (; ; ) {
+      const e = await this.next();
+      if (e === null)
+        throw new EngineExitedError("engine exited mid-turn");
+      if (e.type === "assistant_turn_finished") {
+        result = { turnId: e.turnId, content: e.content };
+      } else if (e.type === "error") {
+        turnError = new TurnError(e.message, e.turnId);
+      } else if (e.type === "idle") {
+        if (turnError)
+          throw turnError;
+        return result ?? { turnId: "", content: "" };
+      }
+    }
+  }
+  /** Cancel the in-flight turn. */
+  interrupt() {
+    this.control({ type: "interrupt" });
+  }
+  /** Re-fetch the last handback without re-running a turn (no clipboard).
+   * Resolves the re-emitted content; rejects TurnError if no prior response. */
+  async copyLastResponse() {
+    this.control({ type: "copy_last_response" });
+    const e = await this.waitForEvent("assistant_turn_finished");
+    if (e.type !== "assistant_turn_finished")
+      throw new Error("unexpected event");
+    return { turnId: e.turnId, content: e.content };
+  }
+  /** Start a fresh conversation; resolves once the engine is idle again. */
+  async newConversation() {
+    this.control({ type: "new_conversation" });
+    await this.waitForEvent("idle");
+  }
+  /** Request an engine/session status event. */
+  async status() {
+    this.control({ type: "status" });
+    return await this.waitForEvent("status");
+  }
+  /** Close the control channel (shuts the engine down) and stop the child.
+   * Idempotent — safe to call from both the version-gate teardown and the
+   * caller. */
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    try {
+      this.transport?.close();
+    } catch {
+    }
+    this.spawned?.child.kill();
+  }
+};
 
 // ../adapter-ai-ezio/dist/ai-ezio-engine.js
-import { Session } from "@ai-ezio/harness";
 var defaultCreateEngineSession = ({ onEvent }) => new Session({ onEvent });
 
 // ../adapter-ai-ezio/dist/ai-ezio-prompt.js
@@ -10763,9 +11141,9 @@ async function captureHandbackText(input) {
 
 // src/runtime/clipboard-change-count.ts
 import { execFile as execFile3 } from "node:child_process";
-import { existsSync as existsSync7 } from "node:fs";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname3, join as join7 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { dirname as dirname4, join as join9 } from "node:path";
 var HELPER_BIN_NAME = "clipboard-change-count";
 function execFileText2(command, args = []) {
   return new Promise((resolve5, reject) => {
@@ -10781,9 +11159,9 @@ function execFileText2(command, args = []) {
 function makeChangeCountReader(deps) {
   const platform = deps?.platform ?? process.platform;
   const runHelper = deps?.runHelper ?? (async () => {
-    const here = dirname3(fileURLToPath2(import.meta.url));
-    const bin = join7(here, "..", "native", HELPER_BIN_NAME);
-    if (!existsSync7(bin)) throw new Error("changeCount helper not built");
+    const here = dirname4(fileURLToPath3(import.meta.url));
+    const bin = join9(here, "..", "native", HELPER_BIN_NAME);
+    if (!existsSync8(bin)) throw new Error("changeCount helper not built");
     return execFileText2(bin);
   });
   return async () => {
@@ -12750,11 +13128,11 @@ async function runCollabDashboard(input) {
 // src/commands/collab/status.ts
 init_dist2();
 import Database2 from "better-sqlite3";
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 
 // src/runtime/evaluator-config.ts
 import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join10 } from "node:path";
 function isEvaluatorReady(status) {
   return status === "ready" || status === "unknown";
 }
@@ -12766,7 +13144,7 @@ function isEvaluatorPreflightBlocked(status) {
 init_dist();
 function runCollabStatus(input) {
   const sqlitePath = getSharedSqlitePath();
-  if (!existsSync8(sqlitePath)) {
+  if (!existsSync9(sqlitePath)) {
     return input.json ? JSON.stringify({ error: "no_collab_for_cwd", cwd: input.cwd }) : `no active collab for ${input.cwd}`;
   }
   const db = new Database2(sqlitePath, { readonly: true });
@@ -13107,9 +13485,9 @@ async function runCollabTell(input) {
 
 // src/runtime/launcher.ts
 import { execSync as execSync3, spawn as nodeSpawn } from "node:child_process";
-import { dirname as dirname4, resolve as resolve4 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-var __dirname = dirname4(fileURLToPath3(import.meta.url));
+import { dirname as dirname5, resolve as resolve4 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+var __dirname = dirname5(fileURLToPath4(import.meta.url));
 var whisperBinPath = resolve4(__dirname, "../bin/whisper.js");
 var relayMonitorBinPath = resolve4(__dirname, "../bin/relay-monitor.js");
 function shellQuote(value) {
@@ -13375,9 +13753,9 @@ async function runWorkflowTypes() {
 // src/commands/skill/install.ts
 import { cp, mkdir, readdir, stat } from "node:fs/promises";
 import path3 from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 function defaultBundledSkillsDir() {
-  const here = path3.dirname(fileURLToPath4(import.meta.url));
+  const here = path3.dirname(fileURLToPath5(import.meta.url));
   return path3.resolve(here, "..", "..", "skills");
 }
 function homeForTarget(target, fakeHome) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-whisper",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Terminal-first relay for paired AI coding agents (Claude + Codex), driven by structured workflows.",
   "license": "Apache-2.0",
   "repository": {
@@ -45,11 +45,11 @@
     "@types/better-sqlite3": "^7.6.12",
     "@types/react": "^19.2.14",
     "ink-testing-library": "^4.0.0",
-    "@ai-whisper/adapter-ai-ezio": "0.0.0",
     "@ai-whisper/adapter-codex": "0.0.0",
-    "@ai-whisper/companion-core": "0.0.0",
-    "@ai-whisper/adapter-claude": "0.0.0",
     "@ai-whisper/broker": "0.0.0",
+    "@ai-whisper/adapter-claude": "0.0.0",
+    "@ai-whisper/adapter-ai-ezio": "0.0.0",
+    "@ai-whisper/companion-core": "0.0.0",
     "@ai-whisper/shared": "0.0.0"
   },
   "files": [