hippo-memory 1.69.0 → 1.71.0

package/dist/cli/flags.d.ts

@@ -0,0 +1,304 @@
+export type FlagKind = 'switch' | 'value' | 'number' | 'list';
+/** One verb's flags by kind: a number is refused unless numeric, and a list collects repeats. */
+export interface VerbFlags {
+    readonly switches?: readonly string[];
+    readonly values?: readonly string[];
+    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[];
+        numbers: 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`. */
+export declare function isKnownFlag(name: string): boolean;
+/** The typed flags this verb does not read, in the order typed. */
+export declare function undeclaredFlags(verb: VerbFlags, typed: readonly string[]): string[];
+//# sourceMappingURL=flags.d.ts.map

package/dist/cli/flags.js

@@ -0,0 +1,169 @@
+// Each verb's flags as data, keyed like the command table: parseArgs needs a flag's kind before the verb's module loads.
+// 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', 'no-expiry'], values: ['label', 'role', 'tenant'], numbers: ['ttl-days'] },
+    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) => [
+    verb,
+    new Map(FIELD_KINDS.flatMap(([field, kind]) => (verb[field] ?? []).map((name) => [name, kind]))),
+]));
+// A flag typed on a verb that does not declare it still has to parse: it takes the kind its
+// declaring verbs agree on, and where they differ it is a plain value.
+const SHARED_KIND = (() => {
+    const shared = new Map();
+    for (const kinds of DECLARED.values()) {
+        for (const [name, kind] of kinds)
+            shared.set(name, (shared.get(name) ?? kind) === kind ? kind : 'value');
+    }
+    return shared;
+})();
+/** How parseArgs reads `--name` on the verb with these flags; `undefined` is a command the table lacks. */
+export function flagKind(verb, name) {
+    return (verb ? DECLARED.get(verb)?.get(name) : undefined) ?? SHARED_KIND.get(name) ?? 'value';
+}
+/** Whether any verb, or the entry point, reads `--name`. */
+export function isKnownFlag(name) {
+    return SHARED_KIND.has(name);
+}
+/** The typed flags this verb does not read, in the order typed. */
+export function undeclaredFlags(verb, typed) {
+    const declared = DECLARED.get(verb);
+    const global = DECLARED.get(GLOBAL_FLAGS);
+    return typed.filter((name) => !declared?.has(name) && !global?.has(name));
+}
+//# sourceMappingURL=flags.js.map

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/cli/github.js

@@ -0,0 +1,184 @@
+/** `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`, 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; 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 };
+    }
+    if (eventName === 'issue_comment' && isGitHubIssueCommentEvent(parsed, eventName)) {
+        return { eventName: 'issue_comment', payload: parsed };
+    }
+    if (eventName === 'pull_request' && isGitHubPullRequestEvent(parsed, eventName)) {
+        return { eventName: 'pull_request', payload: parsed };
+    }
+    if (eventName === 'pull_request_review_comment' &&
+        isGitHubPullRequestReviewCommentEvent(parsed, eventName)) {
+        return { eventName: 'pull_request_review_comment', payload: parsed };
+    }
+    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() {
+    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)');
+    console.log('  --max    Cap items per stream (optional, integer)');
+    console.log('  Requires GITHUB_TOKEN env var with repo read scope.');
+}
+/** `--max` as a whole positive count; undefined (no cap) when absent or not one. */
+function maxPerStreamFlag(maxRaw) {
+    if (isFlagString(maxRaw) || isFlagValueNumberLike(maxRaw)) {
+        const parsed = Number(maxRaw);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return Math.floor(parsed);
+        }
+    }
+    return undefined;
+}
+/** `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();
+        throw new CliExit(2);
+    }
+    const token = envGitHubToken();
+    if (!token) {
+        console.error('GITHUB_TOKEN is not set. Backfill requires a personal access token with repo read scope.');
+        throw new CliExit(2);
+    }
+    const maxPerStream = maxPerStreamFlag(flags['max']);
+    const sinceFlag = flags['since'];
+    const sinceIso = isFlagString(sinceFlag) ? sinceFlag : undefined;
+    const ctx = {
+        hippoRoot,
+        tenantId,
+        actor: adminActor('cli:github-backfill'),
+    };
+    try {
+        const result = await backfillRepo(ctx, {
+            repoFullName: repo,
+            fetcher,
+            token,
+            maxPerStream,
+            sinceIso,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    }
+    catch (e) {
+        console.error('backfill failed:', errorMessage(e));
+        throw new CliExit(3);
+    }
+}
+export function cmdGitHubDlqList(hippoRoot, tenantId, _flags) {
+    const items = listDlq(githubDlq, hippoRoot, { tenantId });
+    if (items.length === 0) {
+        console.log('no entries');
+        return;
+    }
+    for (const it of items) {
+        console.log(`${it.id}\t${it.bucket}\t${it.tenantId}\t${it.eventName ?? '-'}\t${it.receivedAt}\t${it.error}`);
+    }
+}
+const reingestParkedDelivery = async (innerCtx, args) => {
+    const parsed = JSON.parse(args.rawPayload);
+    const event = parsedToIngestEvent(parsed, args.eventName);
+    if (!event) {
+        return { memoryId: null };
+    }
+    // A replayed comment `.deleted` row must route to the deletion handler, NOT to ingestEvent,
+    // which would write the deleted comment as a NEW raw memory instead of archiving the matching ones.
+    if ((event.eventName === 'issue_comment' || event.eventName === 'pull_request_review_comment') &&
+        event.payload.action === 'deleted') {
+        const repo = event.payload.repository?.full_name ?? '';
+        const artifactRef = event.eventName === 'issue_comment'
+            ? `github://${repo}/issue/${event.payload.issue.number}/comment/${event.payload.comment.id}`
+            : `github://${repo}/pull/${event.payload.pull_request.number}/review_comment/${event.payload.comment.id}`;
+        const idempotencyKey = computeDeletionKey(artifactRef, event.payload.comment.updated_at ?? null);
+        const r = await handleCommentDeleted(innerCtx, {
+            artifactRef,
+            idempotencyKey,
+            deliveryId: args.deliveryId,
+            eventName: event.eventName,
+        });
+        // 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, {
+        event,
+        rawBody: args.rawPayload,
+        deliveryId: args.deliveryId,
+    });
+    return { memoryId: r.memoryId };
+};
+export async function cmdGitHubDlqReplay(hippoRoot, tenantId, args, flags) {
+    const idArg = args[0];
+    if (!idArg) {
+        console.error('Usage: hippo github dlq replay <id> [--force]');
+        throw new CliExit(1);
+    }
+    const id = Number(idArg);
+    if (!Number.isFinite(id) || !Number.isInteger(id) || id < 1) {
+        console.error(`replay: invalid id ${idArg}`);
+        throw new CliExit(1);
+    }
+    const force = flags['force'] === true;
+    const ctx = {
+        hippoRoot,
+        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(),
+        ingestHook: reingestParkedDelivery,
+    });
+    if (!result.ok) {
+        console.error(`replay failed: status=${result.status} retry_count=${result.retryCount}${result.reason ? ` reason=${result.reason}` : ''}`);
+        throw new CliExit(1);
+    }
+    console.log(`replay ok: status=${result.status} memory_id=${result.memoryId ?? '(none)'} retry_count=${result.retryCount}`);
+}
+export async function handleGitHub({ hippoRoot, tenantId, args, flags }) {
+    const sub = args[0];
+    if (sub === 'backfill') {
+        await cmdGitHubBackfill(hippoRoot, tenantId, flags);
+        return;
+    }
+    if (sub === 'dlq' && args[1] === 'list') {
+        cmdGitHubDlqList(hippoRoot, tenantId, flags);
+        return;
+    }
+    if (sub === 'dlq' && args[1] === 'replay') {
+        await cmdGitHubDlqReplay(hippoRoot, tenantId, args.slice(2), flags);
+        return;
+    }
+    console.error('Usage: hippo github <backfill|dlq list|dlq replay <id> [--force]> [...]');
+    throw new CliExit(1);
+}
+//# sourceMappingURL=github.js.map

package/dist/cli/goals.d.ts

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