hippo-memory 1.70.0 → 1.71.0

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

@@ -7,32 +7,10 @@ export interface VerifyOpts {
     previousSecret?: string;
 }
 export declare function verifyGitHubSignature(opts: VerifyOpts): boolean;
-/**
- * Source-aware idempotency key: artifact_ref plus the source-side updated_at.
- * A raw-body key would hash a webhook envelope and a REST backfill item of the
- * SAME source event differently and ingest it twice. Same artifact + same
- * revision = same key, whichever path delivered it; an edit gets a new key,
- * which is correct because each edit IS a new memory revision.
- *
- * Both inputs are upstream-derived from the parsed event, not from the
- * unsigned delivery header — replay attacks still cannot bypass dedupe.
- *
- * Inputs:
- *   - artifactRef: e.g. 'github://acme/repo/issue/42' or
- *     'github://acme/repo/issue/42/comment/123'.
- *   - updatedAt: source-side ISO timestamp (issue.updated_at,
- *     comment.updated_at, pull_request.updated_at). Empty string when the
- *     payload omits it (rare; older REST shapes).
- */
+/** Source-aware idempotency key: artifact_ref plus the source-side updated_at, so a webhook and a REST backfill of the SAME event dedupe.
+ *  An edit gets a new key (a new revision); both inputs come from the parsed event, not the unsigned delivery header, so replays cannot bypass dedupe. */
 export declare function computeIdempotencyKey(artifactRef: string, updatedAt: string | null | undefined): string;
-/**
- * Deletion-specific idempotency key: sha256('deleted:' + artifactRef + ':' +
- * updatedAt). Distinct namespace from computeIdempotencyKey so an ingest's row
- * in github_event_log doesn't make a deletion return 'duplicate' before it
- * gets a chance to archive; retries of the SAME deletion still dedupe.
- *
- * Kept as a separate exported function so the namespace prefix is explicit
- * at every call site (server.ts deletion branches, deletion.ts, DLQ replay).
- */
+/** Deletion idempotency key: sha256('deleted:' + artifactRef + ':' + updatedAt).
+ *  A separate namespace so an ingest's event-log row cannot make a deletion return 'duplicate'; retries of the same deletion still dedupe. */
 export declare function computeDeletionKey(artifactRef: string, updatedAt: string | null | undefined): string;
 //# sourceMappingURL=signature.d.ts.map

package/dist/connectors/github/signature.js

@@ -16,35 +16,13 @@ export function verifyGitHubSignature(opts) {
         return true;
     return false;
 }
-/**
- * Source-aware idempotency key: artifact_ref plus the source-side updated_at.
- * A raw-body key would hash a webhook envelope and a REST backfill item of the
- * SAME source event differently and ingest it twice. Same artifact + same
- * revision = same key, whichever path delivered it; an edit gets a new key,
- * which is correct because each edit IS a new memory revision.
- *
- * Both inputs are upstream-derived from the parsed event, not from the
- * unsigned delivery header — replay attacks still cannot bypass dedupe.
- *
- * Inputs:
- *   - artifactRef: e.g. 'github://acme/repo/issue/42' or
- *     'github://acme/repo/issue/42/comment/123'.
- *   - updatedAt: source-side ISO timestamp (issue.updated_at,
- *     comment.updated_at, pull_request.updated_at). Empty string when the
- *     payload omits it (rare; older REST shapes).
- */
+/** Source-aware idempotency key: artifact_ref plus the source-side updated_at, so a webhook and a REST backfill of the SAME event dedupe.
+ *  An edit gets a new key (a new revision); both inputs come from the parsed event, not the unsigned delivery header, so replays cannot bypass dedupe. */
 export function computeIdempotencyKey(artifactRef, updatedAt) {
     return createHash('sha256').update(`${artifactRef}:${updatedAt ?? ''}`).digest('hex');
 }
-/**
- * Deletion-specific idempotency key: sha256('deleted:' + artifactRef + ':' +
- * updatedAt). Distinct namespace from computeIdempotencyKey so an ingest's row
- * in github_event_log doesn't make a deletion return 'duplicate' before it
- * gets a chance to archive; retries of the SAME deletion still dedupe.
- *
- * Kept as a separate exported function so the namespace prefix is explicit
- * at every call site (server.ts deletion branches, deletion.ts, DLQ replay).
- */
+/** Deletion idempotency key: sha256('deleted:' + artifactRef + ':' + updatedAt).
+ *  A separate namespace so an ingest's event-log row cannot make a deletion return 'duplicate'; retries of the same deletion still dedupe. */
 export function computeDeletionKey(artifactRef, updatedAt) {
     return createHash('sha256').update(`deleted:${artifactRef}:${updatedAt ?? ''}`).digest('hex');
 }

package/dist/connectors/github/tenant-routing.d.ts

@@ -5,29 +5,7 @@ export interface ResolveArgs {
     /** `repository.full_name` from the webhook envelope, used for PAT-mode multi-tenant routing. */
     repoFullName?: string | null;
 }
-/**
- * Resolve the tenant_id for a GitHub webhook envelope.
- *
- * Returns:
- *   - mapped tenant_id when `github_installations` has a row for `installationId`
- *     (App-mode multi-tenant — primary path)
- *   - mapped tenant_id when `installation` is absent, `repository.full_name`
- *     matches a `github_repositories` row (PAT-mode multi-tenant)
- *   - the deployment's HIPPO_TENANT fallback (or 'default') when BOTH routing
- *     tables are empty (single-tenant deployment — env fallback is safe)
- *   - null when:
- *       - `installationId` is present but unknown AND `github_installations`
- *         is non-empty (multi-tenant install with foreign installation)
- *       - `installationId` is missing AND either routing table is non-empty
- *         AND no `repository.full_name` match (PAT-mode webhook from a foreign
- *         account)
- *
- * Escape hatch: `GITHUB_ALLOW_UNKNOWN_INSTALLATION_FALLBACK=1` restores the
- * env fallback for emergency rollback only. Mirrors the Slack equivalent
- * (`SLACK_ALLOW_UNKNOWN_TEAM_FALLBACK`).
- *
- * The fail-closed contract lives here so every caller (route handler, CLI
- * replay, future MCP) gets identical protection.
- */
+/** Resolve a GitHub envelope's tenant_id by installation id, then repository.full_name; the HIPPO_TENANT fallback applies only if both tables are empty.
+ *  An unknown installation or repo on a multi-tenant deployment returns null (fail closed); GITHUB_ALLOW_UNKNOWN_INSTALLATION_FALLBACK=1 escapes. */
 export declare function resolveTenantForGitHub(hippoRoot: string, args: ResolveArgs, store?: HippoStore): Promise<string | null>;
 //# sourceMappingURL=tenant-routing.d.ts.map

package/dist/connectors/github/tenant-routing.js

@@ -1,32 +1,10 @@
-import { envGithubAllowUnknownInstallationFallback, envTenant } from '../../util/env.js';
+import { envGitHubAllowUnknownInstallationFallback, envTenant } from '../../util/env.js';
 import { requireGroup, storeFor } from '../../store/index.js';
-/**
- * Resolve the tenant_id for a GitHub webhook envelope.
- *
- * Returns:
- *   - mapped tenant_id when `github_installations` has a row for `installationId`
- *     (App-mode multi-tenant — primary path)
- *   - mapped tenant_id when `installation` is absent, `repository.full_name`
- *     matches a `github_repositories` row (PAT-mode multi-tenant)
- *   - the deployment's HIPPO_TENANT fallback (or 'default') when BOTH routing
- *     tables are empty (single-tenant deployment — env fallback is safe)
- *   - null when:
- *       - `installationId` is present but unknown AND `github_installations`
- *         is non-empty (multi-tenant install with foreign installation)
- *       - `installationId` is missing AND either routing table is non-empty
- *         AND no `repository.full_name` match (PAT-mode webhook from a foreign
- *         account)
- *
- * Escape hatch: `GITHUB_ALLOW_UNKNOWN_INSTALLATION_FALLBACK=1` restores the
- * env fallback for emergency rollback only. Mirrors the Slack equivalent
- * (`SLACK_ALLOW_UNKNOWN_TEAM_FALLBACK`).
- *
- * The fail-closed contract lives here so every caller (route handler, CLI
- * replay, future MCP) gets identical protection.
- */
+/** Resolve a GitHub envelope's tenant_id by installation id, then repository.full_name; the HIPPO_TENANT fallback applies only if both tables are empty.
+ *  An unknown installation or repo on a multi-tenant deployment returns null (fail closed); GITHUB_ALLOW_UNKNOWN_INSTALLATION_FALLBACK=1 escapes. */
 export async function resolveTenantForGitHub(hippoRoot, args, store) {
     const envFallback = () => envTenant();
-    const escapeHatch = envGithubAllowUnknownInstallationFallback();
+    const escapeHatch = envGitHubAllowUnknownInstallationFallback();
     const routing = await requireGroup(storeFor({ hippoRoot, store }), 'connectorEvents').githubRouting(args);
     if (routing.tenant)
         return routing.tenant;

package/dist/connectors/github/transform.js

@@ -1,20 +1,6 @@
 import { scopeFromRepository } from './scope.js';
-/**
- * Convert GitHub webhook events into RememberOpts for api.remember(). Each
- * function returns null when the event has no usable body so the webhook
- * caller can mark the delivery seen for idempotency and skip the insert.
- *
- * Contract (mirrors src/connectors/slack/transform.ts):
- * - kind is the literal 'raw' (connector boundary, see src/importers.ts).
- * - artifact_ref formats are stable; deletion paths look up by these strings.
- *   - issue:               github://<owner/repo>/issue/<number>
- *   - issue_comment:       github://<owner/repo>/issue/<number>/comment/<id>
- *   - pull_request:        github://<owner/repo>/pull/<number>
- *   - pr_review_comment:   github://<owner/repo>/pull/<number>/review_comment/<id>
- * - owner is `user:github:<login>`. Required by the provenance gate.
- * - scope is derived from repository.private via scopeFromRepository (default
- *   private when undetermined).
- */
+/** Convert GitHub webhook events into RememberOpts; each returns null when the event has no usable body so the caller marks it seen and skips the insert.
+ *  artifact_ref formats (github://<owner/repo>/issue|pull/<n>[/comment|review_comment/<id>]) are stable because deletion looks rows up by them. */
 const UNKNOWN_REPO = 'unknown/unknown';
 export function issueEventToRememberOpts(evt) {
     const body = evt.issue.body?.trim();

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

@@ -1,19 +1,7 @@
-/**
- * GitHub webhook event shapes used by the ingestion connector.
- * Spec: https://docs.github.com/en/webhooks/webhook-events-and-payloads
- *
- * V1 cares about four event types: issues, issue_comment, pull_request,
- * pull_request_review_comment. Each guard is gated on the X-GitHub-Event
- * header value so a malicious or misrouted payload cannot satisfy a guard
- * for the wrong event type.
- */
+/** GitHub webhook event shapes for the ingestion connector (https://docs.github.com/en/webhooks/webhook-events-and-payloads).
+ *  Each guard is gated on the X-GitHub-Event header so a misrouted payload cannot satisfy a guard for the wrong event type. */
 import { type JsonValue } from '../../util/json.js';
-/**
- * `private` MUST be optional, not required. The Slack-style
- * fail-safe in scope.ts requires an envelope with `private: undefined` to
- * map to private; a strict boolean type would reject the payload before
- * scope can fail closed.
- */
+/** `private` MUST stay optional: scope.ts maps `private: undefined` to private, and a strict boolean would reject the payload before scope can fail closed. */
 export interface GitHubRepository {
     full_name: string;
     private?: boolean;

package/dist/connectors/github/types.js

@@ -1,12 +1,5 @@
-/**
- * GitHub webhook event shapes used by the ingestion connector.
- * Spec: https://docs.github.com/en/webhooks/webhook-events-and-payloads
- *
- * V1 cares about four event types: issues, issue_comment, pull_request,
- * pull_request_review_comment. Each guard is gated on the X-GitHub-Event
- * header value so a malicious or misrouted payload cannot satisfy a guard
- * for the wrong event type.
- */
+/** GitHub webhook event shapes for the ingestion connector (https://docs.github.com/en/webhooks/webhook-events-and-payloads).
+ *  Each guard is gated on the X-GitHub-Event header so a misrouted payload cannot satisfy a guard for the wrong event type. */
 import { isJsonString, isJsonNumber } from '../../util/json.js';
 function isObjectOrArray(x) {
     return x !== null && typeof x === 'object';

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

@@ -1,20 +1,6 @@
 import type { HippoStore } from '../../store/index.js';
 import { type WebhookRequest } from '../../util/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.
- */
+/** GitHub webhook receiver: HMAC SHA-256 over the raw body, event type from the X-GitHub-Event header, tenant by installation.id then repository.full_name.
+ *  ACKs 200 on signed envelopes (DLQ too); 401 only on a bad signature; 404 when GITHUB_WEBHOOK_SECRET is unset. No Bearer: server.ts checks isPublicRoute. */
 export declare function handleGitHubEventsWebhook(request: WebhookRequest, store?: HippoStore): Promise<void>;
 //# sourceMappingURL=webhook.d.ts.map

package/dist/connectors/github/webhook.js

@@ -1,4 +1,4 @@
-import { envGithubWebhookSecret, envGithubWebhookSecretPrevious } from '../../util/env.js';
+import { envGitHubWebhookSecret, envGitHubWebhookSecretPrevious } from '../../util/env.js';
 import { verifyGitHubSignature } from './signature.js';
 import { isGitHubWebhookEnvelope, isGitHubIssueEvent, isGitHubIssueCommentEvent, isGitHubPullRequestEvent, isGitHubPullRequestReviewCommentEvent, } from './types.js';
 import { ingestEvent as ingestGitHubEvent } from './ingest.js';
@@ -9,33 +9,19 @@ import { resolveTenantForGitHub } from './tenant-routing.js';
 import { computeDeletionKey as computeGitHubDeletionKey } from './signature.js';
 import { resolveTenantId } from '../../store/tenant.js';
 import { HttpError, JSON_HEADERS, isHeaderString, closeIfBodyUnread, readWebhookBody, sendJson, } from '../../util/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.
- */
+/** GitHub webhook receiver: HMAC SHA-256 over the raw body, event type from the X-GitHub-Event header, tenant by installation.id then repository.full_name.
+ *  ACKs 200 on signed envelopes (DLQ too); 401 only on a bad signature; 404 when GITHUB_WEBHOOK_SECRET is unset. No Bearer: server.ts checks isPublicRoute. */
 export async function handleGitHubEventsWebhook(request, store) {
     const { req, res, opts } = request;
     // Secret and signature header before the body, so a caller with neither cannot make the server buffer one.
-    const secret = envGithubWebhookSecret();
+    const secret = envGitHubWebhookSecret();
     if (!secret) {
         closeIfBodyUnread(request);
         res.writeHead(404, JSON_HEADERS);
         res.end(JSON.stringify({ error: 'not found' }));
         return;
     }
-    const previousSecret = envGithubWebhookSecretPrevious();
+    const previousSecret = envGitHubWebhookSecretPrevious();
     const sigHdr = req.headers['x-hub-signature-256'];
     const eventHdr = req.headers['x-github-event'];
     const deliveryHdr = req.headers['x-github-delivery'];
@@ -167,9 +153,7 @@ async function dispatchGitHubEvent(d, ctx, body, deliveryId, routing) {
     if (action === null)
         return false;
     if (action.kind === 'manual-review') {
-        // 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.
+        // issues.deleted (admin-initiated) is logged, not archived: archiving could lose the memory if the issue moves between accounts.
         await parkAndAck(d, {
             ...routing,
             tenantId: ctx.tenantId,

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

@@ -9,14 +9,8 @@ export type SlackHistoryFetcher = (args: {
     channelId: string;
     /** Slack's opaque pagination token. Null on first page of a backfill run. */
     cursor: string | null;
-    /**
-     * Incremental-resume bound: skip messages with ts <= oldest. Set from
-     * `slack_cursors.latest_ts` on the FIRST page of a rerun; unused on
-     * subsequent pages within one run (where `cursor` carries us forward).
-     * Distinct from `cursor` because Slack treats `cursor` as opaque token
-     * and `oldest` as a numeric ts — feeding `latest_ts` as `cursor` breaks
-     * against the live API even though it round-trips through test fetchers.
-     */
+    /** Incremental-resume bound: skip messages with ts <= oldest, set from `slack_cursors.latest_ts` on the first page only.
+     *  Kept apart from `cursor` because Slack treats `cursor` as an opaque token, so feeding latest_ts as cursor fails on the live API. */
     oldest?: string;
 }) => Promise<SlackHistoryPage>;
 export interface BackfillOpts {
@@ -26,15 +20,8 @@ export interface BackfillOpts {
     /** Stop after this many messages. Default: unlimited. */
     maxMessages?: number;
 }
-/**
- * Page through `conversations.history` via the injected fetcher and ingest each
- * message. The cursor is persisted to `slack_cursors` after every page so a
- * crash mid-backfill resumes near where it left off.
- *
- * Each ingested message uses a synthesized eventId of the form
- * `backfill:${teamId}:${channelId}:${ts}`. Reruns dedupe via the
- * `slack_event_log` PK so calling `backfillChannel` twice is safe.
- */
+/** Page through `conversations.history` and ingest each message, persisting the cursor to `slack_cursors` after every page.
+ *  The synthesized eventId `backfill:${teamId}:${channelId}:${ts}` makes reruns dedupe via the `slack_event_log` PK. */
 export declare function backfillChannel(ctx: Context, opts: BackfillOpts): Promise<{
     ingested: number;
     pages: number;

package/dist/connectors/slack/backfill.js

@@ -1,19 +1,10 @@
 import { saveSlackCursor, slackCursor } from '../../store/connectors/slack.js';
 import { ingestMessage } from './ingest.js';
-/**
- * Page through `conversations.history` via the injected fetcher and ingest each
- * message. The cursor is persisted to `slack_cursors` after every page so a
- * crash mid-backfill resumes near where it left off.
- *
- * Each ingested message uses a synthesized eventId of the form
- * `backfill:${teamId}:${channelId}:${ts}`. Reruns dedupe via the
- * `slack_event_log` PK so calling `backfillChannel` twice is safe.
- */
+/** Page through `conversations.history` and ingest each message, persisting the cursor to `slack_cursors` after every page.
+ *  The synthesized eventId `backfill:${teamId}:${channelId}:${ts}` makes reruns dedupe via the `slack_event_log` PK. */
 export async function backfillChannel(ctx, opts) {
-    // Resume bound from previous run; passed as `oldest` (numeric ts) on the
-    // first page only. `cursor` starts null — Slack mints the next-page token
-    // and we feed it back. Mixing the two would feed a numeric ts as an opaque
-    // cursor and break against the live API on rerun.
+    // `oldest` (numeric ts) is the resume bound for the first page only; `cursor` starts null and Slack mints the next-page token.
+    // Mixing the two would feed a numeric ts as an opaque cursor and break on rerun.
     const resumeFrom = slackCursor(ctx.hippoRoot, ctx.tenantId, opts.channel.id);
     let cursor = null;
     let ingested = 0;

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

@@ -14,24 +14,7 @@ export interface ReplayDlqOpts {
     /** Skew window override for tests. */
     skewSeconds?: number;
 }
-/**
- * Replay a DLQ row through the normal ingest path. Used by `hippo slack dlq
- * replay <id> [--force]`.
- *
- * Behavior:
- *   1. SELECT the row.
- *   2. If signature + slack_timestamp are present and `signingSecret` is set,
- *      re-verify with the CURRENT secret (not previous). Failure → bail unless
- *      --force. Legacy rows from before v19 may have NULL signature; those
- *      require --force to replay safely.
- *   3. Re-parse the raw_payload and dispatch to ingestMessage / handleMessageDeleted.
- *   4. On success: mark retried_at, increment retry_count.
- *   5. On failure: increment retry_count only, leave the row.
- *
- * The replay always uses the routing the deployment has NOW (current
- * slack_workspaces table + env), not whatever was in effect when the original
- * envelope was DLQed. That is intentional: the DLQ exists to be drained after
- * the operator fixed the routing.
- */
+/** Replay a DLQ row via the normal ingest path (`hippo slack dlq replay <id> [--force]`), re-verifying the signature with the CURRENT secret unless forced.
+ *  Rows with a NULL signature need --force; replays use today's routing, because the DLQ exists to be drained after the operator fixed routing. */
 export declare function replayDlqEntry(ctx: Pick<Context, 'hippoRoot'>, id: number, opts?: ReplayDlqOpts): Promise<ReplayResult>;
 //# sourceMappingURL=dlq.d.ts.map

package/dist/connectors/slack/dlq.js

@@ -12,25 +12,8 @@ export const slackDlq = {
     letter: (row) => ({ connector: 'slack', ...row }),
     list: listSlackDlq,
 };
-/**
- * Replay a DLQ row through the normal ingest path. Used by `hippo slack dlq
- * replay <id> [--force]`.
- *
- * Behavior:
- *   1. SELECT the row.
- *   2. If signature + slack_timestamp are present and `signingSecret` is set,
- *      re-verify with the CURRENT secret (not previous). Failure → bail unless
- *      --force. Legacy rows from before v19 may have NULL signature; those
- *      require --force to replay safely.
- *   3. Re-parse the raw_payload and dispatch to ingestMessage / handleMessageDeleted.
- *   4. On success: mark retried_at, increment retry_count.
- *   5. On failure: increment retry_count only, leave the row.
- *
- * The replay always uses the routing the deployment has NOW (current
- * slack_workspaces table + env), not whatever was in effect when the original
- * envelope was DLQed. That is intentional: the DLQ exists to be drained after
- * the operator fixed the routing.
- */
+/** Replay a DLQ row via the normal ingest path (`hippo slack dlq replay <id> [--force]`), re-verifying the signature with the CURRENT secret unless forced.
+ *  Rows with a NULL signature need --force; replays use today's routing, because the DLQ exists to be drained after the operator fixed routing. */
 export async function replayDlqEntry(ctx, id, opts = {}) {
     const row = slackDlqEntry(ctx.hippoRoot, id);
     if (!row)

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

@@ -13,8 +13,7 @@ export interface IngestResult {
     status: IngestStatus;
     memoryId: string | null;
 }
-/** Ingests a Slack message as a kind='raw' memory, once per event id: Slack redelivers within a minute.
- *  The pre-check is only the fast path; the store logs the event in the memory's own transaction, which is what holds when two workers race.
- *  An empty body is logged with no memory, so its replay skips the transform. */
+/** Ingests a Slack message as a kind='raw' memory once per event id (Slack redelivers within a minute); the pre-check is only the fast path,
+ *  the store logs the event in the memory's own transaction, which holds when two workers race. An empty body is logged with no memory. */
 export declare function ingestMessage(ctx: Context, input: IngestInput): Promise<IngestResult>;
 //# sourceMappingURL=ingest.d.ts.map

package/dist/connectors/slack/ingest.js

@@ -2,9 +2,8 @@ import { remember } from '../../api/index.js';
 import { requireGroup, storeFor } from '../../store/index.js';
 import { RejectedValueError } from '../../store/rejection.js';
 import { messageToRememberOpts } from './transform.js';
-/** Ingests a Slack message as a kind='raw' memory, once per event id: Slack redelivers within a minute.
- *  The pre-check is only the fast path; the store logs the event in the memory's own transaction, which is what holds when two workers race.
- *  An empty body is logged with no memory, so its replay skips the transform. */
+/** Ingests a Slack message as a kind='raw' memory once per event id (Slack redelivers within a minute); the pre-check is only the fast path,
+ *  the store logs the event in the memory's own transaction, which holds when two workers race. An empty body is logged with no memory. */
 export async function ingestMessage(ctx, input) {
     const events = requireGroup(storeFor(ctx), 'connectorEvents');
     const event = { connector: 'slack', eventId: input.eventId };

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

@@ -4,13 +4,7 @@ export interface ChannelMeta {
     is_im?: boolean;
     is_mpim?: boolean;
 }
-/**
- * Map a Slack channel into a hippo scope string.
- *
- * Default to private when privacy is undetermined. The cost of leaking a
- * public channel into private scope (recall returns nothing) is far smaller
- * than the cost of leaking a private channel into public scope (data exposed
- * to a tenant that should not see it).
- */
+/** Map a Slack channel into a hippo scope string, defaulting to private when privacy is undetermined:
+ *  a public channel leaking into private scope returns nothing, but the reverse exposes data. */
 export declare function scopeFromChannel(ch: ChannelMeta): string;
 //# sourceMappingURL=scope.d.ts.map

package/dist/connectors/slack/scope.js

@@ -1,11 +1,5 @@
-/**
- * Map a Slack channel into a hippo scope string.
- *
- * Default to private when privacy is undetermined. The cost of leaking a
- * public channel into private scope (recall returns nothing) is far smaller
- * than the cost of leaking a private channel into public scope (data exposed
- * to a tenant that should not see it).
- */
+/** Map a Slack channel into a hippo scope string, defaulting to private when privacy is undetermined:
+ *  a public channel leaking into private scope returns nothing, but the reverse exposes data. */
 export function scopeFromChannel(ch) {
     const isPublic = ch.is_private === false && !ch.is_im && !ch.is_mpim;
     return isPublic ? `slack:public:${ch.id}` : `slack:private:${ch.id}`;

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

@@ -3,12 +3,7 @@ export interface VerifyOpts {
     timestamp: string;
     signature: string;
     signingSecret: string;
-    /**
-     * Previous signing secret during a rotation. Deploy with
-     * both `SLACK_SIGNING_SECRET` (new) and `SLACK_SIGNING_SECRET_PREVIOUS` (old)
-     * set, verify both work, drop previous after rollover. The verifier tries
-     * `signingSecret` first, then `previousSecret` if that fails.
-     */
+    /** Previous signing secret during rotation (SLACK_SIGNING_SECRET_PREVIOUS); the verifier tries `signingSecret` first, then this. */
     previousSecret?: string;
     /** Current unix seconds. Injectable for tests. */
     now?: number;

package/dist/connectors/slack/tenant-routing.d.ts

@@ -1,22 +1,5 @@
-import type { DatabaseSyncLike } from '../../db/index.js';
 import { type HippoStore } from '../../store/index.js';
-/**
- * Look up the tenant_id for a Slack team_id.
- *
- * Returns:
- *   - mapped tenant_id when slack_workspaces has a row for `teamId`
- *   - the deployment's HIPPO_TENANT fallback (or 'default') when slack_workspaces
- *     is empty (single-workspace install — env fallback is safe)
- *   - null when slack_workspaces is non-empty AND `teamId` is unknown
- *     (multi-workspace install — fail closed; an unknown team is not the
- *     deployment's tenant). Escape hatch: SLACK_ALLOW_UNKNOWN_TEAM_FALLBACK=1
- *     restores the env fallback for emergency rollback only.
- *
- * The fail-closed contract lives here so every caller (route handler, CLI
- * replay, future MCP) gets the same protection against routing a foreign
- * workspace's events into the deployment tenant.
- */
-export declare function resolveTenantForTeam(db: DatabaseSyncLike, teamId: string): string | null;
-/** resolveTenantForTeam through `store`, else hippo.db under `hippoRoot`. */
+/** Look up the tenant_id for a Slack team_id; the HIPPO_TENANT fallback applies only when slack_workspaces is empty (single-workspace install).
+ *  An unknown team on a multi-workspace install returns null (fail closed); SLACK_ALLOW_UNKNOWN_TEAM_FALLBACK=1 is the emergency escape. */
 export declare function resolveTenantForSlackTeam(hippoRoot: string, teamId: string, store?: HippoStore): Promise<string | null>;
 //# sourceMappingURL=tenant-routing.d.ts.map

package/dist/connectors/slack/tenant-routing.js

@@ -1,26 +1,7 @@
 import { envSlackAllowUnknownTeamFallback, envTenant } from '../../util/env.js';
 import { requireGroup, storeFor } from '../../store/index.js';
-import { slackTeamRouteAt } from '../../store/connectors/slack.js';
-/**
- * Look up the tenant_id for a Slack team_id.
- *
- * Returns:
- *   - mapped tenant_id when slack_workspaces has a row for `teamId`
- *   - the deployment's HIPPO_TENANT fallback (or 'default') when slack_workspaces
- *     is empty (single-workspace install — env fallback is safe)
- *   - null when slack_workspaces is non-empty AND `teamId` is unknown
- *     (multi-workspace install — fail closed; an unknown team is not the
- *     deployment's tenant). Escape hatch: SLACK_ALLOW_UNKNOWN_TEAM_FALLBACK=1
- *     restores the env fallback for emergency rollback only.
- *
- * The fail-closed contract lives here so every caller (route handler, CLI
- * replay, future MCP) gets the same protection against routing a foreign
- * workspace's events into the deployment tenant.
- */
-export function resolveTenantForTeam(db, teamId) {
-    return tenantForRoute(slackTeamRouteAt(db, teamId));
-}
-/** resolveTenantForTeam through `store`, else hippo.db under `hippoRoot`. */
+/** Look up the tenant_id for a Slack team_id; the HIPPO_TENANT fallback applies only when slack_workspaces is empty (single-workspace install).
+ *  An unknown team on a multi-workspace install returns null (fail closed); SLACK_ALLOW_UNKNOWN_TEAM_FALLBACK=1 is the emergency escape. */
 export async function resolveTenantForSlackTeam(hippoRoot, teamId, store) {
     return tenantForRoute(await requireGroup(storeFor({ hippoRoot, store }), 'connectorEvents').slackTeamRoute(teamId));
 }

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

@@ -6,23 +6,7 @@ export interface TransformInput {
     channel: ChannelMeta;
     message: SlackMessageEvent;
 }
-/**
- * Convert a SlackMessageEvent into RememberOpts for api.remember(). Returns
- * null when the message has no usable body (e.g. system events, bot reactions
- * without text). Caller treats null as "skip but mark idempotency seen".
- *
- * Contract:
- * - kind is the literal 'raw' (connector boundary, see src/importers.ts).
- * - artifact_ref format MUST be exactly `slack://${teamId}/${channelId}/${ts}`;
- *   the deletion path looks up by this string.
- * - owner is non-null whenever a row is written. Required by the
- *   provenance gate (`hippo provenance --strict`).
- *   - `user:<slack_user_id>` when the event carries a `user`.
- *   - `bot:<bot_id>` for the `bot_message` subtype (or any userless+text event
- *     that supplies bot_id).
- *   - `bot:unknown` only as a last-resort sentinel so the gate never sees null.
- *     Skipping userless messages instead would silently drop bot ingestion
- *     via the "skipped but seen" path in ingest.ts.
- */
+/** Convert a SlackMessageEvent into RememberOpts; returns null when the message has no usable body so the caller marks it seen and skips it.
+ *  artifact_ref MUST be `slack://${teamId}/${channelId}/${ts}` (deletion looks it up); owner is never null: `user:<id>`, `bot:<bot_id>`, else `bot:unknown`. */
 export declare function messageToRememberOpts(input: TransformInput): RememberOpts | null;
 //# sourceMappingURL=transform.d.ts.map

package/dist/connectors/slack/transform.js

@@ -1,22 +1,6 @@
 import { scopeFromChannel } from './scope.js';
-/**
- * Convert a SlackMessageEvent into RememberOpts for api.remember(). Returns
- * null when the message has no usable body (e.g. system events, bot reactions
- * without text). Caller treats null as "skip but mark idempotency seen".
- *
- * Contract:
- * - kind is the literal 'raw' (connector boundary, see src/importers.ts).
- * - artifact_ref format MUST be exactly `slack://${teamId}/${channelId}/${ts}`;
- *   the deletion path looks up by this string.
- * - owner is non-null whenever a row is written. Required by the
- *   provenance gate (`hippo provenance --strict`).
- *   - `user:<slack_user_id>` when the event carries a `user`.
- *   - `bot:<bot_id>` for the `bot_message` subtype (or any userless+text event
- *     that supplies bot_id).
- *   - `bot:unknown` only as a last-resort sentinel so the gate never sees null.
- *     Skipping userless messages instead would silently drop bot ingestion
- *     via the "skipped but seen" path in ingest.ts.
- */
+/** Convert a SlackMessageEvent into RememberOpts; returns null when the message has no usable body so the caller marks it seen and skips it.
+ *  artifact_ref MUST be `slack://${teamId}/${channelId}/${ts}` (deletion looks it up); owner is never null: `user:<id>`, `bot:<bot_id>`, else `bot:unknown`. */
 export function messageToRememberOpts(input) {
     const text = input.message.text?.trim();
     if (!text)

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

@@ -1,7 +1,5 @@
-/**
- * Slack Events API envelope shapes used by the ingestion connector.
- * Spec: https://api.slack.com/events-api
- */
+/** Slack Events API envelope shapes used by the ingestion connector.
+ *  Spec: https://api.slack.com/events-api */
 import { type JsonValue } from '../../util/json.js';
 export interface SlackUrlVerification {
     type: 'url_verification';
@@ -17,11 +15,7 @@ export interface SlackMessageEvent {
     text?: string;
     ts: string;
     thread_ts?: string;
-    /**
-     * Slack `bot_message` subtype carries `bot_id` instead of `user`. The
-     * provenance gate requires a non-null `owner`, so transform.ts
-     * derives `owner: bot:<bot_id>` when `user` is absent.
-     */
+    /** The `bot_message` subtype carries `bot_id` instead of `user`; transform.ts derives `owner: bot:<bot_id>` from it. */
     bot_id?: string;
     /** Present on subtype='message_deleted'. */
     deleted_ts?: string;