@vibest/cli 0.0.1-beta.13 → 0.0.1-beta.15

package/harnesses/claude/hooks/register.mjs

@@ -1,562 +1,357 @@
-// src/inbox-adapter.ts
-var object = (stdout) => {
-  try {
-    const value = JSON.parse(stdout);
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-      return;
-    return value;
-  } catch {
-    return;
-  }
-};
-var text = (value, key) => typeof value[key] === "string" ? value[key] : undefined;
-var flag = (value, key) => value[key] === true;
-var contradictory = (value, success) => text(value, "error") !== undefined && success;
-var adaptAttach = (code, stdout) => {
-  if (code !== 0)
-    return { kind: "lost" };
-  const value = object(stdout);
-  if (!value)
-    return { kind: "unparsed" };
-  const generation = text(value, "generation");
-  const error = text(value, "error");
-  if (generation !== undefined && generation !== "" && error === undefined && !flag(value, "empty"))
-    return { kind: "attached", generation };
-  if (error === "stale-receiver" && generation === undefined)
-    return { kind: "stale-receiver" };
-  if (error === "not-reported" && !("generation" in value))
-    return { kind: "not-reported" };
-  return { kind: "unparsed" };
-};
-var adaptPull = (code, stdout) => {
-  if (code !== 0)
-    return { kind: "lost" };
-  const value = object(stdout);
-  if (!value)
-    return { kind: "unparsed" };
-  const token = text(value, "token");
-  const file = text(value, "file");
-  const error = text(value, "error");
-  const claim = token !== undefined && token !== "" && file !== undefined && file !== "";
-  if (contradictory(value, claim || flag(value, "empty") || flag(value, "acked") || flag(value, "released")))
-    return { kind: "unparsed" };
-  if (claim && error === undefined && value.empty !== true)
-    return { kind: "claim", token, file };
-  if (value.empty === true && !claim && error === undefined)
-    return { kind: "none" };
-  if (error === "too-large" && !claim)
-    return { kind: "none" };
-  if (error === "stale-receiver" && !claim)
-    return { kind: "stale-receiver" };
-  return { kind: "unparsed" };
-};
-var adaptSettle = (code, stdout, op) => {
-  if (code !== 0)
-    return { kind: "lost" };
-  const value = object(stdout);
-  if (!value)
-    return { kind: "unparsed" };
-  const error = text(value, "error");
-  const acked = value.acked === true;
-  const released = value.released === true;
-  const already = value.already === true;
-  if (value.acked === false || value.released === false || value.already === false)
-    return { kind: "unparsed" };
-  if (error !== undefined && (acked || released || already))
-    return { kind: "unparsed" };
-  if (acked && released)
-    return { kind: "unparsed" };
-  const mine = op === "ack" ? acked : released;
-  const other = op === "ack" ? released : acked;
-  if (other)
-    return { kind: "unparsed" };
-  if (already && !mine)
-    return { kind: "unparsed" };
-  if (already && mine && error === undefined)
-    return { kind: "already" };
-  if (mine && error === undefined)
-    return { kind: "ok" };
-  if (error === "stale-receiver")
-    return { kind: "stale-receiver" };
-  return { kind: "unparsed" };
-};
-
-// src/inbox-client.ts
-var settlement = (phase) => {
-  if (phase === "settle-ack")
-    return "ack";
-  if (phase === "settle-release-retry")
-    return "release-retry";
-  if (phase === "settle-release-fail")
-    return "release-fail";
-  return;
-};
-var createClaudeInboxClient = (io) => {
-  let phase = "new";
-  let generation;
-  let boundSession;
-  let token;
-  let file;
-  let stopReason;
-  let deliveryAccepted = false;
-  let epoch = 1;
-  let owner = 0;
-  let attachStarted = false;
-  const snapshot = () => ({
-    phase,
-    generation,
-    token,
-    busy: owner !== 0,
-    stopReason,
-    deliveryAccepted
-  });
-  const stop = (reason) => {
-    phase = "stopped";
-    stopReason = reason;
-  };
-  const sessionMatches = () => boundSession !== undefined && io.sessionId() === boundSession;
-  const foreignSession = () => {
-    if (sessionMatches())
-      return false;
-    stop("session-mismatch");
-    return true;
-  };
-  const live = (attempt) => attempt.epoch === epoch && attempt.generation === generation && attempt.token === token && phase !== "stopped";
-  const start = async () => {
-    if (attachStarted)
-      return snapshot();
-    attachStarted = true;
-    const seen = epoch;
-    const sessionId = io.sessionId();
-    boundSession = sessionId;
-    let reply;
-    try {
-      reply = await io.attach(sessionId);
-    } catch {
-      reply = { kind: "lost" };
-    }
-    if (seen !== epoch)
-      return snapshot();
-    if (reply.kind === "attached") {
-      generation = reply.generation;
-      phase = "idle";
-      return snapshot();
-    }
-    if (reply.kind === "not-reported") {
-      attachStarted = false;
-      return snapshot();
-    }
-    stop(reply.kind === "stale-receiver" ? "stale-receiver" : "attach-failed");
-    return snapshot();
-  };
-  const reattach = (nextGeneration) => {
-    if (nextGeneration === generation)
-      return snapshot();
-    epoch += 1;
-    owner = 0;
-    attachStarted = true;
-    generation = nextGeneration;
-    boundSession = io.sessionId();
-    token = undefined;
-    file = undefined;
-    deliveryAccepted = false;
-    stopReason = undefined;
-    phase = "idle";
-    return snapshot();
-  };
-  const settle = async (attempt) => {
-    const op = settlement(phase);
-    if (op === undefined || !live(attempt) || foreignSession())
-      return;
-    let reply;
-    try {
-      reply = op === "ack" ? await io.ack(attempt.generation, attempt.sessionId, attempt.token) : await io.release(attempt.generation, attempt.sessionId, attempt.token, op === "release-retry");
-    } catch {
-      return;
-    }
-    if (!live(attempt) || settlement(phase) !== op || foreignSession())
-      return;
-    if (reply.kind === "ok" || reply.kind === "already") {
-      phase = "done";
-      token = undefined;
-      file = undefined;
-      return;
-    }
-    if (reply.kind === "stale-receiver")
-      stop("stale-receiver");
+// ../../protocol/src/protocol.ts
+var PROTOCOL = 4;
+var PROTOCOL_HEADER = "vibest-protocol";
+var CALLER_HEADER = "vibest-caller";
+var SESSION_HEADER = "vibest-session-id";
+var REPOSITORY_HEADER = "vibest-repository";
+var PROJECT_HEADER = "vibest-project-id";
+var HARNESS_SESSION_HEADER = "vibest-harness-session-id";
+var AGENT_HEADER = "vibest-agent";
+var HARNESS_HEADER = "vibest-harness";
+var CWD_HEADER = "vibest-cwd";
+var RUNTIME_HEADER = "vibest-runtime";
+var PLUGIN_VERSION_HEADER = "vibest-plugin-version";
+var POLL_ROUTE = "/inbox/poll";
+var ACK_ROUTE = "/inbox/ack";
+var hookRoute = (harness, hook) => `/hooks/${harness}/${hook}`;
+var isPolled = (body) => typeof body === "object" && body !== null && Array.isArray(body.ids) && typeof body.line === "string" && typeof body.text === "string";
+var sessionHeaders = (who) => {
+  const headers = {
+    [PROTOCOL_HEADER]: String(PROTOCOL),
+    [CALLER_HEADER]: "session",
+    [SESSION_HEADER]: who.sessionId
   };
-  const pull = async (seen) => {
-    if (generation === undefined || boundSession === undefined)
-      return;
-    const pullGeneration = generation;
-    const pullSession = boundSession;
-    let reply;
-    try {
-      reply = await io.pull(pullGeneration, pullSession);
-    } catch {
-      if (seen === epoch)
-        foreignSession();
-      return;
-    }
-    if (seen !== epoch || generation !== pullGeneration || foreignSession())
-      return;
-    if (reply.kind === "stale-receiver") {
-      stop("stale-receiver");
-      return;
-    }
-    if (reply.kind !== "claim")
-      return;
-    token = reply.token;
-    file = reply.file;
-    phase = "holding";
+  const put = (name, value) => {
+    if (value)
+      headers[name] = value;
   };
-  const consume = async (seen) => {
-    if (token === undefined || file === undefined || generation === undefined || boundSession === undefined)
-      return;
-    const attempt = { epoch: seen, generation, sessionId: boundSession, token };
-    let text;
-    try {
-      text = await io.readClaim(file);
-    } catch {
-      text = undefined;
-    }
-    if (!live(attempt) || foreignSession())
-      return;
-    if (text === undefined || text === "") {
-      phase = "settle-release-fail";
-      await settle(attempt);
-      return;
-    }
-    phase = "submitted";
-    let submitted;
-    try {
-      submitted = await io.submit(text);
-    } catch {
-      submitted = { kind: "ambiguous" };
-    }
-    if (!live(attempt) || foreignSession())
-      return;
-    if (submitted.kind === "accepted") {
-      deliveryAccepted = true;
-      phase = "settle-ack";
-    } else if (submitted.kind === "drop") {
-      phase = "settle-release-retry";
-    } else {
-      phase = "settle-release-fail";
-    }
-    await settle(attempt);
-  };
-  const tick = async () => {
-    if (owner !== 0 || phase === "new" || phase === "stopped")
-      return snapshot();
-    const seen = epoch;
-    owner = seen;
-    try {
-      if (!foreignSession()) {
-        if (settlement(phase) !== undefined && generation !== undefined && token !== undefined && boundSession !== undefined) {
-          await settle({ epoch: seen, generation, sessionId: boundSession, token });
-        } else if (phase === "idle" || phase === "done" || phase === "holding") {
-          if (phase === "done") {
-            phase = "idle";
-            deliveryAccepted = false;
-          }
-          if (phase === "idle")
-            await pull(seen);
-          if (seen === epoch && phase === "holding")
-            await consume(seen);
-        }
-      }
-    } finally {
-      if (owner === seen)
-        owner = 0;
-    }
-    return snapshot();
-  };
-  return { start, tick, reattach, snapshot };
+  put(PROJECT_HEADER, who.projectId);
+  put(HARNESS_SESSION_HEADER, who.harnessSessionId);
+  put(AGENT_HEADER, who.agent);
+  put(HARNESS_HEADER, who.harness);
+  put(CWD_HEADER, who.cwd === undefined ? undefined : encodeURIComponent(who.cwd));
+  put(RUNTIME_HEADER, who.runtime);
+  put(PLUGIN_VERSION_HEADER, who.pluginVersion);
+  if (who.repositoryRoot !== undefined)
+    headers[REPOSITORY_HEADER] = who.repositoryRoot;
+  return headers;
 };
 
 // src/plugin.ts
-var REATTACH = "vibest-reattach";
-var POLL_MS = 2000;
-var RUN_TIMEOUT_MS = 15000;
-var BRIDGE_TIMEOUT_MS = 1e4;
-var GUARD_FAILURE = "vibest integration guard failed; the tool call is refused.";
-var errorOf = (stdout) => {
-  try {
-    const value = JSON.parse(stdout);
-    return typeof value?.error === "string" ? value.error : undefined;
-  } catch {
-    return;
-  }
-};
-var refusal = (why) => {
-  if (why === "stale-receiver")
-    return `another receiver holds this coordinator's inbox; run /${REATTACH} to take it`;
-  if (why === "not-reported")
-    return `VIBEST has not recorded this Claude session yet; run /${REATTACH} once it has`;
-  if (why === "session-mismatch")
-    return `the Claude session changed, so delivery stopped; run /${REATTACH}`;
-  if (why.startsWith("exit "))
-    return `vibest inbox attach failed (${why}); check that vibest on PATH has the inbox command`;
-  return `vibest inbox attach refused (${why}); run /${REATTACH} after fixing it`;
-};
-var unknownReplace = (why) => `vibest inbox attach --replace gave no usable answer (${why}). It may have replaced this receiver anyway, so it is not retried automatically and delivery here may stop. Run /${REATTACH} again.`;
+var POLL_MS = 1000;
+var POLL_FAILURES_SHOWN = 5;
+var GUARD_TRY_MS = 2000;
+var GUARD_BACKOFF_MS = [100, 300, 900];
+var REPORT_BACKOFF_MS = [1000, 2000, 4000, 8000, 15000, 30000];
+var REPORT_TRY_MS = 1e4;
+var UNREACHABLE = "vibestd unreachable; the tool call is refused.";
+var FULL_MAX = 100;
 function nativeHost($) {
   return {
-    coordinator: async () => await $.env.get("VIBEST_AGENT") === "coordinator" && (await $.env.get("VIBEST_SESSION_ID") ?? "") !== "",
-    agent: () => $.env.get("VIBEST_AGENT"),
-    vibestSession: () => $.env.get("VIBEST_SESSION_ID"),
+    env: (name) => {
+      switch (name) {
+        case "VIBEST_AGENT":
+          return $.env.get("VIBEST_AGENT");
+        case "VIBEST_SESSION_ID":
+          return $.env.get("VIBEST_SESSION_ID");
+        case "VIBEST_PROJECT_ID":
+          return $.env.get("VIBEST_PROJECT_ID");
+        case "VIBEST_HARNESS":
+          return $.env.get("VIBEST_HARNESS");
+        case "VIBEST_RUNTIME":
+          return $.env.get("VIBEST_RUNTIME");
+        case "VIBEST_HOME":
+          return $.env.get("VIBEST_HOME");
+        case "HOME":
+          return $.env.get("HOME");
+      }
+    },
+    conversation: () => $.session.id(),
     cwd: () => $.session.cwd(),
-    sessionId: () => $.session.id(),
-    run: (argv) => $.process.run(["vibest", "inbox", ...argv], { timeoutMs: RUN_TIMEOUT_MS }),
-    stop: (stdin) => $.process.run(["vibest", "integration", "stop", "--harness", "claude"], { stdin, timeoutMs: BRIDGE_TIMEOUT_MS }),
-    prompt: (stdin) => $.process.run(["vibest", "integration", "prompt", "--harness", "claude"], { stdin, timeoutMs: BRIDGE_TIMEOUT_MS }),
-    guard: (stdin) => $.process.run(["vibest", "integration", "guard", "--harness", "claude"], { stdin, timeoutMs: BRIDGE_TIMEOUT_MS }),
-    read: (file) => $.fs.read(file),
+    plugin: () => $.plugin.name,
+    fetch: (socketPath, path, headers, body) => $.http.fetch(`http://vibestd${path}`, { method: "POST", socketPath, headers, body }),
     submit: (text) => $.prompt.submit({ text }),
-    registerReattach: () => $.command.register({
-      name: REATTACH,
-      description: "Take this coordinator's VIBEST inbox with a new generation (attach --replace)",
-      immediate: true
-    }),
-    every: (fn) => $.clock.every(POLL_MS, fn),
-    status: (text) => $.ui.status(`VIBEST inbox: ${text}`),
-    attached: () => {
-      $.ui.status(undefined);
-      $.ui.toast("VIBEST inbox attached");
+    redraw: () => $.ui.invalidate("ui.render"),
+    every: (ms, fn) => $.clock.every(ms, fn),
+    after: (ms, fn) => $.clock.after(ms, fn),
+    status: (text) => $.ui.status(text),
+    pid: async () => {
+      const pid = Number((await $.process.run(["sh", "-c", 'echo "$PPID"'])).stdout.trim());
+      return Number.isInteger(pid) && pid > 1 ? pid : undefined;
     }
   };
 }
+var RESERVED = new Set(["tool", "tool_use_id", "consent", "agentId"]);
 var toolInput = (event) => {
   const input = {};
   for (const [key, value] of Object.entries(event)) {
-    if (key !== "tool" && key !== "tool_use_id")
+    if (!RESERVED.has(key))
       input[key] = value;
   }
   return input;
 };
-var guardDenyReason = (stdout) => {
-  let value;
+var timeout = (promise, ms, after) => new Promise((resolve, reject) => {
+  const timer = after(ms, () => reject(new Error(`no answer in ${ms} ms`)));
+  promise.then((value) => {
+    timer.cancel();
+    resolve(value);
+  }, (error) => {
+    timer.cancel();
+    reject(error);
+  });
+});
+var parse = (text) => {
   try {
-    value = JSON.parse(stdout);
+    return JSON.parse(text);
   } catch {
     return;
   }
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return;
-  const keys = Object.keys(value);
-  if (keys.length !== 1 || keys[0] !== "hookSpecificOutput")
-    return;
-  const output = value.hookSpecificOutput;
-  if (typeof output !== "object" || output === null || Array.isArray(output))
-    return;
-  const fields = Object.keys(output);
-  if (fields.length !== 3 || !fields.includes("hookEventName") || !fields.includes("permissionDecision") || !fields.includes("permissionDecisionReason"))
-    return;
-  const denial = output;
-  if (denial.hookEventName !== "PreToolUse" || denial.permissionDecision !== "deny" || typeof denial.permissionDecisionReason !== "string")
-    return;
-  return denial.permissionDecisionReason;
-};
-var guardReason = (result) => {
-  if (result.exitCode === 0 && result.stdout.trim() === "")
-    return;
-  if (result.exitCode !== 0)
-    return GUARD_FAILURE;
-  return guardDenyReason(result.stdout) ?? GUARD_FAILURE;
 };
+var errorOf = (body) => typeof body === "object" && body !== null && typeof body.error === "string" ? body.error : undefined;
 function register(on, _options) {
-  let started = false;
-  let client;
-  let lastRefusal = "unparsed";
+  const queue = [];
+  const seen = new Set;
+  const full = new Map;
+  let unacked = [];
+  let release = [];
+  let polling = false;
+  let draining = false;
+  let failures = 0;
+  let mismatched = false;
   let timer;
-  let lifetime = 0;
-  let ended = false;
-  let current = "";
-  let epoch = 0;
-  let busy;
-  let reattaching = false;
-  const readSession = async (host) => {
-    const seen = lifetime;
-    const id = await host.sessionId();
-    return seen === lifetime ? id : undefined;
+  const identity = async (host) => {
+    const agent = await host.env("VIBEST_AGENT");
+    const sessionId = await host.env("VIBEST_SESSION_ID");
+    if (!agent || !sessionId)
+      return;
+    const home = await host.env("VIBEST_HOME") || `${await host.env("HOME") ?? ""}/.vibest`;
+    return { agent, sessionId, socket: `${home}/vibest-http.sock` };
   };
-  const attachArgv = (sessionId, replace) => replace ? ["attach", sessionId, "--replace"] : ["attach", sessionId];
-  const makeClient = (host) => createClaudeInboxClient({
-    sessionId: () => ended ? "" : current,
-    attach: async (sessionId) => {
-      lastRefusal = "no reply";
-      const r = await host.run(attachArgv(sessionId, false));
-      lastRefusal = r.exitCode !== 0 ? `exit ${r.exitCode}` : errorOf(r.stdout) ?? "unparsed";
-      return adaptAttach(r.exitCode, r.stdout);
-    },
-    pull: async (generation, sessionId) => {
-      const r = await host.run(["pull", generation, sessionId]);
-      return adaptPull(r.exitCode, r.stdout);
-    },
-    readClaim: async (file) => {
-      const body = await host.read(file);
-      if (typeof body !== "string")
-        throw new Error("claim body is not text");
-      return body;
-    },
-    submit: async (text) => {
-      const r = await host.submit(text);
-      return r.drop !== undefined ? { kind: "drop" } : { kind: "accepted", text: r.text };
-    },
-    ack: async (generation, sessionId, token) => {
-      const r = await host.run(["ack", generation, sessionId, token]);
-      return adaptSettle(r.exitCode, r.stdout, "ack");
-    },
-    release: async (generation, sessionId, token, retry) => {
-      const r = await host.run(["release", generation, sessionId, token, ...retry ? ["--retry"] : []]);
-      return adaptSettle(r.exitCode, r.stdout, "release");
+  const post = async (host, path, body, ms) => {
+    const who = await identity(host);
+    if (!who)
+      throw new Error("not an VIBEST session");
+    const headers = sessionHeaders({
+      sessionId: who.sessionId,
+      projectId: await host.env("VIBEST_PROJECT_ID"),
+      harnessSessionId: await host.conversation().catch(() => {
+        return;
+      }),
+      agent: who.agent,
+      harness: await host.env("VIBEST_HARNESS") || "claude",
+      cwd: await host.cwd().catch(() => {
+        return;
+      }),
+      runtime: await host.env("VIBEST_RUNTIME"),
+      pluginVersion: "0.0.1-beta.15"
+    });
+    const r = await timeout(host.fetch(who.socket, path, { ...headers, "content-type": "application/json" }, JSON.stringify(body)), ms, host.after);
+    const reply = { status: r.status, body: parse(r.text) };
+    if (reply.status === 409) {
+      mismatched = true;
+      host.status(`VIBEST: ${errorOf(reply.body) ?? "vibest was updated; run vibest update"}`);
+    } else if (mismatched) {
+      mismatched = false;
+      host.status(undefined);
     }
-  });
-  const halt = () => {
-    timer?.cancel();
-    timer = undefined;
+    return reply;
+  };
+  const report = async (host, path, body) => {
+    const attempt = async (n) => {
+      let retry = true;
+      try {
+        const r = await post(host, path, body, REPORT_TRY_MS);
+        retry = r.status >= 500;
+      } catch {}
+      const pause = REPORT_BACKOFF_MS[n];
+      if (retry && pause !== undefined)
+        host.after(pause, () => void attempt(n + 1));
+    };
+    await attempt(0);
   };
-  const step = async (host) => {
-    if (!client || ended || busy === epoch)
+  const tick = async (host) => {
+    if (polling)
       return;
-    const mine = epoch;
-    busy = mine;
+    polling = true;
     try {
-      const id = await readSession(host);
-      if (id === undefined || ended || mine !== epoch)
+      if (unacked.length > 0 || release.length > 0) {
+        const r = await post(host, ACK_ROUTE, { ids: unacked, release }, REPORT_TRY_MS);
+        if (r.status === 200) {
+          unacked = [];
+          release = [];
+        }
+      }
+      const r = await post(host, POLL_ROUTE, {}, REPORT_TRY_MS);
+      if (r.status === 409)
+        return;
+      if (r.status !== 200 || !isPolled(r.body))
+        throw new Error(errorOf(r.body) ?? `poll answered ${r.status}`);
+      if (failures >= POLL_FAILURES_SHOWN)
+        host.status(undefined);
+      failures = 0;
+      const batch = r.body;
+      if (batch.ids.length === 0)
         return;
-      current = id;
-      const before = client.snapshot().phase;
-      const snap = before === "new" ? await client.start() : await client.tick();
-      if (mine !== epoch || ended)
+      const queued = (id) => queue.some((b) => b.ids.includes(id));
+      for (const id of batch.ids)
+        if (seen.has(id) && !queued(id) && !unacked.includes(id))
+          unacked.push(id);
+      const fresh = batch.ids.filter((id) => !seen.has(id));
+      if (fresh.length === 0)
+        return;
+      if (fresh.length < batch.ids.length) {
+        release.push(...fresh);
         return;
-      if (before === "new" && snap.phase === "idle")
-        host.attached();
-      if (before === "new" && snap.phase === "new")
-        host.status("waiting for VIBEST to record this Claude session (after a turn ends)");
-      if (snap.phase === "stopped") {
-        halt();
-        host.status(refusal(snap.stopReason === "attach-failed" ? lastRefusal : snap.stopReason ?? "unparsed"));
       }
-    } catch {} finally {
-      if (busy === mine)
-        busy = undefined;
+      for (const id of batch.ids)
+        seen.add(id);
+      queue.push(batch);
+      host.redraw();
+    } catch {
+      failures += 1;
+      if (failures === POLL_FAILURES_SHOWN)
+        host.status("VIBEST: vibestd does not answer; still trying");
+    } finally {
+      polling = false;
     }
   };
-  const poll = (host) => {
-    timer ??= host.every(() => void step(host));
+  const keep = (line, text) => {
+    const list = full.get(line);
+    if (list)
+      list.push(text);
+    else
+      full.set(line, [text]);
+    while (full.size > FULL_MAX)
+      full.delete(full.keys().next().value);
+  };
+  const forget = (line, text) => {
+    const list = full.get(line);
+    const at = list?.lastIndexOf(text) ?? -1;
+    if (list && at >= 0)
+      list.splice(at, 1);
+    if (list?.length === 0)
+      full.delete(line);
   };
   on("session.start", async ($, e, next) => {
     const host = nativeHost($);
-    if (!started && await host.coordinator()) {
-      started = true;
-      client = makeClient(host);
-      await host.registerReattach();
-      poll(host);
+    if (await identity(host).catch(() => {
+      return;
+    })) {
+      const pid = await host.pid().catch(() => {
+        return;
+      });
+      report(host, "/session/ready", pid === undefined ? {} : { pid });
+    }
+    if (timer === undefined && (await identity(host))?.agent === "coordinator") {
+      timer = host.every(POLL_MS, () => void tick(host));
+      tick(host);
     }
     return next(e);
   });
-  on("session.end", async ($, e, next) => {
-    lifetime += 1;
-    ended = true;
-    if (client) {
-      halt();
-      nativeHost($).status(refusal("session-mismatch"));
+  on("ui.render", { component: "AbovePrompt" }, async ($, e, next) => {
+    const batch = queue[0];
+    if (batch !== undefined && !draining) {
+      const host = nativeHost($);
+      draining = true;
+      queue.shift();
+      keep(batch.line, batch.text);
+      host.submit(batch.line).then((r) => {
+        draining = false;
+        if (r.drop !== undefined) {
+          forget(batch.line, batch.text);
+          queue.unshift(batch);
+        } else
+          unacked.push(...batch.ids);
+        if (queue.length > 0)
+          host.redraw();
+      }, () => {
+        draining = false;
+        forget(batch.line, batch.text);
+        queue.unshift(batch);
+        host.redraw();
+      });
     }
     return next(e);
   });
-  on("command.run", { command: REATTACH }, async ($) => {
-    if (!client)
-      return { text: "Not an VIBEST coordinator session: nothing to reattach." };
-    if (reattaching)
-      return { text: `A /${REATTACH} is already running; wait for its answer.` };
-    reattaching = true;
-    const host = nativeHost($);
-    try {
-      const seen = lifetime;
-      const sessionId = await readSession(host).catch(() => {
+  on("turn.complete", async ($, event, next) => {
+    if (event.agentId === undefined) {
+      const host = nativeHost($);
+      const who = await identity(host).catch(() => {
         return;
       });
-      if (sessionId === undefined)
-        return { text: `Could not read this Claude session; nothing was sent. Run /${REATTACH} again.` };
-      let r;
-      try {
-        r = await host.run(attachArgv(sessionId, true));
-      } catch {
-        return { text: unknownReplace("no reply") };
-      }
-      const reply = adaptAttach(r.exitCode, r.stdout);
-      if (reply.kind !== "attached") {
-        const refused = r.exitCode === 0 ? errorOf(r.stdout) : undefined;
-        if (refused !== undefined)
-          return { text: `VIBEST inbox not reattached (${refused}); the inbox is unchanged.` };
-        return { text: unknownReplace(r.exitCode !== 0 ? `exit ${r.exitCode}` : "unparsed reply") };
-      }
-      if (seen !== lifetime)
-        return { text: `The Claude session changed while reattaching; generation not used here. Run /${REATTACH} again.` };
-      current = sessionId;
-      ended = false;
-      epoch += 1;
-      busy = undefined;
-      client.reattach(reply.generation);
-      host.attached();
-      poll(host);
-      return { text: "VIBEST inbox reattached with a new generation." };
-    } finally {
-      reattaching = false;
+      if (who && who.agent !== "coordinator")
+        report(host, hookRoute("claude", "turn-end"), {
+          hook_event_name: "TurnComplete",
+          session_id: await host.conversation().catch(() => ""),
+          reason: event.reason,
+          last_assistant_message: event.answer,
+          ...event.reason === "refusal" ? { refusal: event.refusal } : {}
+        });
     }
-  });
-  const reportStop = async (host, event, next) => {
-    try {
-      const agent = await host.agent();
-      const session = await host.vibestSession();
-      if (agent && session)
-        await host.stop(JSON.stringify(event));
-    } catch {}
     return next(event);
-  };
-  on("classic.Stop", ($, event, next) => reportStop(nativeHost($), event, next));
-  on("classic.StopFailure", ($, event, next) => reportStop(nativeHost($), event, next));
-  on("classic.UserPromptSubmit", async ($, event, next) => {
-    try {
-      if (!event.agent_id && (event.source === undefined || event.source === "user")) {
-        const host = nativeHost($);
-        const agent = await host.agent();
-        const session = await host.vibestSession();
-        if (agent && session && agent !== "coordinator")
-          await host.prompt(JSON.stringify(event));
-      }
-    } catch {}
+  });
+  on("prompt.submit", async ($, event, next) => {
+    const host = nativeHost($);
+    if (event.origin.kind === "plugin" && event.origin.name === host.plugin()) {
+      const list = full.get(event.text);
+      const text = list?.shift();
+      if (list?.length === 0)
+        full.delete(event.text);
+      if (text === undefined || event.text.trimEnd().endsWith(text.trim()))
+        return next(event);
+      return next({ ...event, context: [...event.context ?? [], text] });
+    }
+    const who = await identity(host).catch(() => {
+      return;
+    });
+    if (who && who.agent !== "coordinator")
+      await report(host, hookRoute("claude", "prompt"), {
+        hook_event_name: "PromptSubmit",
+        text: event.text,
+        origin: event.origin.kind
+      });
     return next(event);
   });
-  on("classic.PreToolUse", async ($, event, next) => {
+  on("tool.call", async ($, event, next) => {
     const host = nativeHost($);
-    if (!await host.agent())
+    if (!await host.env("VIBEST_AGENT"))
       return next(event);
-    try {
-      const reason = guardReason(await host.guard(JSON.stringify({ tool_name: event.tool, tool_input: toolInput(event), cwd: await host.cwd() })));
-      return reason === undefined ? next(event) : { deny: reason };
-    } catch {
-      return { deny: GUARD_FAILURE };
+    const body = { tool_name: event.tool, tool_input: toolInput(event), cwd: await host.cwd() };
+    for (let n = 0;; n++) {
+      try {
+        const r = await post(host, hookRoute("claude", "guard"), body, GUARD_TRY_MS);
+        if (r.status === 200) {
+          const deny = r.body?.deny;
+          return typeof deny === "string" ? { deny } : next(event);
+        }
+        if (r.status < 500)
+          return { deny: `vibest refused the tool call: ${errorOf(r.body) ?? `status ${r.status}`}` };
+      } catch {}
+      const pause = GUARD_BACKOFF_MS[n];
+      if (pause === undefined)
+        return { deny: UNREACHABLE };
+      await new Promise((resolve) => host.after(pause, resolve));
     }
   }).catch(async ($, event, next) => {
     try {
-      if (!await nativeHost($).agent())
+      if (!await nativeHost($).env("VIBEST_AGENT"))
         return;
     } catch {
       return;
     }
     if (next.called)
       return next(event);
-    return { deny: GUARD_FAILURE };
+    return { deny: UNREACHABLE };
   });
 }
 export {
-  BRIDGE_TIMEOUT_MS,
-  GUARD_FAILURE,
+  FULL_MAX,
+  GUARD_BACKOFF_MS,
+  GUARD_TRY_MS,
+  POLL_FAILURES_SHOWN,
   POLL_MS,
-  REATTACH,
-  RUN_TIMEOUT_MS,
+  REPORT_BACKOFF_MS,
+  REPORT_TRY_MS,
+  UNREACHABLE,
   register
 };