switchroom 0.13.58 → 0.13.60

package/telegram-plugin/gateway/gateway.ts

@@ -86,7 +86,6 @@ import { classifyInbound } from '../inbound-classifier.js'
 import * as silencePoke from '../silence-poke.js'
 import * as pendingProgress from '../pending-work-progress.js'
 import { writeSilentEndState, clearSilentEndState, recordUndeliveredTurnEnd } from '../silent-end.js'
-import { markAckSent, clearAckSent } from '../ack-flag.js'
 import { isFinalAnswerReply } from '../final-answer-detect.js'
 import { createAnswerStream, type AnswerStreamHandle } from '../answer-stream.js'
 import { type SessionEvent } from '../session-tail.js'
@@ -4984,16 +4983,6 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
   // silence-poke clock so the next poke is measured from this send.
   signalTracker.noteOutbound(statusKey(chat_id, threadId), Date.now())
   silencePoke.noteOutbound(statusKey(chat_id, threadId), Date.now())
-  // Ack-first gate (`reference/conversational-pacing.md` beat 1):
-  // touch the state-dir flag so the ack-first-pretool hook lets
-  // subsequent non-reply tool calls through this turn. Cleared at
-  // turn_started. Best-effort — a write failure shouldn't break
-  // reply, and the hook is kill-switched anyway.
-  try {
-    markAckSent()
-  } catch (err) {
-    process.stderr.write(`telegram gateway: markAckSent failed: ${err}\n`)
-  }
   // #1741 — only clear silent-end state on a plausibly-final reply.
   // An interim ack (disable_notification:true, short text, no done)
   // must NOT clear the state file; otherwise a turn that ends with
@@ -5589,13 +5578,6 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
       const sKey = statusKey(streamChatId, streamThreadId)
       signalTracker.noteOutbound(sKey, Date.now())
       silencePoke.noteOutbound(sKey, Date.now())
-      // Ack-first gate: stream_reply's first emit also unlocks subsequent
-      // tool calls. See ack-flag.ts + ack-first-pretool.ts.
-      try {
-        markAckSent()
-      } catch (err) {
-        process.stderr.write(`telegram gateway: markAckSent (stream_reply) failed: ${err}\n`)
-      }
       // #1741 — see executeReply for the rationale: only a plausibly-
       // final stream_reply clears the silent-end state. An interim
       // ack via stream_reply must NOT clear; the Stop hook needs
@@ -6944,14 +6926,6 @@ function handleSessionEvent(ev: SessionEvent): void {
           statusKey(ev.chatId, enqThreadId),
           'handback',
         )
-        // Ack-first gate (`reference/conversational-pacing.md` beat 1):
-        // wipe the prior turn's `ack-sent.flag` so the ack-first-
-        // pretool hook re-arms for this fresh turn. Centralised HERE
-        // (not in handleInbound) because `enqueue` is the single
-        // canonical fresh-turn atom — fires for real inbounds, cron
-        // fires, subagent-handback channel wakes, vault-grant resumes,
-        // and restart markers alike. Best-effort — see ack-flag.ts.
-        clearAckSent()
       }
       if (ev.chatId) {
         // Issue #195: if a previous turn left an answer-lane stream open
@@ -7139,15 +7113,6 @@ function handleSessionEvent(ev: SessionEvent): void {
       if (!turn.replyCalled && !isTelegramSurfaceTool(name)) {
         const rendered = registerAndRender(turn.toolActivity, name)
         if (rendered != null) {
-          // Mark the ack-flag synchronously so a PreToolUse hook firing
-          // concurrently for THIS tool call (#1921) sees the flag set
-          // and allows the tool through. The drain runs async; failure
-          // is logged but does not block the model.
-          try {
-            markAckSent()
-          } catch (err) {
-            process.stderr.write(`telegram gateway: activity-summary markAckSent failed: ${err}\n`)
-          }
           turn.activityPendingRender = rendered
           if (turn.activityInFlight == null) {
             turn.activityInFlight = drainActivitySummary(turn)

package/dist/cli/ack-first-pretool.mjs

@@ -1,75 +0,0 @@
-// src/cli/ack-first-pretool.ts
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-var REPLY_TOOL_NAMES = new Set([
-  "mcp__switchroom-telegram__reply",
-  "mcp__switchroom-telegram__stream_reply"
-]);
-var ACK_SENT_MARKER = "ack-sent.flag";
-function decide(input, stateDir) {
-  const toolName = input.tool_name ?? "";
-  if (toolName === "") {
-    return { decision: "allow" };
-  }
-  if (REPLY_TOOL_NAMES.has(toolName)) {
-    return { decision: "allow" };
-  }
-  if (!stateDir) {
-    return { decision: "allow" };
-  }
-  const markerPath = join(stateDir, ACK_SENT_MARKER);
-  let ackAlreadySent = false;
-  try {
-    ackAlreadySent = existsSync(markerPath);
-  } catch {
-    return { decision: "allow" };
-  }
-  if (ackAlreadySent) {
-    return { decision: "allow" };
-  }
-  return {
-    decision: "block",
-    reason: "First call `mcp__switchroom-telegram__reply` with a brief one-line " + "acknowledgement in your persona's voice before using any other tool \u2014 " + 'e.g. "on it \u2014 checking", "good question \u2014 one sec", "let me dig in". ' + "This is the framework's enforcement of the human-feel design " + "(`reference/conversational-pacing.md` beat 1): a colleague answers " + "in a beat. The reply can be the entire short answer if you have one " + "ready (then no further work needed); otherwise it's a brief status " + "and you continue with the work after."
-  };
-}
-async function runHook() {
-  if (process.env.SWITCHROOM_DISABLE_ACK_FIRST_GATE === "1") {
-    process.exit(0);
-  }
-  const stdin = await readStdin();
-  let input;
-  try {
-    input = JSON.parse(stdin);
-  } catch {
-    process.exit(0);
-  }
-  const stateDir = process.env.TELEGRAM_STATE_DIR;
-  const decision = decide(input, stateDir);
-  if (decision.decision === "block") {
-    process.stdout.write(JSON.stringify({ decision: "block", reason: decision.reason }) + `
-`);
-  }
-  process.exit(0);
-}
-async function readStdin() {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    process.stdin.on("data", (chunk) => chunks.push(chunk));
-    process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-    process.stdin.on("error", reject);
-    if (process.stdin.isTTY)
-      resolve("");
-  });
-}
-if (typeof process !== "undefined" && process.argv?.[1]?.endsWith("ack-first-pretool.mjs")) {
-  runHook().catch((err) => {
-    process.stderr.write(`ack-first-pretool: hook failed unexpectedly: ${err}
-`);
-    process.exit(0);
-  });
-}
-export {
-  runHook,
-  decide,
-  ACK_SENT_MARKER
-};

package/telegram-plugin/ack-flag.ts

@@ -1,66 +0,0 @@
-/**
- * Ack-first state flag — load-bearing for the ack-first-pretool hook
- * (see `src/cli/ack-first-pretool.ts` and
- * `reference/conversational-pacing.md` beat 1).
- *
- * The gateway is the source of truth for "has the model called reply
- * yet this turn?". The PreToolUse hook runs as a short-lived child
- * process so it can't read gateway in-memory state; the hand-off is
- * a single file inside `$TELEGRAM_STATE_DIR`:
- *
- *   - `markAckSent()` touches the file on the first reply per turn.
- *   - `clearAckSent()` removes it at turn_started.
- *   - The hook checks `existsSync(path)` → allow / block.
- *
- * Per-agent isolation is built-in: `$TELEGRAM_STATE_DIR` is the
- * agent's per-container state dir (~/.switchroom/agents/<name>/telegram,
- * bind-mounted into /state/agent/home/.switchroom/agents/<name>/telegram
- * inside the container).
- *
- * All operations are best-effort: a write or unlink failure logs to
- * stderr and returns; the gate is informational UX, not a safety
- * primitive, so a broken state-dir must never wedge reply itself.
- */
-
-import { closeSync, existsSync, openSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-
-export const ACK_SENT_MARKER = "ack-sent.flag";
-
-function markerPath(): string | null {
-  const dir = process.env.TELEGRAM_STATE_DIR;
-  if (!dir) return null;
-  return join(dir, ACK_SENT_MARKER);
-}
-
-/** Create the ack-sent marker. Idempotent (no-op if it exists). */
-export function markAckSent(): void {
-  const path = markerPath();
-  if (path == null) return;
-  if (existsSync(path)) return;
-  try {
-    const fd = openSync(path, "w");
-    closeSync(fd);
-  } catch (err) {
-    process.stderr.write(
-      `ack-flag: markAckSent failed path=${path}: ${err}\n`,
-    );
-  }
-}
-
-/** Remove the ack-sent marker. Idempotent. */
-export function clearAckSent(): void {
-  const path = markerPath();
-  if (path == null) return;
-  try {
-    unlinkSync(path);
-  } catch (err: unknown) {
-    // ENOENT is the common case (turn started before any prior turn
-    // ran a reply); silently swallow.
-    const code = (err as { code?: string } | undefined)?.code;
-    if (code === "ENOENT") return;
-    process.stderr.write(
-      `ack-flag: clearAckSent failed path=${path}: ${err}\n`,
-    );
-  }
-}

package/telegram-plugin/tests/ack-flag.test.ts

@@ -1,65 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { markAckSent, clearAckSent, ACK_SENT_MARKER } from "../ack-flag.js";
-
-describe("ack-flag — gateway-side state file for ack-first hook", () => {
-  let stateDir: string;
-  let prevEnv: string | undefined;
-
-  beforeEach(() => {
-    stateDir = mkdtempSync(join(tmpdir(), "ack-flag-"));
-    prevEnv = process.env.TELEGRAM_STATE_DIR;
-    process.env.TELEGRAM_STATE_DIR = stateDir;
-  });
-
-  afterEach(() => {
-    if (prevEnv != null) process.env.TELEGRAM_STATE_DIR = prevEnv;
-    else delete process.env.TELEGRAM_STATE_DIR;
-    rmSync(stateDir, { recursive: true, force: true });
-  });
-
-  it("markAckSent creates the marker file", () => {
-    expect(existsSync(join(stateDir, ACK_SENT_MARKER))).toBe(false);
-    markAckSent();
-    expect(existsSync(join(stateDir, ACK_SENT_MARKER))).toBe(true);
-  });
-
-  it("markAckSent is idempotent (second call is a no-op)", () => {
-    markAckSent();
-    expect(() => markAckSent()).not.toThrow();
-    expect(existsSync(join(stateDir, ACK_SENT_MARKER))).toBe(true);
-  });
-
-  it("clearAckSent removes the marker file", () => {
-    markAckSent();
-    expect(existsSync(join(stateDir, ACK_SENT_MARKER))).toBe(true);
-    clearAckSent();
-    expect(existsSync(join(stateDir, ACK_SENT_MARKER))).toBe(false);
-  });
-
-  it("clearAckSent is idempotent (works when marker doesn't exist)", () => {
-    expect(existsSync(join(stateDir, ACK_SENT_MARKER))).toBe(false);
-    expect(() => clearAckSent()).not.toThrow();
-  });
-
-  it("round-trip: mark → clear → mark cycles work across turns", () => {
-    // turn 1
-    markAckSent();
-    expect(existsSync(join(stateDir, ACK_SENT_MARKER))).toBe(true);
-    // turn end / next turn start
-    clearAckSent();
-    expect(existsSync(join(stateDir, ACK_SENT_MARKER))).toBe(false);
-    // turn 2 first reply
-    markAckSent();
-    expect(existsSync(join(stateDir, ACK_SENT_MARKER))).toBe(true);
-  });
-
-  it("noop when TELEGRAM_STATE_DIR is unset (best-effort)", () => {
-    delete process.env.TELEGRAM_STATE_DIR;
-    expect(() => markAckSent()).not.toThrow();
-    expect(() => clearAckSent()).not.toThrow();
-  });
-});