@mmnto/cli 2.2.1 → 2.4.0

package/dist/commands/resolve-threads-cli-wiring.test.js

@@ -0,0 +1,103 @@
+/**
+ * Command-surface (Commander parser) tests for the `totem resolve-threads`
+ * wiring (mmnto-ai/totem#2841).
+ *
+ * `index.ts` builds its `program` at module scope and auto-runs `parseAsync` on
+ * import, so it cannot be imported without executing the CLI against the test
+ * runner's argv. This therefore tests a hand-maintained MIRROR of the
+ * registration (`buildProgram` below), not `index.ts` itself — the same
+ * structural limit `mail-cli-wiring.test.ts` and `seat-cli-wiring.test.ts`
+ * document.
+ *
+ * The lock that earns this file: the program-level `--json` SWALLOWS a
+ * post-subcommand `--json` (the mmnto-ai/totem#2097 parent/child option
+ * collision). A built-binary run of `totem resolve-threads 2839 --json` printed
+ * the human rows and no JSON before the action was switched to
+ * `optsWithGlobals()`. Parser-level only: no gh, no network, no core import.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Command } from 'commander';
+import { describe, expect, it, vi } from 'vitest';
+/** Mirror of the `resolve-threads` registration in index.ts. */
+function buildProgram(handler) {
+    const program = new Command();
+    program.exitOverride(); // throw on parse error instead of process.exit
+    // The program-level `--json` is what makes the collision reachable.
+    program.option('--json', 'Output structured JSON to stdout');
+    program
+        .command('resolve-threads <pr-number>')
+        .option('--apply', 'Run the resolveReviewThread mutation (default: print the plan only)')
+        .option('--ids <ids>', 'Comma-separated REST root comment ids to narrow the batch')
+        .option('--json', 'Emit the plan rows as one JSON document')
+        .action((prNumber, _opts, cmd) => {
+        // EXACT read from index.ts.
+        const { apply, ids, json } = cmd.optsWithGlobals();
+        handler(prNumber, {
+            apply: apply === true,
+            ...(ids === undefined ? {} : { ids }),
+            json: json === true,
+        });
+    });
+    return program;
+}
+describe('resolve-threads CLI command-surface (Commander wiring, mmnto-ai/totem#2841)', () => {
+    it('defaults to dry-run: no --apply, no --ids, no --json', () => {
+        const handler = vi.fn();
+        buildProgram(handler).parse(['node', 'totem', 'resolve-threads', '2839']);
+        expect(handler).toHaveBeenCalledTimes(1);
+        expect(handler.mock.calls[0][0]).toBe('2839');
+        expect(handler.mock.calls[0][1]).toEqual({ apply: false, json: false });
+    });
+    it('--apply parses to apply: true', () => {
+        const handler = vi.fn();
+        buildProgram(handler).parse(['node', 'totem', 'resolve-threads', '2839', '--apply']);
+        expect(handler.mock.calls[0][1].apply).toBe(true);
+    });
+    it('--ids carries the comma list through verbatim', () => {
+        const handler = vi.fn();
+        buildProgram(handler).parse([
+            'node',
+            'totem',
+            'resolve-threads',
+            '2839',
+            '--ids',
+            '3954062164,3954067481',
+        ]);
+        expect(handler.mock.calls[0][1].ids).toBe('3954062164,3954067481');
+    });
+    it('--json AFTER the subcommand still arrives (the #2097 collision)', () => {
+        const handler = vi.fn();
+        buildProgram(handler).parse(['node', 'totem', 'resolve-threads', '2839', '--json']);
+        expect(handler.mock.calls[0][1].json).toBe(true);
+    });
+    it('--json BEFORE the subcommand arrives too, so both spellings agree', () => {
+        const handler = vi.fn();
+        buildProgram(handler).parse(['node', 'totem', '--json', 'resolve-threads', '2839']);
+        expect(handler.mock.calls[0][1].json).toBe(true);
+    });
+    it('requires the PR positional', () => {
+        const handler = vi.fn();
+        expect(() => buildProgram(handler).parse(['node', 'totem', 'resolve-threads'])).toThrow();
+        expect(handler).not.toHaveBeenCalled();
+    });
+    it("the SHIPPED action carries no action-level gh precondition — the verb probes gh itself so --json fails in contract (PR round 1, greptile P1; the leg's F1 sensor)", () => {
+        // The mirror above cannot see this, and the verb's own test calls the
+        // command directly, so re-inserting `requireGhCli();` as the action's first
+        // statement would restore the exact defect with every other test green.
+        // Read the registration SOURCE structurally, the way lesson.test.ts reads
+        // its deprecation aliases: the `resolve-threads` action block, from its
+        // `.command(` to the next `.command(`, must not call requireGhCli.
+        const indexSrc = fs.readFileSync(path.join(process.cwd(), 'src/index.ts'), 'utf-8');
+        const start = indexSrc.indexOf(".command('resolve-threads <pr-number>')");
+        expect(start, 'the resolve-threads registration is present').toBeGreaterThan(-1);
+        const next = indexSrc.indexOf('.command(', start + 1);
+        const block = indexSrc.slice(start, next === -1 ? undefined : next);
+        expect(block).toContain('resolveThreadsCommand(');
+        expect(block).not.toMatch(/requireGhCli\(\)\s*;/);
+        // The sibling actions still carry it — the sensor is about THIS verb's
+        // contract, not a repo-wide retirement of the precondition.
+        expect(indexSrc).toMatch(/requireGhCli\(\);/);
+    });
+});
+//# sourceMappingURL=resolve-threads-cli-wiring.test.js.map

package/dist/commands/resolve-threads-cli-wiring.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-threads-cli-wiring.test.js","sourceRoot":"","sources":["../../src/commands/resolve-threads-cli-wiring.test.ts"],"names":[],"mappings":"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"}

package/dist/commands/resolve-threads.d.ts

@@ -0,0 +1,472 @@
+/**
+ * `totem resolve-threads <pr>` — resolve the bot review threads a round has
+ * already dispositioned (mmnto-ai/totem#2841, rulings R1-R4 in
+ * `.totem/specs/2841.md`).
+ *
+ * WHY IT EXISTS: the merge-ready gate's predicate 2 (mmnto-ai/totem#2800)
+ * denies a merge while any unresolved, non-outdated review thread rooted by a
+ * known review bot is open. The lawful way past it is to RESOLVE the threads a
+ * round has answered — not to silence the predicate. This verb does exactly
+ * that, deterministically and with zero LLM calls.
+ *
+ * THE EVIDENCE RULE (R2 verbatim): "An in-thread human reply OR a human
+ * PR-level comment created after the thread's root — either suffices." So:
+ *   - `in-thread-reply`: a comment after the root whose author is not a bot
+ *     (the CodeRabbit/Greptile routine); or
+ *   - `pr-level-disposition`: ANY non-bot PR-level (issue) comment created
+ *     AFTER the thread's root comment. It is NOT keyed to the round-disposition
+ *     comment specifically — the rule is any non-bot comment that postdates the
+ *     root, because a PR-level comment is the only lawful answer to a GCA
+ *     thread (bot-protocols forbids replying to GCA in-thread) and no
+ *     deterministic reading distinguishes a disposition from other human prose.
+ *     CONSEQUENCE, stated because it is load-bearing: on a re-invoked round the
+ *     operator's trigger comment ("@coderabbitai review") is itself non-bot
+ *     evidence for every thread it postdates — which is exactly why the round
+ *     disposition must be posted BEFORE this verb runs (the review-reply
+ *     skill's step 4 ordering), not after.
+ * A thread with neither is a `skip:no-evidence` row and is NEVER resolved,
+ * under any flag. There is no override.
+ *
+ * WHAT COUNTS AS A BOT, on each surface (the fail-open trap this holds shut):
+ * the four review-bot logins are core's closed list, but ANY GitHub App can
+ * comment — `github-actions[bot]`, a Copilot reviewer, a scanner — and an App's
+ * comment is not a human answer. So a comment is a bot's when GraphQL says
+ * `author.__typename === 'Bot'`, or the login ends in `[bot]`, or it is on
+ * core's exact list; on REST, when `user.type === 'Bot'`, or the login ends in
+ * `[bot]`, or core's loose review-bot pattern matches. Only what survives all
+ * three arms is evidence. A DELETED account (null author) is deliberately NOT a
+ * bot: the reply it left was a human reply when it was written, and deleting
+ * the account does not retract it (recorded as item (6) of the design's
+ * disagreement list in `.totem/specs/2841.md`).
+ *
+ * SAFETY PROPERTIES this module holds:
+ *   - Dry-run by DEFAULT. `--apply` is the only path that mutates.
+ *   - The verb NEVER posts a comment, a reply or a review. The only mutation it
+ *     can issue is `resolveReviewThread`.
+ *   - A read that could not be completed (a `hasNextPage` it cannot follow, a
+ *     page budget blown, a `gh` failure, a GraphQL `errors` body) is a HARD
+ *     failure — exit 1, nothing resolved. Never a shorter list silently
+ *     treated as the whole PR (the no-silent-shrink rule the spine reader and
+ *     merge-ready both hold).
+ *   - A human-rooted thread is never a candidate, whatever its state.
+ *   - Every bot-rooted thread prints exactly one row carrying its REST root
+ *     comment id (R4), so nothing is skipped silently.
+ *
+ * Every `gh` call goes through the injected {@link GhRunner} seam (the
+ * mmnto-ai/totem#2800 shape: argv in, `{ stdout, exitCode }` out — never a
+ * shell string), so the tests run fully offline against checked-in captures.
+ */
+import { z } from 'zod';
+import type { GhRunner } from '@mmnto/totem';
+/**
+ * The thread read. `comments(first:)` carries `databaseId` — the REST comment
+ * id `totem triage-pr` prints as a finding's `rootCommentId`, which is what
+ * `--ids` selects on and what every row prints (R4).
+ */
+export declare const RESOLVE_THREADS_QUERY = "query TotemResolveThreads($owner: String!, $name: String!, $number: Int!, $threadsAfter: String) {\n  repository(owner: $owner, name: $name) {\n    pullRequest(number: $number) {\n      reviewThreads(first: 100, after: $threadsAfter) {\n        pageInfo { hasNextPage endCursor }\n        nodes {\n          id\n          isResolved\n          isOutdated\n          path\n          comments(first: 100) {\n            pageInfo { hasNextPage endCursor }\n            nodes {\n              databaseId\n              author { __typename login }\n              createdAt\n            }\n          }\n        }\n      }\n    }\n  }\n}";
+/**
+ * The per-thread comment continuation. A nested connection cannot be paged from
+ * the outer document (one cursor cannot address many threads), so a thread that
+ * reports `comments.pageInfo.hasNextPage` is followed by node id until it is
+ * complete. A page that cannot be followed is a failed read, not a short list.
+ */
+export declare const RESOLVE_THREAD_COMMENTS_QUERY = "query TotemResolveThreadComments($threadId: ID!, $commentsAfter: String) {\n  node(id: $threadId) {\n    ... on PullRequestReviewThread {\n      comments(first: 100, after: $commentsAfter) {\n        pageInfo { hasNextPage endCursor }\n        nodes {\n          databaseId\n          author { __typename login }\n          createdAt\n        }\n      }\n    }\n  }\n}";
+/**
+ * The ONLY mutation this verb can issue. It asks the thread back with
+ * `isResolved` so the run can CONFIRM the outcome rather than infer it from a
+ * clean exit (see {@link confirmResolved}).
+ */
+export declare const RESOLVE_THREAD_MUTATION = "mutation TotemResolveReviewThread($threadId: ID!) {\n  resolveReviewThread(input: { threadId: $threadId }) {\n    thread { id isResolved }\n  }\n}";
+/**
+ * `author` is null for a deleted/ghost account — never coerced to a bot.
+ * `__typename` is REQUIRED, not optional: both documents select it, and it is
+ * the only signal that catches a GitHub App outside core's four-name review-bot
+ * list (`github-actions`, a Copilot reviewer, a scanner). Making it optional
+ * would let a document that quietly stopped selecting it fail OPEN — every App
+ * reply reading as a human reply. Absent ⇒ the read fails loud instead.
+ */
+declare const GqlCommentSchema: z.ZodObject<{
+    databaseId: z.ZodNullable<z.ZodNumber>;
+    author: z.ZodNullable<z.ZodObject<{
+        __typename: z.ZodString;
+        login: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        login: string;
+        __typename: string;
+    }, {
+        login: string;
+        __typename: string;
+    }>>;
+    createdAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    createdAt: string;
+    author: {
+        login: string;
+        __typename: string;
+    } | null;
+    databaseId: number | null;
+}, {
+    createdAt: string;
+    author: {
+        login: string;
+        __typename: string;
+    } | null;
+    databaseId: number | null;
+}>;
+declare const GqlThreadSchema: z.ZodObject<{
+    id: z.ZodString;
+    isResolved: z.ZodBoolean;
+    isOutdated: z.ZodBoolean;
+    path: z.ZodString;
+    comments: z.ZodObject<{
+        pageInfo: z.ZodObject<{
+            hasNextPage: z.ZodBoolean;
+            endCursor: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            hasNextPage: boolean;
+            endCursor: string | null;
+        }, {
+            hasNextPage: boolean;
+            endCursor: string | null;
+        }>;
+        nodes: z.ZodArray<z.ZodObject<{
+            databaseId: z.ZodNullable<z.ZodNumber>;
+            author: z.ZodNullable<z.ZodObject<{
+                __typename: z.ZodString;
+                login: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                login: string;
+                __typename: string;
+            }, {
+                login: string;
+                __typename: string;
+            }>>;
+            createdAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            createdAt: string;
+            author: {
+                login: string;
+                __typename: string;
+            } | null;
+            databaseId: number | null;
+        }, {
+            createdAt: string;
+            author: {
+                login: string;
+                __typename: string;
+            } | null;
+            databaseId: number | null;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        pageInfo: {
+            hasNextPage: boolean;
+            endCursor: string | null;
+        };
+        nodes: {
+            createdAt: string;
+            author: {
+                login: string;
+                __typename: string;
+            } | null;
+            databaseId: number | null;
+        }[];
+    }, {
+        pageInfo: {
+            hasNextPage: boolean;
+            endCursor: string | null;
+        };
+        nodes: {
+            createdAt: string;
+            author: {
+                login: string;
+                __typename: string;
+            } | null;
+            databaseId: number | null;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    id: string;
+    comments: {
+        pageInfo: {
+            hasNextPage: boolean;
+            endCursor: string | null;
+        };
+        nodes: {
+            createdAt: string;
+            author: {
+                login: string;
+                __typename: string;
+            } | null;
+            databaseId: number | null;
+        }[];
+    };
+    isResolved: boolean;
+    isOutdated: boolean;
+}, {
+    path: string;
+    id: string;
+    comments: {
+        pageInfo: {
+            hasNextPage: boolean;
+            endCursor: string | null;
+        };
+        nodes: {
+            createdAt: string;
+            author: {
+                login: string;
+                __typename: string;
+            } | null;
+            databaseId: number | null;
+        }[];
+    };
+    isResolved: boolean;
+    isOutdated: boolean;
+}>;
+/**
+ * The REST issue-comment shape. `user.login` keeps its `[bot]` suffix on this
+ * surface and `user.type` is `Bot` for every GitHub App — both are read, so an
+ * app comment can never pass as the human disposition.
+ */
+declare const RestIssueCommentSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    user: z.ZodNullable<z.ZodObject<{
+        login: z.ZodString;
+        type: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        login: string;
+    }, {
+        type: string;
+        login: string;
+    }>>;
+    created_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    user: {
+        type: string;
+        login: string;
+    } | null;
+    id: number;
+    created_at?: string | undefined;
+}, {
+    user: {
+        type: string;
+        login: string;
+    } | null;
+    id: number;
+    created_at?: string | undefined;
+}>;
+/** One validated GraphQL review-thread node (the reader's own shape). */
+export type ReviewThreadNode = z.infer<typeof GqlThreadSchema>;
+/** One validated GraphQL review-thread comment node. */
+export type ReviewCommentNode = z.infer<typeof GqlCommentSchema>;
+/** One validated REST issue comment (the PR-level surface). */
+export type RestIssueComment = z.infer<typeof RestIssueCommentSchema>;
+/** One PR review thread, reduced to what the selector reads. */
+export interface ReviewThreadRecord {
+    /** The GraphQL node id (`PRRT_…`) the mutation takes. */
+    id: string;
+    /**
+     * `PullRequestReviewComment.databaseId` of the FIRST comment — the REST id
+     * `totem triage-pr` carries as a finding's `rootCommentId`. Null only when
+     * GitHub answered no id (an `--ids` entry can then never match the row).
+     */
+    rootCommentId: number | null;
+    /** The root comment's `author.login` (GraphQL spelling, no `[bot]`), or null for a deleted account. */
+    rootAuthor: string | null;
+    /** The root comment's `createdAt` — the instant PR-level evidence must post AFTER. */
+    rootCreatedAt: string;
+    isResolved: boolean;
+    isOutdated: boolean;
+    path: string;
+    /** Comments after the root whose author is NOT a known review bot (a null author counts). */
+    humanReplyCount: number;
+}
+/** One PR-level (issue) comment, reduced to what the evidence rule reads. */
+export interface PrIssueCommentRecord {
+    author: string;
+    /** True for a GitHub App (`user.type === 'Bot'`, a `[bot]` login, or a known review bot). */
+    isBot: boolean;
+    createdAt: string | null;
+}
+/** How the round answered a thread. `none` is never resolvable. */
+export type DispositionEvidence = 'in-thread-reply' | 'pr-level-disposition' | 'none';
+/** What the plan says will happen (or did) to one bot-rooted thread. */
+export type ResolveThreadsVerdict = 'resolve' | 'skip:already-resolved' | 'skip:outdated' | 'skip:no-evidence' | 'skip:not-selected';
+/** One printed row. `--json` carries exactly these fields. */
+export interface ResolveThreadsRow {
+    threadId: string;
+    rootCommentId: number | null;
+    rootAuthor: string | null;
+    rootCreatedAt: string;
+    path: string;
+    isResolved: boolean;
+    isOutdated: boolean;
+    humanReplyCount: number;
+    evidence: DispositionEvidence;
+    verdict: ResolveThreadsVerdict;
+    /** null under dry-run (nothing was attempted); true/false once `--apply` ran the mutation. */
+    applied: boolean | null;
+    /** The mutation's failure text when `applied` is false. */
+    errorText: string | null;
+}
+/**
+ * The three identity predicates, injected so the pure selector stays free of
+ * the heavy core barrel (mmnto-ai/totem#2339) and the tests exercise the
+ * SHIPPED classification rather than a copy. All three come from
+ * `packages/core/src/bot-identity.ts` (mmnto-ai/totem#2800), the one
+ * definition; this file spells no bot name, pattern or suffix of its own, and
+ * `bot-identity-parity.test.ts` scans it to keep it that way.
+ */
+export interface BotIdentityPredicates {
+    /**
+     * The GraphQL surface: `isBotReviewerLoginExact` — a CLOSED-list membership
+     * test over a login spelled WITHOUT the `[bot]` suffix. Exact, never a
+     * pattern, so no human account can be read as a bot.
+     */
+    isBotLoginExact: (login: string) => boolean;
+    /** The REST surface: `isBotReviewerLogin` — the loose pattern over a `name[bot]` login. */
+    isBotLoginLoose: (login: string) => boolean;
+    /** Any surface: `hasBotAppLoginSuffix` — the GitHub App suffix (`name[bot]`) on a login. */
+    hasAppSuffix: (login: string) => boolean;
+}
+/** Options for {@link resolveThreadsCommand}. */
+export interface ResolveThreadsOptions {
+    /** Run the `resolveReviewThread` mutation. Absent = dry-run (the default). */
+    apply?: boolean;
+    /** Comma-separated REST root comment ids narrowing the batch (R4). Unmatched entries abort. */
+    ids?: string;
+    /** Emit one JSON document instead of the human rows. */
+    json?: boolean;
+    /** Working directory for the default `gh` runner. */
+    cwd?: string;
+    /** Injectable `gh` seam (tests). Defaults to a `gh`-backed spawn. */
+    runner?: GhRunner;
+    /** stdout sink (tests). */
+    out?: (text: string) => void;
+    /** stderr sink (tests). */
+    err?: (text: string) => void;
+}
+/** What one run produced. */
+export interface ResolveThreadsResult {
+    exitCode: 0 | 1 | 2;
+    rows: ResolveThreadsRow[];
+}
+/**
+ * Reduce validated GraphQL threads to {@link ReviewThreadRecord}s. Pure given
+ * `identity`. The ENTIRE comment list is inspected — human comments are never
+ * filtered out before the classification, because whether a human replied is
+ * exactly what the evidence rule reads.
+ */
+export declare function toThreadRecords(threads: readonly ReviewThreadNode[], identity: BotIdentityPredicates): ReviewThreadRecord[];
+/**
+ * Is this thread rooted by a review bot? Only bot-rooted threads are candidates
+ * (and only they print a row) — a human-rooted thread is never resolved by this
+ * verb, whatever its state.
+ */
+export declare function isBotRootedThread(record: ReviewThreadRecord, identity: BotIdentityPredicates): boolean;
+/**
+ * Reduce validated REST issue comments to {@link PrIssueCommentRecord}s. Pure
+ * given `identity`. The bot test is the REST mirror of {@link isBotComment}'s
+ * three arms: GitHub's `user.type === 'Bot'` (every App), a `[bot]`-suffixed
+ * login, or core's LOOSE review-bot pattern (the REST surface's own test).
+ * A null user (deleted account) is not a bot, for the same reason a null
+ * GraphQL author is not.
+ */
+export declare function toPrCommentRecords(comments: readonly RestIssueComment[], identity: BotIdentityPredicates): PrIssueCommentRecord[];
+/**
+ * Derive the evidence for one thread (R2). An in-thread human reply wins; else
+ * a non-bot PR-level comment created strictly AFTER the thread's root; else
+ * `none`. An unparseable instant on either side is not evidence — the
+ * conservative direction, since `none` can only ever refuse to resolve.
+ */
+export declare function deriveEvidence(record: ReviewThreadRecord, prComments: readonly PrIssueCommentRecord[]): DispositionEvidence;
+/**
+ * The verdict for one candidate thread. PRECEDENCE, most-informative first: an
+ * already-resolved or outdated thread reports THAT (it is the fact the operator
+ * needs, and neither is ever mutated), then non-selection, then the evidence
+ * rule. Only `resolve` ever reaches the mutation.
+ */
+export declare function classifyThread(record: ReviewThreadRecord, evidence: DispositionEvidence, selected: boolean): ResolveThreadsVerdict;
+/** The parsed `--ids` selection, or the error that aborts the run. */
+export type IdSelection = {
+    ok: true;
+    ids: readonly number[] | null;
+} | {
+    ok: false;
+    invalid: readonly string[];
+};
+/**
+ * Parse `--ids`. `null` (the option absent or empty) means "every evidenced bot
+ * thread" — the default (R4). A malformed entry aborts the run exactly like an
+ * unmatched one: a typo must never silently narrow the batch.
+ */
+export declare function parseIdSelection(raw: string | undefined): IdSelection;
+/** The plan: one row per bot-rooted thread, plus any selected id that matched nothing. */
+export interface ResolveThreadsPlan {
+    rows: ResolveThreadsRow[];
+    /** Selected ids matching no bot-rooted thread. Non-empty ⇒ abort before any mutation. */
+    unmatchedIds: number[];
+}
+/**
+ * Build the plan. Pure. Every bot-rooted thread yields exactly one row; a
+ * human-rooted thread yields none.
+ */
+export declare function buildResolveThreadsPlan(records: readonly ReviewThreadRecord[], prComments: readonly PrIssueCommentRecord[], identity: BotIdentityPredicates, selectedIds: readonly number[] | null): ResolveThreadsPlan;
+/** Build the argv for a `gh api graphql` call. Never a shell string. */
+export declare function graphqlArgs(query: string, variables: ReadonlyArray<readonly [string, string | number]>): string[];
+type ReadFailure = {
+    ok: false;
+    detail: string;
+};
+type ThreadsRead = {
+    ok: true;
+    threads: ReviewThreadNode[];
+} | ReadFailure;
+/**
+ * Read every review thread on the PR, following BOTH connections' cursors.
+ * Any page that cannot be followed — no cursor, the budget blown, a failed or
+ * unparseable response — fails the whole read. There is no arm that returns a
+ * partial thread set.
+ */
+export declare function readReviewThreads(runner: GhRunner, owner: string, name: string, pr: number): ThreadsRead;
+type PrCommentsRead = {
+    ok: true;
+    comments: RestIssueComment[];
+} | ReadFailure;
+/**
+ * Read the PR's issue comments (REST, `--paginate`). This is the surface where
+ * a login keeps its `[bot]` suffix and `user.type` is available, so a bot's own
+ * PR-level comment can never be read as the human disposition. A failure here
+ * is a HARD failure: evidence cannot be derived, so no thread may be resolved.
+ */
+export declare function readPrIssueComments(runner: GhRunner, owner: string, name: string, pr: number): PrCommentsRead;
+/**
+ * Did the mutation actually resolve the thread? `gh` exiting 0 says only that a
+ * request was answered; the ANSWER has to say `isResolved: true`. A null
+ * payload, a null thread, `isResolved: false`, or a body that does not parse
+ * are each a named per-thread failure — a row is never marked applied on a
+ * mutation whose result was not read back.
+ */
+export declare function confirmResolved(body: unknown): {
+    ok: true;
+} | {
+    ok: false;
+    detail: string;
+};
+/** One printed row. The REST root comment id is on EVERY row (R4). */
+export declare function formatRow(row: ResolveThreadsRow): string;
+/**
+ * Run the verb. Returns the exit code rather than exiting, so `index.ts` owns
+ * `process.exitCode` (the `pr merge` / `mail` convention).
+ *
+ * EXIT CODES:
+ *   0 — the plan printed, or `--apply` resolved everything it planned to
+ *   1 — a hard read failure (nothing resolved), or `gh` did not answer
+ *   2 — an unmatched `--ids` entry (nothing resolved); a mutation that failed;
+ *       or, under `--apply`, a SELECTED thread skipped for want of evidence
+ *       (the run did not do what was asked)
+ */
+export declare function resolveThreadsCommand(prArg: string, opts?: ResolveThreadsOptions): Promise<ResolveThreadsResult>;
+export {};
+//# sourceMappingURL=resolve-threads.d.ts.map

package/dist/commands/resolve-threads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-threads.d.ts","sourceRoot":"","sources":["../../src/commands/resolve-threads.ts"],"names":[],"mappings":"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"}