hippo-memory 1.70.0 → 1.72.0

package/dist/cli/flags.d.ts

@@ -6,294 +6,6 @@ export interface VerbFlags {
     readonly numbers?: readonly string[];
     readonly lists?: readonly string[];
 }
-export declare const VERB_FLAGS: {
-    init: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    remember: {
-        switches: string[];
-        values: string[];
-        lists: string[];
-    };
-    recall: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    drill: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    assemble: {
-        switches: string[];
-        values: string[];
-    };
-    supersede: {
-        switches: string[];
-        values: string[];
-        lists: string[];
-    };
-    explain: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    eval: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    trace: {
-        switches: string[];
-        values: string[];
-        lists: string[];
-    };
-    refine: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    sleep: {
-        switches: string[];
-        values: string[];
-    };
-    'last-sleep': {
-        switches: string[];
-        values: string[];
-    };
-    'session-end': {
-        switches: string[];
-        values: string[];
-    };
-    '__session-end-worker': {
-        switches: string[];
-        values: string[];
-    };
-    'pre-compact': {
-        values: string[];
-    };
-    'post-compact': {
-        values: string[];
-    };
-    'capture-error': {
-        values: string[];
-    };
-    'compact-resume': {};
-    'codex-run': {};
-    '__codex-session-end-worker': {
-        values: string[];
-    };
-    dedup: {
-        switches: string[];
-        numbers: string[];
-    };
-    dag: {
-        switches: string[];
-    };
-    auth: {
-        switches: string[];
-        values: string[];
-    };
-    goal: {
-        switches: string[];
-        values: string[];
-    };
-    slack: {
-        switches: string[];
-        values: string[];
-    };
-    github: {
-        switches: string[];
-        values: string[];
-    };
-    audit: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    'correction-latency': {
-        switches: string[];
-    };
-    provenance: {
-        switches: string[];
-    };
-    status: {};
-    outcome: {
-        switches: string[];
-        values: string[];
-    };
-    conflicts: {
-        switches: string[];
-        values: string[];
-    };
-    resolve: {
-        switches: string[];
-        values: string[];
-    };
-    reject: {
-        switches: string[];
-        values: string[];
-    };
-    rejections: {
-        switches: string[];
-    };
-    unreject: {
-        switches: string[];
-    };
-    dormant: {
-        switches: string[];
-        numbers: string[];
-    };
-    projects: {
-        switches: string[];
-    };
-    quarantine: {
-        switches: string[];
-    };
-    tokens: {
-        switches: string[];
-        numbers: string[];
-    };
-    failures: {
-        switches: string[];
-        numbers: string[];
-    };
-    doctor: {
-        switches: string[];
-    };
-    'support-bundle': {
-        switches: string[];
-        values: string[];
-    };
-    snapshot: {
-        switches: string[];
-        values: string[];
-    };
-    session: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    handoff: {
-        switches: string[];
-        values: string[];
-        lists: string[];
-    };
-    card: {
-        switches: string[];
-        values: string[];
-        lists: string[];
-    };
-    predict: {
-        values: string[];
-        numbers: string[];
-    };
-    current: {
-        switches: string[];
-    };
-    forget: {
-        switches: string[];
-        values: string[];
-    };
-    inspect: {};
-    context: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    hook: {};
-    setup: {
-        switches: string[];
-    };
-    'daily-runner': {};
-    embed: {
-        switches: string[];
-    };
-    watch: {};
-    learn: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    promote: {};
-    sync: {
-        switches: string[];
-    };
-    share: {
-        switches: string[];
-        numbers: string[];
-    };
-    peers: {
-        switches: string[];
-    };
-    import: {
-        switches: string[];
-        values: string[];
-        lists: string[];
-    };
-    export: {
-        values: string[];
-    };
-    capture: {
-        switches: string[];
-        values: string[];
-    };
-    dashboard: {
-        numbers: string[];
-    };
-    wm: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    mcp: {};
-    serve: {
-        values: string[];
-        numbers: string[];
-    };
-    invalidate: {
-        switches: string[];
-        values: string[];
-    };
-    decide: {
-        values: string[];
-        numbers: string[];
-    };
-    incident: {
-        values: string[];
-        numbers: string[];
-        lists: string[];
-    };
-    process: {
-        values: string[];
-        numbers: string[];
-        lists: string[];
-    };
-    policy: {
-        values: string[];
-        numbers: string[];
-    };
-    skill: {
-        values: string[];
-        numbers: string[];
-    };
-    brief: {
-        switches: string[];
-        values: string[];
-        numbers: string[];
-    };
-    note: {
-        values: string[];
-        numbers: string[];
-    };
-    graph: {
-        switches: string[];
-        values: string[];
-    };
-};
 /** How parseArgs reads `--name` on the verb with these flags; `undefined` is a command the table lacks. */
 export declare function flagKind(verb: VerbFlags | undefined, name: string): FlagKind;
 /** Whether any verb, or the entry point, reads `--name`. */

package/dist/cli/flags.js

@@ -1,144 +1,9 @@
-// Each verb's flags as data, keyed like the command table: parseArgs needs a flag's kind before the verb's module loads.
+// Each flag's kind, read from the verb table's flags: parseArgs needs a flag's kind before the verb's module loads.
+import { COMMANDS } from './verbs.js';
 // The entry point reads these for every verb, so no verb declares them.
 const GLOBAL_FLAGS = { switches: ['help', 'version'] };
-export const VERB_FLAGS = {
-    init: { switches: ['global', 'no-hooks', 'no-learn', 'no-schedule'], values: ['scan'], numbers: ['days'] },
-    remember: {
-        switches: ['error', 'extract', 'force', 'global', 'inferred', 'observed', 'pin', 'verified'],
-        values: ['artifact-ref', 'kind', 'layer', 'owner', 'scope'],
-        lists: ['tag'],
-    },
-    recall: {
-        switches: ['classic', 'continuity', 'equal-sources', 'evc-adaptive', 'filter-conflicts', 'graph-stream',
-            'include-superseded', 'json', 'multihop', 'no-mmr', 'physics', 'rerank-utility', 'value-aware', 'why'],
-        values: ['as-of', 'budget', 'goal', 'graph-hops', 'graph-seeds', 'hops', 'layer', 'max-neighbors', 'outcome',
-            'reranker', 'salience-threshold', 'scope', 'session-id'],
-        numbers: ['limit', 'local-bump', 'min-results', 'mmr-lambda', 'reranker-top-k'],
-    },
-    drill: { switches: ['json'], values: ['budget', 'depth'], numbers: ['limit'] },
-    assemble: { switches: ['json', 'no-summarize-older'], values: ['budget', 'fresh-tail', 'scope', 'session'] },
-    supersede: { switches: ['pin'], values: ['layer'], lists: ['tag'] },
-    explain: {
-        switches: ['classic', 'equal-sources', 'include-superseded', 'json', 'no-mmr', 'physics'],
-        values: ['as-of', 'budget', 'scope'],
-        numbers: ['limit', 'local-bump', 'mmr-lambda'],
-    },
-    eval: {
-        switches: ['bootstrap', 'equal-sources', 'json', 'no-mmr', 'save-baseline', 'show-cases', 'suite'],
-        values: ['baseline', 'compare', 'out'],
-        numbers: ['embedding-weight', 'local-bump', 'max-cases', 'min-mrr', 'mmr-lambda'],
-    },
-    trace: { switches: ['json'], values: ['outcome', 'session', 'source', 'steps', 'task'], lists: ['tag'] },
-    refine: { switches: ['all', 'dry-run', 'json'], values: ['model'], numbers: ['limit'] },
-    sleep: { switches: ['dry-run', 'no-learn', 'no-share'], values: ['log-file'] },
-    'last-sleep': { switches: ['keep'], values: ['path'] },
-    'session-end': {
-        switches: ['dry-run', 'no-learn', 'no-share', 'turn'],
-        values: ['format', 'log-file', 'runtime', 'session-id', 'transcript'],
-    },
-    '__session-end-worker': {
-        switches: ['dry-run', 'no-learn', 'no-share', 'turn'],
-        values: ['log-file', 'session-id', 'transcript'],
-    },
-    'pre-compact': { values: ['format', 'log-file', 'runtime'] },
-    'post-compact': { values: ['log-file'] },
-    'capture-error': { values: ['format', 'runtime'] },
-    'compact-resume': {},
-    'codex-run': {},
-    '__codex-session-end-worker': { values: ['codex-home', 'history-path', 'log-file', 'start-offset', 'started-at'] },
-    dedup: { switches: ['dry-run'], numbers: ['threshold'] },
-    dag: { switches: ['stats'] },
-    auth: { switches: ['all', 'global', 'json'], values: ['label', 'role', 'tenant'] },
-    goal: {
-        switches: ['all', 'no-propagate'],
-        values: ['level', 'outcome', 'parent', 'policy', 'session-id', 'success', 'tenant-id'],
-    },
-    slack: { switches: ['force'], values: ['channel', 'since', 'team', 'tenant'] },
-    github: { switches: ['force'], values: ['max', 'repo', 'since'] },
-    audit: {
-        switches: ['apply', 'dry-run', 'fix', 'global', 'json'],
-        values: ['older-than', 'op', 'since', 'tenant'],
-        numbers: ['limit'],
-    },
-    'correction-latency': { switches: ['json'] },
-    provenance: { switches: ['json', 'strict'] },
-    status: {},
-    outcome: { switches: ['bad', 'good'], values: ['id'] },
-    conflicts: { switches: ['json'], values: ['status'] },
-    resolve: { switches: ['forget', 'reject-loser'], values: ['keep', 'reason'] },
-    reject: { switches: ['global'], values: ['reason', 'value'] },
-    rejections: { switches: ['global', 'json'] },
-    unreject: { switches: ['global'] },
-    dormant: { switches: ['global', 'json'], numbers: ['limit'] },
-    projects: { switches: ['apply', 'global', 'json'] },
-    quarantine: { switches: ['all', 'global', 'json'] },
-    tokens: { switches: ['global', 'json'], numbers: ['days'] },
-    failures: { switches: ['global', 'json'], numbers: ['days'] },
-    doctor: { switches: ['json'] },
-    'support-bundle': { switches: ['include-logs'], values: ['out'] },
-    snapshot: { switches: ['json'], values: ['id', 'next-step', 'session', 'source', 'status', 'summary', 'task'] },
-    session: {
-        switches: ['json'],
-        values: ['content', 'id', 'outcome', 'session', 'source', 'summary', 'task', 'type'],
-        numbers: ['limit'],
-    },
-    handoff: {
-        switches: ['json'],
-        values: ['card-id', 'id', 'next', 'outcome', 'session', 'summary', 'target-runtime', 'task', 'tests'],
-        lists: ['artifact', 'constraint'],
-    },
-    // Every card subcommand's flags together; card.ts then refuses the ones its subcommand does not read.
-    card: {
-        switches: ['json'],
-        values: ['author', 'body', 'budget', 'contract', 'outcome', 'reason', 'repo', 'run', 'runtime', 'session',
-            'status', 'title'],
-        lists: ['depends-on'],
-    },
-    predict: {
-        values: ['actual', 'class', 'estimate', 'note', 'state', 'status', 'target', 'unit'],
-        numbers: ['limit'],
-    },
-    current: { switches: ['json'] },
-    forget: { switches: ['archive', 'dry-run'], values: ['reason'] },
-    inspect: {},
-    context: {
-        switches: ['auto', 'cross-project', 'pinned-only'],
-        values: ['budget', 'format', 'framing', 'include-recent', 'runtime', 'scope'],
-        numbers: ['limit'],
-    },
-    hook: {},
-    setup: { switches: ['all', 'dry-run', 'no-learn', 'no-schedule'] },
-    'daily-runner': {},
-    embed: { switches: ['global', 'reset-physics', 'status'] },
-    watch: {},
-    learn: { switches: ['git'], values: ['repos'], numbers: ['days'] },
-    promote: {},
-    sync: { switches: ['cross-project'] },
-    share: { switches: ['auto', 'dry-run', 'force'], numbers: ['min-score'] },
-    peers: { switches: ['all-tenants'] },
-    import: {
-        switches: ['agents', 'dry-run', 'global'],
-        values: ['chatgpt', 'claude', 'cursor', 'file', 'markdown', 'name', 'scope', 'vault'],
-        lists: ['tag'],
-    },
-    export: { values: ['format'] },
-    capture: { switches: ['dry-run', 'global', 'last-session', 'stdin'], values: ['file', 'log-file', 'transcript'] },
-    dashboard: { numbers: ['port'] },
-    wm: { switches: ['json'], values: ['content', 'importance', 'scope', 'session', 'task'], numbers: ['limit'] },
-    mcp: {},
-    serve: { values: ['host', 'tls-cert', 'tls-key'], numbers: ['port'] },
-    invalidate: { switches: ['churn', 'dry-run'], values: ['id', 'reason'] },
-    decide: { values: ['context', 'status', 'supersedes'], numbers: ['limit'] },
-    incident: { values: ['context', 'resolution', 'status'], numbers: ['limit'], lists: ['link'] },
-    process: { values: ['change', 'description', 'status'], numbers: ['limit'], lists: ['step'] },
-    policy: { values: ['change', 'from', 'name', 'status', 'text', 'to'], numbers: ['limit'] },
-    skill: { values: ['change', 'instructions', 'status', 'trigger'], numbers: ['limit'] },
-    brief: { switches: ['dry-run'], values: ['change', 'repo', 'status', 'summary'], numbers: ['limit'] },
-    note: { values: ['change', 'customer', 'status', 'text'], numbers: ['limit'] },
-    graph: { switches: ['json', 'open'], values: ['entity', 'format', 'out'] },
-};
 const FIELD_KINDS = [['switches', 'switch'], ['values', 'value'], ['numbers', 'number'], ['lists', 'list']];
-const DECLARED = new Map([GLOBAL_FLAGS, ...Object.values(VERB_FLAGS)].map((verb) => [
+const DECLARED = new Map([GLOBAL_FLAGS, ...Object.values(COMMANDS).map((row) => row.flags)].map((verb) => [
     verb,
     new Map(FIELD_KINDS.flatMap(([field, kind]) => (verb[field] ?? []).map((name) => [name, kind]))),
 ]));

package/dist/cli/github.d.ts

@@ -0,0 +1,14 @@
+/** `hippo github` subcommands, split out of cli.ts so tests can import them without triggering main().
+ * The dispatcher in cli.ts re-exports handleGitHub. */
+import { type GitHubFetcher } from '../connectors/github/octokit-client.js';
+import type { CommandContext } from './flag-values.js';
+type FlagValue = string | boolean | string[];
+type Flags = Record<string, FlagValue>;
+export declare function printGitHubBackfillUsage(): void;
+/** `hippo github backfill`; the fetcher is injectable so tests avoid the network (default `realGitHubFetcher`). */
+export declare function cmdGitHubBackfill(hippoRoot: string, tenantId: string, flags: Flags, fetcher?: GitHubFetcher): Promise<void>;
+export declare function cmdGitHubDlqList(hippoRoot: string, tenantId: string, _flags: Flags): void;
+export declare function cmdGitHubDlqReplay(hippoRoot: string, tenantId: string, args: string[], flags: Flags): Promise<void>;
+export declare function handleGitHub({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
+export {};
+//# sourceMappingURL=github.d.ts.map

package/dist/{connectors/github/cli-impl.js → cli/github.js}

@@ -1,43 +1,28 @@
-/**
- * Implementation of `hippo github` CLI subcommands. Extracted from the main
- * cli.ts so unit tests can import these functions directly without triggering
- * the cli.ts main() side effects. The cli.ts dispatcher re-exports the
- * top-level cmdGithub.
- *
- * Subcommands mirror the Slack connector shape (cli.ts §Slack subcommands):
- *   - hippo github backfill --repo <owner/name> [--since ISO] [--max <N>]
- *   - hippo github dlq list
- *   - hippo github dlq replay <id> [--force]
- */
-import { envGithubToken, envGithubWebhookSecret, envGithubWebhookSecretPrevious } from '../../util/env.js';
-import { adminActor } from '../../api/index.js';
-import { seedCursors } from '../../store/connectors/github.js';
-import { resolveTenantId } from '../../store/tenant.js';
-import { backfillRepo } from './backfill.js';
-import { realGitHubFetcher } from './octokit-client.js';
-import { listDlq } from '../dlq.js';
-import { githubDlq, replayDlqEntry } from './dlq.js';
-import { ingestEvent } from './ingest.js';
-import { handleCommentDeleted } from './deletion.js';
-import { computeDeletionKey } from './signature.js';
-import { isGitHubIssueEvent, isGitHubIssueCommentEvent, isGitHubPullRequestEvent, isGitHubPullRequestReviewCommentEvent, } from './types.js';
+/** `hippo github` subcommands, split out of cli.ts so tests can import them without triggering main().
+ * The dispatcher in cli.ts re-exports handleGitHub. */
+import { envGitHubToken, envGitHubWebhookSecret, envGitHubWebhookSecretPrevious } from '../util/env.js';
+import { adminActor } from '../api/index.js';
+import { backfillRepo } from '../connectors/github/backfill.js';
+import { realGitHubFetcher } from '../connectors/github/octokit-client.js';
+import { listDlq } from '../connectors/dlq.js';
+import { githubDlq, replayDlqEntry } from '../connectors/github/dlq.js';
+import { ingestEvent } from '../connectors/github/ingest.js';
+import { handleCommentDeleted } from '../connectors/github/deletion.js';
+import { computeDeletionKey } from '../connectors/github/signature.js';
+import { isGitHubIssueEvent, isGitHubIssueCommentEvent, isGitHubPullRequestEvent, isGitHubPullRequestReviewCommentEvent, } from '../connectors/github/types.js';
+import { CliExit } from './exit.js';
+import { errorMessage } from '../util/log.js';
 function isFlagString(value) {
     return typeof value === 'string';
 }
-// FlagValue never includes `number` (see its declaration above), so a
-// `value is number` predicate directly on FlagValue would not type-check —
-// the generic wrapper narrows a value of any type T instead.
+// FlagValue never includes `number`, so a `value is number` predicate on it would not type-check; the generic wrapper narrows any type T instead.
 function isNumberLike(value) {
     return typeof value === 'number';
 }
 function isFlagValueNumberLike(value) {
     return isNumberLike(value);
 }
-/**
- * Map a parsed envelope + eventName header to an IngestEvent discriminated
- * union. Returns null for unknown event types or shapes that don't pass the
- * type guards.
- */
+/** Map a parsed envelope + eventName header to an IngestEvent; null for unknown event types or shapes failing the type guards. */
 function parsedToIngestEvent(parsed, eventName) {
     if (eventName === 'issues' && isGitHubIssueEvent(parsed, eventName)) {
         return { eventName: 'issues', payload: parsed };
@@ -55,7 +40,7 @@ function parsedToIngestEvent(parsed, eventName) {
     return null;
 }
 // Console lines below are the `hippo github` command's printed result and usage text, so they stay off the logger.
-export function printGithubBackfillUsage() {
+export function printGitHubBackfillUsage() {
     console.log('hippo github backfill --repo <owner/name> [--since ISO] [--max <N>]');
     console.log('  --repo   GitHub repository in owner/name format (required, e.g. acme/widgets)');
     console.log('  --since  Initial high-water-mark for first run (optional, ISO 8601)');
@@ -72,31 +57,21 @@ function maxPerStreamFlag(maxRaw) {
     }
     return undefined;
 }
-/**
- * `hippo github backfill`. The fetcher is injectable so tests can drive the
- * code path without hitting the network. Defaults to `realGitHubFetcher`.
- */
-export async function cmdGithubBackfill(hippoRoot, flags, fetcher = realGitHubFetcher) {
+/** `hippo github backfill`; the fetcher is injectable so tests avoid the network (default `realGitHubFetcher`). */
+export async function cmdGitHubBackfill(hippoRoot, tenantId, flags, fetcher = realGitHubFetcher) {
     const repo = flags['repo'];
     if (!isFlagString(repo) || !repo.includes('/')) {
-        printGithubBackfillUsage();
-        process.exit(2);
+        printGitHubBackfillUsage();
+        throw new CliExit(2);
     }
-    const token = envGithubToken();
+    const token = envGitHubToken();
     if (!token) {
         console.error('GITHUB_TOKEN is not set. Backfill requires a personal access token with repo read scope.');
-        process.exit(2);
+        throw new CliExit(2);
     }
     const maxPerStream = maxPerStreamFlag(flags['max']);
     const sinceFlag = flags['since'];
     const sinceIso = isFlagString(sinceFlag) ? sinceFlag : undefined;
-    const tenantId = resolveTenantId({});
-    // Seed the github_cursors row so all 3 streams use --since on a fresh run.
-    // COALESCE preserves any existing HWM (subsequent runs ignore --since for
-    // streams that already drained at least once — same idempotency story as
-    // Slack's slack_cursors).
-    if (sinceIso)
-        seedCursors(hippoRoot, tenantId, repo, sinceIso);
     const ctx = {
         hippoRoot,
         tenantId,
@@ -108,19 +83,17 @@ export async function cmdGithubBackfill(hippoRoot, flags, fetcher = realGitHubFe
             fetcher,
             token,
             maxPerStream,
+            sinceIso,
         });
         console.log(JSON.stringify(result, null, 2));
     }
     catch (e) {
-        // SAFETY: this is a best-effort error message only; property access on
-        // any JS value is safe (undefined if absent), preserving the existing
-        // lenient formatting even when something non-Error was thrown.
-        console.error('backfill failed:', e.message);
-        process.exit(3);
+        console.error('backfill failed:', errorMessage(e));
+        throw new CliExit(3);
     }
 }
-export function cmdGithubDlqList(hippoRoot, _flags) {
-    const items = listDlq(githubDlq, hippoRoot, { tenantId: resolveTenantId({}) });
+export function cmdGitHubDlqList(hippoRoot, tenantId, _flags) {
+    const items = listDlq(githubDlq, hippoRoot, { tenantId });
     if (items.length === 0) {
         console.log('no entries');
         return;
@@ -150,9 +123,8 @@ const reingestParkedDelivery = async (innerCtx, args) => {
             deliveryId: args.deliveryId,
             eventName: event.eventName,
         });
-        // archivedCount maps to memoryId only loosely — return null since the
-        // archive operation can affect multiple rows. The replay-result audit
-        // trail is in github_dlq.retry_count + retried_at.
+        // archivedCount maps to memoryId only loosely (the archive can affect multiple rows), so return null;
+        // the replay audit trail is github_dlq.retry_count + retried_at.
         return { memoryId: r.archivedCount > 0 ? 'archived' : null };
     }
     const r = await ingestEvent(innerCtx, {
@@ -162,51 +134,51 @@ const reingestParkedDelivery = async (innerCtx, args) => {
     });
     return { memoryId: r.memoryId };
 };
-export async function cmdGithubDlqReplay(hippoRoot, args, flags) {
+export async function cmdGitHubDlqReplay(hippoRoot, tenantId, args, flags) {
     const idArg = args[0];
     if (!idArg) {
         console.error('Usage: hippo github dlq replay <id> [--force]');
-        process.exit(1);
+        throw new CliExit(1);
     }
     const id = Number(idArg);
     if (!Number.isFinite(id) || !Number.isInteger(id) || id < 1) {
         console.error(`replay: invalid id ${idArg}`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     const force = flags['force'] === true;
     const ctx = {
         hippoRoot,
-        tenantId: resolveTenantId({}),
+        tenantId,
         actor: adminActor('cli:github-dlq-replay'),
     };
     // Without an ingestHook replay only bumps retry_count while printing "replay ok"; the real hook re-runs ingest.
     const result = await replayDlqEntry(ctx, id, {
         force,
-        webhookSecret: envGithubWebhookSecret(),
-        previousSecret: envGithubWebhookSecretPrevious(),
+        webhookSecret: envGitHubWebhookSecret(),
+        previousSecret: envGitHubWebhookSecretPrevious(),
         ingestHook: reingestParkedDelivery,
     });
     if (!result.ok) {
         console.error(`replay failed: status=${result.status} retry_count=${result.retryCount}${result.reason ? ` reason=${result.reason}` : ''}`);
-        process.exit(1);
+        throw new CliExit(1);
     }
     console.log(`replay ok: status=${result.status} memory_id=${result.memoryId ?? '(none)'} retry_count=${result.retryCount}`);
 }
-export async function cmdGithub(hippoRoot, args, flags) {
+export async function handleGitHub({ hippoRoot, tenantId, args, flags }) {
     const sub = args[0];
     if (sub === 'backfill') {
-        await cmdGithubBackfill(hippoRoot, flags);
+        await cmdGitHubBackfill(hippoRoot, tenantId, flags);
         return;
     }
     if (sub === 'dlq' && args[1] === 'list') {
-        cmdGithubDlqList(hippoRoot, flags);
+        cmdGitHubDlqList(hippoRoot, tenantId, flags);
         return;
     }
     if (sub === 'dlq' && args[1] === 'replay') {
-        await cmdGithubDlqReplay(hippoRoot, args.slice(2), flags);
+        await cmdGitHubDlqReplay(hippoRoot, tenantId, args.slice(2), flags);
         return;
     }
     console.error('Usage: hippo github <backfill|dlq list|dlq replay <id> [--force]> [...]');
-    process.exit(1);
+    throw new CliExit(1);
 }
-//# sourceMappingURL=cli-impl.js.map
+//# sourceMappingURL=github.js.map

package/dist/cli/goals.d.ts

@@ -1,3 +1,3 @@
-import { type CliFlags } from './flag-values.js';
-export declare function cmdGoal(hippoRoot: string, args: string[], flags: CliFlags): void;
+import { type CommandContext } from './flag-values.js';
+export declare function handleGoal({ hippoRoot, tenantId, args, flags }: CommandContext): void;
 //# sourceMappingURL=goals.d.ts.map