@vibesdotdev/forge 0.0.0-stage → 1.0.0-rc.4

package/dist/tools/tools/forge-pr-merge-status.impl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * forge-pr-merge-status implementation (lazy-loaded; the unit under test).
+ */
+import type { VibesRuntime, ToolCallContext } from '@vibesdotdev/kernel';
+import { type PrMergeStatusInput, type PrMergeStatusOutput } from './schemas.ts';
+import { sendForgeToolRequest, type ForgeToolScope } from '../lib/transport.ts';
+import { resolveRepositoryIdScoped } from '../lib/repo-context.ts';
+export interface PrMergeStatusDeps {
+    resolveRepositoryIdScoped: typeof resolveRepositoryIdScoped;
+    sendForgeToolRequest: typeof sendForgeToolRequest;
+}
+export declare function executePrMergeStatus(input: PrMergeStatusInput, deps?: PrMergeStatusDeps, token?: string | ForgeToolScope, ctx?: ToolCallContext): Promise<PrMergeStatusOutput>;
+declare const _default: {
+    execute(input: PrMergeStatusInput, runtime: VibesRuntime, ctx: ToolCallContext): Promise<PrMergeStatusOutput>;
+};
+export default _default;
+//# sourceMappingURL=forge-pr-merge-status.impl.d.ts.map

package/dist/tools/tools/forge-pr-merge-status.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-pr-merge-status.impl.d.ts","sourceRoot":"","sources":["../../../src/tools/tools/forge-pr-merge-status.impl.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAEN,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAA8B,oBAAoB,EAAqD,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC/J,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAGnE,MAAM,WAAW,iBAAiB;IACjC,yBAAyB,EAAE,OAAO,yBAAyB,CAAC;IAC5D,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;CAClD;AAOD,wBAAsB,oBAAoB,CACzC,KAAK,EAAE,kBAAkB,EACzB,IAAI,GAAE,iBAA+B,EACrC,KAAK,CAAC,EAAE,MAAM,GAAG,cAAc,EAC/B,GAAG,CAAC,EAAE,eAAe,GACnB,OAAO,CAAC,mBAAmB,CAAC,CAW9B;;mBAIQ,kBAAkB,WAChB,YAAY,OAChB,eAAe,GAClB,OAAO,CAAC,mBAAmB,CAAC;;AALhC,wBASE"}

package/dist/tools/tools/forge-pr-merge-status.impl.js

@@ -0,0 +1,31 @@
+/**
+ * forge-pr-merge-status implementation (lazy-loaded; the unit under test).
+ */
+import { PrMergeStatusInputSchema } from "./schemas.js";
+import { buildPrMergeStatusRequest } from "../lib/requests.js";
+import { resolveRepoScopedToolScope, sendForgeToolRequest, requireForgeToolData, forgeToolFailure, toolScope } from "../lib/transport.js";
+import { resolveRepositoryIdScoped } from "../lib/repo-context.js";
+import { enforcePullRequestAutomation } from "../lib/pull-request-automation.js";
+const defaultDeps = {
+    resolveRepositoryIdScoped,
+    sendForgeToolRequest
+};
+export async function executePrMergeStatus(input, deps = defaultDeps, token, ctx) {
+    const parsed = PrMergeStatusInputSchema.parse(input);
+    const scope = toolScope(token);
+    const repoId = await deps.resolveRepositoryIdScoped(parsed.repo, scope);
+    await enforcePullRequestAutomation(ctx, repoId, parsed.issueNumber, 'read', deps.sendForgeToolRequest, scope);
+    const spec = buildPrMergeStatusRequest(repoId, parsed);
+    const res = await deps.sendForgeToolRequest(spec, scope);
+    if (!res.ok) {
+        throw forgeToolFailure('forge-pr-merge-status', res);
+    }
+    return requireForgeToolData(res, 'forge-pr-merge-status').result;
+}
+export default {
+    async execute(input, runtime, ctx) {
+        const token = await resolveRepoScopedToolScope(runtime, ctx);
+        return executePrMergeStatus(input, defaultDeps, token, ctx);
+    }
+};
+//# sourceMappingURL=forge-pr-merge-status.impl.js.map

package/dist/tools/tools/forge-pr-merge-status.impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-pr-merge-status.impl.js","sourceRoot":"","sources":["../../../src/tools/tools/forge-pr-merge-status.impl.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACN,wBAAwB,EAGxB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,SAAS,EAAuB,MAAM,qBAAqB,CAAC;AAC/J,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AAOjF,MAAM,WAAW,GAAsB;IACtC,yBAAyB;IACzB,oBAAoB;CACpB,CAAC;AAEF,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACzC,KAAyB,EACzB,OAA0B,WAAW,EACrC,KAA+B,EAC/B,GAAqB;IAErB,MAAM,MAAM,GAAG,wBAAwB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACrD,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IAC/B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACxE,MAAM,4BAA4B,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;IAC9G,MAAM,IAAI,GAAG,yBAAyB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAkC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC1F,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;QACb,MAAM,gBAAgB,CAAC,uBAAuB,EAAE,GAAG,CAAC,CAAC;IACtD,CAAC;IACD,OAAO,oBAAoB,CAAC,GAAG,EAAE,uBAAuB,CAAC,CAAC,MAAM,CAAC;AAClE,CAAC;AAED,eAAe;IACd,KAAK,CAAC,OAAO,CACZ,KAAyB,EACzB,OAAqB,EACrB,GAAoB;QAEpB,MAAM,KAAK,GAAG,MAAM,0BAA0B,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QAC7D,OAAO,oBAAoB,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;IAC7D,CAAC;CACD,CAAC"}

package/dist/tools/tools/forge-pr-merge.descriptor.d.ts

@@ -0,0 +1,135 @@
+/**
+ * forge-pr-merge descriptor. Safe to import anywhere (no impl).
+ */
+declare const _default: {
+    readonly kind: "tools/tool";
+    readonly id: "forge-pr-merge";
+    readonly name: "forge-pr-merge";
+    readonly description: "Merge a pull request on a git repository.";
+    readonly mcpDescription: "Merge a Vibes Forge pull request through the platform merge gate. Call forge-pr-merge-status first when you need readiness details.";
+    readonly hardware: readonly ["consumer", "cloud"];
+    readonly purpose: ["direct", "worker", "mcp", "agent"];
+    readonly category: "forge";
+    readonly subcategory: "pull-requests";
+    readonly safety: "write";
+    readonly tags: readonly ["forge", "git", "pr", "pull-request", "merge"];
+    readonly schemas: {
+        readonly input: import("zod").ZodObject<{
+            repo: import("zod").ZodString;
+            issueNumber: import("zod").ZodNumber;
+            expectedHeadSha: import("zod").ZodOptional<import("zod").ZodString>;
+            strategy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                merge: "merge";
+                squash: "squash";
+                rebase: "rebase";
+                ff: "ff";
+            }>>;
+            message: import("zod").ZodOptional<import("zod").ZodString>;
+            authorName: import("zod").ZodOptional<import("zod").ZodString>;
+            authorEmail: import("zod").ZodOptional<import("zod").ZodString>;
+            ownerOverrideReason: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            merged: import("zod").ZodBoolean;
+            sha: import("zod").ZodOptional<import("zod").ZodString>;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+            replayed: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            pullRequest: import("zod").ZodOptional<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                projectId: import("zod").ZodOptional<import("zod").ZodString>;
+                repositoryId: import("zod").ZodOptional<import("zod").ZodString>;
+                issueNumber: import("zod").ZodOptional<import("zod").ZodNumber>;
+                type: import("zod").ZodEnum<{
+                    task: "task";
+                    bug: "bug";
+                    research: "research";
+                    ops: "ops";
+                    doc: "doc";
+                    pr: "pr";
+                }>;
+                title: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                status: import("zod").ZodEnum<{
+                    done: "done";
+                    blocked: "blocked";
+                    draft: "draft";
+                    backlog: "backlog";
+                    planned: "planned";
+                    in_progress: "in_progress";
+                    in_review: "in_review";
+                    cancelled: "cancelled";
+                }>;
+                priority: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    urgent: "urgent";
+                }>>;
+                effortId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                milestoneId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                ownerParticipantId: import("zod").ZodOptional<import("zod").ZodString>;
+                assignedParticipantId: import("zod").ZodOptional<import("zod").ZodString>;
+                tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                links: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    kind: import("zod").ZodString;
+                    id: import("zod").ZodString;
+                    source: import("zod").ZodString;
+                    role: import("zod").ZodDefault<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>>;
+                pr: import("zod").ZodOptional<import("zod").ZodObject<{
+                    sourceRef: import("zod").ZodString;
+                    targetRef: import("zod").ZodString;
+                    mergeBase: import("zod").ZodOptional<import("zod").ZodString>;
+                    headSha: import("zod").ZodOptional<import("zod").ZodString>;
+                    mergeCommitSha: import("zod").ZodOptional<import("zod").ZodString>;
+                    state: import("zod").ZodEnum<{
+                        open: "open";
+                        draft: "draft";
+                        merged: "merged";
+                        closed: "closed";
+                    }>;
+                    ciStatus: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        success: "success";
+                        error: "error";
+                        pending: "pending";
+                        failure: "failure";
+                    }>>;
+                    stack: import("zod").ZodOptional<import("zod").ZodObject<{
+                        id: import("zod").ZodUUID;
+                        stackNumber: import("zod").ZodNumber;
+                        position: import("zod").ZodNumber;
+                        size: import("zod").ZodNumber;
+                        trunkRef: import("zod").ZodString;
+                        state: import("zod").ZodEnum<{
+                            active: "active";
+                            merged: "merged";
+                            merging: "merging";
+                            dissolved: "dissolved";
+                        }>;
+                        health: import("zod").ZodEnum<{
+                            clean: "clean";
+                            "restack-required": "restack-required";
+                            conflicted: "conflicted";
+                        }>;
+                        landingPolicy: import("zod").ZodEnum<{
+                            "batch-allowed": "batch-allowed";
+                            "one-layer-at-a-time": "one-layer-at-a-time";
+                        }>;
+                        revision: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$loose>>;
+                metadata: import("zod").ZodOptional<import("zod").ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, import("zod/v4/core").$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+                createdAt: import("zod").ZodOptional<import("zod").ZodString>;
+                updatedAt: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>>;
+            strategy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                merge: "merge";
+                squash: "squash";
+                rebase: "rebase";
+                ff: "ff";
+            }>>;
+        }, import("zod/v4/core").$strip>;
+    };
+};
+export default _default;
+//# sourceMappingURL=forge-pr-merge.descriptor.d.ts.map

package/dist/tools/tools/forge-pr-merge.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-pr-merge.descriptor.d.ts","sourceRoot":"","sources":["../../../src/tools/tools/forge-pr-merge.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKH,wBAiBG"}

package/dist/tools/tools/forge-pr-merge.descriptor.js

@@ -0,0 +1,23 @@
+/**
+ * forge-pr-merge descriptor. Safe to import anywhere (no impl).
+ */
+import { createRuntimeAsset } from '@vibesdotdev/kernel/factory';
+import { PrMergeInputSchema, PrMergeOutputSchema } from "./schemas.js";
+export default createRuntimeAsset({
+    kind: 'tools/tool',
+    id: 'forge-pr-merge',
+    name: 'forge-pr-merge',
+    description: 'Merge a pull request on a git repository.',
+    mcpDescription: 'Merge a Vibes Forge pull request through the platform merge gate. Call forge-pr-merge-status first when you need readiness details.',
+    hardware: ['consumer', 'cloud'],
+    purpose: ['direct', 'worker', 'mcp', 'agent'],
+    category: 'forge',
+    subcategory: 'pull-requests',
+    safety: 'write',
+    tags: ['forge', 'git', 'pr', 'pull-request', 'merge'],
+    schemas: {
+        input: PrMergeInputSchema,
+        output: PrMergeOutputSchema
+    }
+});
+//# sourceMappingURL=forge-pr-merge.descriptor.js.map

package/dist/tools/tools/forge-pr-merge.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-pr-merge.descriptor.js","sourceRoot":"","sources":["../../../src/tools/tools/forge-pr-merge.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEvE,eAAe,kBAAkB,CAAC;IACjC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,gBAAgB;IACpB,IAAI,EAAE,gBAAgB;IACtB,WAAW,EAAE,2CAA2C;IACxD,cAAc,EACb,qIAAqI;IACtI,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC;IAC7C,QAAQ,EAAE,OAAO;IACjB,WAAW,EAAE,eAAe;IAC5B,MAAM,EAAE,OAAO;IACf,IAAI,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC;IACrD,OAAO,EAAE;QACR,KAAK,EAAE,kBAAkB;QACzB,MAAM,EAAE,mBAAmB;KAC3B;CACD,CAAC,CAAC"}

package/dist/tools/tools/forge-pr-merge.impl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * forge-pr-merge implementation (lazy-loaded; the unit under test).
+ */
+import type { VibesRuntime, ToolCallContext } from '@vibesdotdev/kernel';
+import { type PrMergeInput, type PrMergeOutput } from './schemas.ts';
+import { sendForgeToolRequest, type ForgeToolScope } from '../lib/transport.ts';
+import { resolveRepositoryIdScoped } from '../lib/repo-context.ts';
+export interface PrMergeDeps {
+    resolveRepositoryIdScoped: typeof resolveRepositoryIdScoped;
+    sendForgeToolRequest: typeof sendForgeToolRequest;
+}
+export declare function executePrMerge(input: PrMergeInput, deps?: PrMergeDeps, token?: string | ForgeToolScope, ctx?: ToolCallContext): Promise<PrMergeOutput>;
+declare const _default: {
+    execute(input: PrMergeInput, runtime: VibesRuntime, ctx: ToolCallContext): Promise<PrMergeOutput>;
+};
+export default _default;
+//# sourceMappingURL=forge-pr-merge.impl.d.ts.map

package/dist/tools/tools/forge-pr-merge.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-pr-merge.impl.d.ts","sourceRoot":"","sources":["../../../src/tools/tools/forge-pr-merge.impl.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAsB,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAEzF,OAAO,EAA8B,oBAAoB,EAAqD,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE/J,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAGnE,MAAM,WAAW,WAAW;IAC3B,yBAAyB,EAAE,OAAO,yBAAyB,CAAC;IAC5D,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;CAClD;AAOD,wBAAsB,cAAc,CACnC,KAAK,EAAE,YAAY,EACnB,IAAI,GAAE,WAAyB,EAC/B,KAAK,CAAC,EAAE,MAAM,GAAG,cAAc,EAC/B,GAAG,CAAC,EAAE,eAAe,GACnB,OAAO,CAAC,aAAa,CAAC,CA0BxB;;mBAIQ,YAAY,WACV,YAAY,OAChB,eAAe,GAClB,OAAO,CAAC,aAAa,CAAC;;AAL1B,wBASE"}

package/dist/tools/tools/forge-pr-merge.impl.js

@@ -0,0 +1,47 @@
+/**
+ * forge-pr-merge implementation (lazy-loaded; the unit under test).
+ */
+import { PrMergeInputSchema } from "./schemas.js";
+import { buildPrMergeRequest } from "../lib/requests.js";
+import { resolveRepoScopedToolScope, sendForgeToolRequest, requireForgeToolData, forgeToolFailure, toolScope } from "../lib/transport.js";
+import { CapabilityError } from '@vibesdotdev/kernel';
+import { resolveRepositoryIdScoped } from "../lib/repo-context.js";
+import { enforcePullRequestAutomation } from "../lib/pull-request-automation.js";
+const defaultDeps = {
+    resolveRepositoryIdScoped,
+    sendForgeToolRequest
+};
+export async function executePrMerge(input, deps = defaultDeps, token, ctx) {
+    const parsed = PrMergeInputSchema.parse(input);
+    const scope = toolScope(token);
+    const repoId = await deps.resolveRepositoryIdScoped(parsed.repo, scope);
+    if (ctx) {
+        const expectedHeadSha = await enforcePullRequestAutomation(ctx, repoId, parsed.issueNumber, 'merge', deps.sendForgeToolRequest, scope);
+        if (expectedHeadSha) {
+            if (parsed.ownerOverrideReason) {
+                throw new CapabilityError('PR automation cannot override merge policy.', 'PERMISSION_DENIED', {
+                    reason: 'automation-merge-override-denied'
+                });
+            }
+            if (parsed.expectedHeadSha && parsed.expectedHeadSha.toLowerCase() !== expectedHeadSha.toLowerCase()) {
+                throw new CapabilityError('The merge SHA conflicts with the authorized pull-request head.', 'CONFLICT', {
+                    reason: 'automation-head-conflict'
+                });
+            }
+            parsed.expectedHeadSha = expectedHeadSha;
+        }
+    }
+    const spec = buildPrMergeRequest(repoId, parsed);
+    const res = await deps.sendForgeToolRequest(spec, scope);
+    if (!res.ok) {
+        throw forgeToolFailure('forge-pr-merge', res);
+    }
+    return requireForgeToolData(res, 'forge-pr-merge').result;
+}
+export default {
+    async execute(input, runtime, ctx) {
+        const token = await resolveRepoScopedToolScope(runtime, ctx);
+        return executePrMerge(input, defaultDeps, token, ctx);
+    }
+};
+//# sourceMappingURL=forge-pr-merge.impl.js.map

package/dist/tools/tools/forge-pr-merge.impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-pr-merge.impl.js","sourceRoot":"","sources":["../../../src/tools/tools/forge-pr-merge.impl.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,kBAAkB,EAAyC,MAAM,cAAc,CAAC;AACzF,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,SAAS,EAAuB,MAAM,qBAAqB,CAAC;AAC/J,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AAOjF,MAAM,WAAW,GAAgB;IAChC,yBAAyB;IACzB,oBAAoB;CACpB,CAAC;AAEF,MAAM,CAAC,KAAK,UAAU,cAAc,CACnC,KAAmB,EACnB,OAAoB,WAAW,EAC/B,KAA+B,EAC/B,GAAqB;IAErB,MAAM,MAAM,GAAG,kBAAkB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC/C,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IAC/B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACxE,IAAI,GAAG,EAAE,CAAC;QACT,MAAM,eAAe,GAAG,MAAM,4BAA4B,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;QACvI,IAAI,eAAe,EAAE,CAAC;YACrB,IAAI,MAAM,CAAC,mBAAmB,EAAE,CAAC;gBAChC,MAAM,IAAI,eAAe,CAAC,6CAA6C,EAAE,mBAAmB,EAAE;oBAC7F,MAAM,EAAE,kCAAkC;iBAC1C,CAAC,CAAC;YACJ,CAAC;YACD,IAAI,MAAM,CAAC,eAAe,IAAI,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,KAAK,eAAe,CAAC,WAAW,EAAE,EAAE,CAAC;gBACtG,MAAM,IAAI,eAAe,CAAC,gEAAgE,EAAE,UAAU,EAAE;oBACvG,MAAM,EAAE,0BAA0B;iBAClC,CAAC,CAAC;YACJ,CAAC;YACD,MAAM,CAAC,eAAe,GAAG,eAAe,CAAC;QAC1C,CAAC;IACF,CAAC;IACD,MAAM,IAAI,GAAG,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAA4B,IAAI,EAAE,KAAK,CAAC,CAAC;IACpF,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;QACb,MAAM,gBAAgB,CAAC,gBAAgB,EAAE,GAAG,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,oBAAoB,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC,MAAM,CAAC;AAC3D,CAAC;AAED,eAAe;IACd,KAAK,CAAC,OAAO,CACZ,KAAmB,EACnB,OAAqB,EACrB,GAAoB;QAEpB,MAAM,KAAK,GAAG,MAAM,0BAA0B,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QAC7D,OAAO,cAAc,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;IACvD,CAAC;CACD,CAAC"}

package/dist/tools/tools/forge-pr-reopen.descriptor.d.ts

@@ -0,0 +1,119 @@
+/**
+ * forge-pr-reopen descriptor. Safe to import anywhere (no impl).
+ */
+declare const _default: {
+    readonly kind: "tools/tool";
+    readonly id: "forge-pr-reopen";
+    readonly name: "forge-pr-reopen";
+    readonly description: "Reopen a pull request on a git repository.";
+    readonly mcpDescription: "Reopen a closed pull request and return it to review.";
+    readonly hardware: readonly ["consumer", "cloud"];
+    readonly purpose: ["direct", "worker", "mcp", "agent"];
+    readonly category: "forge";
+    readonly subcategory: "pull-requests";
+    readonly safety: "write";
+    readonly tags: readonly ["forge", "git", "pr", "pull-request", "reopen"];
+    readonly schemas: {
+        readonly input: import("zod").ZodObject<{
+            repo: import("zod").ZodString;
+            issueNumber: import("zod").ZodNumber;
+            status: import("zod").ZodDefault<import("zod").ZodEnum<{
+                planned: "planned";
+                in_progress: "in_progress";
+                in_review: "in_review";
+            }>>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            item: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                projectId: import("zod").ZodOptional<import("zod").ZodString>;
+                repositoryId: import("zod").ZodOptional<import("zod").ZodString>;
+                issueNumber: import("zod").ZodOptional<import("zod").ZodNumber>;
+                type: import("zod").ZodEnum<{
+                    task: "task";
+                    bug: "bug";
+                    research: "research";
+                    ops: "ops";
+                    doc: "doc";
+                    pr: "pr";
+                }>;
+                title: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                status: import("zod").ZodEnum<{
+                    done: "done";
+                    blocked: "blocked";
+                    draft: "draft";
+                    backlog: "backlog";
+                    planned: "planned";
+                    in_progress: "in_progress";
+                    in_review: "in_review";
+                    cancelled: "cancelled";
+                }>;
+                priority: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    urgent: "urgent";
+                }>>;
+                effortId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                milestoneId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                ownerParticipantId: import("zod").ZodOptional<import("zod").ZodString>;
+                assignedParticipantId: import("zod").ZodOptional<import("zod").ZodString>;
+                tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                links: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    kind: import("zod").ZodString;
+                    id: import("zod").ZodString;
+                    source: import("zod").ZodString;
+                    role: import("zod").ZodDefault<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>>;
+                pr: import("zod").ZodOptional<import("zod").ZodObject<{
+                    sourceRef: import("zod").ZodString;
+                    targetRef: import("zod").ZodString;
+                    mergeBase: import("zod").ZodOptional<import("zod").ZodString>;
+                    headSha: import("zod").ZodOptional<import("zod").ZodString>;
+                    mergeCommitSha: import("zod").ZodOptional<import("zod").ZodString>;
+                    state: import("zod").ZodEnum<{
+                        open: "open";
+                        draft: "draft";
+                        merged: "merged";
+                        closed: "closed";
+                    }>;
+                    ciStatus: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        success: "success";
+                        error: "error";
+                        pending: "pending";
+                        failure: "failure";
+                    }>>;
+                    stack: import("zod").ZodOptional<import("zod").ZodObject<{
+                        id: import("zod").ZodUUID;
+                        stackNumber: import("zod").ZodNumber;
+                        position: import("zod").ZodNumber;
+                        size: import("zod").ZodNumber;
+                        trunkRef: import("zod").ZodString;
+                        state: import("zod").ZodEnum<{
+                            active: "active";
+                            merged: "merged";
+                            merging: "merging";
+                            dissolved: "dissolved";
+                        }>;
+                        health: import("zod").ZodEnum<{
+                            clean: "clean";
+                            "restack-required": "restack-required";
+                            conflicted: "conflicted";
+                        }>;
+                        landingPolicy: import("zod").ZodEnum<{
+                            "batch-allowed": "batch-allowed";
+                            "one-layer-at-a-time": "one-layer-at-a-time";
+                        }>;
+                        revision: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$loose>>;
+                metadata: import("zod").ZodOptional<import("zod").ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, import("zod/v4/core").$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+                createdAt: import("zod").ZodOptional<import("zod").ZodString>;
+                updatedAt: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>;
+        }, import("zod/v4/core").$strip>;
+    };
+};
+export default _default;
+//# sourceMappingURL=forge-pr-reopen.descriptor.d.ts.map

package/dist/tools/tools/forge-pr-reopen.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-pr-reopen.descriptor.d.ts","sourceRoot":"","sources":["../../../src/tools/tools/forge-pr-reopen.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKH,wBAgBG"}

package/dist/tools/tools/forge-pr-reopen.descriptor.js

@@ -0,0 +1,23 @@
+/**
+ * forge-pr-reopen descriptor. Safe to import anywhere (no impl).
+ */
+import { createRuntimeAsset } from '@vibesdotdev/kernel/factory';
+import { PrReopenInputSchema, PrReopenOutputSchema } from "./schemas.js";
+export default createRuntimeAsset({
+    kind: 'tools/tool',
+    id: 'forge-pr-reopen',
+    name: 'forge-pr-reopen',
+    description: 'Reopen a pull request on a git repository.',
+    mcpDescription: 'Reopen a closed pull request and return it to review.',
+    hardware: ['consumer', 'cloud'],
+    purpose: ['direct', 'worker', 'mcp', 'agent'],
+    category: 'forge',
+    subcategory: 'pull-requests',
+    safety: 'write',
+    tags: ['forge', 'git', 'pr', 'pull-request', 'reopen'],
+    schemas: {
+        input: PrReopenInputSchema,
+        output: PrReopenOutputSchema
+    }
+});
+//# sourceMappingURL=forge-pr-reopen.descriptor.js.map

package/dist/tools/tools/forge-pr-reopen.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-pr-reopen.descriptor.js","sourceRoot":"","sources":["../../../src/tools/tools/forge-pr-reopen.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzE,eAAe,kBAAkB,CAAC;IACjC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,iBAAiB;IACrB,IAAI,EAAE,iBAAiB;IACvB,WAAW,EAAE,4CAA4C;IACzD,cAAc,EAAE,uDAAuD;IACvE,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC;IAC7C,QAAQ,EAAE,OAAO;IACjB,WAAW,EAAE,eAAe;IAC5B,MAAM,EAAE,OAAO;IACf,IAAI,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,QAAQ,CAAC;IACtD,OAAO,EAAE;QACR,KAAK,EAAE,mBAAmB;QAC1B,MAAM,EAAE,oBAAoB;KAC5B;CACD,CAAC,CAAC"}

package/dist/tools/tools/forge-pr-reopen.impl.d.ts

@@ -0,0 +1,13 @@
+/**
+ * forge-pr-reopen implementation (lazy-loaded; the unit under test).
+ */
+import type { VibesRuntime, ToolCallContext } from '@vibesdotdev/kernel';
+import { type PrReopenInput, type PrReopenOutput } from './schemas.ts';
+import { type TrackingMutationDeps } from './forge-tracking-mutations.ts';
+export type PrReopenDeps = TrackingMutationDeps;
+export declare function executePrReopen(input: PrReopenInput, deps?: PrReopenDeps, token?: string, runtime?: VibesRuntime): Promise<PrReopenOutput>;
+declare const _default: {
+    execute(input: PrReopenInput, runtime: VibesRuntime, ctx: ToolCallContext): Promise<PrReopenOutput>;
+};
+export default _default;
+//# sourceMappingURL=forge-pr-reopen.impl.d.ts.map

package/dist/tools/tools/forge-pr-reopen.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-pr-reopen.impl.d.ts","sourceRoot":"","sources":["../../../src/tools/tools/forge-pr-reopen.impl.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAuB,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAE5F,OAAO,EAKN,KAAK,oBAAoB,EACzB,MAAM,+BAA+B,CAAC;AAEvC,MAAM,MAAM,YAAY,GAAG,oBAAoB,CAAC;AAEhD,wBAAsB,eAAe,CACpC,KAAK,EAAE,aAAa,EACpB,IAAI,GAAE,YAA0C,EAChD,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,YAAY,GACpB,OAAO,CAAC,cAAc,CAAC,CAqBzB;;mBAIQ,aAAa,WACX,YAAY,OAChB,eAAe,GAClB,OAAO,CAAC,cAAc,CAAC;;AAL3B,wBASE"}

package/dist/tools/tools/forge-pr-reopen.impl.js

@@ -0,0 +1,20 @@
+/**
+ * forge-pr-reopen implementation (lazy-loaded; the unit under test).
+ */
+import { PrReopenInputSchema } from "./schemas.js";
+import { resolveRepoScopedToolToken } from "../lib/transport.js";
+import { assertPrItem, defaultTrackingMutationDeps, patchTrackingItem, readTrackingItem } from "./forge-tracking-mutations.js";
+export async function executePrReopen(input, deps = defaultTrackingMutationDeps, token, runtime) {
+    const parsed = PrReopenInputSchema.parse(input);
+    const { repoId, item } = await readTrackingItem('forge-pr-reopen', parsed.repo, parsed.issueNumber, deps, token, runtime);
+    assertPrItem('forge-pr-reopen', parsed.issueNumber, item);
+    const updated = await patchTrackingItem('forge-pr-reopen', repoId, parsed.issueNumber, { status: parsed.status, pr: { ...item.pr, state: 'open' } }, deps, token, runtime);
+    return { item: updated };
+}
+export default {
+    async execute(input, runtime, ctx) {
+        const token = await resolveRepoScopedToolToken(runtime, ctx);
+        return executePrReopen(input, defaultTrackingMutationDeps, token, runtime);
+    }
+};
+//# sourceMappingURL=forge-pr-reopen.impl.js.map

package/dist/tools/tools/forge-pr-reopen.impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-pr-reopen.impl.js","sourceRoot":"","sources":["../../../src/tools/tools/forge-pr-reopen.impl.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,mBAAmB,EAA2C,MAAM,cAAc,CAAC;AAC5F,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EACN,YAAY,EACZ,2BAA2B,EAC3B,iBAAiB,EACjB,gBAAgB,EAEhB,MAAM,+BAA+B,CAAC;AAIvC,MAAM,CAAC,KAAK,UAAU,eAAe,CACpC,KAAoB,EACpB,OAAqB,2BAA2B,EAChD,KAAc,EACd,OAAsB;IAEtB,MAAM,MAAM,GAAG,mBAAmB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAChD,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,gBAAgB,CAC9C,iBAAiB,EACjB,MAAM,CAAC,IAAI,EACX,MAAM,CAAC,WAAW,EAClB,IAAI,EACJ,KAAK,EACL,OAAO,CACP,CAAC;IACF,YAAY,CAAC,iBAAiB,EAAE,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;IAC1D,MAAM,OAAO,GAAG,MAAM,iBAAiB,CACtC,iBAAiB,EACjB,MAAM,EACN,MAAM,CAAC,WAAW,EAClB,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAC5D,IAAI,EACJ,KAAK,EACL,OAAO,CACP,CAAC;IACF,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AAC1B,CAAC;AAED,eAAe;IACd,KAAK,CAAC,OAAO,CACZ,KAAoB,EACpB,OAAqB,EACrB,GAAoB;QAEpB,MAAM,KAAK,GAAG,MAAM,0BAA0B,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QAC7D,OAAO,eAAe,CAAC,KAAK,EAAE,2BAA2B,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC;CACD,CAAC"}

package/dist/tools/tools/forge-pr-review-comment.descriptor.d.ts

@@ -0,0 +1,72 @@
+/**
+ * forge-pr-review-comment descriptor. Safe to import anywhere (no impl).
+ *
+ * Posts an agent-authored review comment (source:'agent') with an optional
+ * verdict + inline anchors. Goes through the authed comments route so
+ * checkReviewVerdict (no self-approve, verdict only on PRs) still applies.
+ */
+declare const _default: {
+    readonly kind: "tools/tool";
+    readonly id: "forge-pr-review-comment";
+    readonly name: "forge-pr-review-comment";
+    readonly description: "Post a review comment or verdict on a pull request.";
+    readonly mcpDescription: "Post a PR review comment/verdict, optionally with inline file/line anchors.";
+    readonly hardware: readonly ["consumer", "cloud"];
+    readonly purpose: ["direct", "worker", "mcp", "agent"];
+    readonly category: "forge";
+    readonly subcategory: "pull-requests";
+    readonly safety: "write";
+    readonly requiresApproval: true;
+    readonly tags: readonly ["forge", "git", "pr", "review", "comment"];
+    readonly schemas: {
+        readonly input: import("zod").ZodObject<{
+            repo: import("zod").ZodString;
+            issueNumber: import("zod").ZodNumber;
+            body: import("zod").ZodString;
+            reviewState: import("zod").ZodOptional<import("zod").ZodEnum<{
+                approved: "approved";
+                "changes-requested": "changes-requested";
+                commented: "commented";
+            }>>;
+            reviewPath: import("zod").ZodOptional<import("zod").ZodString>;
+            reviewLine: import("zod").ZodOptional<import("zod").ZodNumber>;
+            reviewSide: import("zod").ZodOptional<import("zod").ZodEnum<{
+                old: "old";
+                new: "new";
+            }>>;
+            reviewCommitSha: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            comment: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                projectId: import("zod").ZodOptional<import("zod").ZodString>;
+                itemId: import("zod").ZodOptional<import("zod").ZodString>;
+                authorParticipantId: import("zod").ZodOptional<import("zod").ZodString>;
+                body: import("zod").ZodString;
+                source: import("zod").ZodEnum<{
+                    human: "human";
+                    agent: "agent";
+                    system: "system";
+                }>;
+                sourceSessionId: import("zod").ZodOptional<import("zod").ZodString>;
+                ephemeral: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                reviewPath: import("zod").ZodOptional<import("zod").ZodString>;
+                reviewLine: import("zod").ZodOptional<import("zod").ZodNumber>;
+                reviewSide: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    old: "old";
+                    new: "new";
+                }>>;
+                reviewCommitSha: import("zod").ZodOptional<import("zod").ZodString>;
+                reviewState: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    approved: "approved";
+                    "changes-requested": "changes-requested";
+                    commented: "commented";
+                }>>;
+                createdAt: import("zod").ZodOptional<import("zod").ZodString>;
+                updatedAt: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>;
+        }, import("zod/v4/core").$strip>;
+    };
+};
+export default _default;
+//# sourceMappingURL=forge-pr-review-comment.descriptor.d.ts.map

package/dist/tools/tools/forge-pr-review-comment.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-pr-review-comment.descriptor.d.ts","sourceRoot":"","sources":["../../../src/tools/tools/forge-pr-review-comment.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQH,wBAiBG"}

package/dist/tools/tools/forge-pr-review-comment.descriptor.js

@@ -0,0 +1,28 @@
+/**
+ * forge-pr-review-comment descriptor. Safe to import anywhere (no impl).
+ *
+ * Posts an agent-authored review comment (source:'agent') with an optional
+ * verdict + inline anchors. Goes through the authed comments route so
+ * checkReviewVerdict (no self-approve, verdict only on PRs) still applies.
+ */
+import { createRuntimeAsset } from '@vibesdotdev/kernel/factory';
+import { PrReviewCommentInputSchema, PrReviewCommentOutputSchema } from "./schemas.js";
+export default createRuntimeAsset({
+    kind: 'tools/tool',
+    id: 'forge-pr-review-comment',
+    name: 'forge-pr-review-comment',
+    description: 'Post a review comment or verdict on a pull request.',
+    mcpDescription: 'Post a PR review comment/verdict, optionally with inline file/line anchors.',
+    hardware: ['consumer', 'cloud'],
+    purpose: ['direct', 'worker', 'mcp', 'agent'],
+    category: 'forge',
+    subcategory: 'pull-requests',
+    safety: 'write',
+    requiresApproval: true,
+    tags: ['forge', 'git', 'pr', 'review', 'comment'],
+    schemas: {
+        input: PrReviewCommentInputSchema,
+        output: PrReviewCommentOutputSchema
+    }
+});
+//# sourceMappingURL=forge-pr-review-comment.descriptor.js.map

package/dist/tools/tools/forge-pr-review-comment.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-pr-review-comment.descriptor.js","sourceRoot":"","sources":["../../../src/tools/tools/forge-pr-review-comment.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EACN,0BAA0B,EAC1B,2BAA2B,EAC3B,MAAM,cAAc,CAAC;AAEtB,eAAe,kBAAkB,CAAC;IACjC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,yBAAyB;IAC7B,IAAI,EAAE,yBAAyB;IAC/B,WAAW,EAAE,qDAAqD;IAClE,cAAc,EAAE,6EAA6E;IAC7F,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC;IAC7C,QAAQ,EAAE,OAAO;IACjB,WAAW,EAAE,eAAe;IAC5B,MAAM,EAAE,OAAO;IACf,gBAAgB,EAAE,IAAI;IACtB,IAAI,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,CAAC;IACjD,OAAO,EAAE;QACR,KAAK,EAAE,0BAA0B;QACjC,MAAM,EAAE,2BAA2B;KACnC;CACD,CAAC,CAAC"}

package/dist/tools/tools/forge-pr-review-comment.impl.d.ts

@@ -0,0 +1,15 @@
+/**
+ * forge-pr-review-comment implementation (lazy-loaded; the unit under test).
+ *
+ * POSTs an agent-authored (source:'agent') review comment + optional verdict +
+ * inline anchors through the AUTHED comments route, so the route's
+ * checkReviewVerdict gate (no self-approve, verdict only on PRs) still applies
+ * to the acting caller. The tool re-implements no authz.
+ */
+import { type VibesRuntime, type ToolCallContext } from '@vibesdotdev/kernel';
+import { type PrReviewCommentInput, type PrReviewCommentOutput } from './schemas.ts';
+declare const _default: {
+    execute(input: PrReviewCommentInput, runtime: VibesRuntime, ctx: ToolCallContext): Promise<PrReviewCommentOutput>;
+};
+export default _default;
+//# sourceMappingURL=forge-pr-review-comment.impl.d.ts.map