@simonepri/refined-antigravity-acp 0.1.1 → 0.2.0

package/build/paseo/server/sanitize.ts

@@ -0,0 +1,286 @@
+export const HARNESS_TAGS = [
+  "system_message",
+  "system_notification",
+  "system_information",
+  "system_instruction",
+  "task_notification",
+  "task_output",
+  "context",
+  "messaging",
+  "receive_notifications_directly",
+  "wait_for_task",
+  "additional_metadata",
+  "user_request",
+  "user_information",
+  "scratchpad",
+  "identity",
+  "communication_style",
+  "mcp_servers",
+  "subagents",
+  "artifacts",
+  "ask_question",
+] as const;
+
+const HARNESS_SET = new Set(HARNESS_TAGS.map((t) => t.toLowerCase()));
+
+/**
+ * Marker prepended to the replacement prompt Paseo dispatches when the user steers
+ * a running turn. It tells the model the new text interrupts and supersedes the
+ * instruction it was working on. It is stripped again on every read path:
+ * assistant output (`sanitizeAssistantText`, `cleanStreamingChunk`) and SQLite
+ * history replay (`server/history.ts`), so it never reaches the Paseo timeline.
+ */
+export const STEERING_PREFIX = "[Mid-turn update]: ";
+
+const STEERING_PREFIX_PATTERN = /(?:^|\n)\s*\[Mid-turn update\]:\s*/gi;
+
+/** Removes any echoed steering marker from text that is about to be displayed. */
+export function stripSteeringPrefix(text: string): string {
+  return text.replace(STEERING_PREFIX_PATTERN, "");
+}
+
+function isHarnessTag(tagName: string): boolean {
+  return HARNESS_SET.has(tagName.toLowerCase());
+}
+
+function isPossibleHarnessPrefix(str: string): boolean {
+  const clean = str.replace(/^<\/?/, "").toLowerCase();
+  if (clean === "") return true;
+  if (/^[^\sa-zA-Z0-9_-]/.test(clean)) return false;
+  return HARNESS_TAGS.some((t) => t.toLowerCase().startsWith(clean));
+}
+
+const SYSTEM_MSG_INTRO = "The following is a <SYSTEM_MESSAGE> not actually sent by the user";
+
+function checkBannerPartialPrefix(input: string): number | null {
+  const minPrefixLen = 15;
+  for (let len = Math.min(input.length, SYSTEM_MSG_INTRO.length); len >= minPrefixLen; len--) {
+    const candidate = input.slice(input.length - len);
+    if (SYSTEM_MSG_INTRO.toLowerCase().startsWith(candidate.toLowerCase())) {
+      return input.length - len;
+    }
+  }
+  return null;
+}
+
+function cleanStreamingChunk(text: string): string {
+  return text
+    .replace(
+      /(?:\b(?:The\s+request\s+was\s+cancell?ed\s+by\s+the\s+client|context\s+cancell?ed)\b\.?)/gi,
+      "",
+    )
+    .replace(STEERING_PREFIX_PATTERN, "")
+    .replace(/\$\s*\\(?:to|rightarrow)\s*\$/gi, "→")
+    .replace(/\$\s*\\leftarrow\s*\$/gi, "←")
+    .replace(/\$\s*\\(?:implies|Rightarrow)\s*\$/gi, "⇒")
+    .replace(/\$\s*\\leftrightarrow\s*\$/gi, "↔")
+    .replace(/\$\s*\\le(?:q)?\s*\$/gi, "≤")
+    .replace(/\$\s*\\ge(?:q)?\s*\$/gi, "≥")
+    .replace(/\$\s*\\ne(?:q)?\s*\$/gi, "≠")
+    .replace(/\$\s*\\approx\s*\$/gi, "≈")
+    .replace(/\$\s*\\times\s*\$/gi, "×")
+    .replace(/\$\s*\\pm\s*\$/gi, "±")
+    .replace(/\$\s*\\infty\s*\$/gi, "∞")
+    .replace(/\\(?:to|rightarrow)\b/gi, "→")
+    .replace(/\\leftarrow\b/gi, "←")
+    .replace(/<kbd>(.*?)<\/kbd>/gi, "`$1`")
+    .replace(/<u>(.*?)<\/u>/gi, "*$1*")
+    .replace(/<mark>(.*?)<\/mark>/gi, "**$1**")
+    .replace(/<sup>(.*?)<\/sup>/gi, "^($1)");
+}
+
+export class StreamSanitizer {
+  private inHarnessTag = false;
+  private buffer = "";
+
+  reset(): void {
+    this.inHarnessTag = false;
+    this.buffer = "";
+  }
+
+  private processInHarness(input: string): string {
+    const closeMatch = input.match(/<\/\s*([a-zA-Z0-9_-]+)\s*>/i);
+    if (closeMatch && closeMatch.index !== undefined) {
+      const tagName = closeMatch[1].toLowerCase();
+      const endIdx = closeMatch.index + closeMatch[0].length;
+      if (isHarnessTag(tagName)) {
+        this.inHarnessTag = false;
+      }
+      return input.slice(endIdx);
+    }
+
+    const lastLt = input.lastIndexOf("<");
+    if (lastLt !== -1 && lastLt >= input.length - 40) {
+      const candidate = input.slice(lastLt);
+      if (isPossibleHarnessPrefix(candidate)) {
+        this.buffer = candidate;
+        return "";
+      }
+    }
+    return "";
+  }
+
+  private handleFullTag(input: string, gtIdx: number): { text: string; remainder: string } {
+    const fullTag = input.slice(0, gtIdx + 1);
+    const match = fullTag.match(/^<\s*(\/?)\s*([a-zA-Z0-9_-]+)/);
+    if (match) {
+      const isClosing = match[1] === "/";
+      const tagName = match[2].toLowerCase();
+      if (isHarnessTag(tagName)) {
+        if (!isClosing) this.inHarnessTag = true;
+        return { text: "", remainder: input.slice(gtIdx + 1) };
+      }
+    }
+    return { text: input[0], remainder: input.slice(1) };
+  }
+
+  process(chunk: string): string {
+    let input = this.buffer + chunk;
+    this.buffer = "";
+    let output = "";
+
+    while (input.length > 0) {
+      if (this.inHarnessTag) {
+        input = this.processInHarness(input);
+        continue;
+      }
+
+      const sysMatch = input.match(
+        /The following is a <SYSTEM_MESSAGE> not actually sent by the user[^\n]*\n?/i,
+      );
+      if (sysMatch && sysMatch.index !== undefined) {
+        output += input.slice(0, sysMatch.index);
+        input = input.slice(sysMatch.index + sysMatch[0].length);
+        this.inHarnessTag = true;
+        continue;
+      }
+
+      const bannerPrefixIdx = checkBannerPartialPrefix(input);
+      if (bannerPrefixIdx !== null) {
+        output += input.slice(0, bannerPrefixIdx);
+        this.buffer = input.slice(bannerPrefixIdx);
+        break;
+      }
+
+      const ltIdx = input.indexOf("<");
+      if (ltIdx === -1) {
+        output += input;
+        break;
+      }
+
+      if (ltIdx > 0) {
+        output += input.slice(0, ltIdx);
+        input = input.slice(ltIdx);
+      }
+
+      const gtIdx = input.indexOf(">");
+      if (gtIdx === -1) {
+        if (isPossibleHarnessPrefix(input)) {
+          this.buffer = input;
+          break;
+        }
+        output += input[0];
+        input = input.slice(1);
+        continue;
+      }
+
+      const res = this.handleFullTag(input, gtIdx);
+      output += res.text;
+      input = res.remainder;
+    }
+
+    return cleanStreamingChunk(output);
+  }
+
+  flush(): string {
+    const remaining = this.buffer;
+    this.buffer = "";
+    if (this.inHarnessTag) return "";
+    return cleanStreamingChunk(remaining);
+  }
+}
+
+export function sanitizeAssistantText(text: string): string {
+  const harnessPattern = HARNESS_TAGS.join("|");
+  return (
+    text
+      // Strip leaked internal harness tags & system notifications (both paired and streaming/unclosed)
+      .replace(
+        /The following is a <SYSTEM_MESSAGE> not actually sent by the user[\s\S]*?<\/SYSTEM_MESSAGE>/gi,
+        "",
+      )
+      .replace(
+        new RegExp(
+          `<(?:${harnessPattern})>(?:[\\s\\S]*?<\\/(?:${harnessPattern})>|[\\s\\S]*$)`,
+          "gi",
+        ),
+        "",
+      )
+      // Strip stray unclosed/opened harness tags if any remain
+      .replace(new RegExp(`<\\/?(?:${harnessPattern})>`, "gi"), "")
+      // Strip client cancellation error messages emitted during turn abort / steering
+      .replace(
+        /(?:\b(?:The\s+request\s+was\s+cancell?ed\s+by\s+the\s+client|context\s+cancell?ed)\b\.?)/gi,
+        "",
+      )
+      // Strip any echoed mid-turn update prefixes
+      .replace(STEERING_PREFIX_PATTERN, "")
+      // Convert common LaTeX math escapes to Unicode (Paseo does not render KaTeX/LaTeX)
+      .replace(/\$\s*\\(?:to|rightarrow)\s*\$/gi, "→")
+      .replace(/\$\s*\\leftarrow\s*\$/gi, "←")
+      .replace(/\$\s*\\(?:implies|Rightarrow)\s*\$/gi, "⇒")
+      .replace(/\$\s*\\leftrightarrow\s*\$/gi, "↔")
+      .replace(/\$\s*\\le(?:q)?\s*\$/gi, "≤")
+      .replace(/\$\s*\\ge(?:q)?\s*\$/gi, "≥")
+      .replace(/\$\s*\\ne(?:q)?\s*\$/gi, "≠")
+      .replace(/\$\s*\\approx\s*\$/gi, "≈")
+      .replace(/\$\s*\\times\s*\$/gi, "×")
+      .replace(/\$\s*\\pm\s*\$/gi, "±")
+      .replace(/\$\s*\\infty\s*\$/gi, "∞")
+      .replace(/\\(?:to|rightarrow)\b/gi, "→")
+      .replace(/\\leftarrow\b/gi, "←")
+      // Normalize keyboard keys for Paseo
+      .replace(/<kbd>(.*?)<\/kbd>/gi, "`$1`")
+      // Normalize basic styling tags that Paseo markdown parser does not wrap
+      .replace(/<u>(.*?)<\/u>/gi, "*$1*")
+      .replace(/<mark>(.*?)<\/mark>/gi, "**$1**")
+      .replace(/<sup>(.*?)<\/sup>/gi, "^($1)")
+      .trim()
+  );
+}
+
+export function formatSystemContext(systemPrompt?: string): string {
+  const parts: string[] = [];
+
+  if (systemPrompt && systemPrompt.trim().length > 0) {
+    parts.push(`[System Context]:\n${systemPrompt.trim()}`);
+  }
+
+  parts.push(
+    `[Formatting Guidance]:
+- Math: The UI does not render LaTeX ($...$, $$...$$, \\to, \\frac). Use plain text or Unicode formulas (e.g. x^2, a/b, →, √, ∑).
+- Mermaid: Always wrap both node labels AND edge labels containing spaces, punctuation, slashes, or parentheses in double quotes (e.g. id["Label (Details)"] and -->|"Label (Details)"|). Never put unquoted parentheses inside edge pipes |...| or node shapes.
+- Keys & Markup: Use markdown backticks (\`Cmd\`, \`Ctrl+C\`) instead of HTML <kbd> tags. Never output internal tags like <system_message>.`,
+  );
+
+  return parts.join("\n\n");
+}
+
+/**
+ * Formats the replacement prompt for a steered turn, marking it as a mid-turn
+ * interruption so the model treats it as superseding the instruction in flight.
+ */
+const SYSTEM_CONTEXT_PATTERN =
+  /(?:\[System Context\]:[\s\S]*?)?\[Formatting Guidance\]:[\s\S]*?(?=\n\n|$)\n*/g;
+
+/**
+ * Removes injected system context and formatting guidance from replayed user text so it
+ * does not clutter the Paseo timeline.
+ */
+export function stripSystemContext(text: string): string {
+  return text.replace(SYSTEM_CONTEXT_PATTERN, "");
+}
+
+export function formatSteeringPrompt(userText: string): string {
+  return `${STEERING_PREFIX}${userText.trim()}`;
+}

package/build/paseo/server/skills.ts

@@ -0,0 +1,183 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export interface AvailableCommand {
+  name: string;
+  description: string;
+}
+
+export interface DiscoveredSkill {
+  name: string;
+  description: string;
+  instructions: string;
+  userInvocable: boolean;
+  filePath: string;
+}
+
+function unquote(val: string): string {
+  const trimmed = val.trim();
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed.slice(1, -1).replace(/''/g, "'");
+  }
+  const commentIdx = trimmed.search(/\s+#/);
+  return commentIdx !== -1 ? trimmed.slice(0, commentIdx).trim() : trimmed;
+}
+
+function parseInvocable(val: string): boolean {
+  const v = unquote(val).toLowerCase();
+  return v !== "false" && v !== "no" && v !== "0";
+}
+
+function parseDescription(
+  rest: string,
+  lines: string[],
+  i: number,
+): { desc: string; nextIndex: number } {
+  if (rest === ">" || rest === ">-" || rest === "|" || rest === "|-") {
+    const block: string[] = [];
+    let idx = i + 1;
+    while (idx < lines.length && (/^\s+/.test(lines[idx]) || lines[idx].trim().length === 0)) {
+      block.push(lines[idx].trim());
+      idx++;
+    }
+    const text = rest.startsWith(">") ? block.join(" ") : block.join("\n").trim();
+    return { desc: text, nextIndex: idx - 1 };
+  }
+  return { desc: unquote(rest), nextIndex: i };
+}
+
+function parseFrontmatter(frontmatter: string): {
+  name?: string;
+  description?: string;
+  userInvocable: boolean;
+} {
+  const lines = frontmatter.split(/\r?\n/);
+  let name: string | undefined;
+  let description: string | undefined;
+  let userInvocable = true;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const nameMatch = line.match(/^name:\s*(.*)$/);
+    if (nameMatch) name = unquote(nameMatch[1]);
+
+    const invocableMatch = line.match(/^(?:user-invocable|user_invocable):\s*(.*)$/);
+    if (invocableMatch) userInvocable = parseInvocable(invocableMatch[1]);
+
+    const descMatch = line.match(/^description:\s*(.*)$/);
+    if (descMatch) {
+      const parsed = parseDescription(descMatch[1].trim(), lines, i);
+      description = parsed.desc;
+      i = parsed.nextIndex;
+    }
+  }
+  return { name, description, userInvocable };
+}
+
+export function parseSkillFile(filePath: string): DiscoveredSkill | null {
+  if (!existsSync(filePath)) return null;
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n(?:---|\.\.\.)(?:\r?\n|$)([\s\S]*)$/);
+    const meta = fmMatch ? parseFrontmatter(fmMatch[1]) : { userInvocable: true };
+    const instructions = fmMatch ? fmMatch[2].trim() : content;
+    const fallbackName = path.basename(path.dirname(filePath));
+
+    return {
+      name: meta.name && meta.name.length > 0 ? meta.name : fallbackName,
+      description:
+        meta.description && meta.description.length > 0
+          ? meta.description
+          : `Skill: ${fallbackName}`,
+      instructions,
+      userInvocable: meta.userInvocable,
+      filePath,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function resolveSkillRoots(cwd?: string): string[] {
+  const candidates: string[] = [];
+  if (cwd) {
+    candidates.push(
+      path.join(cwd, ".agents/skills"),
+      path.join(cwd, ".gemini/skills"),
+      path.join(cwd, ".codex/skills"),
+      path.join(cwd, "skills"),
+    );
+  }
+  const home = os.homedir();
+  candidates.push(
+    path.join(home, ".gemini/antigravity-cli/skills"),
+    path.join(home, ".gemini/config/skills"),
+    path.join(home, ".gemini/skills"),
+    path.join(home, ".agents/skills"),
+    path.join(home, ".claude/skills"),
+    path.join(home, ".codex/skills"),
+  );
+  return Array.from(new Set(candidates.filter((dir) => existsSync(dir))));
+}
+
+export function discoverSkills(cwd?: string): Map<string, DiscoveredSkill> {
+  const roots = resolveSkillRoots(cwd);
+  const skills = new Map<string, DiscoveredSkill>();
+
+  for (const root of roots) {
+    try {
+      for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+        const skill = parseSkillFile(path.join(root, entry.name, "SKILL.md"));
+        if (skill && !skills.has(skill.name)) {
+          skills.set(skill.name, skill);
+        }
+      }
+    } catch {
+      // Ignore unreadable dirs
+    }
+  }
+  return skills;
+}
+
+export function augmentCommands(
+  existingCommands: AvailableCommand[] | undefined,
+  cwd?: string,
+): AvailableCommand[] {
+  const result = new Map<string, AvailableCommand>();
+  if (Array.isArray(existingCommands)) {
+    for (const cmd of existingCommands) {
+      if (cmd?.name) result.set(cmd.name, cmd);
+    }
+  }
+  for (const skill of discoverSkills(cwd).values()) {
+    if (skill.userInvocable && !result.has(skill.name)) {
+      result.set(skill.name, { name: skill.name, description: skill.description });
+    }
+  }
+  return Array.from(result.values());
+}
+
+export function expandSkillInvocation(text: string, cwd?: string): string {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/")) return text;
+  const match = trimmed.match(/^\/([a-zA-Z0-9_-]+)(?:\s+([\s\S]*))?$/);
+  if (!match) return text;
+
+  const [_, commandName, rawArgs] = match;
+  const args = rawArgs ?? "";
+  const skill = discoverSkills(cwd).get(commandName);
+  if (!skill) return text;
+
+  let expanded = skill.instructions;
+  if (expanded.includes("$ARGUMENTS")) {
+    expanded = expanded.replaceAll("$ARGUMENTS", args);
+  } else if (args.trim().length > 0) {
+    expanded = `${expanded}\n\n**Arguments:** ${args}`;
+  }
+  return `[Skill: ${skill.name}]\n${expanded}\n[/Skill: ${skill.name}]`;
+}

package/build/paseo/server/steering.ts

@@ -0,0 +1,199 @@
+import type {
+  ProviderConnectRequest,
+  ProviderConnection,
+  ProviderEvent,
+  ProviderInput,
+} from "@getpaseo/plugin/server/provider";
+import { readConversationHistory } from "./history.js";
+import { formatSteeringPrompt } from "./sanitize.js";
+import { augmentCommands, expandSkillInvocation } from "./skills.js";
+
+function transformPromptInput(
+  input: ProviderInput,
+  isSteerReplacement: boolean,
+  cwd?: string,
+): ProviderInput {
+  if (input.type !== "session.prompt" || input.prompt.input.type !== "message") {
+    return input;
+  }
+  // Only the first text part carries the steering marker; prefixing every part would
+  // repeat it throughout a multi-part prompt.
+  let markerPending = isSteerReplacement;
+  const content = input.prompt.input.content.map((part) => {
+    if (part.type !== "text") return part;
+    let text = expandSkillInvocation(part.text, cwd);
+    if (markerPending) {
+      text = formatSteeringPrompt(text);
+      markerPending = false;
+    }
+    return { ...part, text };
+  });
+  return {
+    ...input,
+    prompt: {
+      ...input.prompt,
+      input: { ...input.prompt.input, content },
+    },
+  };
+}
+
+function readNativeSessionId(persistence: unknown): string | null {
+  if (!persistence || typeof persistence !== "object" || Array.isArray(persistence)) {
+    return null;
+  }
+  const data = (persistence as { data?: unknown }).data;
+  if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+  const sessionId = (data as { sessionId?: unknown }).sessionId;
+  return typeof sessionId === "string" ? sessionId : null;
+}
+
+/**
+ * Connection wrapper that decorates a base ProviderConnection with:
+ * 1. Mid-turn steering (`prompt.steer`)
+ * 2. Slash skill command advertising (`session.commands`)
+ * 3. Slash skill expansion on prompt submission
+ * 4. Automatic conversation history replay from Antigravity SQLite on session reload
+ */
+export class SteeringConnection implements ProviderConnection {
+  readonly version: number;
+  readonly capabilities: readonly string[];
+
+  private readonly sessionCwds = new Map<string, string>();
+  private readonly pendingSteers = new Set<string>();
+  private readonly replaySessions = new Set<string>();
+  private readonly listeners = new Set<(event: ProviderEvent) => void>();
+  private readonly unbindBase: () => void;
+
+  constructor(
+    private readonly base: ProviderConnection,
+    private readonly request: ProviderConnectRequest,
+  ) {
+    this.version = base.version;
+    this.capabilities = request.capabilities.includes("prompt.steer")
+      ? Array.from(new Set([...base.capabilities, "prompt.steer"]))
+      : base.capabilities;
+
+    this.unbindBase = this.base.onEvent((event) => this.handleBaseEvent(event));
+  }
+
+  private emitSessionSkills(sessionId: string, cwd: string): void {
+    try {
+      const commands = augmentCommands(undefined, cwd);
+      if (commands.length > 0) {
+        this.emit({ type: "session.commands", sessionId, commands });
+      }
+    } catch (err) {
+      console.error("[paseo-antigravity] Failed to emit session.commands on session.opened:", err);
+    }
+  }
+
+  private replaySessionHistory(sessionId: string, nativeSessionId: string): void {
+    try {
+      const history = readConversationHistory(nativeSessionId);
+      for (const entry of history) {
+        this.emit({
+          type: "timeline.item",
+          sessionId,
+          item: entry.item,
+          timestamp: entry.timestamp,
+        });
+      }
+    } catch (err) {
+      console.error(`[paseo-antigravity] Failed to replay history for ${sessionId}:`, err);
+    }
+  }
+
+  private handleSessionOpened(event: Extract<ProviderEvent, { type: "session.opened" }>): void {
+    const cwd = (event as { cwd?: string }).cwd ?? process.cwd();
+    this.sessionCwds.set(event.sessionId, cwd);
+
+    const sessionCaps = this.request.capabilities.includes("prompt.steer")
+      ? Array.from(new Set([...event.capabilities, "prompt.steer"]))
+      : event.capabilities;
+    this.emit({ ...event, capabilities: sessionCaps });
+
+    if (this.replaySessions.delete(event.sessionId)) {
+      const nativeId = readNativeSessionId(event.persistence);
+      if (nativeId) {
+        this.replaySessionHistory(event.sessionId, nativeId);
+      }
+    }
+
+    this.emitSessionSkills(event.sessionId, cwd);
+  }
+
+  private handleBaseEvent(event: ProviderEvent): void {
+    if (event.type === "session.opened") {
+      this.handleSessionOpened(event);
+      return;
+    }
+    if (event.type === "session.commands") {
+      const cwd = this.sessionCwds.get(event.sessionId);
+      const commands = augmentCommands(event.commands, cwd);
+      this.emit({ ...event, commands });
+      return;
+    }
+    this.emit(event);
+  }
+
+  private emit(event: ProviderEvent): void {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+
+  private handleSteerPrompt(sessionId: string, clientMessageId: string): void {
+    this.pendingSteers.add(sessionId);
+    this.emit({
+      type: "session.prompt_result",
+      sessionId,
+      clientMessageId,
+      result: { type: "completed" },
+    });
+  }
+
+  async send(input: ProviderInput): Promise<void> {
+    if (input.type === "session.open") {
+      if (input.history === "replay") {
+        this.replaySessions.add(input.sessionId);
+      }
+    }
+
+    if (input.type === "session.prompt") {
+      if (input.prompt.delivery === "steer") {
+        this.handleSteerPrompt(input.sessionId, input.prompt.clientMessageId);
+        return;
+      }
+      // Paseo answers a steer by cancelling the turn and re-dispatching the text as a
+      // normal prompt. `pendingSteers` is how we recognise that replacement so it can be
+      // marked as a mid-turn interruption rather than a fresh instruction.
+      const isReplacement = this.pendingSteers.delete(input.sessionId);
+      const cwd = this.sessionCwds.get(input.sessionId);
+      input = transformPromptInput(input, isReplacement, cwd);
+    }
+
+    if (input.type === "session.close") {
+      this.pendingSteers.delete(input.sessionId);
+      this.replaySessions.delete(input.sessionId);
+      this.sessionCwds.delete(input.sessionId);
+    }
+
+    return this.base.send(input);
+  }
+
+  onEvent(listener: (event: ProviderEvent) => void): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  async close(): Promise<void> {
+    this.pendingSteers.clear();
+    this.replaySessions.clear();
+    this.sessionCwds.clear();
+    this.listeners.clear();
+    this.unbindBase();
+    return this.base.close();
+  }
+}

package/dist/src/connector.d.ts

@@ -56,7 +56,6 @@ export declare class HangDetector {
     private onGraceTimerFired;
     private checkInactivity;
     private handleWaitingForTasks;
-    private handleTurnCompleteCandidate;
     private clearGraceTimersForSession;
     processStderrLine(line: string): void;
     processOutbound(msg: AcpStreamMessage): void;