feat: comments marked as decisions, on top of the ticket and searchable

Whoever can change the ticket flags a comment as a decision (new event
CommentDecisionMarkedEvent on the comment). The ticket page lists its
decisions above the description, with a link to the comment in the
conversation (`?comment=<id>` scrolls to it and points at it), and the
search palette finds them by their text across my projects.

API: markDecision / PUT-DELETE /api/comments/{id}/decision; Issue.decisions
and GET /api/issues/{issue}/decisions; decisions(projectId?, search) and
GET /api/projects/{project}/decisions, GET /api/me/decisions. MCP:
mark_decision, search_decisions, and get_issue includes them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

libs/api/tracker/application/src/lib/commands/command-handlers.ts

@@ -1,4 +1,5 @@
 import { ReactToCommentCommandHandler } from './react-to-comment.command-handler';
+import { MarkDecisionCommandHandler } from './mark-decision.command-handler';
 import { VoteIssueCommandHandler } from './vote-issue.command-handler';
 import { CreateProjectCommandHandler } from './create-project.command-handler';
 import { UpdateProjectCommandHandler } from './update-project.command-handler';
@@ -46,6 +47,7 @@ import {
 export const COMMAND_HANDLERS = [
   VoteIssueCommandHandler,
   ReactToCommentCommandHandler,
+  MarkDecisionCommandHandler,
   CreateProjectCommandHandler,
   UpdateProjectCommandHandler,
   UpdateProjectSettingsCommandHandler,

libs/api/tracker/application/src/lib/commands/commands.spec.ts

@@ -77,6 +77,7 @@ import { UserDirectory } from '../ports/user-directory';
 import { AttachmentStorage } from '../ports/attachment-storage';
 import { AddCommentCommand } from './add-comment.command';
 import { ReactToCommentCommand } from './react-to-comment.command';
+import { MarkDecisionCommand } from './mark-decision.command';
 import { UpdateProjectCommand } from './update-project.command';
 import { VoteIssueCommand } from './vote-issue.command';
 import { AddProjectMemberCommand } from './add-project-member.command';
@@ -916,6 +917,32 @@ describe('tracker commands (event sourced)', () => {
     ).rejects.toThrow(ForbiddenError);
   });
 
+  it('lets the team mark a comment as a decision, and only the team', async () => {
+    const { run, rehydrator } = await setup();
+    const projectId = await projectWithTeam(run);
+    const issue = await run(
+      new CreateIssueCommand('dev', projectId, IssueType.TASK, 'Caché', {}),
+    );
+    const comment = await run(
+      new AddCommentCommand('qa', issue.id, 'Usamos Redis'),
+    );
+    await run(new MarkDecisionCommand('dev', comment.id, true));
+    // Twice is still once.
+    const again = await run(new MarkDecisionCommand('dev', comment.id, true));
+    expect(again.version).toBe(2);
+    expect((await rehydrator.rehydrate(comment.id, Comment)).decision).toBe(
+      true,
+    );
+    // A viewer reads the decisions but does not make them.
+    await expect(
+      run(new MarkDecisionCommand('pm', comment.id, false)),
+    ).rejects.toThrow(ForbiddenError);
+    await run(new MarkDecisionCommand('owner', comment.id, false));
+    expect((await rehydrator.rehydrate(comment.id, Comment)).decision).toBe(
+      false,
+    );
+  });
+
   it('takes votes from members, and from anyone once it is public', async () => {
     const { run, rehydrator } = await setup();
     const projectId = await projectWithTeam(run);

libs/api/tracker/application/src/lib/commands/mark-decision.command-handler.ts

@@ -0,0 +1,20 @@
+import { CommandHandler, ICommandHandler } from '@nestjs/cqrs';
+import { CommandResult, ack } from './command-result';
+import { MarkDecisionCommand } from './mark-decision.command';
+import { WriteAccess } from './write-access';
+
+/** The team decides: whoever can change the ticket marks its decisions. */
+@CommandHandler(MarkDecisionCommand)
+export class MarkDecisionCommandHandler
+  implements ICommandHandler<MarkDecisionCommand>
+{
+  constructor(private readonly access: WriteAccess) {}
+
+  async execute(command: MarkDecisionCommand): Promise<CommandResult> {
+    const comment = await this.access.comment(command.commentId);
+    await this.access.issueForContributor(comment.issueId, command.actorId);
+    comment.markDecision(command.actorId, command.on);
+    await comment.commitAndWait();
+    return ack(comment);
+  }
+}

libs/api/tracker/application/src/lib/commands/mark-decision.command.ts

@@ -0,0 +1,13 @@
+import { Command } from '@nestjs/cqrs';
+import { CommandResult } from './command-result';
+
+/** Marks a comment as a decision of its ticket (`on`) or unmarks it. */
+export class MarkDecisionCommand extends Command<CommandResult> {
+  constructor(
+    public readonly actorId: string,
+    public readonly commentId: string,
+    public readonly on: boolean,
+  ) {
+    super();
+  }
+}

libs/api/tracker/application/src/lib/comments.service.ts

@@ -1,14 +1,22 @@
 import { CommandRunner } from '@task-stream/api/shared/application';
 import { Injectable } from '@nestjs/common';
 import { QueryBus } from '@nestjs/cqrs';
-import { CommentReadModel } from '@task-stream/api/tracker/domain';
+import {
+  CommentReadModel,
+  DecisionReadModel,
+} from '@task-stream/api/tracker/domain';
 import { AddCommentCommand } from './commands/add-comment.command';
 import { CommandResult } from './commands/command-result';
 import { DeleteCommentCommand } from './commands/delete-comment.command';
 import { EditCommentCommand } from './commands/edit-comment.command';
 import { ReactToCommentCommand } from './commands/react-to-comment.command';
+import { MarkDecisionCommand } from './commands/mark-decision.command';
 import { Page } from './ports/find-issues.repository';
 import { GetCommentsQuery } from './queries/get-comments.query';
+import {
+  GetIssueDecisionsQuery,
+  SearchDecisionsQuery,
+} from './queries/decisions.query';
 
 @Injectable()
 export class CommentsService {
@@ -50,6 +58,35 @@ export class CommentsService {
     );
   }
 
+  /** Marks it as a decision of its ticket (`on`) or unmarks it: the team does. */
+  markDecision(
+    actorId: string,
+    commentId: string,
+    on: boolean,
+  ): Promise<CommandResult> {
+    return this.commands.execute(
+      new MarkDecisionCommand(actorId, commentId, on),
+    );
+  }
+
+  /** A ticket's decisions, oldest first. */
+  decisions(
+    viewerId: string | null,
+    issueId: string,
+  ): Promise<CommentReadModel[]> {
+    return this.queryBus.execute(new GetIssueDecisionsQuery(viewerId, issueId));
+  }
+
+  /** Decisions by their text: of a project, or of all mine without one. */
+  searchDecisions(
+    viewerId: string | null,
+    filter: { projectId?: string; search?: string; limit?: number },
+  ): Promise<DecisionReadModel[]> {
+    return this.queryBus.execute(
+      new SearchDecisionsQuery(viewerId, { limit: 20, ...filter }),
+    );
+  }
+
   delete(actorId: string, commentId: string): Promise<CommandResult> {
     return this.commands.execute(new DeleteCommentCommand(actorId, commentId));
   }

libs/api/tracker/application/src/lib/event-handlers/comment-added.event-handler.ts

@@ -30,6 +30,9 @@ export class CommentAddedEventHandler
       replyTo: comment.replyTo ?? null,
       deleted: false,
       reactions: [],
+      decision: false,
+      decidedBy: null,
+      decidedAt: null,
       createdAt: comment.createdAt,
       editedAt: null,
       version: versionOf(event),

libs/api/tracker/application/src/lib/event-handlers/comment-decision-marked.event-handler.ts

@@ -0,0 +1,30 @@
+import { EventsHandler, IEventHandler } from '@nestjs/cqrs';
+import { CommentDecisionMarkedEvent } from '@task-stream/api/tracker/domain';
+import { UpsertMaterializedCommentRepository } from '../ports/upsert-materialized-comment.repository';
+import { UserDirectory } from '../ports/user-directory';
+import { ReadModelNotifier, versionOf } from './read-model-notifier';
+
+@EventsHandler(CommentDecisionMarkedEvent)
+export class CommentDecisionMarkedEventHandler
+  implements IEventHandler<CommentDecisionMarkedEvent>
+{
+  constructor(
+    private readonly upsertMaterializedCommentRepository: UpsertMaterializedCommentRepository,
+    private readonly users: UserDirectory,
+    private readonly notifier: ReadModelNotifier,
+  ) {}
+
+  async handle(event: CommentDecisionMarkedEvent) {
+    const refs = await this.users.refs([event.actorId]);
+    await this.upsertMaterializedCommentRepository.upsert({
+      id: event.aggregateId,
+      decision: event.decision,
+      decidedBy: event.decision ? refs.of(event.actorId) : null,
+      decidedAt: event.decision ? event.occurredAt : null,
+      version: versionOf(event),
+    });
+    await this.notifier.comment(event.aggregateId, event.issueId, event);
+    // The ticket shows its decisions on top: its page reloads them.
+    await this.notifier.issue(event.issueId, event);
+  }
+}

libs/api/tracker/application/src/lib/event-handlers/event-handlers.ts

@@ -3,6 +3,7 @@ import { CommentAddedEventHandler } from './comment-added.event-handler';
 import { CommentDeletedEventHandler } from './comment-deleted.event-handler';
 import { CommentEditedEventHandler } from './comment-edited.event-handler';
 import { CommentReactedEventHandler } from './comment-reacted.event-handler';
+import { CommentDecisionMarkedEventHandler } from './comment-decision-marked.event-handler';
 import { IssueVotedEventHandler } from './issue-voted.event-handler';
 import { IssueAssignedEventHandler } from './issue-assigned.event-handler';
 import { IssueCreatedEventHandler } from './issue-created.event-handler';
@@ -50,6 +51,7 @@ export const EVENT_HANDLERS = [
   CommentDeletedEventHandler,
   CommentEditedEventHandler,
   CommentReactedEventHandler,
+  CommentDecisionMarkedEventHandler,
   IssueVotedEventHandler,
   IssueAssignedEventHandler,
   IssueCreatedEventHandler,

libs/api/tracker/application/src/lib/ports/find-comments.repository.ts

@@ -11,4 +11,14 @@ export abstract class FindCommentsRepository {
   /** Comments still standing (deleted ones kept for their replies do not count). */
   abstract countByIssue(issueId: string): Promise<number>;
   abstract countReplies(commentId: string): Promise<number>;
+  /**
+   * Comments marked as decisions (not deleted): of one ticket, or of some
+   * projects, oldest first for a ticket and most recent first otherwise.
+   */
+  abstract findDecisions(filter: {
+    issueId?: string;
+    projectIds?: string[];
+    search?: string;
+    limit: number;
+  }): Promise<CommentReadModel[]>;
 }

libs/api/tracker/application/src/lib/queries/decisions.query.ts

@@ -0,0 +1,112 @@
+import { IQueryHandler, Query, QueryHandler } from '@nestjs/cqrs';
+import {
+  CommentReadModel,
+  DecisionReadModel,
+} from '@task-stream/api/tracker/domain';
+import { FindCommentsRepository } from '../ports/find-comments.repository';
+import { FindIssuesRepository } from '../ports/find-issues.repository';
+import { FindProjectsRepository } from '../ports/find-projects.repository';
+import { ReadAccess } from './read-access';
+
+/** The decisions of a ticket, oldest first (shown above its conversation). */
+export class GetIssueDecisionsQuery extends Query<CommentReadModel[]> {
+  constructor(
+    /** Null: anonymous (public projects only). */
+    public readonly viewerId: string | null,
+    public readonly issueId: string,
+  ) {
+    super();
+  }
+}
+
+/**
+ * Decisions by their text, most recently decided first: of one project, or
+ * (without one) of every project the viewer belongs to.
+ */
+export class SearchDecisionsQuery extends Query<DecisionReadModel[]> {
+  constructor(
+    public readonly viewerId: string | null,
+    public readonly filter: {
+      projectId?: string;
+      search?: string;
+      limit: number;
+    },
+  ) {
+    super();
+  }
+}
+
+@QueryHandler(GetIssueDecisionsQuery)
+export class GetIssueDecisionsQueryHandler
+  implements IQueryHandler<GetIssueDecisionsQuery, CommentReadModel[]>
+{
+  constructor(
+    private readonly findIssues: FindIssuesRepository,
+    private readonly findComments: FindCommentsRepository,
+    private readonly access: ReadAccess,
+  ) {}
+
+  async execute(query: GetIssueDecisionsQuery): Promise<CommentReadModel[]> {
+    const issue = this.access.assertFound(
+      await this.findIssues.findById(query.issueId),
+      'Issue',
+      query.issueId,
+    );
+    await this.access.assertCanViewIssue(issue, query.viewerId);
+    return this.findComments.findDecisions({ issueId: issue.id, limit: 50 });
+  }
+}
+
+@QueryHandler(SearchDecisionsQuery)
+export class SearchDecisionsQueryHandler
+  implements IQueryHandler<SearchDecisionsQuery, DecisionReadModel[]>
+{
+  constructor(
+    private readonly findProjects: FindProjectsRepository,
+    private readonly findIssues: FindIssuesRepository,
+    private readonly findComments: FindCommentsRepository,
+    private readonly access: ReadAccess,
+  ) {}
+
+  async execute(query: SearchDecisionsQuery): Promise<DecisionReadModel[]> {
+    const { filter, viewerId } = query;
+    let projectIds: string[];
+    if (filter.projectId) {
+      await this.access.assertCanView(filter.projectId, viewerId);
+      projectIds = [filter.projectId];
+    } else {
+      if (!viewerId) return [];
+      projectIds = (await this.findProjects.findByMember(viewerId)).map(
+        (p) => p.id,
+      );
+    }
+    if (projectIds.length === 0) return [];
+    const limit = Math.min(filter.limit, 100);
+    // Read a few more: some may sit in the trash or, for a guest, in
+    // tickets they do not take part in.
+    const comments = await this.findComments.findDecisions({
+      projectIds,
+      search: filter.search?.trim().slice(0, 200) || undefined,
+      limit: limit * 2,
+    });
+    const issues = new Map(
+      (
+        await this.findIssues.findByIds([
+          ...new Set(comments.map((c) => c.issueId)),
+        ])
+      ).map((issue) => [issue.id, issue]),
+    );
+    const found: DecisionReadModel[] = [];
+    for (const comment of comments) {
+      const issue = issues.get(comment.issueId);
+      if (!issue || issue.trashedAt) continue;
+      if (!(await this.access.canViewIssue(issue, viewerId))) continue;
+      found.push({
+        comment,
+        issue: { id: issue.id, key: issue.key, title: issue.title },
+      });
+      if (found.length === limit) break;
+    }
+    return found;
+  }
+}

libs/api/tracker/application/src/lib/queries/query-handlers.ts

@@ -26,6 +26,10 @@ import { GetReleaseNotesDraftQueryHandler } from './get-release-notes-draft.quer
 import { GetTrashQueryHandler } from './get-trash.query';
 import { GetShowcaseQueryHandler } from './get-showcase.query';
 import { SearchMyIssuesQueryHandler } from './search-my-issues.query-handler';
+import {
+  GetIssueDecisionsQueryHandler,
+  SearchDecisionsQueryHandler,
+} from './decisions.query';
 
 export const QUERY_HANDLERS = [
   GetPublicProjectsQueryHandler,
@@ -33,6 +37,8 @@ export const QUERY_HANDLERS = [
   GetActivityQueryHandler,
   GetBoardQueryHandler,
   GetCommentsQueryHandler,
+  GetIssueDecisionsQueryHandler,
+  SearchDecisionsQueryHandler,
   GetIssueQueryHandler,
   GetIssuesByIdsQueryHandler,
   GetMyProjectsQueryHandler,

libs/api/tracker/domain/src/lib/comment/comment.ts

@@ -5,6 +5,7 @@ import {
   assertThat,
 } from '@task-stream/api/shared/domain';
 import { CommentAddedEvent } from '../events/comment-added.event';
+import { CommentDecisionMarkedEvent } from '../events/comment-decision-marked.event';
 import { CommentDeletedEvent } from '../events/comment-deleted.event';
 import { CommentEditedEvent } from '../events/comment-edited.event';
 import { CommentReactedEvent } from '../events/comment-reacted.event';
@@ -41,6 +42,8 @@ export class Comment extends VersionedAggregateRoot implements CommentProps {
   public replyTo: string | null = null;
   /** Who chose each emoji (only the ones somebody chose). */
   public reactions: Record<string, string[]> = {};
+  /** What was decided on the ticket: shown above it and searchable. */
+  public decision = false;
   public deleted = false;
   public createdAt!: string;
   public editedAt: string | null = null;
@@ -93,6 +96,24 @@ export class Comment extends VersionedAggregateRoot implements CommentProps {
     );
   }
 
+  /**
+   * Marks it as a decision of the ticket (`on`) or unmarks it; repeating it
+   * changes nothing. Who may do it (the team) is the caller's check.
+   */
+  markDecision(actorId: string, on: boolean): void {
+    this.assertAlive();
+    if (on === this.decision) return;
+    this.apply(
+      new CommentDecisionMarkedEvent(
+        actorId,
+        this.id,
+        this.projectId,
+        this.issueId,
+        on,
+      ),
+    );
+  }
+
   /** @param canModerate whether the actor manages the project (may delete others' comments). */
   delete(actorId: string, canModerate: boolean): void {
     this.assertAlive();
@@ -121,6 +142,10 @@ export class Comment extends VersionedAggregateRoot implements CommentProps {
     this.reactions = event.reactions;
   }
 
+  onCommentDecisionMarkedEvent(event: CommentDecisionMarkedEvent): void {
+    this.decision = event.decision;
+  }
+
   onCommentDeletedEvent(): void {
     this.deleted = true;
   }

libs/api/tracker/domain/src/lib/events/comment-decision-marked.event.ts

@@ -0,0 +1,17 @@
+import { AutowiredEvent } from '@task-stream/api/shared/domain';
+import { TrackerEvent } from './tracker.event';
+
+/** A comment was marked as a decision of the ticket, or unmarked. */
+@AutowiredEvent
+export class CommentDecisionMarkedEvent extends TrackerEvent {
+  constructor(
+    actorId: string,
+    commentId: string,
+    projectId: string,
+    readonly issueId: string,
+    /** False: it is no longer a decision. */
+    readonly decision: boolean,
+  ) {
+    super(actorId, commentId, projectId);
+  }
+}

libs/api/tracker/domain/src/lib/events/index.ts

@@ -15,6 +15,7 @@ export * from './issue-release-changed.event';
 export * from './comment-added.event';
 export * from './comment-edited.event';
 export * from './comment-reacted.event';
+export * from './comment-decision-marked.event';
 export * from './comment-deleted.event';
 export * from './release-created.event';
 export * from './release-updated.event';

libs/api/tracker/domain/src/lib/read-models/comment.read-model.ts

@@ -21,7 +21,18 @@ export class CommentReadModel {
   deleted!: boolean;
   /** In the order they are offered; only the ones somebody chose. */
   reactions!: CommentReactionReadModel[];
+  /** Marked as a decision of the ticket. */
+  decision!: boolean;
+  /** Who marked it and when (null when it is not a decision). */
+  decidedBy!: UserRefReadModel | null;
+  decidedAt!: string | null;
   createdAt!: string;
   editedAt!: string | null;
   version!: number;
 }
+
+/** A decision with the ticket it belongs to, for searching across tickets. */
+export class DecisionReadModel {
+  comment!: CommentReadModel;
+  issue!: { id: string; key: string; title: string };
+}

libs/api/tracker/infrastructure/src/lib/mongo/find.repositories.ts

@@ -51,6 +51,9 @@ const commentFromDoc = (doc: CommentDoc): CommentReadModel => ({
   replyTo: doc.replyTo ?? null,
   deleted: doc.deleted ?? false,
   reactions: doc.reactions ?? [],
+  decision: doc.decision ?? false,
+  decidedBy: doc.decidedBy ?? null,
+  decidedAt: doc.decidedAt ?? null,
 });
 
 const escapeRegex = (text: string) =>
@@ -545,6 +548,28 @@ export class MongoFindCommentsRepository extends FindCommentsRepository {
   countReplies(commentId: string): Promise<number> {
     return this.comments.countDocuments({ replyTo: commentId });
   }
+
+  async findDecisions(filter: {
+    issueId?: string;
+    projectIds?: string[];
+    search?: string;
+    limit: number;
+  }): Promise<CommentReadModel[]> {
+    const query: Record<string, unknown> = {
+      decision: true,
+      deleted: { $ne: true },
+    };
+    if (filter.issueId) query['issueId'] = filter.issueId;
+    if (filter.projectIds) query['projectId'] = { $in: filter.projectIds };
+    if (filter.search)
+      query['body'] = { $regex: escapeRegex(filter.search), $options: 'i' };
+    const docs = await this.comments
+      .find(query)
+      .sort(filter.issueId ? { createdAt: 1 } : { decidedAt: -1 })
+      .limit(filter.limit)
+      .lean<CommentDoc[]>();
+    return docs.map(commentFromDoc);
+  }
 }
 
 @Injectable()

libs/api/tracker/infrastructure/src/lib/mongo/read-model.schemas.ts

@@ -239,6 +239,10 @@ class CommentDocument {
 }
 export const CommentSchema = SchemaFactory.createForClass(CommentDocument);
 CommentSchema.index({ issueId: 1, createdAt: 1 });
+CommentSchema.index(
+  { projectId: 1, decidedAt: -1 },
+  { partialFilterExpression: { decision: true } },
+);
 
 @Schema({ ...LOOSE, collection: 'releases_view' })
 class ReleaseDocument {

libs/api/tracker/presenters/src/lib/graphql/comment.resolver.ts

@@ -1,8 +1,12 @@
-import { Args, ID, Mutation, Resolver } from '@nestjs/graphql';
+import { Args, ID, Int, Mutation, Query, Resolver } from '@nestjs/graphql';
 import { User } from '@task-stream/api/identity/domain';
-import { CurrentUser } from '@task-stream/api/identity/presenters';
+import {
+  CurrentUser,
+  OptionalAuth,
+} from '@task-stream/api/identity/presenters';
 import { CommentsService } from '@task-stream/api/tracker/application';
-import { CommandResultGql, CommentGql } from './types';
+import { viewerOf } from '../common/viewer';
+import { CommandResultGql, CommentGql, DecisionGql } from './types';
 
 @Resolver(() => CommentGql)
 export class CommentResolver {
@@ -43,6 +47,37 @@ export class CommentResolver {
     return this.comments.react(me.id, commentId, emoji, on);
   }
 
+  @Mutation(() => CommandResultGql, {
+    description:
+      'Mark a comment as a decision of its ticket, or unmark it (on: false). Whoever can change the ticket',
+  })
+  markDecision(
+    @CurrentUser() me: User,
+    @Args('commentId', { type: () => ID }) commentId: string,
+    @Args('on', { defaultValue: true }) on: boolean,
+  ) {
+    return this.comments.markDecision(me.id, commentId, on);
+  }
+
+  @OptionalAuth()
+  @Query(() => [DecisionGql], {
+    description:
+      'Decisions by their text, most recent first: of a project, or of all my projects without one',
+  })
+  decisions(
+    @CurrentUser() me: User | undefined,
+    @Args('projectId', { type: () => ID, nullable: true })
+    projectId: string | null,
+    @Args('search', { nullable: true }) search: string | null,
+    @Args('limit', { type: () => Int, defaultValue: 20 }) limit: number,
+  ) {
+    return this.comments.searchDecisions(viewerOf(me), {
+      projectId: projectId ?? undefined,
+      search: search ?? undefined,
+      limit,
+    });
+  }
+
   @Mutation(() => CommandResultGql, { description: 'Author or project admin' })
   deleteComment(
     @CurrentUser() me: User,

libs/api/tracker/presenters/src/lib/graphql/issue.resolver.ts

@@ -44,6 +44,7 @@ import {
   ActivityGql,
   BulkResultGql,
   CommandResultGql,
+  CommentGql,
   CommentPageGql,
   EpicGql,
   CustomFieldValueGql,
@@ -247,6 +248,16 @@ export class IssueResolver {
     return !!me && issue.voterIds.includes(me.id);
   }
 
+  @ResolveField(() => [CommentGql], {
+    description: 'Its comments marked as decisions, oldest first',
+  })
+  decisions(
+    @CurrentUser() me: User | undefined,
+    @Parent() issue: IssueReadModel,
+  ) {
+    return this.commentsService.decisions(viewerOf(me), issue.id);
+  }
+
   @ResolveField(() => Boolean, {
     description: 'Whether I pinned it (false without a token)',
   })

libs/api/tracker/presenters/src/lib/graphql/types.ts

@@ -548,6 +548,16 @@ export class CommentGql {
     description: 'In the order they are offered; only the ones somebody chose',
   })
   reactions!: CommentReactionGql[];
+  @Field({
+    description: 'Marked as a decision of the ticket (shown above it)',
+  })
+  decision!: boolean;
+  @Field(() => UserRefGql, {
+    nullable: true,
+    description: 'Who marked it as a decision',
+  })
+  decidedBy!: UserRefGql | null;
+  @Field(() => String, { nullable: true }) decidedAt!: string | null;
   @Field() createdAt!: string;
   @Field(() => String, { nullable: true }) editedAt!: string | null;
   @Field(() => Int) version!: number;
@@ -559,6 +569,14 @@ export class CommentPageGql {
   @Field(() => Int) total!: number;
 }
 
+@ObjectType('Decision', {
+  description: 'A comment marked as a decision, with its ticket',
+})
+export class DecisionGql {
+  @Field(() => CommentGql) comment!: CommentGql;
+  @Field(() => IssueParentGql) issue!: IssueParentGql;
+}
+
 @ObjectType('Release')
 export class ReleaseGql {
   @Field(() => ID) id!: string;

libs/api/tracker/presenters/src/lib/http/comments.controller.ts

@@ -6,6 +6,7 @@ import {
   Param,
   Patch,
   Post,
+  Put,
 } from '@nestjs/common';
 import { ApiOkResponse, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { User } from '@task-stream/api/identity/domain';
@@ -54,6 +55,29 @@ export class CommentsController {
     return this.comments.react(me.id, commentId, body.emoji, body.on);
   }
 
+  @Put(':commentId/decision')
+  @ApiOperation({
+    summary: 'Mark a comment as a decision of its ticket',
+    description:
+      'Whoever can change the ticket. Decisions are shown above the ticket and searchable (GET …/decisions).',
+  })
+  @ApiOkResponse({ type: CommandResultDto })
+  @ApiCommandErrors()
+  markDecision(@CurrentUser() me: User, @Param('commentId') commentId: string) {
+    return this.comments.markDecision(me.id, commentId, true);
+  }
+
+  @Delete(':commentId/decision')
+  @ApiOperation({ summary: 'It is no longer a decision' })
+  @ApiOkResponse({ type: CommandResultDto })
+  @ApiCommandErrors()
+  unmarkDecision(
+    @CurrentUser() me: User,
+    @Param('commentId') commentId: string,
+  ) {
+    return this.comments.markDecision(me.id, commentId, false);
+  }
+
   @Delete(':commentId')
   @ApiOperation({ summary: 'Delete a comment (author or project admin)' })
   @ApiOkResponse({ type: CommandResultDto })

libs/api/tracker/presenters/src/lib/http/dto/requests.dto.ts

@@ -501,6 +501,22 @@ export class PageQueryDto {
   offset = 0;
 }
 
+export class DecisionsQueryDto {
+  @ApiPropertyOptional({ description: 'Words in the decision' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(200)
+  search?: string;
+
+  @ApiPropertyOptional({ type: Number, default: 20, minimum: 1, maximum: 100 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  limit = 20;
+}
+
 // ---- Issues -----------------------------------------------------------------
 
 export class MyIssuesQueryDto extends PageQueryDto {

libs/api/tracker/presenters/src/lib/http/dto/responses.dto.ts

@@ -625,12 +625,30 @@ export class CommentDto {
     description: 'In the order they are offered; only the ones somebody chose',
   })
   reactions!: CommentReactionDto[];
+  @ApiProperty({
+    description: 'Marked as a decision of the ticket (shown above it)',
+  })
+  decision!: boolean;
+  @ApiProperty({
+    type: UserRefDto,
+    nullable: true,
+    description: 'Who marked it as a decision',
+  })
+  decidedBy!: UserRefDto | null;
+  @ApiProperty({ type: String, nullable: true, format: 'date-time' })
+  decidedAt!: string | null;
   @ApiProperty({ format: 'date-time' }) createdAt!: string;
   @ApiProperty({ type: String, nullable: true, format: 'date-time' })
   editedAt!: string | null;
   @ApiProperty() version!: number;
 }
 
+/** A comment marked as a decision, with its ticket. */
+export class DecisionDto {
+  @ApiProperty({ type: CommentDto }) comment!: CommentDto;
+  @ApiProperty({ type: IssueParentDto }) issue!: IssueParentDto;
+}
+
 export class CommentPageDto {
   @ApiProperty({ type: [CommentDto] }) items!: CommentDto[];
   @ApiProperty() total!: number;

libs/api/tracker/presenters/src/lib/http/issues.controller.ts

@@ -45,6 +45,7 @@ import {
   ChecklistItemBodyDto,
   AddCommentDto,
   CreateIssueDto,
+  DecisionsQueryDto,
   IssueSearchQueryDto,
   PresenceBodyDto,
   LinkIssueDto,
@@ -61,7 +62,9 @@ import {
   ActivityDto,
   BulkResultDto,
   CommandResultDto,
+  CommentDto,
   CommentPageDto,
+  DecisionDto,
   EpicDto,
   IssueDto,
   IssuePageDto,
@@ -707,6 +710,57 @@ export class IssuesController {
     );
   }
 
+  @Get('issues/:issue/decisions')
+  @ApiOptionalPireonAuth()
+  @ISSUE
+  @ApiOperation({
+    summary: 'Comments of the ticket marked as decisions (oldest first)',
+  })
+  @ApiOkResponse({ type: [CommentDto] })
+  @ApiReadErrors()
+  async issueDecisions(
+    @CurrentUser() me: User | undefined,
+    @Param('issue') issue: string,
+  ) {
+    return this.comments.decisions(
+      viewerOf(me),
+      await this.refs.issueId(viewerOf(me), issue),
+    );
+  }
+
+  @Get('projects/:project/decisions')
+  @ApiOptionalPireonAuth()
+  @PROJECT
+  @ApiOperation({
+    summary: "Search a project's decisions (most recent first)",
+  })
+  @ApiOkResponse({ type: [DecisionDto] })
+  @ApiReadErrors()
+  async projectDecisions(
+    @CurrentUser() me: User | undefined,
+    @Param('project') project: string,
+    @Query() query: DecisionsQueryDto,
+  ) {
+    return this.comments.searchDecisions(viewerOf(me), {
+      projectId: await this.refs.projectId(viewerOf(me), project),
+      search: query.search,
+      limit: query.limit,
+    });
+  }
+
+  @Get('me/decisions')
+  @ApiOperation({
+    summary: 'Search the decisions of all my projects (most recent first)',
+  })
+  @ApiOkResponse({ type: [DecisionDto] })
+  @ApiReadErrors()
+  myDecisions(@CurrentUser() me: User, @Query() query: DecisionsQueryDto) {
+    return this.comments.searchDecisions(me.id, {
+      search: query.search,
+      limit: query.limit,
+    });
+  }
+
   @Post('issues/:issue/comments')
   @ISSUE
   @ApiOperation({