Fix mangled merge of main into paper/1023-history

The merge of main smashed GetProposalHistory and GetProposalSideEffects
together (missing opening brace, duplicate var result lines) and dropped
the ISimilarDecisionService constructor parameter and GetSimilarPast
endpoint entirely.

This commit restores:
- ISimilarDecisionService field, constructor parameter, and DI registration
- Separated GetProposalHistory and GetProposalSideEffects into distinct methods
- GetSimilarPast endpoint after the diff endpoint
- All supporting files: SimilarDecisionService, ISimilarDecisionService,
  SimilarPastDtos, Domain SimilarPast entities, repository method, and tests

Author: Chris0Jeky

backend/src/Taskdeck.Api/Controllers/AutomationProposalsController.cs

@@ -26,20 +26,23 @@ public class AutomationProposalsController : AuthenticatedControllerBase
 
     private readonly IAutomationProposalService _proposalService;
     private readonly IAutomationExecutorService _executorService;
+    private readonly ISimilarDecisionService _similarDecisionService;
     private readonly BoardAuthorizationService _authorizationService;
     private readonly ICardHistoryService _cardHistoryService;
     private readonly ISideEffectAnalyzer _sideEffectAnalyzer;
 
     public AutomationProposalsController(
         IAutomationProposalService proposalService,
         IAutomationExecutorService executorService,
+        ISimilarDecisionService similarDecisionService,
         BoardAuthorizationService authorizationService,
         ICardHistoryService cardHistoryService,
         ISideEffectAnalyzer sideEffectAnalyzer,
         IUserContext userContext) : base(userContext)
     {
         _proposalService = proposalService;
         _executorService = executorService;
+        _similarDecisionService = similarDecisionService;
         _authorizationService = authorizationService;
         _cardHistoryService = cardHistoryService;
         _sideEffectAnalyzer = sideEffectAnalyzer;
@@ -272,6 +275,19 @@ public async Task<IActionResult> DismissProposals(
     /// </summary>
     [HttpGet("{id}/history")]
     public async Task<IActionResult> GetProposalHistory(Guid id, CancellationToken cancellationToken = default)
+    {
+        if (!TryGetCurrentUserId(out var callerUserId, out var errorResult))
+            return errorResult!;
+
+        var auth = await AuthorizeProposalAsync(id, callerUserId, requireWriteAccess: false, cancellationToken);
+        if (auth.ErrorResult is not null)
+            return auth.ErrorResult;
+
+        var result = await _cardHistoryService.GetCardHistoryForProposalAsync(id, cancellationToken);
+        return result.IsSuccess ? Ok(result.Value) : result.ToErrorActionResult();
+    }
+
+    /// <summary>
     /// Gets the side-effect analysis for a proposal, including the 7-category breakdown
     /// and reversibility posture.
     /// </summary>
@@ -285,7 +301,6 @@ public async Task<IActionResult> GetProposalSideEffects(Guid id, CancellationTok
         if (auth.ErrorResult is not null)
             return auth.ErrorResult;
 
-        var result = await _cardHistoryService.GetCardHistoryForProposalAsync(id, cancellationToken);
         var result = await _sideEffectAnalyzer.AnalyzeAsync(id, cancellationToken);
         return result.IsSuccess ? Ok(result.Value) : result.ToErrorActionResult();
     }
@@ -307,6 +322,24 @@ public async Task<IActionResult> GetProposalDiff(Guid id, CancellationToken canc
         return result.IsSuccess ? Ok(new { diff = result.Value }) : result.ToErrorActionResult();
     }
 
+    /// <summary>
+    /// Gets similar past decisions for a proposal, including the latest 3 decisions
+    /// with the same action class and an aggregate apply rate.
+    /// </summary>
+    [HttpGet("{id}/similar-past")]
+    public async Task<IActionResult> GetSimilarPast(Guid id, CancellationToken cancellationToken = default)
+    {
+        if (!TryGetCurrentUserId(out var callerUserId, out var errorResult))
+            return errorResult!;
+
+        var auth = await AuthorizeProposalAsync(id, callerUserId, requireWriteAccess: false, cancellationToken);
+        if (auth.ErrorResult is not null)
+            return auth.ErrorResult;
+
+        var result = await _similarDecisionService.GetSimilarPastAsync(id, callerUserId, cancellationToken);
+        return result.IsSuccess ? Ok(result.Value) : result.ToErrorActionResult();
+    }
+
     private async Task<(ProposalDto? Proposal, IActionResult? ErrorResult)> AuthorizeProposalAsync(
         Guid proposalId,
         Guid callerUserId,

backend/src/Taskdeck.Api/Extensions/ApplicationServiceRegistration.cs

@@ -50,6 +50,7 @@ public static IServiceCollection AddApplicationServices(this IServiceCollection
         services.AddScoped<ICardHistoryService, CardHistoryService>();
         services.AddScoped<ISideEffectAnalyzer, SideEffectAnalyzer>();
         services.AddScoped<IProposalRevisionService, ProposalRevisionService>();
+        services.AddScoped<ISimilarDecisionService, SimilarDecisionService>();
         services.AddScoped<IAutomationPolicyEngine, AutomationPolicyEngine>();
         services.AddScoped<IAutomationPlannerService, AutomationPlannerService>();
         services.AddScoped<IAutomationExecutorService, AutomationExecutorService>();

backend/src/Taskdeck.Application/DTOs/SimilarPastDtos.cs

@@ -0,0 +1,17 @@
+namespace Taskdeck.Application.DTOs;
+
+/// <summary>
+/// DTO for a single similar past decision.
+/// </summary>
+public record SimilarPastDecisionDto(
+    string Serial,
+    string Title,
+    string Verdict,
+    string Date);
+
+/// <summary>
+/// DTO for the aggregated similar past result.
+/// </summary>
+public record SimilarPastResultDto(
+    IReadOnlyList<SimilarPastDecisionDto> Decisions,
+    double ApplyRate);

backend/src/Taskdeck.Application/Interfaces/IAutomationProposalRepository.cs

@@ -21,4 +21,16 @@ public interface IAutomationProposalRepository : IRepository<AutomationProposal>
         ProposalSourceType sourceType,
         CancellationToken cancellationToken = default);
     Task<IEnumerable<AutomationProposal>> GetExpiredAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Gets proposals that have at least one operation matching the given action type
+    /// and are in a terminal state (Applied or Rejected), ordered by most recent first.
+    /// Optionally scoped to a specific board. Limited to a lookback window for performance.
+    /// </summary>
+    Task<IReadOnlyList<AutomationProposal>> GetTerminalByActionTypeAsync(
+        string actionType,
+        Guid? boardId,
+        Guid userId,
+        int limit = 100,
+        CancellationToken cancellationToken = default);
 }

backend/src/Taskdeck.Application/Services/ISimilarDecisionService.cs

@@ -0,0 +1,20 @@
+using Taskdeck.Application.DTOs;
+using Taskdeck.Domain.Common;
+
+namespace Taskdeck.Application.Services;
+
+/// <summary>
+/// Surfaces similar past proposal decisions for a given proposal,
+/// providing reviewers with a historical base rate.
+/// </summary>
+public interface ISimilarDecisionService
+{
+    /// <summary>
+    /// Gets the most recent similar past decisions for a proposal,
+    /// matching on the proposal's primary action class.
+    /// </summary>
+    Task<Result<SimilarPastResultDto>> GetSimilarPastAsync(
+        Guid proposalId,
+        Guid userId,
+        CancellationToken cancellationToken = default);
+}

backend/src/Taskdeck.Application/Services/SimilarDecisionService.cs

@@ -0,0 +1,163 @@
+using System.Globalization;
+using Taskdeck.Application.DTOs;
+using Taskdeck.Application.Interfaces;
+using Taskdeck.Domain.Common;
+using Taskdeck.Domain.Entities;
+using Taskdeck.Domain.Exceptions;
+using Taskdeck.Domain.SimilarPast;
+
+namespace Taskdeck.Application.Services;
+
+/// <summary>
+/// Queries past proposals with the same action class to surface similar
+/// historical decisions and an aggregate apply rate.
+/// </summary>
+public class SimilarDecisionService : ISimilarDecisionService
+{
+    /// <summary>
+    /// Maximum number of similar decisions to return.
+    /// </summary>
+    internal const int MaxDecisions = 3;
+
+    /// <summary>
+    /// Maximum number of past proposals to query for rate calculation.
+    /// Limits the lookback window to avoid unbounded queries.
+    /// </summary>
+    internal const int LookbackLimit = 200;
+
+    private readonly IUnitOfWork _unitOfWork;
+
+    public SimilarDecisionService(IUnitOfWork unitOfWork)
+    {
+        _unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
+    }
+
+    public async Task<Result<SimilarPastResultDto>> GetSimilarPastAsync(
+        Guid proposalId,
+        Guid userId,
+        CancellationToken cancellationToken = default)
+    {
+        // Load the current proposal to determine its action class
+        var proposal = await _unitOfWork.AutomationProposals.GetByIdAsync(proposalId, cancellationToken);
+        if (proposal is null)
+            return Result.Failure<SimilarPastResultDto>(ErrorCodes.NotFound, "Proposal not found.");
+
+        // Determine the primary action type from the proposal's operations
+        var actionType = GetPrimaryActionType(proposal);
+        if (string.IsNullOrWhiteSpace(actionType))
+        {
+            // Proposal has no operations -- return empty result
+            return Result.Success(ToDto(SimilarPastResult.Empty));
+        }
+
+        // Query past proposals with the same action class in terminal states,
+        // always scoped to the proposal's board to prevent cross-board title leakage.
+        // No cross-board fallback: if the board has no history, return empty rather
+        // than surfacing proposal titles from other boards.
+        var pastProposals = (await _unitOfWork.AutomationProposals
+            .GetTerminalByActionTypeAsync(actionType, proposal.BoardId, userId, LookbackLimit, cancellationToken))
+            ?? Array.Empty<AutomationProposal>();
+
+        // Exclude the current proposal itself from the results
+        var filtered = pastProposals
+            .Where(p => p.Id != proposalId)
+            .ToList();
+
+        if (filtered.Count == 0)
+            return Result.Success(ToDto(SimilarPastResult.Empty));
+
+        // Compute apply rate across ALL matching proposals (not just top 3)
+        var appliedCount = filtered.Count(p => p.Status == ProposalStatus.Applied);
+        var rejectedCount = filtered.Count(p => p.Status == ProposalStatus.Rejected);
+        var applyRate = SimilarPastResult.ComputeApplyRate(appliedCount, rejectedCount);
+
+        // Take the 3 most recent for display
+        var topDecisions = filtered
+            .Take(MaxDecisions)
+            .Select((p, index) => SimilarPastDecision.Create(
+                serial: $"#{(index + 1):D3}",
+                title: GetProposalTitle(p),
+                verdict: MapVerdict(p.Status),
+                date: FormatWeekDate(p.DecidedAt ?? p.CreatedAt)))
+            .ToList();
+
+        var result = new SimilarPastResult(topDecisions, applyRate);
+        return Result.Success(ToDto(result));
+    }
+
+    /// <summary>
+    /// Gets the primary action type from the first operation of a proposal.
+    /// The "action class" is the ActionType string of the first (or most representative) operation.
+    /// </summary>
+    internal static string? GetPrimaryActionType(AutomationProposal proposal)
+    {
+        if (proposal.Operations.Count == 0)
+            return null;
+
+        // Use the first operation's action type as the primary action class.
+        // For multi-operation proposals (e.g. bulk_move generates multiple "move" ops),
+        // the first operation is representative.
+        return proposal.Operations
+            .OrderBy(op => op.Sequence)
+            .First()
+            .ActionType;
+    }
+
+    /// <summary>
+    /// Gets a display title from a proposal: its summary, or the first operation description.
+    /// </summary>
+    internal static string GetProposalTitle(AutomationProposal proposal)
+    {
+        if (!string.IsNullOrWhiteSpace(proposal.Summary))
+            return proposal.Summary;
+
+        if (proposal.Operations.Count > 0)
+        {
+            var firstOp = proposal.Operations
+                .OrderBy(op => op.Sequence)
+                .First();
+            return $"{firstOp.ActionType} {firstOp.TargetType}";
+        }
+
+        return "Untitled proposal";
+    }
+
+    /// <summary>
+    /// Maps a proposal terminal status to a <see cref="PastVerdict"/>.
+    /// </summary>
+    internal static PastVerdict MapVerdict(ProposalStatus status)
+    {
+        return status switch
+        {
+            ProposalStatus.Applied => PastVerdict.Applied,
+            ProposalStatus.Rejected => PastVerdict.Rejected,
+            _ => throw new InvalidOperationException(
+                $"Cannot map non-terminal status '{status}' to a PastVerdict.")
+        };
+    }
+
+    /// <summary>
+    /// Formats a DateTime as an ISO week string, e.g. "wk 14 '26".
+    /// Uses ISO 8601 week numbering (Monday-start, first 4-day week).
+    /// Includes the 2-digit year to disambiguate cross-year boundaries.
+    /// </summary>
+    internal static string FormatWeekDate(DateTimeOffset dateTime)
+    {
+        var weekNumber = ISOWeek.GetWeekOfYear(dateTime.UtcDateTime);
+        var isoYear = ISOWeek.GetYear(dateTime.UtcDateTime);
+        return $"wk {weekNumber} '{isoYear % 100:D2}";
+    }
+
+    private static SimilarPastResultDto ToDto(SimilarPastResult result)
+    {
+        var decisions = result.Decisions
+            .Select(d => new SimilarPastDecisionDto(
+                d.Serial,
+                d.Title,
+                d.Verdict.ToString().ToLowerInvariant(),
+                d.Date))
+            .ToList();
+
+        return new SimilarPastResultDto(decisions, result.ApplyRate);
+    }
+}

backend/src/Taskdeck.Domain/SimilarPast/PastVerdict.cs

@@ -0,0 +1,10 @@
+namespace Taskdeck.Domain.SimilarPast;
+
+/// <summary>
+/// Terminal verdict for a past automation proposal decision.
+/// </summary>
+public enum PastVerdict
+{
+    Applied,
+    Rejected
+}

backend/src/Taskdeck.Domain/SimilarPast/SimilarPastDecision.cs

@@ -0,0 +1,40 @@
+namespace Taskdeck.Domain.SimilarPast;
+
+/// <summary>
+/// A past proposal decision surfaced as context for the current proposal review.
+/// Immutable value object.
+/// </summary>
+/// <param name="Serial">Display serial, e.g. '#001'.</param>
+/// <param name="Title">Proposal summary or first operation description.</param>
+/// <param name="Verdict">Whether the proposal was applied or rejected.</param>
+/// <param name="Date">Pre-formatted date string, e.g. 'wk 14'.</param>
+public sealed record SimilarPastDecision(
+    string Serial,
+    string Title,
+    PastVerdict Verdict,
+    string Date)
+{
+    /// <summary>
+    /// Maximum title length to prevent unbounded strings from leaking into the UI.
+    /// </summary>
+    public const int MaxTitleLength = 200;
+
+    /// <summary>
+    /// Creates a <see cref="SimilarPastDecision"/> with validation.
+    /// </summary>
+    public static SimilarPastDecision Create(string serial, string title, PastVerdict verdict, string date)
+    {
+        if (string.IsNullOrWhiteSpace(serial))
+            throw new ArgumentException("Serial cannot be empty.", nameof(serial));
+        if (string.IsNullOrWhiteSpace(title))
+            throw new ArgumentException("Title cannot be empty.", nameof(title));
+        if (string.IsNullOrWhiteSpace(date))
+            throw new ArgumentException("Date cannot be empty.", nameof(date));
+
+        var truncatedTitle = title.Length > MaxTitleLength
+            ? title[..MaxTitleLength]
+            : title;
+
+        return new SimilarPastDecision(serial, truncatedTitle, verdict, date);
+    }
+}

backend/src/Taskdeck.Domain/SimilarPast/SimilarPastResult.cs

@@ -0,0 +1,36 @@
+namespace Taskdeck.Domain.SimilarPast;
+
+/// <summary>
+/// Aggregated result of similar past decisions for a proposal, including
+/// the top N most recent decisions and the overall apply rate.
+/// </summary>
+/// <param name="Decisions">The most recent similar decisions (up to 3).</param>
+/// <param name="ApplyRate">
+/// Ratio of applied to total terminal decisions (applied + rejected).
+/// 0.0 when there is no history.
+/// </param>
+public sealed record SimilarPastResult(
+    IReadOnlyList<SimilarPastDecision> Decisions,
+    double ApplyRate)
+{
+    /// <summary>
+    /// An empty result representing no prior history.
+    /// </summary>
+    public static SimilarPastResult Empty { get; } =
+        new(Array.Empty<SimilarPastDecision>(), 0.0);
+
+    /// <summary>
+    /// Computes the apply rate from applied and rejected counts,
+    /// returning 0.0 when the denominator is zero.
+    /// </summary>
+    public static double ComputeApplyRate(int appliedCount, int rejectedCount)
+    {
+        if (appliedCount < 0)
+            throw new ArgumentOutOfRangeException(nameof(appliedCount), "Applied count cannot be negative.");
+        if (rejectedCount < 0)
+            throw new ArgumentOutOfRangeException(nameof(rejectedCount), "Rejected count cannot be negative.");
+
+        var total = appliedCount + rejectedCount;
+        return total == 0 ? 0.0 : (double)appliedCount / total;
+    }
+}