hippo-memory 1.56.0 → 1.58.0

package/dist/client.js

@@ -13,6 +13,8 @@
  * Network errors (ECONNREFUSED on a stale pidfile, etc.) propagate as the
  * native fetch failure so the caller can detect them and self-heal.
  */
+/** A write the local server has not answered in this long is stuck; the caller treats it as delivery-unknown. */
+const SERVER_TIMEOUT_MS = 30_000;
 function buildHeaders(apiKey, withBody) {
     const headers = {};
     if (withBody)
@@ -58,6 +60,7 @@ export async function remember(serverUrl, apiKey, opts) {
     const res = await fetch(`${serverUrl}/v1/memories`, {
         method: 'POST',
         headers: buildHeaders(apiKey, true),
+        signal: AbortSignal.timeout(SERVER_TIMEOUT_MS),
         body: JSON.stringify(opts),
     });
     if (!res.ok)
@@ -69,6 +72,7 @@ export async function forget(serverUrl, apiKey, id) {
     const res = await fetch(`${serverUrl}/v1/memories/${encodeURIComponent(id)}`, {
         method: 'DELETE',
         headers: buildHeaders(apiKey, false),
+        signal: AbortSignal.timeout(SERVER_TIMEOUT_MS),
     });
     if (!res.ok)
         await throwForStatus(res);
@@ -79,6 +83,7 @@ export async function promote(serverUrl, apiKey, id) {
     const res = await fetch(`${serverUrl}/v1/memories/${encodeURIComponent(id)}/promote`, {
         method: 'POST',
         headers: buildHeaders(apiKey, false),
+        signal: AbortSignal.timeout(SERVER_TIMEOUT_MS),
     });
     if (!res.ok)
         await throwForStatus(res);
@@ -89,6 +94,7 @@ export async function archiveRaw(serverUrl, apiKey, id, reason) {
     const res = await fetch(`${serverUrl}/v1/memories/${encodeURIComponent(id)}/archive`, {
         method: 'POST',
         headers: buildHeaders(apiKey, true),
+        signal: AbortSignal.timeout(SERVER_TIMEOUT_MS),
         body: JSON.stringify({ reason }),
     });
     if (!res.ok)
@@ -123,6 +129,9 @@ export function classifyTransportFailure(err) {
     }
     if (message.includes('socket hang up') || message.includes('fetch failed'))
         return 'delivery-unknown';
+    // The request was sent and the server went quiet, so it may have committed.
+    if (err.name === 'TimeoutError')
+        return 'delivery-unknown';
     return 'none';
 }
 //# sourceMappingURL=client.js.map

package/dist/codex-patch.js

@@ -1,7 +1,7 @@
 // Files named by a Codex apply_patch call, read the way openai/codex codex-rs/apply-patch reads them
 // (parser.rs for the body, invocation.rs for the shell forms it runs as apply_patch).
 import * as path from 'path';
-import { isStringValue } from './capture.js';
+import { isStringValue } from './capture-contract.js';
 /** Codex prints this line only when a patch applied (apply-patch lib.rs). */
 export const PATCH_SUCCESS_LINE = 'Success. Updated the following files:';
 const BEGIN_PATCH = '*** Begin Patch';

package/dist/compaction-record.d.ts

@@ -2,7 +2,7 @@ import { type DatabaseSyncLike } from './db.js';
 /** PostCompact has 10 s in all (PreCompact 30 s), so a locked store must be given up on early. */
 export declare const COMPACTION_DB_WAIT_MS = 2000;
 /** Tested verbatim: Claude Code hands PreCompact stdout to the summariser as instructions. */
-export declare const PRE_COMPACT_INSTRUCTION = "In your summary, add a last section titled 'Memories for hippo'. List, one per line starting with '- ', each lesson learned, decision made (with its reason) and correction the user gave in this session that should outlive it. Write each as a standalone sentence that names its subject. Leave out anything an earlier summary already listed under 'Memories for hippo'. Write '- none' if nothing new remains.";
+export declare const PRE_COMPACT_INSTRUCTION = "In your summary, add a last section titled 'Memories for hippo'. List, one per line starting with '- ', each lesson learned, decision made (with its reason) and correction the user gave in this session that should outlive it. Write each as a standalone sentence that names its subject. Leave out anything an earlier summary already listed under 'Memories for hippo', and anything this session already saved with `hippo remember`. Write '- none' if nothing new remains.";
 /** Long enough that a live hook has finished with its own record. */
 export declare const REPLAY_AFTER_MS: number;
 /** Claude Code deletes transcripts after 30 days, so an older gap can never be filled. */

package/dist/compaction-record.js

@@ -1,7 +1,8 @@
 // One record per Claude Code compaction, and what turns its summary into kept memories.
 import * as fs from 'fs';
 import * as path from 'path';
-import { errorMessage, isObjectLike, isStringValue, readTranscriptTail, truncateCodePointSafe } from './capture.js';
+import { errorMessage, readTranscriptTail, truncateCodePointSafe } from './capture.js';
+import { isObjectLike, isStringValue } from './capture-contract.js';
 import { compactSummaryBody, parseCompactionItems, selectItemRows } from './compaction-items.js';
 import { loadConfig } from './config.js';
 import { closeHippoDb, isSqliteBusy, openHippoDb } from './db.js';
@@ -14,7 +15,7 @@ import { resolveTenantId } from './tenant.js';
 /** PostCompact has 10 s in all (PreCompact 30 s), so a locked store must be given up on early. */
 export const COMPACTION_DB_WAIT_MS = 2000;
 /** Tested verbatim: Claude Code hands PreCompact stdout to the summariser as instructions. */
-export const PRE_COMPACT_INSTRUCTION = "In your summary, add a last section titled 'Memories for hippo'. List, one per line starting with '- ', each lesson learned, decision made (with its reason) and correction the user gave in this session that should outlive it. Write each as a standalone sentence that names its subject. Leave out anything an earlier summary already listed under 'Memories for hippo'. Write '- none' if nothing new remains.";
+export const PRE_COMPACT_INSTRUCTION = "In your summary, add a last section titled 'Memories for hippo'. List, one per line starting with '- ', each lesson learned, decision made (with its reason) and correction the user gave in this session that should outlive it. Write each as a standalone sentence that names its subject. Leave out anything an earlier summary already listed under 'Memories for hippo', and anything this session already saved with `hippo remember`. Write '- none' if nothing new remains.";
 const SUMMARY_MAX_CHARS = 256 * 1024;
 /** Long enough that a live hook has finished with its own record. */
 export const REPLAY_AFTER_MS = 10 * 60_000;

package/dist/config.d.ts

@@ -145,6 +145,11 @@ export interface HippoConfig {
     deliveryLedger: {
         enabled: boolean;
     };
+    /** Pilot holdout (src/pilot-arm.ts): share of sessions, in basis points 0-10000, that get no memories pushed.
+     *  Default 0 = off. Read from the store the token ledger writes to. */
+    pilot: {
+        holdoutRateBp: number;
+    };
 }
 export declare function loadConfig(hippoRoot: string): HippoConfig;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -88,6 +88,9 @@ const DEFAULT_CONFIG = {
     deliveryLedger: {
         enabled: false,
     },
+    pilot: {
+        holdoutRateBp: 0,
+    },
 };
 function isMemoryValueConfig(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -115,6 +118,19 @@ function deliveryLedgerEnabled(value) {
         `(got ${JSON.stringify(value)}) - using false.`);
     return false;
 }
+// Only an integer 0..10000 counts; anything else warns and turns the pilot off.
+function pilotHoldoutRate(value) {
+    if (value === undefined)
+        return 0;
+    const rate = value?.holdoutRateBp;
+    if (rate === undefined && value !== null && value.constructor === Object)
+        return 0;
+    if (Number.isInteger(rate) && rate >= 0 && rate <= 10000)
+        return rate;
+    console.error(`Warning: config.json's "pilot" must be an object like {"holdoutRateBp": 2000}, an integer from 0 to 10000 ` +
+        `(got ${JSON.stringify(value)}) - using 0 (pilot off).`);
+    return 0;
+}
 function agentMemoryTools(value) {
     if (value === undefined || value === null)
         return null;
@@ -226,6 +242,7 @@ export function loadConfig(hippoRoot) {
             },
             agentMemories: { tools: agentMemoryTools(raw.agentMemories?.tools) },
             deliveryLedger: { enabled: deliveryLedgerEnabled(raw.deliveryLedger) },
+            pilot: { holdoutRateBp: pilotHoldoutRate(raw.pilot) },
         };
     }
     catch (err) {

package/dist/connectors/github/dlq.js

@@ -1,13 +1,16 @@
 import { openHippoDb, closeHippoDb } from '../../db.js';
 import { verifyGitHubSignature } from './signature.js';
 import { isGitHubWebhookEnvelope } from './types.js';
+import { redactPayload, DLQ_REDACTED_NOTE } from '../../secret-detect.js';
 export function writeToDlq(db, opts) {
+    const rawPayload = redactPayload(opts.rawPayload);
+    const redacted = rawPayload !== opts.rawPayload;
     const result = db
         .prepare(`INSERT INTO github_dlq
         (tenant_id, raw_payload, error, event_name, delivery_id, signature,
          installation_id, repo_full_name, received_at, bucket)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(opts.tenantId ?? '__unroutable__', opts.rawPayload, opts.error, opts.eventName ?? null, opts.deliveryId ?? null, opts.signature ?? null, opts.installationId ?? null, opts.repoFullName ?? null, new Date().toISOString(), opts.bucket ?? 'parse_error');
+        .run(opts.tenantId ?? '__unroutable__', rawPayload, redacted ? `${opts.error}; ${DLQ_REDACTED_NOTE}` : opts.error, opts.eventName ?? null, opts.deliveryId ?? null, redacted ? null : opts.signature ?? null, opts.installationId ?? null, opts.repoFullName ?? null, new Date().toISOString(), opts.bucket ?? 'parse_error');
     return Number(result.lastInsertRowid);
 }
 const SELECT_COLUMNS = `id, tenant_id, raw_payload, error, event_name, delivery_id,
@@ -107,7 +110,7 @@ export async function replayDlqEntry(ctx, id, opts = {}) {
                 status: 'sig_missing',
                 memoryId: null,
                 retryCount: row.retryCount,
-                reason: 'legacy row without signature; pass --force to replay',
+                reason: 'row has no signature (legacy, or redacted before storing); pass --force to replay',
             };
         }
         const sigOk = verifyGitHubSignature({

package/dist/connectors/github/octokit-client.js

@@ -10,6 +10,7 @@
  * operator signal, so this code path is now load-bearing.
  */
 import { parseRateLimit } from './ratelimit.js';
+import { fetchWithRetry } from '../../http-retry.js';
 export class GitHubFetchError extends Error {
     status;
     bodyExcerpt;
@@ -42,14 +43,15 @@ function headersToRecord(h) {
     });
     return Object.fromEntries(entries);
 }
+const GITHUB_TIMEOUT_MS = 30_000;
 export const realGitHubFetcher = async ({ url, token }) => {
-    const res = await fetch(url, {
+    const res = await fetchWithRetry(url, {
         headers: {
             Authorization: `Bearer ${token}`,
             Accept: 'application/vnd.github+json',
             'X-GitHub-Api-Version': '2022-11-28',
         },
-    });
+    }, { timeoutMs: GITHUB_TIMEOUT_MS });
     const headers = headersToRecord(res.headers);
     const rateLimit = parseRateLimit(headers, res.status);
     // Codex P1 #4: don't silently turn 401/403/404/500 into empty pages.

package/dist/connectors/github/webhook.d.ts

@@ -0,0 +1,19 @@
+import { type WebhookRequest } from '../../http-util.js';
+/**
+ * GitHub webhook receiver. Mirrors the Slack route shape but with
+ * GitHub-specific idioms:
+ *   1. HMAC SHA-256 over the raw body (X-Hub-Signature-256), no timestamp.
+ *   2. Event type discriminated by the X-GitHub-Event header (not body.type).
+ *   3. X-GitHub-Delivery is required audit metadata (NOT the dedupe seam - see
+ *      computeIdempotencyKey, which folds the signed body into the key so a
+ *      replayed body with a fresh delivery UUID still dedupes).
+ *   4. Tenant resolved by installation.id → github_installations, then by
+ *      repository.full_name → github_repositories (PAT-mode multi-tenant).
+ *   5. ALWAYS ACK 200 on signed envelopes (DLQ included). 401 only on bad
+ *      signature; 404 only when GITHUB_WEBHOOK_SECRET is unset (don't expose
+ *      the route's existence on builds where it's gated off).
+ *
+ * Bearer auth is skipped on purpose: server.ts checks isPublicRoute before calling this.
+ */
+export declare function handleGitHubEventsWebhook({ req, res, opts }: WebhookRequest): Promise<void>;
+//# sourceMappingURL=webhook.d.ts.map

package/dist/connectors/github/webhook.js

@@ -0,0 +1,313 @@
+import { verifyGitHubSignature } from './signature.js';
+import { isGitHubWebhookEnvelope, isGitHubIssueEvent, isGitHubIssueCommentEvent, isGitHubPullRequestEvent, isGitHubPullRequestReviewCommentEvent, } from './types.js';
+import { ingestEvent as ingestGitHubEvent } from './ingest.js';
+import { handleCommentDeleted as handleGitHubCommentDeleted } from './deletion.js';
+import { writeToDlq as writeToGitHubDlq } from './dlq.js';
+import { resolveTenantForGitHub } from './tenant-routing.js';
+import { computeDeletionKey as computeGitHubDeletionKey } from './signature.js';
+import { resolveTenantId } from '../../tenant.js';
+import { openHippoDb, closeHippoDb } from '../../db.js';
+import { adminActor } from '../../api.js';
+import { HttpError, JSON_HEADERS, isHeaderString, readBody, sendJson, } from '../../http-util.js';
+/**
+ * GitHub webhook receiver. Mirrors the Slack route shape but with
+ * GitHub-specific idioms:
+ *   1. HMAC SHA-256 over the raw body (X-Hub-Signature-256), no timestamp.
+ *   2. Event type discriminated by the X-GitHub-Event header (not body.type).
+ *   3. X-GitHub-Delivery is required audit metadata (NOT the dedupe seam - see
+ *      computeIdempotencyKey, which folds the signed body into the key so a
+ *      replayed body with a fresh delivery UUID still dedupes).
+ *   4. Tenant resolved by installation.id → github_installations, then by
+ *      repository.full_name → github_repositories (PAT-mode multi-tenant).
+ *   5. ALWAYS ACK 200 on signed envelopes (DLQ included). 401 only on bad
+ *      signature; 404 only when GITHUB_WEBHOOK_SECRET is unset (don't expose
+ *      the route's existence on builds where it's gated off).
+ *
+ * Bearer auth is skipped on purpose: server.ts checks isPublicRoute before calling this.
+ */
+export async function handleGitHubEventsWebhook({ req, res, opts }) {
+    const rawBody = await readBody(req);
+    const secret = process.env.GITHUB_WEBHOOK_SECRET;
+    if (!secret) {
+        res.writeHead(404, JSON_HEADERS);
+        res.end(JSON.stringify({ error: 'not found' }));
+        return;
+    }
+    const previousSecret = process.env.GITHUB_WEBHOOK_SECRET_PREVIOUS;
+    const sigHdr = req.headers['x-hub-signature-256'];
+    const eventHdr = req.headers['x-github-event'];
+    const deliveryHdr = req.headers['x-github-delivery'];
+    const sigStr = isHeaderString(sigHdr) ? sigHdr : null;
+    const eventName = isHeaderString(eventHdr) ? eventHdr : null;
+    const deliveryId = isHeaderString(deliveryHdr) ? deliveryHdr : null;
+    if (sigStr === null ||
+        !verifyGitHubSignature({
+            rawBody,
+            signature: sigStr,
+            webhookSecret: secret,
+            previousSecret,
+        })) {
+        throw new HttpError(401, 'invalid GitHub signature');
+    }
+    // Signature OK from here on. Everything else is ACK-200; bad envelopes go
+    // to the DLQ and a human can replay later.
+    // Cheap regex extraction of installation_id / repo for DLQ rows that fail
+    // to JSON.parse - gives operators something to triage.
+    const installationFromRaw = (() => {
+        const m = rawBody.match(/"installation"\s*:\s*\{[^}]*"id"\s*:\s*(\d+)/);
+        return m ? m[1] : null;
+    })();
+    const repoFromRaw = (() => {
+        const m = rawBody.match(/"full_name"\s*:\s*"([^"]+)"/);
+        return m ? m[1] : null;
+    })();
+    if (deliveryId === null) {
+        // Body was signed but caller omitted the audit header. Park.
+        const db = openHippoDb(opts.hippoRoot);
+        try {
+            writeToGitHubDlq(db, {
+                tenantId: resolveTenantId({}),
+                rawPayload: rawBody,
+                error: 'missing X-GitHub-Delivery header',
+                bucket: 'parse_error',
+                eventName,
+                deliveryId: null,
+                signature: sigStr,
+                installationId: installationFromRaw,
+                repoFullName: repoFromRaw,
+            });
+        }
+        finally {
+            closeHippoDb(db);
+        }
+        sendJson(res, 200, { ok: true, status: 'dlq' });
+        return;
+    }
+    // Ping fires once at hook creation. Don't ingest, don't DLQ - just pong.
+    if (eventName === 'ping') {
+        sendJson(res, 200, { pong: true });
+        return;
+    }
+    const ALLOWED_EVENTS = new Set([
+        'issues',
+        'issue_comment',
+        'pull_request',
+        'pull_request_review_comment',
+    ]);
+    if (eventName === null || !ALLOWED_EVENTS.has(eventName)) {
+        const db = openHippoDb(opts.hippoRoot);
+        try {
+            writeToGitHubDlq(db, {
+                tenantId: resolveTenantId({}),
+                rawPayload: rawBody,
+                error: `unhandled event: ${eventName ?? '(missing X-GitHub-Event)'}`,
+                bucket: 'unhandled',
+                eventName,
+                deliveryId,
+                signature: sigStr,
+                installationId: installationFromRaw,
+                repoFullName: repoFromRaw,
+            });
+        }
+        finally {
+            closeHippoDb(db);
+        }
+        sendJson(res, 200, { ok: true, status: 'dlq' });
+        return;
+    }
+    let body;
+    try {
+        body = JSON.parse(rawBody);
+    }
+    catch {
+        const db = openHippoDb(opts.hippoRoot);
+        try {
+            writeToGitHubDlq(db, {
+                tenantId: resolveTenantId({}),
+                rawPayload: rawBody,
+                error: 'invalid JSON',
+                bucket: 'parse_error',
+                eventName,
+                deliveryId,
+                signature: sigStr,
+                installationId: installationFromRaw,
+                repoFullName: repoFromRaw,
+            });
+        }
+        finally {
+            closeHippoDb(db);
+        }
+        sendJson(res, 200, { ok: true, status: 'dlq' });
+        return;
+    }
+    if (body === undefined || !isGitHubWebhookEnvelope(body)) {
+        const db = openHippoDb(opts.hippoRoot);
+        try {
+            writeToGitHubDlq(db, {
+                tenantId: resolveTenantId({}),
+                rawPayload: rawBody,
+                error: 'not a GitHub webhook envelope',
+                bucket: 'parse_error',
+                eventName,
+                deliveryId,
+                signature: sigStr,
+                installationId: installationFromRaw,
+                repoFullName: repoFromRaw,
+            });
+        }
+        finally {
+            closeHippoDb(db);
+        }
+        sendJson(res, 200, { ok: true, status: 'dlq' });
+        return;
+    }
+    const installationId = body.installation?.id != null ? String(body.installation.id) : null;
+    const repoFullName = body.repository?.full_name ?? null;
+    // Tenant resolution. Fail closed on multi-tenant installs with unknown
+    // routing - same policy as Slack.
+    let resolvedTenant;
+    {
+        const db = openHippoDb(opts.hippoRoot);
+        try {
+            resolvedTenant = resolveTenantForGitHub(db, {
+                installationId,
+                repoFullName,
+            });
+        }
+        finally {
+            closeHippoDb(db);
+        }
+    }
+    if (resolvedTenant === null) {
+        const db = openHippoDb(opts.hippoRoot);
+        try {
+            writeToGitHubDlq(db, {
+                tenantId: null,
+                rawPayload: rawBody,
+                error: `unroutable: installation_id=${installationId ?? '(none)'} repo=${repoFullName ?? '(none)'}`,
+                bucket: 'unroutable',
+                eventName,
+                deliveryId,
+                signature: sigStr,
+                installationId,
+                repoFullName,
+            });
+        }
+        finally {
+            closeHippoDb(db);
+        }
+        sendJson(res, 200, { ok: true, status: 'dlq' });
+        return;
+    }
+    const ctx = {
+        hippoRoot: opts.hippoRoot,
+        tenantId: resolvedTenant,
+        actor: adminActor('connector:github'),
+    };
+    // Dispatch by event header. Type guards cross-check the body shape against
+    // the header so a payload of one event type cannot satisfy another's guard.
+    if (eventName === 'issues' && isGitHubIssueEvent(body, 'issues')) {
+        if (body.action === 'deleted') {
+            // GitHub does fire issues.deleted (admin-initiated). Don't archive - V1
+            // policy is to log and let an operator decide. Archive could lose the
+            // memory if the issue is being moved between accounts.
+            const db = openHippoDb(opts.hippoRoot);
+            try {
+                writeToGitHubDlq(db, {
+                    tenantId: resolvedTenant,
+                    rawPayload: rawBody,
+                    error: 'issues.deleted requires manual review',
+                    bucket: 'unhandled',
+                    eventName,
+                    deliveryId,
+                    signature: sigStr,
+                    installationId,
+                    repoFullName,
+                });
+            }
+            finally {
+                closeHippoDb(db);
+            }
+            sendJson(res, 200, { ok: true, status: 'dlq' });
+            return;
+        }
+        const ingestInput = { eventName: 'issues', payload: body };
+        const r = ingestGitHubEvent(ctx, { event: ingestInput, rawBody, deliveryId });
+        sendJson(res, 200, { ok: true, status: r.status, memoryId: r.memoryId });
+        return;
+    }
+    if (eventName === 'issue_comment' && isGitHubIssueCommentEvent(body, 'issue_comment')) {
+        if (body.action === 'deleted') {
+            const repo = body.repository?.full_name ?? '';
+            const artifactRef = `github://${repo}/issue/${body.issue.number}/comment/${body.comment.id}`;
+            // The "deleted:" key namespace keeps this from colliding with the ingest key for the
+            // same artifact; a shared key would make hasSeenKey skip the archive.
+            const idempotencyKey = computeGitHubDeletionKey(artifactRef, body.comment.updated_at ?? null);
+            const r = handleGitHubCommentDeleted(ctx, {
+                artifactRef,
+                idempotencyKey,
+                deliveryId,
+                eventName,
+            });
+            sendJson(res, 200, { ok: true, status: r.status, archivedCount: r.archivedCount });
+            return;
+        }
+        const ingestInput = { eventName: 'issue_comment', payload: body };
+        const r = ingestGitHubEvent(ctx, { event: ingestInput, rawBody, deliveryId });
+        sendJson(res, 200, { ok: true, status: r.status, memoryId: r.memoryId });
+        return;
+    }
+    if (eventName === 'pull_request' && isGitHubPullRequestEvent(body, 'pull_request')) {
+        const ingestInput = { eventName: 'pull_request', payload: body };
+        const r = ingestGitHubEvent(ctx, { event: ingestInput, rawBody, deliveryId });
+        sendJson(res, 200, { ok: true, status: r.status, memoryId: r.memoryId });
+        return;
+    }
+    if (eventName === 'pull_request_review_comment' &&
+        isGitHubPullRequestReviewCommentEvent(body, 'pull_request_review_comment')) {
+        if (body.action === 'deleted') {
+            const repo = body.repository?.full_name ?? '';
+            const artifactRef = `github://${repo}/pull/${body.pull_request.number}/review_comment/${body.comment.id}`;
+            // Same "deleted:" key namespace as the issue_comment branch above.
+            const idempotencyKey = computeGitHubDeletionKey(artifactRef, body.comment.updated_at ?? null);
+            const r = handleGitHubCommentDeleted(ctx, {
+                artifactRef,
+                idempotencyKey,
+                deliveryId,
+                eventName,
+            });
+            sendJson(res, 200, { ok: true, status: r.status, archivedCount: r.archivedCount });
+            return;
+        }
+        const ingestInput = {
+            eventName: 'pull_request_review_comment',
+            payload: body,
+        };
+        const r = ingestGitHubEvent(ctx, { event: ingestInput, rawBody, deliveryId });
+        sendJson(res, 200, { ok: true, status: r.status, memoryId: r.memoryId });
+        return;
+    }
+    // Header allow-listed but body shape didn't satisfy the matching guard.
+    {
+        const db = openHippoDb(opts.hippoRoot);
+        try {
+            writeToGitHubDlq(db, {
+                tenantId: resolvedTenant,
+                rawPayload: rawBody,
+                error: `body shape did not match X-GitHub-Event=${eventName}`,
+                bucket: 'parse_error',
+                eventName,
+                deliveryId,
+                signature: sigStr,
+                installationId,
+                repoFullName,
+            });
+        }
+        finally {
+            closeHippoDb(db);
+        }
+        sendJson(res, 200, { ok: true, status: 'dlq' });
+        return;
+    }
+}
+//# sourceMappingURL=webhook.js.map

package/dist/connectors/slack/dlq.js

@@ -5,12 +5,16 @@ import { resolveTenantForTeam } from './tenant-routing.js';
 import { verifySlackSignature } from './signature.js';
 import { isSlackEventEnvelope, isSlackMessageEvent } from './types.js';
 import { handleMessageDeleted } from './deletion.js';
+import { redactPayload, DLQ_REDACTED_NOTE } from '../../secret-detect.js';
 export function writeToDlq(db, opts) {
+    const rawPayload = redactPayload(opts.rawPayload);
+    // A redacted body can never match its signature, so the row keeps none and replay needs --force.
+    const redacted = rawPayload !== opts.rawPayload;
     const result = db
         .prepare(`INSERT INTO slack_dlq
         (tenant_id, team_id, raw_payload, error, received_at, bucket, signature, slack_timestamp)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(opts.tenantId ?? '__unroutable__', opts.teamId ?? null, opts.rawPayload, opts.error, new Date().toISOString(), opts.bucket ?? 'parse_error', opts.signature ?? null, opts.slackTimestamp ?? null);
+        .run(opts.tenantId ?? '__unroutable__', opts.teamId ?? null, rawPayload, redacted ? `${opts.error}; ${DLQ_REDACTED_NOTE}` : opts.error, new Date().toISOString(), opts.bucket ?? 'parse_error', redacted ? null : opts.signature ?? null, opts.slackTimestamp ?? null);
     return Number(result.lastInsertRowid);
 }
 export function listDlq(db, opts) {
@@ -95,7 +99,7 @@ export function replayDlqEntry(ctx, id, opts = {}) {
                 status: 'sig_missing',
                 memoryId: null,
                 retryCount: row.retryCount,
-                reason: 'legacy row without signature/timestamp; pass --force to replay',
+                reason: 'row has no signature/timestamp (legacy, or redacted before storing); pass --force to replay',
             };
         }
         if (opts.signingSecret) {

package/dist/connectors/slack/web-client.js

@@ -1,7 +1,8 @@
-import { fetchWithRetry } from './ratelimit.js';
+import { fetchWithRetry, isRetryableStatus } from '../../http-retry.js';
 function isJsonString(value) {
     return typeof value === 'string';
 }
+const SLACK_TIMEOUT_MS = 30_000;
 export function slackHistoryFetcher(token, fetchImpl) {
     return async ({ channelId, cursor, oldest }) => {
         const url = new URL('https://slack.com/api/conversations.history');
@@ -11,11 +12,12 @@ export function slackHistoryFetcher(token, fetchImpl) {
             url.searchParams.set('cursor', cursor);
         if (oldest)
             url.searchParams.set('oldest', oldest);
-        const r = await fetchWithRetry({
-            url: url.toString(),
-            init: { method: 'GET', headers: { authorization: `Bearer ${token}` } },
-            fetchImpl,
+        const r = await fetchWithRetry(url, { method: 'GET', headers: { authorization: `Bearer ${token}` } }, {
+            timeoutMs: SLACK_TIMEOUT_MS,
+            fetchFn: fetchImpl,
         });
+        if (isRetryableStatus(r.status))
+            throw new Error(`slack: still rate-limited or unavailable (HTTP ${r.status})`);
         // SAFETY: body is the Slack `conversations.history` response; per the
         // documented shape it's `{ ok, error?, messages?, response_metadata? }`.
         const body = (await r.json());

package/dist/connectors/slack/webhook.d.ts

@@ -0,0 +1,22 @@
+import { type WebhookRequest } from '../../http-util.js';
+/**
+ * Slack Events API webhook. Auth is signature-based (HMAC over the raw
+ * body with SLACK_SIGNING_SECRET); Bearer is NOT required, which is why
+ * this route is in PUBLIC_ROUTES. The route is responsible for:
+ *   1. Echoing the one-time url_verification challenge.
+ *   2. Verifying the HMAC on every other inbound payload.
+ *   3. Resolving body.team_id → tenantId via slack_workspaces, falling
+ *      back to HIPPO_TENANT then 'default'.
+ *   4. Dispatching event_callback envelopes to ingestMessage /
+ *      handleMessageDeleted.
+ *   5. Parking malformed or unhandled payloads in slack_dlq and STILL
+ *      ACKing 200 - Slack retries forever otherwise.
+ *
+ * When SLACK_SIGNING_SECRET is unset we return 404, not
+ * 503, so an external probe cannot distinguish "route gated off by config"
+ * from "route does not exist on this build".
+ *
+ * Bearer auth is skipped on purpose: server.ts checks isPublicRoute before calling this.
+ */
+export declare function handleSlackEventsWebhook({ req, res, opts }: WebhookRequest): Promise<void>;
+//# sourceMappingURL=webhook.d.ts.map