switchroom 0.16.46 → 0.17.0

package/vendor/hindsight-memory/tests/test_client.py

@@ -230,3 +230,133 @@ class TestHindsightClientSetBankMission:
         assert "my-bank" in captured["url"]
         assert captured["body"]["updates"]["reflect_mission"] == "I am Claude"
         assert captured["body"]["updates"]["retain_mission"] == "Extract facts"
+
+
+class TestHindsightClientRecallTagFilters:
+    """Upstream 962140eef — tag filters are forwarded in the recall body."""
+
+    def test_sends_tag_filters(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["body"] = json.loads(req.data.decode())
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall(
+                "bank",
+                "query",
+                tags=["memory_type:rule"],
+                tags_match="any_strict",
+                tag_groups=[{"op": "all", "tags": ["memory_type:rule", "tech_stack:supabase"]}],
+            )
+
+        assert captured["body"]["tags"] == ["memory_type:rule"]
+        assert captured["body"]["tags_match"] == "any_strict"
+        assert captured["body"]["tag_groups"] == [
+            {"op": "all", "tags": ["memory_type:rule", "tech_stack:supabase"]}
+        ]
+
+    def test_omits_tag_filters_when_unset(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["body"] = json.loads(req.data.decode())
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query")
+
+        assert "tags" not in captured["body"]
+        assert "tags_match" not in captured["body"]
+        assert "tag_groups" not in captured["body"]
+
+
+class TestRequestTimeoutOverride:
+    """Upstream 55ef70679 — the constructor override replaces the per-call
+    timeout that recall/retain/_request would otherwise use. When unset,
+    the original per-call default is preserved."""
+
+    def test_override_replaces_recall_default(self):
+        c = HindsightClient("http://localhost:9077", request_timeout_override=60)
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query")
+
+        assert captured["timeout"] == 60
+
+    def test_override_replaces_retain_default(self):
+        c = HindsightClient("http://localhost:9077", request_timeout_override=60)
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResp({})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.retain("bank", "content")
+
+        assert captured["timeout"] == 60
+
+    def test_override_replaces_explicit_recall_timeout(self):
+        # Even an explicit per-call timeout (like recall.py's 8s hook
+        # budget) is replaced when the override is set — which is exactly
+        # why recall.py does NOT construct its client with the override.
+        c = HindsightClient("http://localhost:9077", request_timeout_override=60)
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query", timeout=8)
+
+        assert captured["timeout"] == 60
+
+    def test_no_override_preserves_recall_default(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query")
+
+        assert captured["timeout"] == 10
+
+    def test_no_override_preserves_retain_default(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResp({})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.retain("bank", "content")
+
+        assert captured["timeout"] == 15
+
+    def test_override_does_not_affect_health_check(self):
+        c = HindsightClient("http://localhost:9077", request_timeout_override=60)
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResp({}, status=200)
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            with patch("time.sleep"):
+                c.health_check()
+
+        assert captured["timeout"] == 5

package/vendor/hindsight-memory/tests/test_config.py

@@ -126,3 +126,50 @@ class TestLoadConfig:
         monkeypatch.setenv("HINDSIGHT_RECALL_BUDGET", "high")
         cfg = load_config()
         assert cfg["recallBudget"] == "high"
+
+    # Upstream 962140eef — recall tag filter env overrides.
+
+    def test_recall_tags_env_override_accepts_comma_list(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv("HINDSIGHT_RECALL_TAGS", "memory_type:rule, tech_stack:supabase")
+        cfg = load_config()
+        assert cfg["recallTags"] == ["memory_type:rule", "tech_stack:supabase"]
+
+    def test_recall_tags_env_override_accepts_json(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv("HINDSIGHT_RECALL_TAGS", '["memory_type:rule"]')
+        cfg = load_config()
+        assert cfg["recallTags"] == ["memory_type:rule"]
+
+    def test_recall_tag_groups_env_override_accepts_json(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv(
+            "HINDSIGHT_RECALL_TAG_GROUPS",
+            '[{"op":"all","tags":["memory_type:rule","tech_stack:supabase"]}]',
+        )
+        cfg = load_config()
+        assert cfg["recallTagGroups"] == [{"op": "all", "tags": ["memory_type:rule", "tech_stack:supabase"]}]
+
+    def test_recall_additional_bank_filters_env_override_accepts_json(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv(
+            "HINDSIGHT_RECALL_ADDITIONAL_BANK_FILTERS",
+            '{"normative":{"recallTags":["memory_type:rule"],"recallTagsMatch":"all"}}',
+        )
+        cfg = load_config()
+        assert cfg["recallAdditionalBankFilters"] == {
+            "normative": {"recallTags": ["memory_type:rule"], "recallTagsMatch": "all"}
+        }
+
+    # Upstream 55ef70679 — request timeout override.
+
+    def test_request_timeout_default_none(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        cfg = load_config()
+        assert cfg["requestTimeoutSeconds"] is None
+
+    def test_request_timeout_env_override(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv("HINDSIGHT_REQUEST_TIMEOUT_SECONDS", "60")
+        cfg = load_config()
+        assert cfg["requestTimeoutSeconds"] == 60

package/vendor/hindsight-memory/tests/test_content.py

@@ -1,11 +1,14 @@
 """Tests for lib/content.py — pure content-processing functions."""
 
+import re
+
 import pytest
 
 from lib.content import (
     _extract_text_content,
     _is_channel_message_tool,
     compose_recall_query,
+    format_current_time,
     format_memories,
     prepare_retention_transcript,
     slice_last_turns_by_user_boundary,
@@ -469,3 +472,18 @@ class TestPrepareRetentionTranscript:
         transcript, _ = prepare_retention_transcript(msgs, retain_full_window=True, include_tool_calls=False)
         assert "[role: user]" in transcript
         assert "[user:end]" in transcript
+
+
+# ---------------------------------------------------------------------------
+# format_current_time
+# ---------------------------------------------------------------------------
+
+
+class TestFormatCurrentTime:
+    def test_includes_utc_suffix(self):
+        # The "UTC" suffix prevents client LLMs from misreading the
+        # timestamp as local time.
+        assert format_current_time().endswith(" UTC")
+
+    def test_format_shape(self):
+        assert re.fullmatch(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2} UTC", format_current_time())

package/vendor/hindsight-memory/tests/test_hooks.py

@@ -310,6 +310,68 @@ class TestRecallHook:
             cache_path = tmp_path / "plugin_data" / "state" / "recall_cache.json"
             assert not cache_path.exists(), f"Cache should not be written for TTL={bad!r}"
 
+    def test_passes_tag_filters_to_recall_api(self, monkeypatch, tmp_path):
+        # Upstream 962140eef.
+        captured = {}
+
+        def capture_and_respond(req, timeout=None):
+            if "/recall" in req.full_url:
+                captured["body"] = json.loads(req.data.decode())
+            return FakeHTTPResponse({"results": []})
+
+        hook_input = make_hook_input(prompt="What project rules apply here?")
+        _run_hook(
+            "recall",
+            hook_input,
+            monkeypatch,
+            tmp_path,
+            urlopen_side_effect=capture_and_respond,
+            extra_settings={
+                "recallTags": ["memory_type:rule"],
+                "recallTagsMatch": "any_strict",
+                "recallTagGroups": [{"op": "all", "tags": ["memory_type:rule", "tech_stack:supabase"]}],
+            },
+        )
+
+        assert captured["body"]["tags"] == ["memory_type:rule"]
+        assert captured["body"]["tags_match"] == "any_strict"
+        assert captured["body"]["tag_groups"] == [{"op": "all", "tags": ["memory_type:rule", "tech_stack:supabase"]}]
+
+    def test_additional_bank_filters_override_global_tags(self, monkeypatch, tmp_path):
+        # Upstream 962140eef — per-bank overrides beat the global filters.
+        captured = []
+
+        def capture_and_respond(req, timeout=None):
+            if "/recall" in req.full_url:
+                captured.append(json.loads(req.data.decode()))
+            return FakeHTTPResponse({"results": []})
+
+        hook_input = make_hook_input(prompt="What project rules apply here?")
+        _run_hook(
+            "recall",
+            hook_input,
+            monkeypatch,
+            tmp_path,
+            urlopen_side_effect=capture_and_respond,
+            extra_settings={
+                "bankId": "project-bank",
+                "recallAdditionalBanks": ["normative-bank"],
+                "recallTags": ["tech_stack:supabase"],
+                "recallTagsMatch": "any",
+                "recallAdditionalBankFilters": {
+                    "normative-bank": {
+                        "recallTags": ["memory_type:rule"],
+                        "recallTagsMatch": "all_strict",
+                    }
+                },
+            },
+        )
+
+        assert captured[0]["tags"] == ["tech_stack:supabase"]
+        assert captured[0]["tags_match"] == "any"
+        assert captured[1]["tags"] == ["memory_type:rule"]
+        assert captured[1]["tags_match"] == "all_strict"
+
     def test_disabled_auto_recall_produces_no_output(self, monkeypatch, tmp_path):
         (tmp_path / "plugin_root").mkdir(exist_ok=True)
         (tmp_path / "plugin_data").mkdir(exist_ok=True)

package/telegram-plugin/gateway/error-envelope-card.ts

@@ -1,64 +0,0 @@
-/**
- * Render a one-tap unlock card for hostd error_envelopes that carry a
- * `flip_yaml_flag` fix (#1758 Phase 1).
- *
- * CRITICAL safety: the `yaml_path` MUST be on the
- * `UNLOCK_CARD_YAML_ALLOWLIST` exported from
- * `src/host-control/config-edit-validator.ts`. A malformed or hostile
- * envelope from any backend could otherwise nudge the operator into
- * one-tap-approving an arbitrary flag flip. Non-allowlisted paths fall
- * back to plain-text rendering (the caller surfaces `resp.error` as
- * today).
- *
- * Phase 1 scope: ONLY `flip_yaml_flag`. `request_vault_grant` is
- * explicitly deferred to a later phase (still plain-text rendered).
- */
-
-import type { HostdResponse } from "../../src/host-control/protocol.js";
-import { isAllowlistedYamlPath } from "../../src/host-control/config-edit-validator.js";
-import {
-  buildApprovalCard,
-  type BuiltApprovalCard,
-} from "./approval-card.js";
-
-export type UnlockCardOutcome =
-  | { kind: "card"; card: BuiltApprovalCard; yaml_path: string; to: unknown }
-  | { kind: "plain-text" };
-
-/**
- * Decide whether to render a one-tap unlock card for the given
- * response. Returns `{kind: "plain-text"}` whenever the envelope
- * lacks a `flip_yaml_flag` fix OR the path isn't on the allowlist.
- *
- * `approvalRequestId` is the 32-hex nonce minted by the approval
- * kernel; caller is responsible for binding the card to that nonce
- * and recording the apply-on-tap intent.
- */
-export function renderErrorEnvelopeCard(
-  resp: HostdResponse,
-  agentName: string,
-  approvalRequestId: string,
-): UnlockCardOutcome {
-  const env = resp.error_envelope;
-  if (!env || !env.fix) return { kind: "plain-text" };
-  if (env.fix.kind !== "flip_yaml_flag") {
-    // request_vault_grant is Phase-2 work; everything else has no
-    // unlock-card UX. Caller falls back to plain-text rendering.
-    return { kind: "plain-text" };
-  }
-  const { yaml_path, to } = env.fix;
-  if (!isAllowlistedYamlPath(yaml_path)) {
-    // Defense-in-depth: never render a one-tap card for a path the
-    // operator hasn't explicitly opted into.
-    return { kind: "plain-text" };
-  }
-  const card = buildApprovalCard({
-    request_id: approvalRequestId,
-    agent: agentName,
-    scope_humanized: `flip ${yaml_path} → ${JSON.stringify(to)}`,
-    why: env.human + (env.why ? ` — ${env.why}` : ""),
-    offer_always: false,
-    offer_ttl: false,
-  });
-  return { kind: "card", card, yaml_path, to };
-}

package/telegram-plugin/gateway/resolve-calling-subagent.ts

@@ -1,78 +0,0 @@
-/**
- * Issue #305 Option A — resolve which sub-agent (by jsonl_agent_id) is
- * calling progress_update.
- *
- * Three resolution strategies, in priority order:
- *   1. agentIdHint — exact match on subagents.jsonl_agent_id
- *   2. toolUseIdHint — exact match on subagents.id (parent's Agent tool_use_id)
- *   3. Heuristic: most-recently-started running sub-agent in the active turn
- *      for this chat. Logs a stderr warning when multiple candidates exist.
- *
- * Returns null if no match (caller falls through to message-send).
- * Never throws; SQL errors return null.
- *
- * Extracted from gateway.ts so the resolver can be unit-tested against an
- * in-memory SQLite DB without spinning up the full grammY bot harness.
- */
-
-/**
- * Minimal duck-typed interface that matches both bun:sqlite's `Database`
- * and the `SqliteDatabase` shape returned by `openTurnsDb`. We accept the
- * narrowed shape so the resolver can run against any equivalent handle.
- */
-export interface ResolverDb {
-  prepare(sql: string): {
-    get(...params: unknown[]): unknown
-    all(...params: unknown[]): unknown[]
-  }
-}
-
-export interface ResolveCallingSubagentOpts {
-  db: ResolverDb | null
-  chatId: string
-  threadId?: number | string
-  agentIdHint: string | null
-  toolUseIdHint: string | null
-}
-
-export type ResolveCallingSubagentResult = { agentId: string } | null
-
-export function resolveCallingSubagent(
-  opts: ResolveCallingSubagentOpts,
-): ResolveCallingSubagentResult {
-  if (opts.db == null) return null
-  try {
-    if (opts.agentIdHint != null) {
-      const row = opts.db.prepare(
-        "SELECT jsonl_agent_id FROM subagents WHERE jsonl_agent_id = ? AND status = 'running'",
-      ).get(opts.agentIdHint) as { jsonl_agent_id: string } | undefined
-      if (row?.jsonl_agent_id) return { agentId: row.jsonl_agent_id }
-    }
-    if (opts.toolUseIdHint != null) {
-      const row = opts.db.prepare(
-        "SELECT jsonl_agent_id FROM subagents WHERE id = ? AND status = 'running'",
-      ).get(opts.toolUseIdHint) as { jsonl_agent_id: string | null } | undefined
-      if (row?.jsonl_agent_id) return { agentId: row.jsonl_agent_id }
-    }
-    // Heuristic fallback.
-    const turnRow = opts.db.prepare(
-      "SELECT turn_key FROM turns WHERE chat_id = ? AND ended_at IS NULL ORDER BY started_at DESC LIMIT 1",
-    ).get(opts.chatId) as { turn_key: string } | undefined
-    if (turnRow?.turn_key == null) return null
-    const candidates = opts.db.prepare(
-      "SELECT jsonl_agent_id FROM subagents WHERE parent_turn_key = ? AND status = 'running' AND jsonl_agent_id IS NOT NULL ORDER BY started_at DESC",
-    ).all(turnRow.turn_key) as Array<{ jsonl_agent_id: string }>
-    if (candidates.length === 0) return null
-    if (candidates.length > 1) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        `progress_update: heuristic resolution selected most-recent of ${candidates.length} running sub-agents (chat=${opts.chatId}); pass agent_id explicitly to avoid mis-attribution`,
-      )
-    }
-    return { agentId: candidates[0].jsonl_agent_id }
-  } catch (err) {
-    // eslint-disable-next-line no-console
-    console.warn('progress_update: resolveCallingSubagent SQL error', err)
-    return null
-  }
-}

package/telegram-plugin/silent-reply.ts

@@ -1,58 +0,0 @@
-/**
- * Silent-reply markers + allowlist guard.
- *
- * Lives in its own module (separate from server.ts) so that tests and
- * other importers can pull these helpers in without booting the
- * full MCP server — server.ts has top-level side effects (env load,
- * TELEGRAM_BOT_TOKEN check, history.db open, session-tail spawn) that
- * are inappropriate for a unit-test import boundary.
- *
- * Sprint1 review finding #6: an earlier revision of the reply /
- * stream_reply tool handlers returned the silent-reply ack BEFORE
- * calling `assertAllowedChat`, so unauthorised chats could bypass the
- * outbound allowlist by having the agent emit `NO_REPLY`. The ack
- * itself is a cross-chat signal (it confirms to the LLM that the chat
- * exists and is reachable) even though no Telegram message is sent, so
- * we must refuse disallowed chats *before* producing it. The
- * guardSilentReply helper locks that ordering in.
- */
-
-const SILENT_REPLY_MARKERS = new Set(['NO_REPLY', 'HEARTBEAT_OK'])
-
-// Derive the char-length bound from the marker set so adding a new
-// marker doesn't silently desync with a hand-tuned constant.
-const SILENT_REPLY_MAX_LEN = Math.max(
-  ...Array.from(SILENT_REPLY_MARKERS, (m) => m.length),
-) + 2 // small buffer for trailing punctuation callers might add accidentally
-
-export function isSilentReplyMarker(text: string | undefined): boolean {
-  if (typeof text !== 'string') return false
-  const trimmed = text.trim()
-  if (trimmed.length === 0) return false
-  if (trimmed.length > SILENT_REPLY_MAX_LEN) return false
-  // Case-insensitive match: models occasionally emit `no_reply` or
-  // `NoReply`. Require letters/underscores/digits only so legitimate
-  // prose that happens to contain "NO_REPLY was suggested" still sends.
-  return SILENT_REPLY_MARKERS.has(trimmed.toUpperCase())
-}
-
-/**
- * Decide whether a `reply`/`stream_reply` invocation should be short-
- * circuited as a silent-reply ack, enforcing the allowlist FIRST.
- *
- * `assertAllowed` throws when `chat_id` is not on the allowlist; callers
- * let that propagate so the MCP tool call fails loudly.
- */
-export function guardSilentReply(params: {
-  chat_id: string
-  text: string | undefined
-  hasFiles: boolean
-  assertAllowed: (chat_id: string) => void
-}): { kind: 'silent'; markerText: string } | { kind: 'continue' } {
-  const { chat_id, text, hasFiles, assertAllowed } = params
-  if (hasFiles) return { kind: 'continue' }
-  if (!isSilentReplyMarker(text)) return { kind: 'continue' }
-  // Allowlist check BEFORE returning the ack — see docblock above.
-  assertAllowed(chat_id)
-  return { kind: 'silent', markerText: (text as string).trim() }
-}

package/telegram-plugin/tests/error-envelope-unlock-card.test.ts

@@ -1,79 +0,0 @@
-/**
- * Telegram bridge unlock-card safety (#1758 Phase 1).
- *
- * The bridge MUST validate `flip_yaml_flag.yaml_path` against the
- * config-edit-validator allowlist before rendering a one-tap approval
- * card. A malformed or hostile envelope from any backend could
- * otherwise nudge the operator into approving an arbitrary flag flip.
- */
-
-import { describe, it, expect } from "vitest";
-import { renderErrorEnvelopeCard } from "../gateway/error-envelope-card.js";
-import type { HostdResponse } from "../../src/host-control/protocol.js";
-
-function mkResp(fix: HostdResponse["error_envelope"]["fix"]): HostdResponse {
-  return {
-    v: 1,
-    request_id: "r-1",
-    result: "error",
-    exit_code: null,
-    duration_ms: 0,
-    error: "E_FOO: foo",
-    error_envelope: {
-      v: 1,
-      code: "E_FOO",
-      human: "foo",
-      fix,
-      request_id: "r-1",
-    },
-  } as HostdResponse;
-}
-
-describe("renderErrorEnvelopeCard — allowlist guard", () => {
-  it("renders an approval card for an allowlisted yaml_path", () => {
-    const resp = mkResp({
-      kind: "flip_yaml_flag",
-      yaml_path: "hostd.config_edit_enabled",
-      to: true,
-    });
-    const out = renderErrorEnvelopeCard(resp, "klanker", "a".repeat(32));
-    expect(out.kind).toBe("card");
-    if (out.kind === "card") {
-      expect(out.yaml_path).toBe("hostd.config_edit_enabled");
-      expect(out.to).toBe(true);
-      expect(out.card.text).toContain("klanker");
-    }
-  });
-
-  it("falls back to plain-text for a NON-allowlisted yaml_path", () => {
-    const resp = mkResp({
-      kind: "flip_yaml_flag",
-      yaml_path: "hostd.evil_backdoor_flag",
-      to: true,
-    });
-    const out = renderErrorEnvelopeCard(resp, "klanker", "a".repeat(32));
-    expect(out).toEqual({ kind: "plain-text" });
-  });
-
-  it("falls back to plain-text for request_vault_grant (Phase 2 scope)", () => {
-    const resp = mkResp({
-      kind: "request_vault_grant",
-      vault_key: "openai/api-key",
-    });
-    const out = renderErrorEnvelopeCard(resp, "klanker", "a".repeat(32));
-    expect(out).toEqual({ kind: "plain-text" });
-  });
-
-  it("falls back to plain-text when no envelope is present", () => {
-    const resp: HostdResponse = {
-      v: 1,
-      request_id: "r-1",
-      result: "error",
-      exit_code: null,
-      duration_ms: 0,
-      error: "legacy string",
-    };
-    const out = renderErrorEnvelopeCard(resp, "klanker", "a".repeat(32));
-    expect(out).toEqual({ kind: "plain-text" });
-  });
-});