gsd-pi 2.19.0 → 2.20.0

package/src/resources/extensions/gsd/tests/prompt-db.test.ts

@@ -0,0 +1,385 @@
+// prompt-db: Tests for DB-aware inline helpers (inlineDecisionsFromDb, inlineRequirementsFromDb, inlineProjectFromDb)
+//
+// Validates:
+// (a) DB-aware helpers return scoped content when DB has data
+// (b) Helpers fall back to non-null output when DB unavailable
+// (c) Scoped filtering actually reduces content
+
+import { createTestContext } from './test-helpers.ts';
+import {
+  openDatabase,
+  closeDatabase,
+  isDbAvailable,
+  insertDecision,
+  insertRequirement,
+  insertArtifact,
+} from '../gsd-db.ts';
+import {
+  queryDecisions,
+  queryRequirements,
+  queryProject,
+  formatDecisionsForPrompt,
+  formatRequirementsForPrompt,
+} from '../context-store.ts';
+
+const { assertEq, assertTrue, assertMatch, assertNoMatch, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// prompt-db: DB-aware decisions helper returns scoped content
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== prompt-db: scoped decisions from DB ===');
+{
+  openDatabase(':memory:');
+
+  // Insert decisions across 3 milestones
+  for (let i = 1; i <= 10; i++) {
+    const milestoneNum = ((i - 1) % 3) + 1;
+    insertDecision({
+      id: `D${String(i).padStart(3, '0')}`,
+      when_context: `M00${milestoneNum}/S01`,
+      scope: 'architecture',
+      decision: `decision ${i}`,
+      choice: `choice ${i}`,
+      rationale: `rationale ${i}`,
+      revisable: 'yes',
+      superseded_by: null,
+    });
+  }
+
+  // Query scoped to M001
+  const m001Decisions = queryDecisions({ milestoneId: 'M001' });
+  assertTrue(m001Decisions.length > 0, 'M001 decisions should exist');
+  assertTrue(m001Decisions.length < 10, `scoped query should return fewer than 10 (got ${m001Decisions.length})`);
+
+  // Verify all returned decisions are for M001
+  for (const d of m001Decisions) {
+    assertMatch(d.when_context, /M001/, `decision ${d.id} should be for M001`);
+  }
+
+  // Format and verify wrapping
+  const formatted = formatDecisionsForPrompt(m001Decisions);
+  assertTrue(formatted.length > 0, 'formatted decisions should be non-empty');
+  assertMatch(formatted, /\| # \| When \| Scope/, 'formatted decisions have table header');
+
+  // Verify the expected wrapper format that inlineDecisionsFromDb would produce
+  const wrapped = `### Decisions\nSource: \`.gsd/DECISIONS.md\`\n\n${formatted}`;
+  assertMatch(wrapped, /^### Decisions/, 'wrapped decisions start with ### Decisions');
+  assertMatch(wrapped, /Source:.*DECISIONS\.md/, 'wrapped decisions have source path');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// prompt-db: DB-aware requirements helper returns scoped content
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== prompt-db: scoped requirements from DB ===');
+{
+  openDatabase(':memory:');
+
+  // Insert requirements across different slices
+  insertRequirement({
+    id: 'R001', class: 'functional', status: 'active',
+    description: 'feature A', why: 'needed', source: 'M001', primary_owner: 'S01',
+    supporting_slices: '', validation: 'test', notes: '', full_content: '',
+    superseded_by: null,
+  });
+  insertRequirement({
+    id: 'R002', class: 'functional', status: 'active',
+    description: 'feature B', why: 'needed', source: 'M001', primary_owner: 'S02',
+    supporting_slices: 'S01', validation: 'test', notes: '', full_content: '',
+    superseded_by: null,
+  });
+  insertRequirement({
+    id: 'R003', class: 'functional', status: 'active',
+    description: 'feature C', why: 'needed', source: 'M001', primary_owner: 'S03',
+    supporting_slices: '', validation: 'test', notes: '', full_content: '',
+    superseded_by: null,
+  });
+
+  // Query scoped to S01 — should get R001 (primary) and R002 (supporting)
+  const s01Reqs = queryRequirements({ sliceId: 'S01' });
+  assertEq(s01Reqs.length, 2, 'S01 requirements should be 2 (primary + supporting)');
+  const ids = s01Reqs.map(r => r.id).sort();
+  assertEq(ids, ['R001', 'R002'], 'S01 owns R001 and supports R002');
+
+  // Unscoped query returns all 3
+  const allReqs = queryRequirements();
+  assertEq(allReqs.length, 3, 'unscoped requirements should return all 3');
+
+  // Format and verify wrapping
+  const formatted = formatRequirementsForPrompt(s01Reqs);
+  assertTrue(formatted.length > 0, 'formatted requirements should be non-empty');
+  assertMatch(formatted, /### R001/, 'formatted requirements include R001');
+  assertMatch(formatted, /### R002/, 'formatted requirements include R002');
+  assertNoMatch(formatted, /### R003/, 'formatted requirements exclude R003');
+
+  // Verify the expected wrapper format that inlineRequirementsFromDb would produce
+  const wrapped = `### Requirements\nSource: \`.gsd/REQUIREMENTS.md\`\n\n${formatted}`;
+  assertMatch(wrapped, /^### Requirements/, 'wrapped requirements start with ### Requirements');
+  assertMatch(wrapped, /Source:.*REQUIREMENTS\.md/, 'wrapped requirements have source path');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// prompt-db: DB-aware project helper returns content from DB
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== prompt-db: project content from DB ===');
+{
+  openDatabase(':memory:');
+
+  insertArtifact({
+    path: 'PROJECT.md',
+    artifact_type: 'project',
+    milestone_id: null,
+    slice_id: null,
+    task_id: null,
+    full_content: '# Test Project\n\nThis is the project description.',
+  });
+
+  const content = queryProject();
+  assertEq(content, '# Test Project\n\nThis is the project description.', 'queryProject returns content');
+
+  // Verify the expected wrapper format that inlineProjectFromDb would produce
+  const wrapped = `### Project\nSource: \`.gsd/PROJECT.md\`\n\n${content}`;
+  assertMatch(wrapped, /^### Project/, 'wrapped project starts with ### Project');
+  assertMatch(wrapped, /Source:.*PROJECT\.md/, 'wrapped project has source path');
+  assertMatch(wrapped, /# Test Project/, 'wrapped project includes content');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// prompt-db: fallback when DB unavailable
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== prompt-db: fallback when DB unavailable ===');
+{
+  closeDatabase();
+  assertTrue(!isDbAvailable(), 'DB should not be available');
+
+  // queryDecisions returns [] when DB closed — helper would fall back
+  const decisions = queryDecisions({ milestoneId: 'M001' });
+  assertEq(decisions, [], 'queryDecisions returns [] when DB closed');
+
+  // queryRequirements returns [] when DB closed — helper would fall back
+  const requirements = queryRequirements({ sliceId: 'S01' });
+  assertEq(requirements, [], 'queryRequirements returns [] when DB closed');
+
+  // queryProject returns null when DB closed — helper would fall back
+  const project = queryProject();
+  assertEq(project, null, 'queryProject returns null when DB closed');
+
+  // formatDecisionsForPrompt returns '' for empty input
+  const formatted = formatDecisionsForPrompt([]);
+  assertEq(formatted, '', 'formatDecisionsForPrompt returns empty for empty input');
+
+  // formatRequirementsForPrompt returns '' for empty input
+  const formattedReqs = formatRequirementsForPrompt([]);
+  assertEq(formattedReqs, '', 'formatRequirementsForPrompt returns empty for empty input');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// prompt-db: scoped filtering reduces content vs unscoped
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== prompt-db: scoped filtering reduces content ===');
+{
+  openDatabase(':memory:');
+
+  // Insert 10 decisions across 3 milestones
+  for (let i = 1; i <= 10; i++) {
+    const milestoneNum = ((i - 1) % 3) + 1;
+    insertDecision({
+      id: `D${String(i).padStart(3, '0')}`,
+      when_context: `M00${milestoneNum}/S01`,
+      scope: 'architecture',
+      decision: `decision ${i} with some lengthy description for token measurement`,
+      choice: `choice ${i}`,
+      rationale: `rationale ${i} with additional context`,
+      revisable: 'yes',
+      superseded_by: null,
+    });
+  }
+
+  const allDecisions = queryDecisions();
+  const m001Decisions = queryDecisions({ milestoneId: 'M001' });
+
+  assertEq(allDecisions.length, 10, 'unscoped returns all 10 decisions');
+  assertTrue(m001Decisions.length < 10, `M001-scoped returns fewer than 10 (got ${m001Decisions.length})`);
+  assertTrue(m001Decisions.length > 0, 'M001-scoped returns at least 1');
+
+  // Format both and compare sizes — scoped should be shorter
+  const allFormatted = formatDecisionsForPrompt(allDecisions);
+  const scopedFormatted = formatDecisionsForPrompt(m001Decisions);
+
+  assertTrue(
+    scopedFormatted.length < allFormatted.length,
+    `scoped content (${scopedFormatted.length} chars) should be shorter than unscoped (${allFormatted.length} chars)`,
+  );
+
+  // Insert requirements across 4 slices
+  for (let i = 1; i <= 8; i++) {
+    const sliceNum = ((i - 1) % 4) + 1;
+    insertRequirement({
+      id: `R${String(i).padStart(3, '0')}`,
+      class: 'functional',
+      status: 'active',
+      description: `requirement ${i} with detailed description`,
+      why: `justification ${i}`,
+      source: 'M001',
+      primary_owner: `S0${sliceNum}`,
+      supporting_slices: '',
+      validation: `validation ${i}`,
+      notes: '',
+      full_content: '',
+      superseded_by: null,
+    });
+  }
+
+  const allReqs = queryRequirements();
+  const s01Reqs = queryRequirements({ sliceId: 'S01' });
+
+  assertEq(allReqs.length, 8, 'unscoped returns all 8 requirements');
+  assertTrue(s01Reqs.length < 8, `S01-scoped returns fewer than 8 (got ${s01Reqs.length})`);
+  assertTrue(s01Reqs.length > 0, 'S01-scoped returns at least 1');
+
+  const allReqsFormatted = formatRequirementsForPrompt(allReqs);
+  const scopedReqsFormatted = formatRequirementsForPrompt(s01Reqs);
+
+  assertTrue(
+    scopedReqsFormatted.length < allReqsFormatted.length,
+    `scoped requirements (${scopedReqsFormatted.length} chars) should be shorter than unscoped (${allReqsFormatted.length} chars)`,
+  );
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// prompt-db: DB helpers produce correct wrapper format
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== prompt-db: DB helpers wrapper format matches expected pattern ===');
+{
+  openDatabase(':memory:');
+
+  insertDecision({
+    id: 'D001', when_context: 'M001/S01', scope: 'architecture',
+    decision: 'use SQLite', choice: 'better-sqlite3', rationale: 'fast',
+    revisable: 'yes', superseded_by: null,
+  });
+
+  insertRequirement({
+    id: 'R001', class: 'functional', status: 'active',
+    description: 'persist decisions', why: 'memory', source: 'M001',
+    primary_owner: 'S01', supporting_slices: '', validation: 'test',
+    notes: '', full_content: '', superseded_by: null,
+  });
+
+  insertArtifact({
+    path: 'PROJECT.md',
+    artifact_type: 'project',
+    milestone_id: null,
+    slice_id: null,
+    task_id: null,
+    full_content: '# Project Name\n\nDescription.',
+  });
+
+  // Simulate what inlineDecisionsFromDb does
+  const decisions = queryDecisions({ milestoneId: 'M001' });
+  assertTrue(decisions.length === 1, 'got 1 decision for M001');
+  const dFormatted = formatDecisionsForPrompt(decisions);
+  const dWrapped = `### Decisions\nSource: \`.gsd/DECISIONS.md\`\n\n${dFormatted}`;
+  assertMatch(dWrapped, /^### Decisions\nSource: `.gsd\/DECISIONS\.md`\n\n\| #/, 'decisions wrapper format correct');
+
+  // Simulate what inlineRequirementsFromDb does
+  const reqs = queryRequirements({ sliceId: 'S01' });
+  assertTrue(reqs.length === 1, 'got 1 requirement for S01');
+  const rFormatted = formatRequirementsForPrompt(reqs);
+  const rWrapped = `### Requirements\nSource: \`.gsd/REQUIREMENTS.md\`\n\n${rFormatted}`;
+  assertMatch(rWrapped, /^### Requirements\nSource: `.gsd\/REQUIREMENTS\.md`\n\n### R001/, 'requirements wrapper format correct');
+
+  // Simulate what inlineProjectFromDb does
+  const project = queryProject();
+  assertTrue(project !== null, 'project content exists');
+  const pWrapped = `### Project\nSource: \`.gsd/PROJECT.md\`\n\n${project}`;
+  assertMatch(pWrapped, /^### Project\nSource: `.gsd\/PROJECT\.md`\n\n# Project Name/, 'project wrapper format correct');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// prompt-db: re-import updates DB when source markdown changes
+// ═══════════════════════════════════════════════════════════════════════════
+
+import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { migrateFromMarkdown } from '../md-importer.ts';
+
+console.log('\n=== prompt-db: re-import updates DB when source markdown changes ===');
+{
+  // Create a temp dir simulating a project with .gsd/DECISIONS.md
+  const tmpDir = mkdtempSync(join(tmpdir(), 'prompt-db-reimport-'));
+  const gsdDir = join(tmpDir, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  // Write initial DECISIONS.md with 2 decisions
+  const initialDecisions = `# Decisions Register
+
+| # | When | Scope | Decision | Choice | Rationale | Revisable? |
+|---|------|-------|----------|--------|-----------|------------|
+| D001 | M001/S01 | architecture | use SQLite | better-sqlite3 | fast and embedded | yes |
+| D002 | M001/S01 | tooling | use vitest | vitest | modern test runner | yes |
+`;
+  writeFileSync(join(gsdDir, 'DECISIONS.md'), initialDecisions);
+
+  // Open in-memory DB and do initial import
+  openDatabase(':memory:');
+  migrateFromMarkdown(tmpDir);
+
+  // Verify initial state: 2 decisions
+  const initial = queryDecisions();
+  assertEq(initial.length, 2, 're-import: initial import has 2 decisions');
+  const initialIds = initial.map(d => d.id).sort();
+  assertEq(initialIds, ['D001', 'D002'], 're-import: initial decisions are D001, D002');
+
+  // Now "the LLM modifies DECISIONS.md" — add a third decision
+  const updatedDecisions = `# Decisions Register
+
+| # | When | Scope | Decision | Choice | Rationale | Revisable? |
+|---|------|-------|----------|--------|-----------|------------|
+| D001 | M001/S01 | architecture | use SQLite | better-sqlite3 | fast and embedded | yes |
+| D002 | M001/S01 | tooling | use vitest | vitest | modern test runner | yes |
+| D003 | M001/S02 | runtime | dynamic imports | D014 pattern | lazy loading | yes |
+`;
+  writeFileSync(join(gsdDir, 'DECISIONS.md'), updatedDecisions);
+
+  // Re-import (simulating what handleAgentEnd does)
+  migrateFromMarkdown(tmpDir);
+
+  // Verify DB now has 3 decisions
+  const afterReimport = queryDecisions();
+  assertEq(afterReimport.length, 3, 're-import: after re-import has 3 decisions');
+  const afterIds = afterReimport.map(d => d.id).sort();
+  assertEq(afterIds, ['D001', 'D002', 'D003'], 're-import: decisions are D001, D002, D003');
+
+  // Verify the new decision has correct data
+  const d003 = afterReimport.find(d => d.id === 'D003');
+  assertTrue(d003 !== undefined, 're-import: D003 exists');
+  assertEq(d003!.when_context, 'M001/S02', 're-import: D003 when_context is M001/S02');
+  assertEq(d003!.scope, 'runtime', 're-import: D003 scope is runtime');
+  assertEq(d003!.choice, 'D014 pattern', 're-import: D003 choice is D014 pattern');
+
+  // Verify scoped query picks up the new decision
+  const m001Scoped = queryDecisions({ milestoneId: 'M001' });
+  assertTrue(m001Scoped.length === 3, 're-import: all 3 decisions are for M001');
+
+  closeDatabase();
+}
+
+// ─── Final Report ──────────────────────────────────────────────────────────
+report();

package/src/resources/extensions/gsd/tests/remote-questions.test.ts

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { parseSlackReply, parseDiscordResponse, formatForDiscord } from "../../remote-questions/format.ts";
+import { parseSlackReply, parseDiscordResponse, formatForDiscord, formatForSlack, parseSlackReactionResponse, formatForTelegram, parseTelegramResponse } from "../../remote-questions/format.ts";
 import { resolveRemoteConfig, isValidChannelId } from "../../remote-questions/config.ts";
 import { sanitizeError } from "../../remote-questions/manager.ts";
 
@@ -94,6 +94,21 @@ test("parseDiscordResponse rejects multi-question reaction parsing", () => {
   assert.match(String(result.answers.second.user_note), /single-question prompts/i);
 });
 
+test("parseSlackReactionResponse handles single-question reactions", () => {
+  const result = parseSlackReactionResponse(["two"], [{
+    id: "choice",
+    header: "Choice",
+    question: "Pick one",
+    allowMultiple: false,
+    options: [
+      { label: "Alpha", description: "A" },
+      { label: "Beta", description: "B" },
+    ],
+  }]);
+
+  assert.deepEqual(result, { answers: { choice: { answers: ["Beta"] } } });
+});
+
 test("parseSlackReply truncates user_note longer than 500 chars", () => {
   const longText = "x".repeat(600);
   const result = parseSlackReply(longText, [{
@@ -189,6 +204,65 @@ test("formatForDiscord includes context source in footer when present", () => {
   assert.ok(embeds[0].footer?.text.includes("auto-mode-dispatch"), "footer should include context source");
 });
 
+test("formatForSlack includes context source when present", () => {
+  const blocks = formatForSlack({
+    id: "slack-1",
+    channel: "slack",
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    context: { source: "ask_user_questions" },
+    questions: [{
+      id: "q1",
+      header: "Confirm",
+      question: "Proceed?",
+      options: [
+        { label: "Yes", description: "Continue" },
+        { label: "No", description: "Stop" },
+      ],
+      allowMultiple: false,
+    }],
+  });
+
+  const sourceBlock = blocks.find((block) => block.type === "context" && block.elements?.some((el) => el.text.includes("Source:")));
+  assert.ok(sourceBlock, "Slack blocks should include a context source block");
+});
+
+test("formatForSlack multi-question prompts explain semicolon and newline reply format", () => {
+  const blocks = formatForSlack({
+    id: "slack-2",
+    channel: "slack",
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [
+      {
+        id: "q1",
+        header: "First",
+        question: "Pick one",
+        options: [
+          { label: "Alpha", description: "A" },
+          { label: "Beta", description: "B" },
+        ],
+        allowMultiple: false,
+      },
+      {
+        id: "q2",
+        header: "Second",
+        question: "Explain",
+        options: [
+          { label: "Gamma", description: "G" },
+          { label: "Delta", description: "D" },
+        ],
+        allowMultiple: false,
+      },
+    ],
+  });
+
+  const instructionBlock = blocks.find((block) => block.type === "context" && block.elements?.some((el) => el.text.includes("one line per question")));
+  assert.ok(instructionBlock, "Slack multi-question prompts should explain one-line or semicolon reply format");
+});
+
 test("formatForDiscord omits source from footer when context is absent", () => {
   const prompt = {
     id: "test-2",
@@ -356,6 +430,27 @@ test("DiscordAdapter source-level: acknowledgeAnswer method exists", () => {
   assert.ok(adapterSrc.includes("✅"), "should use checkmark emoji for acknowledgement");
 });
 
+test("SlackAdapter source-level: supports reaction polling and acknowledgement", () => {
+  const adapterSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "slack-adapter.ts"),
+    "utf-8",
+  );
+  assert.ok(adapterSrc.includes("reactions.get"), "should poll Slack reactions");
+  assert.ok(adapterSrc.includes("reactions.add"), "should add Slack reactions");
+  assert.ok(adapterSrc.includes("async acknowledgeAnswer"), "should acknowledge Slack answers");
+  assert.ok(adapterSrc.includes("white_check_mark"), "should use a checkmark acknowledgement reaction");
+});
+
+test("Slack setup source-level: offers channel picker with manual fallback", () => {
+  const commandSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "remote-command.ts"),
+    "utf-8",
+  );
+  assert.ok(commandSrc.includes("users.conversations"), "Slack setup should query Slack channels");
+  assert.ok(commandSrc.includes("Select a Slack channel"), "Slack setup should present a channel picker");
+  assert.ok(commandSrc.includes("Enter channel ID manually"), "Slack setup should preserve manual fallback");
+});
+
 test("DiscordAdapter source-level: resolves guild ID for message URLs", () => {
   const adapterSrc = readFileSync(
     join(__dirname, "..", "..", "remote-questions", "discord-adapter.ts"),
@@ -369,6 +464,172 @@ test("DiscordAdapter source-level: resolves guild ID for message URLs", () => {
   );
 });
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Telegram Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("formatForTelegram single-question produces inline keyboard", () => {
+  const prompt = {
+    id: "tg-1",
+    channel: "telegram" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [{
+      id: "q1",
+      header: "Confirm",
+      question: "Proceed?",
+      options: [
+        { label: "Yes", description: "Continue" },
+        { label: "No", description: "Stop" },
+      ],
+      allowMultiple: false,
+    }],
+  };
+
+  const msg = formatForTelegram(prompt);
+  assert.equal(msg.parse_mode, "HTML");
+  assert.ok(msg.text.includes("<b>GSD needs your input</b>"));
+  assert.ok(msg.text.includes("<b>Confirm</b>"));
+  assert.ok(msg.reply_markup, "single-question should have inline keyboard");
+  assert.equal(msg.reply_markup!.inline_keyboard.length, 2, "should have 2 button rows");
+  assert.equal(msg.reply_markup!.inline_keyboard[0][0].callback_data, "tg-1:0");
+  assert.equal(msg.reply_markup!.inline_keyboard[1][0].callback_data, "tg-1:1");
+});
+
+test("formatForTelegram multi-question omits inline keyboard", () => {
+  const prompt = {
+    id: "tg-2",
+    channel: "telegram" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [
+      {
+        id: "q1",
+        header: "First",
+        question: "Pick",
+        options: [{ label: "A", description: "a" }],
+        allowMultiple: false,
+      },
+      {
+        id: "q2",
+        header: "Second",
+        question: "Pick",
+        options: [{ label: "B", description: "b" }],
+        allowMultiple: false,
+      },
+    ],
+  };
+
+  const msg = formatForTelegram(prompt);
+  assert.equal(msg.reply_markup, undefined, "multi-question should not have inline keyboard");
+  assert.ok(msg.text.includes("1/2"), "should show question position");
+  assert.ok(msg.text.includes("2/2"), "should show question position");
+});
+
+test("formatForTelegram escapes HTML in user content", () => {
+  const prompt = {
+    id: "tg-3",
+    channel: "telegram" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [{
+      id: "q1",
+      header: "Test <script>",
+      question: "Is 5 > 3 & 2 < 4?",
+      options: [{ label: "<b>Yes</b>", description: "it's true" }],
+      allowMultiple: false,
+    }],
+  };
+
+  const msg = formatForTelegram(prompt);
+  assert.ok(msg.text.includes("&lt;script&gt;"), "should escape < > in header");
+  assert.ok(msg.text.includes("5 &gt; 3 &amp; 2 &lt; 4"), "should escape in question");
+  assert.ok(msg.text.includes("&lt;b&gt;Yes&lt;/b&gt;"), "should escape in option label");
+});
+
+test("parseTelegramResponse handles callback_data button press", () => {
+  const questions = [{
+    id: "choice",
+    header: "Pick",
+    question: "Choose",
+    allowMultiple: false,
+    options: [
+      { label: "Alpha", description: "A" },
+      { label: "Beta", description: "B" },
+    ],
+  }];
+
+  const result = parseTelegramResponse("prompt-123:1", null, questions, "prompt-123");
+  assert.deepEqual(result, { answers: { choice: { answers: ["Beta"] } } });
+});
+
+test("parseTelegramResponse handles text reply delegation", () => {
+  const questions = [{
+    id: "choice",
+    header: "Pick",
+    question: "Choose",
+    allowMultiple: false,
+    options: [
+      { label: "Alpha", description: "A" },
+      { label: "Beta", description: "B" },
+    ],
+  }];
+
+  const result = parseTelegramResponse(null, "1", questions, "prompt-123");
+  assert.deepEqual(result, { answers: { choice: { answers: ["Alpha"] } } });
+});
+
+test("parseTelegramResponse handles multi-question semicolons", () => {
+  const questions = [
+    {
+      id: "first",
+      header: "First",
+      question: "Pick",
+      allowMultiple: false,
+      options: [
+        { label: "Alpha", description: "A" },
+        { label: "Beta", description: "B" },
+      ],
+    },
+    {
+      id: "second",
+      header: "Second",
+      question: "Pick",
+      allowMultiple: false,
+      options: [
+        { label: "Gamma", description: "G" },
+        { label: "Delta", description: "D" },
+      ],
+    },
+  ];
+
+  const result = parseTelegramResponse(null, "2;1", questions, "prompt-123");
+  assert.deepEqual(result.answers.first.answers, ["Beta"]);
+  assert.deepEqual(result.answers.second.answers, ["Gamma"]);
+});
+
+test("isValidChannelId validates Telegram chat IDs", () => {
+  // Valid positive ID
+  assert.equal(isValidChannelId("telegram", "12345"), true);
+  // Valid negative group ID
+  assert.equal(isValidChannelId("telegram", "-1001234567890"), true);
+  // Too short
+  assert.equal(isValidChannelId("telegram", "1234"), false);
+  // Non-numeric
+  assert.equal(isValidChannelId("telegram", "abc12345"), false);
+  // URL injection
+  assert.equal(isValidChannelId("telegram", "https://evil.com"), false);
+});
+
+test("sanitizeError strips Telegram bot token patterns", () => {
+  const fakeToken = "1234567890:ABCdefGHIjklMNOpqrSTUvwxyz12345678";
+  const result = sanitizeError(`Token: ${fakeToken}`);
+  assert.ok(!result.includes("1234567890:ABC"), "should strip Telegram bot token");
+});
+
 test("DiscordAdapter source-level: sendPrompt sets threadUrl in ref", () => {
   const adapterSrc = readFileSync(
     join(__dirname, "..", "..", "remote-questions", "discord-adapter.ts"),