agent-bober 0.17.1 → 0.19.0

package/dist/telegram/handlers/approvals.js

@@ -0,0 +1,122 @@
+/**
+ * handlers/approvals.ts — Resolve pending disk-marker checkpoints from Telegram
+ * inline-keyboard taps. Writes the SAME markers as src/cli/commands/{approve,reject}.ts.
+ * No new approval mechanism (nonGoal #1). Replies returned as strings → sendSafe.
+ *
+ * Multi-turn Adjust/Reject: tapping the button stashes {action, checkpointId} in the
+ * ephemeral per-chat pending-callback map; the NEXT plain-text message from that chat
+ * resolves it (handleApprovalFollowup). The stash lives only in process memory — no disk.
+ *
+ * grammy is NOT imported here — this module speaks the neutral types from keyboard.ts
+ * (principles.md:28,41).
+ */
+import { isAllowed } from "../whitelist.js";
+import { deletePending, pendingExists, saveApproved, saveRejected, } from "../../state/approval-state.js";
+import { decodeCallback } from "../keyboard.js";
+export function createPendingState() {
+    return new Map();
+}
+// ── Button tap (callback_query) ────────────────────────────────────────────
+/**
+ * Handle a button tap from an inline-keyboard approval message.
+ *
+ * Returns:
+ *   reply  — text to send back via sendSafe (null = nothing to send)
+ *   answer — text for answerCallbackQuery (always present to dismiss the spinner)
+ *
+ * Guard chain (mirrors approve.ts:44):
+ *   1. Whitelist re-check on the CALLBACK sender id (sc-4-5).
+ *   2. pendingExists guard — write NOTHING if no .pending.json (sc-4-4).
+ *   3. Approve  → saveApproved {approvedAt, approverId}; editDelta key ABSENT.
+ *   4. Adjust   → stash in pending map; return prompt for replacement text.
+ *   5. Reject   → stash in pending map; return prompt for feedback text.
+ */
+export async function handleApprovalCallback(args) {
+    // 1. Whitelist re-check on the callback sender id (sc-4-5)
+    if (!isAllowed(args.senderId, args.allowed)) {
+        return { reply: null, answer: "Denied" };
+    }
+    const decoded = decodeCallback(args.data);
+    if (!decoded) {
+        return { reply: null, answer: "Unknown" };
+    }
+    // 2. No-pending guard (mirror approve.ts:44 — write NOTHING; sc-4-4)
+    if (!(await pendingExists(args.projectRoot, decoded.checkpointId))) {
+        return { reply: `No pending checkpoint: ${decoded.checkpointId}`, answer: "Gone" };
+    }
+    const now = args.now ?? (() => new Date().toISOString());
+    if (decoded.action === "approve") {
+        // Plain Approve: editDelta key MUST be absent (byte-identical to approve.ts:68-72)
+        const m = {
+            approvedAt: now(),
+            approverId: String(args.senderId),
+        };
+        await saveApproved(args.projectRoot, decoded.checkpointId, m);
+        await deletePending(args.projectRoot, decoded.checkpointId);
+        return { reply: `Approved ${decoded.checkpointId}`, answer: "Approved" };
+    }
+    // confirm/cancel are upload opt-in actions (Sprint 5) — not handled here.
+    // The poll loop routes them to handleUploadCallback before reaching this handler,
+    // but guard defensively so the type narrows to "adjust" | "reject" below.
+    if (decoded.action === "confirm" || decoded.action === "cancel") {
+        return { reply: null, answer: "Unknown" };
+    }
+    // Adjust / Reject: stash and await the next text message from this chat
+    args.pending.set(args.chatId, {
+        action: decoded.action,
+        checkpointId: decoded.checkpointId,
+    });
+    return {
+        reply: decoded.action === "adjust"
+            ? "Send the replacement text."
+            : "Send rejection feedback.",
+        answer: "OK",
+    };
+}
+// ── Follow-up text resolves a stashed Adjust/Reject ───────────────────────
+/**
+ * Check whether the incoming plain-text message is a follow-up to a stashed
+ * Adjust or Reject tap. If so, resolves it and returns a reply string.
+ * Returns null when there is no stash for this chat — the caller falls through
+ * to normal text routing (capture / command dispatch).
+ *
+ * Key invariants:
+ *   - Adjust follow-up writes ApprovedMarker with editDelta = text.
+ *   - Reject follow-up writes RejectedMarker with rejecterId (NOT rejectorId).
+ *   - Both call deletePending after a successful write.
+ *   - Non-whitelisted sender: belt-and-suspenders return null without deleting stash
+ *     (the outer loop already blocks non-whitelisted messages).
+ */
+export async function handleApprovalFollowup(args) {
+    const stash = args.pending.get(args.chatId);
+    if (!stash)
+        return null;
+    // Belt-and-suspenders: outer loop already guards, but check here too
+    if (!isAllowed(args.senderId, args.allowed))
+        return null;
+    args.pending.delete(args.chatId);
+    if (!(await pendingExists(args.projectRoot, stash.checkpointId))) {
+        return `No pending checkpoint: ${stash.checkpointId}`;
+    }
+    const now = args.now ?? (() => new Date().toISOString());
+    if (stash.action === "adjust") {
+        const m = {
+            approvedAt: now(),
+            approverId: String(args.senderId),
+            editDelta: args.text,
+        };
+        await saveApproved(args.projectRoot, stash.checkpointId, m);
+        await deletePending(args.projectRoot, stash.checkpointId);
+        return `Adjusted + approved ${stash.checkpointId}`;
+    }
+    // reject
+    const m = {
+        rejectedAt: now(),
+        rejecterId: String(args.senderId),
+        feedback: args.text,
+    };
+    await saveRejected(args.projectRoot, stash.checkpointId, m);
+    await deletePending(args.projectRoot, stash.checkpointId);
+    return `Rejected ${stash.checkpointId}`;
+}
+//# sourceMappingURL=approvals.js.map

package/dist/telegram/handlers/approvals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approvals.js","sourceRoot":"","sources":["../../../src/telegram/handlers/approvals.ts"],"names":[],"mappings":"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"}

package/dist/telegram/handlers/capture.d.ts

@@ -0,0 +1,43 @@
+/**
+ * handlers/capture.ts — Route whitelisted plain text into the task inbox (zero-friction).
+ * No side effects in the handler itself — the inbox sink is injected so unit tests
+ * can pass a fake with no FactStore.
+ */
+/**
+ * Injected inbox sink.
+ * Production default: opens a FactStore and persists via captureTask.
+ * Tests: pass a fake that records calls without touching the filesystem.
+ */
+export type InboxCapture = (text: string) => Promise<{
+    id?: string;
+    title: string;
+}>;
+/**
+ * Production InboxCapture implementation.
+ * Opens a FactStore for the current project, stamps wall-clock time at
+ * this boundary (captureTask is PURE — never calls Date.now()), persists
+ * the task via captureTask, then closes the store.
+ *
+ * Per the hybrid rule in the briefing: captureTask IS exported from
+ * src/hub/task-inbox.ts, so we import it directly (Option A).
+ *
+ * bober: opens a new FactStore per capture message; swap for a long-lived
+ *        store + connection pool if bot throughput grows beyond a few
+ *        messages per second.
+ */
+export declare function defaultCapture(text: string): Promise<{
+    id?: string;
+    title: string;
+}>;
+/**
+ * Capture `text` as one open task and return a one-line confirmation.
+ *
+ * Zero-friction: the raw message text becomes the task title verbatim.
+ * The handler NEVER prompts for a due date, domain, or any other field
+ * before capturing (nonGoal #3, evaluatorNotes).
+ *
+ * The confirmation string always contains the captured title (sc-2-3).
+ * Callers pass the reply to sendSafe — this function has no transport access.
+ */
+export declare function handleCapture(text: string, capture: InboxCapture): Promise<string>;
+//# sourceMappingURL=capture.d.ts.map

package/dist/telegram/handlers/capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../../src/telegram/handlers/capture.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAIrF;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAW1F;AAID;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAGxF"}

package/dist/telegram/handlers/capture.js

@@ -0,0 +1,51 @@
+/**
+ * handlers/capture.ts — Route whitelisted plain text into the task inbox (zero-friction).
+ * No side effects in the handler itself — the inbox sink is injected so unit tests
+ * can pass a fake with no FactStore.
+ */
+import { captureTask } from "../../hub/task-inbox.js";
+import { FactStore, factsDbPath, ensureFactsDir } from "../../state/facts.js";
+import { findProjectRoot } from "../../utils/fs.js";
+// ── defaultCapture ────────────────────────────────────────────────────
+/**
+ * Production InboxCapture implementation.
+ * Opens a FactStore for the current project, stamps wall-clock time at
+ * this boundary (captureTask is PURE — never calls Date.now()), persists
+ * the task via captureTask, then closes the store.
+ *
+ * Per the hybrid rule in the briefing: captureTask IS exported from
+ * src/hub/task-inbox.ts, so we import it directly (Option A).
+ *
+ * bober: opens a new FactStore per capture message; swap for a long-lived
+ *        store + connection pool if bot throughput grows beyond a few
+ *        messages per second.
+ */
+export async function defaultCapture(text) {
+    const projectRoot = (await findProjectRoot()) ?? process.cwd();
+    await ensureFactsDir(projectRoot); // namespace omitted → default pool (.bober/memory/)
+    const now = new Date().toISOString(); // clock at boundary — NEVER inside captureTask
+    const store = new FactStore(factsDbPath(projectRoot));
+    try {
+        const f = await captureTask(store, text, { now }); // domain omitted → "inbox" pool
+        return { id: f.id, title: f.title };
+    }
+    finally {
+        store.close();
+    }
+}
+// ── handleCapture ─────────────────────────────────────────────────────
+/**
+ * Capture `text` as one open task and return a one-line confirmation.
+ *
+ * Zero-friction: the raw message text becomes the task title verbatim.
+ * The handler NEVER prompts for a due date, domain, or any other field
+ * before capturing (nonGoal #3, evaluatorNotes).
+ *
+ * The confirmation string always contains the captured title (sc-2-3).
+ * Callers pass the reply to sendSafe — this function has no transport access.
+ */
+export async function handleCapture(text, capture) {
+    const { title, id } = await capture(text);
+    return id !== undefined ? `Captured: ${title} (#${id})` : `Captured: ${title}`;
+}
+//# sourceMappingURL=capture.js.map

package/dist/telegram/handlers/capture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.js","sourceRoot":"","sources":["../../../src/telegram/handlers/capture.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAWpD,yEAAyE;AAEzE;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,IAAY;IAC/C,MAAM,WAAW,GAAG,CAAC,MAAM,eAAe,EAAE,CAAC,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAC/D,MAAM,cAAc,CAAC,WAAW,CAAC,CAAC,CAAC,oDAAoD;IACvF,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC,+CAA+C;IACrF,MAAM,KAAK,GAAG,IAAI,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC;IACtD,IAAI,CAAC;QACH,MAAM,CAAC,GAAG,MAAM,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,gCAAgC;QACnF,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;IACtC,CAAC;YAAS,CAAC;QACT,KAAK,CAAC,KAAK,EAAE,CAAC;IAChB,CAAC;AACH,CAAC;AAED,yEAAyE;AAEzE;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,IAAY,EAAE,OAAqB;IACrE,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,OAAO,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,aAAa,KAAK,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,aAAa,KAAK,EAAE,CAAC;AACjF,CAAC"}

package/dist/telegram/handlers/prioritize.d.ts

@@ -0,0 +1,50 @@
+import type { Scope } from "../../hub/scope.js";
+/** Minimal hub-query result. Only title is rendered by this adapter (nonGoal #3). */
+export type HubResult = {
+    title: string;
+};
+/**
+ * Injected hub-query function.
+ * Production default: invokes the hub CLI via execa — the subprocess fully owns
+ * any LLM calls, keeping the adapter thin (nonGoal #5).
+ * Tests: pass a fake returning fixture HubResult objects without any subprocess.
+ */
+export type HubQuery = (scope: Scope) => Promise<HubResult[]>;
+/**
+ * Type alias for the `prioritize` parameter in bot.ts.
+ * Mirrors InboxCapture for the capture parameter.
+ */
+export type PrioritizeFn = HubQuery;
+/**
+ * Production HubQuery — invokes the hub CLI in a subprocess via execa.
+ * The subprocess fully owns the LLM and any model calls so the adapter
+ * never constructs an LLM client (nonGoal #5).
+ *
+ * Scope → CLI command mapping:
+ *   general   → node <cli> hub priority
+ *   filtered  → node <cli> hub priority [--due N] [--domain D] [--tag T]
+ *   decision  → node <cli> hub decide "optionA vs optionB"
+ *
+ * Parses `N. <title>` stdout lines into HubResult objects.
+ * Exit code ≠ 0 throws (callers see the error in the Telegram reply via sendSafe).
+ *
+ * bober: one child process per bot command; swap for in-process
+ *        rankFindings + collectFindings if subprocess startup latency
+ *        exceeds acceptable Telegram response time under load.
+ */
+export declare function defaultPrioritize(scope: Scope): Promise<HubResult[]>;
+/**
+ * Handle /today, /priority, and /decide X vs Y commands.
+ *
+ * 1. Parses an ephemeral Scope from (name, args) via parseScopeFromCommand.
+ * 2. Calls the injected hub query with that scope.
+ * 3. Returns a numbered list of finding titles in the hub's returned order.
+ *
+ * ORDER PRESERVED VERBATIM — the hub already ranked the findings;
+ * this adapter must NOT re-sort (nonGoal #1).
+ *
+ * Returns a string for the caller to pass to sendSafe — no transport access here.
+ * Unknown commands (parseScopeFromCommand returns null) return the Unknown-command stub.
+ */
+export declare function handlePrioritize(name: string, args: string, query?: HubQuery): Promise<string>;
+//# sourceMappingURL=prioritize.d.ts.map

package/dist/telegram/handlers/prioritize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prioritize.d.ts","sourceRoot":"","sources":["../../../src/telegram/handlers/prioritize.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAOhD,qFAAqF;AACrF,MAAM,MAAM,SAAS,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;AAE9D;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;AAIpC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CA4C1E;AAID;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,QAA4B,GAClC,OAAO,CAAC,MAAM,CAAC,CAMjB"}

package/dist/telegram/handlers/prioritize.js

@@ -0,0 +1,99 @@
+/**
+ * handlers/prioritize.ts — Scoped hub-priority commands (/today, /priority, /decide X vs Y).
+ *
+ * Pure adapter: parse an ephemeral Scope from the command text, call the injected hub
+ * query, render ranked finding titles through the sendSafe funnel.
+ * No persistence, no LLM reasoning in this module (nonGoal #5: hub owns all model calls).
+ *
+ * The production default (defaultPrioritize) invokes the hub CLI in a subprocess via execa
+ * so the process isolation is complete — the adapter never constructs an LLM client.
+ * Tests pass an injected fake HubQuery to avoid subprocess spawning entirely.
+ */
+import { execa } from "execa";
+import { parseScopeFromCommand } from "../router.js";
+import { findProjectRoot } from "../../utils/fs.js";
+import { resolveCliEntry } from "../../fleet/runner.js";
+// ── defaultPrioritize ─────────────────────────────────────────────────
+/**
+ * Production HubQuery — invokes the hub CLI in a subprocess via execa.
+ * The subprocess fully owns the LLM and any model calls so the adapter
+ * never constructs an LLM client (nonGoal #5).
+ *
+ * Scope → CLI command mapping:
+ *   general   → node <cli> hub priority
+ *   filtered  → node <cli> hub priority [--due N] [--domain D] [--tag T]
+ *   decision  → node <cli> hub decide "optionA vs optionB"
+ *
+ * Parses `N. <title>` stdout lines into HubResult objects.
+ * Exit code ≠ 0 throws (callers see the error in the Telegram reply via sendSafe).
+ *
+ * bober: one child process per bot command; swap for in-process
+ *        rankFindings + collectFindings if subprocess startup latency
+ *        exceeds acceptable Telegram response time under load.
+ */
+export async function defaultPrioritize(scope) {
+    const projectRoot = (await findProjectRoot()) ?? process.cwd();
+    const cliEntry = resolveCliEntry();
+    let cliArgs;
+    if (scope.mode === "decision") {
+        cliArgs = [cliEntry, "hub", "decide", `${scope.optionA} vs ${scope.optionB}`];
+    }
+    else if (scope.mode === "filtered") {
+        cliArgs = [cliEntry, "hub", "priority"];
+        if (scope.dueWithinDays !== undefined) {
+            cliArgs.push("--due", String(scope.dueWithinDays));
+        }
+        if (scope.domain !== undefined) {
+            cliArgs.push("--domain", scope.domain);
+        }
+        if (scope.tag !== undefined) {
+            cliArgs.push("--tag", scope.tag);
+        }
+    }
+    else {
+        // general
+        cliArgs = [cliEntry, "hub", "priority"];
+    }
+    const result = await execa(process.execPath, cliArgs, {
+        cwd: projectRoot,
+        reject: false,
+        all: true,
+    });
+    if (result.exitCode !== 0) {
+        const output = result.all ?? result.stderr ?? "";
+        throw new Error(`hub priority failed (exit ${result.exitCode ?? -1}): ${output.slice(0, 300)}`);
+    }
+    // Parse "N. <title>" lines from stdout — the hub CLI prints exactly this format (hub.ts:152-154).
+    const lines = (result.stdout ?? "").split("\n");
+    const findings = [];
+    for (const line of lines) {
+        const match = /^\d+\.\s(.+)$/.exec(line.trim());
+        if (match)
+            findings.push({ title: match[1].trim() });
+    }
+    return findings;
+}
+// ── handlePrioritize ──────────────────────────────────────────────────
+/**
+ * Handle /today, /priority, and /decide X vs Y commands.
+ *
+ * 1. Parses an ephemeral Scope from (name, args) via parseScopeFromCommand.
+ * 2. Calls the injected hub query with that scope.
+ * 3. Returns a numbered list of finding titles in the hub's returned order.
+ *
+ * ORDER PRESERVED VERBATIM — the hub already ranked the findings;
+ * this adapter must NOT re-sort (nonGoal #1).
+ *
+ * Returns a string for the caller to pass to sendSafe — no transport access here.
+ * Unknown commands (parseScopeFromCommand returns null) return the Unknown-command stub.
+ */
+export async function handlePrioritize(name, args, query = defaultPrioritize) {
+    const scope = parseScopeFromCommand(name, args);
+    if (scope === null)
+        return `Unknown command: /${name}`;
+    const findings = await query(scope);
+    if (findings.length === 0)
+        return "No findings to prioritize.";
+    return findings.map((f, i) => `${i + 1}. ${f.title}`).join("\n");
+}
+//# sourceMappingURL=prioritize.js.map

package/dist/telegram/handlers/prioritize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prioritize.js","sourceRoot":"","sources":["../../../src/telegram/handlers/prioritize.ts"],"names":[],"mappings":"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"}

package/dist/telegram/handlers/upload.d.ts

@@ -0,0 +1,105 @@
+import type { AllowedUsers } from "../whitelist.js";
+/**
+ * Downloads the Telegram file_id to destPath.
+ * Production default: transport.downloadDocument (grammy wired in bot.ts).
+ * Tests: spy that records calls without any network or disk access.
+ */
+export type DownloadFn = (fileId: string, destPath: string) => Promise<void>;
+/**
+ * Hands a LOCAL file path to the existing src/medical ingest path.
+ * Returns a NON-SENSITIVE count — never marker values/names (nonGoal #3).
+ * Production default: defaultMedicalIngest (execa subprocess below).
+ * Tests: spy that returns fixture counts without spawning any subprocess.
+ */
+export type MedicalIngest = (filePath: string) => Promise<{
+    recordsParsed: number;
+    newRows: number;
+}>;
+/**
+ * In-memory stash of pending upload confirmations keyed by uploadId.
+ * Created in the loop, cleared on restart, never written to disk.
+ *
+ * bober: single-process map; extend to a shared Redis key-value store if the bot
+ *        runs across multiple processes (low-probability at current scale).
+ */
+export type PendingUpload = {
+    fileId: string;
+    fileName: string;
+    chatId: number;
+};
+export type PendingUploadState = Map<string, PendingUpload>;
+export declare function createPendingUploadState(): PendingUploadState;
+/**
+ * The LOCAL medical ingest destination disclosed to the user BEFORE confirmation.
+ * Named as a constant so unit tests can assert it is present in the prompt text
+ * without hardcoding the exact string in both the handler and the test.
+ */
+export declare const LOCAL_INGEST_DEST = ".bober/medical (local health store)";
+/**
+ * Build the per-upload opt-in prompt that is shown BEFORE any download.
+ * Must name the local ingest destination and disclose the non-E2E nature of Telegram
+ * so consent is fully informed (sc-5-5).
+ */
+export declare function buildUploadPrompt(fileName: string): string;
+/**
+ * Called when a document message arrives from a whitelisted user.
+ * Stashes the upload in the ephemeral pending map and returns the opt-in prompt.
+ * The file is NOT downloaded at this point — download happens only after Yes (sc-5-2).
+ */
+export declare function registerUpload(args: {
+    uploadId: string;
+    chatId: number;
+    fileId: string;
+    fileName: string;
+    pending: PendingUploadState;
+}): {
+    reply: string;
+};
+/**
+ * Handle a Yes (confirm) or No (cancel) button tap for a pending upload.
+ *
+ * On Yes (confirm):
+ *   1. Look up the stash; consume it (single-shot).
+ *   2. Download the file to a temporary directory via the injected download fn.
+ *   3. Pass the local path to the injected ingest fn exactly once.
+ *   4. Reply with a NON-SENSITIVE count only — never marker values/names (sc-5-5, nonGoal #3).
+ *   5. Remove the temp directory in a finally block (nonGoal #4).
+ *
+ * On No (cancel) or missing stash:
+ *   - Ingest fn is NEVER called (sc-5-4).
+ *   - Download fn is NEVER called.
+ *   - Any ephemeral stash entry is discarded.
+ *
+ * Whitelist re-check on the callback sender id (mirror approvals.ts:63-66, sc-4-5 analog).
+ */
+export declare function handleUploadCallback(args: {
+    senderId: number;
+    allowed: AllowedUsers;
+    data: string;
+    pending: PendingUploadState;
+    download: DownloadFn;
+    ingest: MedicalIngest;
+}): Promise<{
+    reply: string | null;
+    answer: string;
+}>;
+/**
+ * Production MedicalIngest — invokes `agent-bober medical import <filePath>` in a
+ * subprocess via execa. The subprocess runs the full medical pipeline including all
+ * EgressGuard / ConsentGate / AuditLog guardrails, keeping them authoritative in the
+ * child process (nonGoal #5). This mirrors defaultPrioritize in prioritize.ts.
+ *
+ * Parses the non-sensitive count from stdout:
+ *   records parsed: <N>
+ *   new rows:       <M>
+ * (see src/cli/commands/medical.ts:255-257 for the exact format)
+ *
+ * bober: one child process per upload confirmation; swap for in-process
+ *        IngestionNormalizer.importFile() if subprocess startup latency
+ *        exceeds acceptable Telegram response time under load.
+ */
+export declare function defaultMedicalIngest(filePath: string): Promise<{
+    recordsParsed: number;
+    newRows: number;
+}>;
+//# sourceMappingURL=upload.d.ts.map

package/dist/telegram/handlers/upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../../src/telegram/handlers/upload.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAOpD;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAE7E;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAItG;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AACjF,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAE5D,wBAAgB,wBAAwB,IAAI,kBAAkB,CAE7D;AAID;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,wCAAwC,CAAC;AAEvE;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAM1D;AAID;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,kBAAkB,CAAC;CAC7B,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAOpB;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,YAAY,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,kBAAkB,CAAC;IAC5B,QAAQ,EAAE,UAAU,CAAC;IACrB,MAAM,EAAE,aAAa,CAAC;CACvB,GAAG,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAsCpD;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAqBrD"}

package/dist/telegram/handlers/upload.js

@@ -0,0 +1,149 @@
+/**
+ * handlers/upload.ts — Per-upload opt-in gate for document → src/medical ingest.
+ *
+ * Telegram is NOT end-to-end encrypted. A document is NEVER downloaded or passed to
+ * any medical code until the user taps an explicit Yes. The ingest fn and download fn
+ * are INJECTED so tests use spies (no grammy, no network, no real medical pipeline).
+ * grammy stays in bot.ts only (principles.md:28).
+ *
+ * Privacy invariants enforced here:
+ *   - No download before Yes (sc-5-2, sc-5-4).
+ *   - ingest called exactly once on Yes, never on No or no-confirm (sc-5-3, sc-5-4).
+ *   - Post-ingest reply carries only a NON-SENSITIVE integer count (sc-5-5, nonGoal #3).
+ *   - Temp file is always removed in a finally block — no PHI persists on disk (nonGoal #4).
+ *
+ * The existing medical egress/consent guardrails (EgressGuard, ConsentGate, AuditLog)
+ * run inside the subprocess — they are NOT duplicated here (nonGoal #5).
+ */
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execa } from "execa";
+import { isAllowed } from "../whitelist.js";
+import { decodeCallback } from "../keyboard.js";
+import { findProjectRoot } from "../../utils/fs.js";
+import { resolveCliEntry } from "../../fleet/runner.js";
+export function createPendingUploadState() {
+    return new Map();
+}
+// ── Prompt + reply text (sc-5-5) ──────────────────────────────────────
+/**
+ * The LOCAL medical ingest destination disclosed to the user BEFORE confirmation.
+ * Named as a constant so unit tests can assert it is present in the prompt text
+ * without hardcoding the exact string in both the handler and the test.
+ */
+export const LOCAL_INGEST_DEST = ".bober/medical (local health store)";
+/**
+ * Build the per-upload opt-in prompt that is shown BEFORE any download.
+ * Must name the local ingest destination and disclose the non-E2E nature of Telegram
+ * so consent is fully informed (sc-5-5).
+ */
+export function buildUploadPrompt(fileName) {
+    return (`Telegram is not end-to-end encrypted. ` +
+        `Send "${fileName}" to the LOCAL medical ingest (${LOCAL_INGEST_DEST})? ` +
+        `Nothing is processed until you tap Yes.`);
+}
+// ── registerUpload — stash + return prompt (NO download here) ─────────
+/**
+ * Called when a document message arrives from a whitelisted user.
+ * Stashes the upload in the ephemeral pending map and returns the opt-in prompt.
+ * The file is NOT downloaded at this point — download happens only after Yes (sc-5-2).
+ */
+export function registerUpload(args) {
+    args.pending.set(args.uploadId, {
+        fileId: args.fileId,
+        fileName: args.fileName,
+        chatId: args.chatId,
+    });
+    return { reply: buildUploadPrompt(args.fileName) };
+}
+// ── handleUploadCallback — Yes/No resolution ──────────────────────────
+/**
+ * Handle a Yes (confirm) or No (cancel) button tap for a pending upload.
+ *
+ * On Yes (confirm):
+ *   1. Look up the stash; consume it (single-shot).
+ *   2. Download the file to a temporary directory via the injected download fn.
+ *   3. Pass the local path to the injected ingest fn exactly once.
+ *   4. Reply with a NON-SENSITIVE count only — never marker values/names (sc-5-5, nonGoal #3).
+ *   5. Remove the temp directory in a finally block (nonGoal #4).
+ *
+ * On No (cancel) or missing stash:
+ *   - Ingest fn is NEVER called (sc-5-4).
+ *   - Download fn is NEVER called.
+ *   - Any ephemeral stash entry is discarded.
+ *
+ * Whitelist re-check on the callback sender id (mirror approvals.ts:63-66, sc-4-5 analog).
+ */
+export async function handleUploadCallback(args) {
+    // 1. Whitelist re-check on the callback sender id (defense-in-depth)
+    if (!isAllowed(args.senderId, args.allowed)) {
+        return { reply: null, answer: "Denied" };
+    }
+    const decoded = decodeCallback(args.data);
+    if (!decoded) {
+        return { reply: null, answer: "Unknown" };
+    }
+    const up = args.pending.get(decoded.checkpointId);
+    if (!up) {
+        return { reply: "Upload expired or already handled.", answer: "Gone" };
+    }
+    // Single-shot: consume the stash immediately so a duplicate tap is a no-op
+    args.pending.delete(decoded.checkpointId);
+    // No (cancel) → discard; do NOT download or ingest (sc-5-4)
+    if (decoded.action === "cancel") {
+        return { reply: "Discarded — nothing was ingested.", answer: "Cancelled" };
+    }
+    // Yes (confirm) → download then ingest exactly once (sc-5-3)
+    const dir = await mkdtemp(join(tmpdir(), "bober-tg-upload-"));
+    const dest = join(dir, up.fileName);
+    try {
+        await args.download(up.fileId, dest);
+        const { newRows } = await args.ingest(dest);
+        // Reply with a NON-SENSITIVE count only — no marker values/names echoed (sc-5-5, nonGoal #3)
+        return {
+            reply: `Imported ${newRows} results into local medical store.`,
+            answer: "Imported",
+        };
+    }
+    finally {
+        // Always remove the temp dir — no PHI bytes remain on disk after ingest (nonGoal #4)
+        await rm(dir, { recursive: true, force: true });
+    }
+}
+// ── defaultMedicalIngest — execa subprocess (§3b) ─────────────────────
+/**
+ * Production MedicalIngest — invokes `agent-bober medical import <filePath>` in a
+ * subprocess via execa. The subprocess runs the full medical pipeline including all
+ * EgressGuard / ConsentGate / AuditLog guardrails, keeping them authoritative in the
+ * child process (nonGoal #5). This mirrors defaultPrioritize in prioritize.ts.
+ *
+ * Parses the non-sensitive count from stdout:
+ *   records parsed: <N>
+ *   new rows:       <M>
+ * (see src/cli/commands/medical.ts:255-257 for the exact format)
+ *
+ * bober: one child process per upload confirmation; swap for in-process
+ *        IngestionNormalizer.importFile() if subprocess startup latency
+ *        exceeds acceptable Telegram response time under load.
+ */
+export async function defaultMedicalIngest(filePath) {
+    const projectRoot = (await findProjectRoot()) ?? process.cwd();
+    const cliEntry = resolveCliEntry();
+    const r = await execa(process.execPath, [cliEntry, "medical", "import", filePath], {
+        cwd: projectRoot,
+        reject: false,
+        all: true,
+    });
+    if (r.exitCode !== 0) {
+        const out = (r.all ?? "").slice(0, 300);
+        throw new Error(`medical import failed (exit ${r.exitCode ?? -1}): ${out}`);
+    }
+    const parsedMatch = /records parsed:\s*(\d+)/.exec(r.stdout ?? "");
+    const rowsMatch = /new rows:\s*(\d+)/.exec(r.stdout ?? "");
+    return {
+        recordsParsed: parsedMatch ? Number(parsedMatch[1]) : 0,
+        newRows: rowsMatch ? Number(rowsMatch[1]) : 0,
+    };
+}
+//# sourceMappingURL=upload.js.map