@hivefloor/cli 0.1.5 → 0.1.8

package/dist/chunk-5OJUJCE3.js

@@ -0,0 +1,817 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  ensurePrivateDir,
+  privateDirTrouble,
+  privateFileTrouble,
+  safeName
+} from "./chunk-SBOEAOHD.js";
+import {
+  runFile
+} from "./chunk-XAXKZ572.js";
+import {
+  atomicWrite,
+  configDir,
+  controlDecisionsDir,
+  controlInboxDir,
+  isRecord,
+  readText,
+  removeFile,
+  serviceLogFile,
+  sessionsFile,
+  spoolFile
+} from "./chunk-XPGL7VYE.js";
+import {
+  cleanControlText,
+  stripControlChars
+} from "./chunk-HWBUESB4.js";
+
+// src/service/control/sessions.ts
+import { randomBytes } from "crypto";
+import fs from "fs";
+import path from "path";
+var SESSION_TTL_MS = 24 * 36e5;
+var CWD_MAX = 500;
+function validCwd(v) {
+  return typeof v === "string" && v.length > 0 && v.length <= CWD_MAX && path.isAbsolute(v) && !/[\u0000-\u001f\u007f]/.test(v);
+}
+function validTranscript(v) {
+  return validCwd(v) && v.endsWith(".jsonl");
+}
+function parseEntry(v, now) {
+  if (!isRecord(v) || typeof v.event !== "string" || typeof v.at !== "number" || typeof v.tool !== "string") return void 0;
+  if (now - v.at > SESSION_TTL_MS) return void 0;
+  const e = { tool: v.tool, event: v.event, at: v.at };
+  if (typeof v.pid === "number" && Number.isInteger(v.pid) && v.pid > 0) e.pid = v.pid;
+  if (typeof v.start === "string") e.start = v.start;
+  if (typeof v.prompt_id === "string") e.prompt_id = v.prompt_id;
+  if (typeof v.prompt_at === "number") e.prompt_at = v.prompt_at;
+  if (typeof v.msg_at === "number") e.msg_at = v.msg_at;
+  if (validCwd(v.cwd)) e.cwd = v.cwd;
+  if (validTranscript(v.transcript)) e.transcript = v.transcript;
+  if (v.ended === true) e.ended = true;
+  return e;
+}
+function readSessions(now, file = sessionsFile()) {
+  if (privateFileTrouble(file)) return {};
+  try {
+    const j = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (!isRecord(j)) return {};
+    const out = {};
+    for (const [id, v] of Object.entries(j)) {
+      const e = parseEntry(v, now);
+      if (e) out[id] = e;
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+var LOCK_WAIT_MS = 200;
+var LOCK_STALE_MS = 2e3;
+var LOCK_STEP_MS = 5;
+var pause = (ms) => void Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+function takeStaleLock(lock) {
+  let st;
+  try {
+    st = fs.statSync(lock);
+  } catch {
+    return;
+  }
+  if (Date.now() - st.mtimeMs < LOCK_STALE_MS) return;
+  const aside = `${lock}.stale-${process.pid}-${randomBytes(4).toString("hex")}`;
+  try {
+    fs.renameSync(lock, aside);
+  } catch {
+    return;
+  }
+  try {
+    if (fs.statSync(aside).ino !== st.ino) fs.linkSync(aside, lock);
+  } catch {
+  }
+  fs.rmSync(aside, { force: true });
+}
+function lockMap(lock) {
+  const until = Date.now() + LOCK_WAIT_MS;
+  for (; ; ) {
+    try {
+      fs.closeSync(fs.openSync(lock, "wx", 384));
+      return true;
+    } catch (e) {
+      if (e.code !== "EEXIST") return false;
+    }
+    takeStaleLock(lock);
+    if (Date.now() >= until) return false;
+    pause(LOCK_STEP_MS);
+  }
+}
+function updateMap(now, mutate, file) {
+  let locked = false;
+  const lock = `${file}.lock`;
+  try {
+    ensurePrivateDir(path.dirname(file));
+    locked = lockMap(lock);
+    if (!locked) return false;
+    const map = readSessions(now, file);
+    mutate(map);
+    atomicWrite(file, `${JSON.stringify(map)}
+`, 384);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    if (locked) fs.rmSync(lock, { force: true });
+  }
+}
+function updateSession(id, now, mutate, file = sessionsFile()) {
+  updateMap(
+    now,
+    (map) => {
+      const next = mutate(map[id]);
+      if (next) map[id] = next;
+      else delete map[id];
+    },
+    file
+  );
+}
+function markSessionsEnded(picks, now, file = sessionsFile()) {
+  if (picks.length === 0) return;
+  updateMap(
+    now,
+    (map) => {
+      for (const p of picks) {
+        const e = map[p.id];
+        if (e && !e.ended && e.pid === p.pid && e.start === p.start && e.at === p.at) map[p.id] = { ...e, ended: true };
+      }
+    },
+    file
+  );
+}
+
+// src/spool.ts
+import fs2 from "fs";
+import path2 from "path";
+var SPOOL_MAX_BYTES = 1024 * 1024;
+var LOCK_STALE_MS2 = 1e4;
+var CLAIM_STALE_MS = 6e4;
+var LOCK_WAIT_MS2 = 250;
+var CAP_SLACK = 64 * 1024;
+var counter = 0;
+var uniq = () => `${Date.now()}-${process.pid}-${counter++}`;
+function parseSpool(text) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+function capped(events, maxBytes = SPOOL_MAX_BYTES) {
+  const lines = events.map((e) => JSON.stringify(e));
+  let total = lines.reduce((n, l) => n + Buffer.byteLength(l) + 1, 0);
+  let start = 0;
+  while (total > maxBytes && start < lines.length) {
+    total -= Buffer.byteLength(lines[start]) + 1;
+    start += 1;
+  }
+  return { events: events.slice(start), dropped: start };
+}
+function droppedEvents(file = spoolFile()) {
+  try {
+    return Number(fs2.readFileSync(`${file}.dropped`, "utf8").trim()) || 0;
+  } catch {
+    return 0;
+  }
+}
+function noteDropped(spool, dropped) {
+  if (dropped <= 0) return;
+  try {
+    fs2.writeFileSync(`${spool}.dropped`, String(droppedEvents(spool) + dropped), { mode: 384 });
+  } catch {
+  }
+  try {
+    fs2.appendFileSync(serviceLogFile(), `${(/* @__PURE__ */ new Date()).toISOString()} spool full: dropped ${dropped} event(s), the cap is ${SPOOL_MAX_BYTES} bytes
+`, { mode: 384 });
+  } catch {
+  }
+}
+function pause2(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+var lockPath = (file) => `${file}.lock`;
+function acquireLock(file) {
+  const lp = lockPath(file);
+  const deadline = Date.now() + LOCK_WAIT_MS2;
+  for (; ; ) {
+    try {
+      fs2.closeSync(fs2.openSync(lp, "wx", 384));
+      return true;
+    } catch (e) {
+      if (e.code !== "EEXIST") return false;
+    }
+    try {
+      if (Date.now() - fs2.statSync(lp).mtimeMs > LOCK_STALE_MS2) {
+        fs2.rmSync(lp, { force: true });
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    if (Date.now() >= deadline) return false;
+    pause2(5);
+  }
+}
+function releaseLock(file) {
+  removeFile(lockPath(file));
+}
+var claimPath = (file) => `${file}.claim-${uniq()}`;
+var pendingPath = (file) => `${file}.pending-${uniq()}`;
+function sideFiles(dir, file, kind) {
+  const prefix = `${path2.basename(file)}.${kind}-`;
+  let names;
+  try {
+    names = fs2.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.filter((n) => n.startsWith(prefix)).sort().map((n) => path2.join(dir, n));
+}
+function owner(file) {
+  const m = /\.(?:claim|pending)-(\d+)-(\d+)-\d+$/.exec(path2.basename(file));
+  if (!m) return void 0;
+  return { ts: Number(m[1]), pid: Number(m[2]) };
+}
+function alive(pid) {
+  if (pid === process.pid) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function abandoned(file) {
+  const o = owner(file);
+  if (!o) return false;
+  if (!alive(o.pid)) return true;
+  return Date.now() - o.ts > CLAIM_STALE_MS;
+}
+function writeEvents(file, events) {
+  const tmp = `${file}.tmp-${process.pid}-${counter++}`;
+  try {
+    fs2.writeFileSync(tmp, events.map((e) => JSON.stringify(e)).join("\n") + (events.length ? "\n" : ""), { mode: 384 });
+    fs2.renameSync(tmp, file);
+  } catch (e) {
+    removeFile(tmp);
+    throw e;
+  }
+}
+function writeSpool(file, events, maxBytes = SPOOL_MAX_BYTES) {
+  const { events: kept, dropped } = capped(events, maxBytes);
+  if (dropped > 0) noteDropped(file, dropped);
+  writeEvents(file, kept);
+}
+function recover(file) {
+  const dir = path2.dirname(file);
+  const stale = [...sideFiles(dir, file, "claim").filter(abandoned), ...sideFiles(dir, file, "pending")].sort();
+  if (stale.length === 0) return;
+  const events = [];
+  for (const f of stale) events.push(...parseSpool(readText(f) ?? ""));
+  if (events.length > 0) {
+    const existing = parseSpool(readText(file) ?? "");
+    writeSpool(file, [...events, ...existing]);
+  }
+  for (const f of stale) removeFile(f);
+}
+function takeSpool(file = spoolFile()) {
+  fs2.mkdirSync(configDir(), { recursive: true, mode: 448 });
+  if (!acquireLock(file)) return void 0;
+  try {
+    recover(file);
+    const claim = claimPath(file);
+    try {
+      fs2.renameSync(file, claim);
+    } catch {
+      return void 0;
+    }
+    let events;
+    try {
+      events = parseSpool(fs2.readFileSync(claim, "utf8"));
+    } catch {
+      return void 0;
+    }
+    if (events.length === 0) {
+      removeFile(claim);
+      return void 0;
+    }
+    return { spool: file, file: claim, events };
+  } finally {
+    releaseLock(file);
+  }
+}
+function releaseSpool(claim, keep, spool = spoolFile()) {
+  if (keep.length === 0) {
+    if (claim) removeFile(claim.file);
+    return;
+  }
+  const target = claim?.spool ?? spool;
+  try {
+    returnToSpool(keep, target);
+  } catch {
+    if (claim) {
+      try {
+        writeEvents(claim.file, keep);
+      } catch {
+      }
+      return;
+    }
+    try {
+      writeEvents(pendingPath(target), keep);
+    } catch {
+    }
+    return;
+  }
+  if (claim) removeFile(claim.file);
+}
+function returnToSpool(events, file = spoolFile()) {
+  if (events.length === 0) return;
+  fs2.mkdirSync(configDir(), { recursive: true, mode: 448 });
+  if (!acquireLock(file)) {
+    writeEvents(pendingPath(file), events);
+    return;
+  }
+  try {
+    const existing = parseSpool(readText(file) ?? "");
+    writeSpool(file, [...events, ...existing]);
+  } finally {
+    releaseLock(file);
+  }
+}
+function appendToSpool(event, file = spoolFile()) {
+  fs2.mkdirSync(configDir(), { recursive: true, mode: 448 });
+  const line = JSON.stringify(event) + "\n";
+  if (!acquireLock(file)) {
+    fs2.appendFileSync(file, line, { mode: 384 });
+    return;
+  }
+  try {
+    fs2.appendFileSync(file, line, { mode: 384 });
+    let size = 0;
+    try {
+      size = fs2.statSync(file).size;
+    } catch {
+      size = 0;
+    }
+    if (size > SPOOL_MAX_BYTES) writeSpool(file, parseSpool(readText(file) ?? ""), SPOOL_MAX_BYTES - CAP_SLACK);
+  } finally {
+    releaseLock(file);
+  }
+}
+
+// src/nudge.ts
+import fs3 from "fs";
+import path3 from "path";
+var STASH_TTL_MS = 24 * 36e5;
+var nudgeStashFile = () => path3.join(configDir(), "nudges.jsonl");
+var CONTEXT_EVENTS = {
+  claude: ["UserPromptSubmit", "SessionStart", "PreToolUse", "PostToolUse"],
+  codex: ["UserPromptSubmit", "SessionStart"]
+};
+function contextEventName(tool, native) {
+  return CONTEXT_EVENTS[tool]?.find((e) => e.toLowerCase() === native.toLowerCase()) ?? null;
+}
+var isNudge = (v) => typeof v === "object" && v !== null && typeof v.session_id === "string" && typeof v.text === "string";
+function nudgesOf(json) {
+  const list = typeof json === "object" && json !== null ? json.nudges : void 0;
+  return Array.isArray(list) ? list.filter(isNudge) : [];
+}
+function contextOutput(hookEventName, texts) {
+  return JSON.stringify({ hookSpecificOutput: { hookEventName, additionalContext: texts.join("\n\n") } });
+}
+function stashNudges(nudges, nowMs, file = nudgeStashFile()) {
+  if (nudges.length === 0) return;
+  try {
+    fs3.mkdirSync(path3.dirname(file), { recursive: true, mode: 448 });
+    fs3.appendFileSync(file, nudges.map((n) => `${JSON.stringify({ ...n, at: nowMs })}
+`).join(""), { mode: 384 });
+  } catch {
+  }
+}
+function takeStashed(sessionId, nowMs, file = nudgeStashFile()) {
+  if (!fs3.existsSync(file)) return [];
+  const claim = `${file}.${process.pid}-${nowMs}`;
+  try {
+    fs3.renameSync(file, claim);
+  } catch {
+    return [];
+  }
+  const mine = [];
+  const rest = [];
+  try {
+    for (const line of fs3.readFileSync(claim, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const n = JSON.parse(line);
+        if (!isNudge(n) || nowMs - (n.at ?? 0) > STASH_TTL_MS) continue;
+        if (n.session_id === sessionId) mine.push(n.text);
+        else rest.push(line);
+      } catch {
+      }
+    }
+    if (rest.length > 0) fs3.appendFileSync(file, `${rest.join("\n")}
+`, { mode: 384 });
+  } catch {
+  }
+  try {
+    fs3.rmSync(claim, { force: true });
+  } catch {
+  }
+  return mine;
+}
+
+// src/service/control/procinfo.ts
+import fs4 from "fs";
+function parseProcStat(text) {
+  const open = text.indexOf("(");
+  const close = text.lastIndexOf(")");
+  if (open < 0 || close < open) return void 0;
+  const rest = text.slice(close + 2).split(" ");
+  const ppid = Number(rest[1]);
+  const start = rest[19];
+  if (!Number.isInteger(ppid) || !start) return void 0;
+  return { ppid, comm: text.slice(open + 1, close), start };
+}
+function parsePs(text) {
+  const m = /^\s*(\d+)\s+(\S+\s+\S+\s+\d+\s+[\d:]+\s+\d{4})\s+(.+?)\s*$/m.exec(text);
+  if (!m) return void 0;
+  return { ppid: Number(m[1]), start: m[2], comm: m[3].split("/").pop() ?? m[3] };
+}
+function realProc(run = runFile) {
+  return {
+    async info(pid) {
+      if (!Number.isInteger(pid) || pid <= 0) return void 0;
+      if (process.platform === "linux") {
+        try {
+          return parseProcStat(fs4.readFileSync(`/proc/${pid}/stat`, "utf8"));
+        } catch {
+          return void 0;
+        }
+      }
+      if (process.platform === "win32") return void 0;
+      const r = await run("ps", ["-o", "ppid=,lstart=,comm=", "-p", String(pid)], { env: { ...process.env, LC_ALL: "C" }, timeoutMs: 3e3 });
+      return r.code === 0 ? parsePs(r.stdout) : void 0;
+    }
+  };
+}
+var SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "fish", "ksh", "csh", "tcsh", "ash"]);
+async function agentPidOf(proc, hookPid, hookParent) {
+  void hookPid;
+  let pid = hookParent;
+  for (let hop = 0; hop < 4; hop++) {
+    const i = await proc.info(pid);
+    if (!i) return void 0;
+    const name = i.comm.replace(/^-/, "").toLowerCase();
+    if (!SHELLS.has(name)) return { pid, start: i.start };
+    pid = i.ppid;
+  }
+  return void 0;
+}
+async function sameProcess(proc, pid, start) {
+  if (pid === void 0 || !start) return false;
+  const i = await proc.info(pid);
+  return i !== void 0 && i.start === start;
+}
+async function ancestors(proc, pid, max = 64) {
+  const out = [];
+  let p = pid;
+  for (let k = 0; k < max && p > 1; k++) {
+    out.push(p);
+    const i = await proc.info(p);
+    if (!i || i.ppid === p) break;
+    p = i.ppid;
+  }
+  return out;
+}
+
+// src/service/control/decisions.ts
+import fs5 from "fs";
+import path4 from "path";
+var fileOf = (promptId, dir) => path4.join(dir, `${safeName(promptId)}.json`);
+function writeDecision(promptId, d, dir = controlDecisionsDir()) {
+  ensurePrivateDir(dir);
+  const file = fileOf(promptId, dir);
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs5.writeFileSync(tmp, JSON.stringify(d), { mode: 384 });
+  fs5.renameSync(tmp, file);
+}
+function takeDecision(promptId, dir = controlDecisionsDir()) {
+  try {
+    const file = fileOf(promptId, dir);
+    if (!fs5.existsSync(file)) return void 0;
+    if (privateDirTrouble(dir) || privateFileTrouble(file)) {
+      fs5.rmSync(file, { force: true });
+      return void 0;
+    }
+    const text = fs5.readFileSync(file, "utf8");
+    fs5.rmSync(file, { force: true });
+    const j = JSON.parse(text);
+    if (!isRecord(j) || j.behavior !== "allow" && j.behavior !== "deny") return void 0;
+    return { behavior: j.behavior, ...typeof j.message === "string" ? { message: j.message.slice(0, 300) } : {} };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/service/control/inbox.ts
+import fs6 from "fs";
+import path5 from "path";
+var INBOX_MAX = 6;
+var fileOf2 = (session, dir) => path5.join(dir, `${safeName(session)}.jsonl`);
+function parseLines(text) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const j = JSON.parse(line);
+      if (isRecord(j) && typeof j.id === "string" && typeof j.from === "string" && typeof j.text === "string" && typeof j.at === "number" && typeof j.expires_at === "number") {
+        out.push({ id: j.id, from: j.from, text: j.text, at: j.at, expires_at: j.expires_at });
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+function readEntries(file) {
+  if (privateFileTrouble(file)) return [];
+  try {
+    return parseLines(fs6.readFileSync(file, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function rewrite(file, entries) {
+  if (entries.length === 0) {
+    fs6.rmSync(file, { force: true });
+    return;
+  }
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs6.writeFileSync(tmp, entries.map((e) => `${JSON.stringify(e)}
+`).join(""), { mode: 384 });
+  fs6.renameSync(tmp, file);
+}
+function addToInbox(session, entry, now, dir = controlInboxDir()) {
+  ensurePrivateDir(dir);
+  const file = fileOf2(session, dir);
+  const live = readEntries(file).filter((e) => e.expires_at > now);
+  if (live.length >= INBOX_MAX) return "full";
+  live.push(entry);
+  rewrite(file, live);
+  return "ok";
+}
+function takeInbox(session, now, dir = controlInboxDir()) {
+  try {
+    if (privateDirTrouble(dir)) return [];
+    const file = fileOf2(session, dir);
+    if (!fs6.existsSync(file)) return [];
+    const claim = `${file}.${process.pid}-${now}.taken`;
+    fs6.renameSync(file, claim);
+    try {
+      if (privateFileTrouble(claim)) return [];
+      return parseLines(fs6.readFileSync(claim, "utf8")).filter((e) => e.expires_at > now);
+    } finally {
+      fs6.rmSync(claim, { force: true });
+    }
+  } catch {
+    return [];
+  }
+}
+function sweepInbox(now, dir = controlInboxDir()) {
+  const gone = [];
+  try {
+    if (privateDirTrouble(dir)) return gone;
+    for (const name of fs6.readdirSync(dir)) {
+      if (!name.endsWith(".jsonl")) continue;
+      const file = path5.join(dir, name);
+      const all = readEntries(file);
+      const live = all.filter((e) => e.expires_at > now);
+      if (live.length === all.length) continue;
+      for (const e of all) if (e.expires_at <= now) gone.push({ session: name.slice(0, -".jsonl".length), entry: e });
+      rewrite(file, live);
+    }
+  } catch {
+  }
+  return gone;
+}
+
+// src/service/control/tmux.ts
+var T = 4e3;
+function parsePanes(out) {
+  const panes = [];
+  for (const line of out.split("\n")) {
+    const m = /^(%\d+) (\d+)$/.exec(line.trim());
+    if (m) panes.push([m[1], Number(m[2])]);
+  }
+  return panes;
+}
+async function findPane(run, proc, agentPid) {
+  const r = await run("tmux", ["list-panes", "-a", "-F", "#{pane_id} #{pane_pid}"], { timeoutMs: T });
+  if (r.code !== 0) return void 0;
+  const panes = parsePanes(r.stdout);
+  if (panes.length === 0) return void 0;
+  const chain = new Set(await ancestors(proc, agentPid));
+  return panes.find(([, pid]) => chain.has(pid))?.[0];
+}
+var fail = (what, stderr) => ({ ok: false, detail: `${what}: ${stderr.trim().slice(0, 120)}` });
+async function typeLine(run, pane, text) {
+  const a = await run("tmux", ["send-keys", "-t", pane, "-l", "--", text], { timeoutMs: T });
+  if (a.code !== 0) return fail("send-keys", a.stderr);
+  return await sendKey(run, pane, "Enter");
+}
+async function pasteText(run, pane, text, id) {
+  const buf = `hf-${id.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 40)}`;
+  const l = await run("tmux", ["load-buffer", "-b", buf, "-"], { input: text, timeoutMs: T });
+  if (l.code !== 0) return fail("load-buffer", l.stderr);
+  const p = await run("tmux", ["paste-buffer", "-p", "-d", "-b", buf, "-t", pane], { timeoutMs: T });
+  if (p.code !== 0) {
+    await run("tmux", ["delete-buffer", "-b", buf], { timeoutMs: T });
+    return fail("paste-buffer", p.stderr);
+  }
+  return await sendKey(run, pane, "Enter");
+}
+async function sendKey(run, pane, key) {
+  const r = await run("tmux", ["send-keys", "-t", pane, key], { timeoutMs: T });
+  return r.code === 0 ? { ok: true } : fail("send-keys", r.stderr);
+}
+async function capture(run, pane) {
+  const r = await run("tmux", ["capture-pane", "-p", "-t", pane], { timeoutMs: T });
+  return r.code === 0 ? r.stdout : void 0;
+}
+function inputBoxHolds(screen, text) {
+  const snippet = text.split("\n")[0].trim().slice(0, 24);
+  if (snippet === "") return false;
+  const lines = screen.split("\n").slice(-20);
+  return lines.some((l) => {
+    const t = l.replace(/^[\s│|┃]+/, "");
+    return /^[>❯]\s/.test(t) && t.includes(snippet);
+  });
+}
+function parseFg(out) {
+  const m = /^\s*(-?\d+)\s+(\d+)\s+(\S+)\s*$/m.exec(out);
+  return m ? { tpgid: Number(m[1]), pgid: Number(m[2]), tty: m[3] } : void 0;
+}
+var ttyName = (t) => t.replace(/^\/dev\//, "");
+async function paneFocusTrouble(run, pane, agentPid) {
+  const d = await run("tmux", ["display-message", "-p", "-t", pane, "#{pane_tty} #{pane_in_mode}"], { timeoutMs: T });
+  const m = d.code === 0 ? /^(\S+) (\d+)\s*$/.exec(d.stdout.trim()) : null;
+  if (!m) return "pane state unknown";
+  if (m[2] !== "0") return "pane in a mode";
+  const p = await run("ps", ["-o", "tpgid=,pgid=,tty=", "-p", String(agentPid)], { env: { ...process.env, LC_ALL: "C" }, timeoutMs: T });
+  const fg = p.code === 0 ? parseFg(p.stdout) : void 0;
+  if (!fg) return "agent process unknown";
+  if (ttyName(fg.tty) !== ttyName(m[1])) return "agent not on the pane terminal";
+  if (fg.tpgid !== fg.pgid) return "agent not in the foreground";
+  return void 0;
+}
+function promptState(screen) {
+  const lines = screen.replace(/\s+$/, "").split("\n").slice(-12);
+  for (let k = lines.length - 1; k >= 0; k--) {
+    const t = lines[k].replace(/^[\s│|┃]+/, "").replace(/[\s│|┃]+$/, "");
+    if (t.startsWith("!")) return "bash";
+    if (/^[>❯]/.test(t)) return t.length === 1 ? "empty" : "draft";
+  }
+  return "none";
+}
+async function clientIdleSec(run, pane, nowMs) {
+  const s = await run("tmux", ["display-message", "-p", "-t", pane, "#{session_id}"], { timeoutMs: T });
+  const sid = s.stdout.trim();
+  if (s.code !== 0 || !/^\$\d+$/.test(sid)) return void 0;
+  const c = await run("tmux", ["list-clients", "-t", sid, "-F", "#{client_activity}"], { timeoutMs: T });
+  if (c.code !== 0) return void 0;
+  const times = c.stdout.split("\n").map((l) => Number(l.trim())).filter((n) => Number.isFinite(n) && n > 0);
+  if (times.length === 0) return void 0;
+  return Math.max(0, nowMs / 1e3 - Math.max(...times));
+}
+
+// src/service/control/claude.ts
+var PASTE_VERIFIED = [2, 1, 323];
+var PROMPT_FRESH_MS = 3e4;
+var INPUT_RECHECK_MS = 400;
+var INBOX_MAX_MS = 12e4;
+function pasteVerified(version) {
+  const m = version ? /(\d+)\.(\d+)\.(\d+)/.exec(version) : null;
+  if (!m) return false;
+  const v = [Number(m[1]), Number(m[2]), Number(m[3])];
+  if (v[0] !== PASTE_VERIFIED[0]) return false;
+  if (v[1] !== PASTE_VERIFIED[1]) return v[1] > PASTE_VERIFIED[1];
+  return v[2] >= PASTE_VERIFIED[2];
+}
+var promptOpen = (e, now) => e.prompt_id !== void 0 && now - (e.prompt_at ?? 0) < PROMPT_FRESH_MS;
+var isIdle = (e, now) => (e.event === "Stop" || e.event === "SessionStart") && !promptOpen(e, now);
+var senderName = (name) => stripControlChars(name).replace(/\s+/g, " ").trim().slice(0, 60) || "someone";
+function guardFirstChar(text) {
+  return /^\s*[!/#]/.test(text) ? `Message: ${text}` : text;
+}
+var joinLines = (text) => text.split("\n").map((l) => l.trim()).filter((l) => l !== "").join(" ");
+async function typingSafe(env, pane, pid) {
+  if (await paneFocusTrouble(env.run, pane, pid) !== void 0) return false;
+  const screen = await capture(env.run, pane);
+  return screen !== void 0 && promptState(screen) === "empty";
+}
+var fail2 = (code, detail) => ({ status: "failed", code, ...detail ? { detail: detail.slice(0, 200) } : {} });
+async function claudeMessage(cmd, id, entry, env) {
+  const raw = typeof cmd.args.text === "string" ? cmd.args.text : "";
+  const text = cleanControlText(raw);
+  if (text === null) return fail2("invalid", "empty message");
+  const now = env.now();
+  const pane = entry.pid !== void 0 ? await findPane(env.run, env.proc, entry.pid) : void 0;
+  if (pane && isIdle(entry, now) && await typingSafe(env, pane, entry.pid)) {
+    const typed = guardFirstChar(text);
+    let r;
+    if (typed.includes("\n") && pasteVerified(await env.claudeVersion())) {
+      r = await pasteText(env.run, pane, typed, id);
+    } else {
+      r = await typeLine(env.run, pane, joinLines(typed).replace(/\t/g, " "));
+    }
+    if (!r.ok) return fail2("tmux_error", r.detail);
+    await env.sleep(INPUT_RECHECK_MS);
+    const screen = await capture(env.run, pane);
+    if (screen !== void 0 && inputBoxHolds(screen, typed)) await sendKey(env.run, pane, "Enter");
+    updateSession(cmd.session.external_id, env.now(), (e) => e ? { ...e, msg_at: env.now() } : e);
+    return { status: "done", via: "tmux" };
+  }
+  const who = senderName(cmd.requested_by.name);
+  const at = env.now();
+  const res = addToInbox(cmd.session.external_id, { id, from: who, text, at, expires_at: at + Math.min(Math.max(0, cmd.expires_in_ms), INBOX_MAX_MS) }, at);
+  if (res === "full") return fail2("inbox_full");
+  updateSession(cmd.session.external_id, env.now(), (e) => e ? { ...e, msg_at: env.now() } : e);
+  return { status: "done", via: "hook" };
+}
+function claudeDecision(cmd, entry, now) {
+  const promptId = typeof cmd.args.prompt_id === "string" ? cmd.args.prompt_id : "";
+  if (!promptId || entry.prompt_id !== promptId || !promptOpen(entry, now)) return fail2("prompt_gone");
+  try {
+    if (cmd.kind === "approve") {
+      writeDecision(promptId, { behavior: "allow" });
+    } else {
+      const reason = typeof cmd.args.reason === "string" ? cleanControlText(cmd.args.reason, 300) : null;
+      writeDecision(promptId, { behavior: "deny", message: reason ? `${senderName(cmd.requested_by.name)} denied this through HiveFloor: ${reason}` : `${senderName(cmd.requested_by.name)} denied this through HiveFloor` });
+    }
+  } catch (e) {
+    return fail2("decision_error", e.message);
+  }
+  return { status: "done", via: "hook" };
+}
+async function stopSession(cmd, entry, env) {
+  const now = env.now();
+  if (cmd.args.mode === "end") {
+    if (!await sameProcess(env.proc, entry.pid, entry.start)) return fail2("unknown_session");
+    try {
+      env.kill(entry.pid, "SIGTERM");
+    } catch (e) {
+      return fail2("kill_failed", e.message);
+    }
+    return { status: "done" };
+  }
+  if (cmd.args.mode !== "interrupt") return fail2("invalid", "unknown stop mode");
+  if (entry.tool !== "claude") return fail2("unsupported", "interrupt is only for Claude Code");
+  if (promptOpen(entry, now)) return fail2("prompt_open");
+  if (isIdle(entry, now)) return { status: "done", detail: "idle" };
+  const pane = entry.pid !== void 0 ? await findPane(env.run, env.proc, entry.pid) : void 0;
+  if (!pane) return fail2("no_pane");
+  const trouble = await paneFocusTrouble(env.run, pane, entry.pid);
+  if (trouble) return fail2("pane_busy", trouble);
+  const r = await sendKey(env.run, pane, "Escape");
+  return r.ok ? { status: "done", via: "tmux" } : fail2("tmux_error", r.detail);
+}
+
+export {
+  validCwd,
+  validTranscript,
+  readSessions,
+  updateSession,
+  markSessionsEnded,
+  takeSpool,
+  releaseSpool,
+  appendToSpool,
+  contextEventName,
+  nudgesOf,
+  contextOutput,
+  stashNudges,
+  takeStashed,
+  takeDecision,
+  takeInbox,
+  sweepInbox,
+  realProc,
+  agentPidOf,
+  sameProcess,
+  findPane,
+  clientIdleSec,
+  senderName,
+  claudeMessage,
+  claudeDecision,
+  stopSession
+};