Merge origin/main into paper/1018-line-for-tomorrow

Combines streak (#1032), side-effects (#1033), and similar-past (#1038)
from main with the tomorrow-note endpoints on this branch.
Resolved smoke.spec.ts conflict by taking main's version (addColumn fix).

Author: Chris0Jeky

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

@@ -26,17 +26,23 @@ public class AutomationProposalsController : AuthenticatedControllerBase
 
     private readonly IAutomationProposalService _proposalService;
     private readonly IAutomationExecutorService _executorService;
+    private readonly ISimilarDecisionService _similarDecisionService;
     private readonly BoardAuthorizationService _authorizationService;
+    private readonly ISideEffectAnalyzer _sideEffectAnalyzer;
 
     public AutomationProposalsController(
         IAutomationProposalService proposalService,
         IAutomationExecutorService executorService,
+        ISimilarDecisionService similarDecisionService,
         BoardAuthorizationService authorizationService,
+        ISideEffectAnalyzer sideEffectAnalyzer,
         IUserContext userContext) : base(userContext)
     {
         _proposalService = proposalService;
         _executorService = executorService;
+        _similarDecisionService = similarDecisionService;
         _authorizationService = authorizationService;
+        _sideEffectAnalyzer = sideEffectAnalyzer;
     }
 
     /// <summary>
@@ -261,6 +267,24 @@ public async Task<IActionResult> DismissProposals(
             : result.ToErrorActionResult();
     }
 
+    /// <summary>
+    /// Gets the side-effect analysis for a proposal, including the 7-category breakdown
+    /// and reversibility posture.
+    /// </summary>
+    [HttpGet("{id}/side-effects")]
+    public async Task<IActionResult> GetProposalSideEffects(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 _sideEffectAnalyzer.AnalyzeAsync(id, cancellationToken);
+        return result.IsSuccess ? Ok(result.Value) : result.ToErrorActionResult();
+    }
+
     /// <summary>
     /// Gets a diff preview for a proposal showing what changes will be made.
     /// </summary>
@@ -278,6 +302,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/Controllers/TodayController.cs

@@ -9,27 +9,65 @@
 namespace Taskdeck.Api.Controllers;
 
 /// <summary>
-/// Today-view endpoints: cadence aggregation and daily dossier data.
+/// Today-view endpoints: streak data, cadence aggregation, and daily dossier data.
 /// </summary>
 [ApiController]
 [Authorize]
 [Route("api/[controller]")]
 [Produces("application/json")]
 public class TodayController : AuthenticatedControllerBase
 {
+    private readonly IStreakService _streakService;
     private readonly ICadenceService _cadenceService;
     private readonly ITomorrowNoteService _tomorrowNoteService;
 
     public TodayController(
+        IStreakService streakService,
         ICadenceService cadenceService,
         ITomorrowNoteService tomorrowNoteService,
         IUserContext userContext)
         : base(userContext)
     {
+        _streakService = streakService;
         _cadenceService = cadenceService;
         _tomorrowNoteService = tomorrowNoteService;
     }
 
+    /// <summary>
+    /// Get streak data (daily activity intensity and sealed status) for the authenticated user.
+    /// </summary>
+    /// <param name="days">Number of days to include (1-365, default 90).</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>Streak data with daily intensity buckets and streak lengths.</returns>
+    /// <response code="200">Streak data returned successfully.</response>
+    /// <response code="400">Invalid days parameter.</response>
+    /// <response code="401">Authentication required.</response>
+    [HttpGet("streak")]
+    [ProducesResponseType(typeof(StreakResponse), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiErrorResponse), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ApiErrorResponse), StatusCodes.Status401Unauthorized)]
+    public async Task<IActionResult> GetStreak(
+        [FromQuery] int days = 90,
+        CancellationToken cancellationToken = default)
+    {
+        if (!TryGetCurrentUserId(out var userId, out var errorResult))
+            return errorResult!;
+
+        var result = await _streakService.GetStreakAsync(userId, days, cancellationToken);
+
+        if (!result.IsSuccess)
+            return result.ToErrorActionResult();
+
+        var streakResult = result.Value;
+        var response = new StreakResponse(
+            streakResult.Days.Select(d => new StreakDayResponse(d.Date, d.IsSealed, d.IntensityBucket)).ToList(),
+            streakResult.CurrentStreakLength,
+            streakResult.LongestStreakLength,
+            streakResult.Days.Count);
+
+        return Ok(response);
+    }
+
     /// <summary>
     /// Get the per-hour cadence snapshot for the authenticated user on the specified date.
     /// Returns 24 hourly buckets with event counts plus first/peak/last action timestamps.

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

@@ -47,7 +47,9 @@ public static IServiceCollection AddApplicationServices(this IServiceCollection
         services.AddScoped<HistoryService>();
         services.AddScoped<IHistoryService>(sp => sp.GetRequiredService<HistoryService>());
         services.AddScoped<IAutomationProposalService, AutomationProposalService>();
+        services.AddScoped<ISideEffectAnalyzer, SideEffectAnalyzer>();
         services.AddScoped<IProposalRevisionService, ProposalRevisionService>();
+        services.AddScoped<ISimilarDecisionService, SimilarDecisionService>();
         services.AddScoped<IAutomationPolicyEngine, AutomationPolicyEngine>();
         services.AddScoped<IAutomationPlannerService, AutomationPlannerService>();
         services.AddScoped<IAutomationExecutorService, AutomationExecutorService>();
@@ -76,6 +78,7 @@ public static IServiceCollection AddApplicationServices(this IServiceCollection
             new BoardMetricsService(
                 sp.GetRequiredService<IUnitOfWork>(),
                 sp.GetRequiredService<IAuthorizationService>()));
+        services.AddScoped<IStreakService, StreakService>();
         services.AddScoped<ApiKeyService>();
         services.AddScoped<IForecastingService>(sp =>
             new ForecastingService(

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

@@ -0,0 +1,18 @@
+namespace Taskdeck.Application.DTOs;
+
+public record SideEffectRowDto(
+    string Key,
+    string Value,
+    string Tone // "active" | "passive"
+);
+
+public record ReversibilityDto(
+    string Summary,
+    string Description,
+    long WindowMs
+);
+
+public record ProposalSideEffectsDto(
+    IReadOnlyList<SideEffectRowDto> Rows,
+    ReversibilityDto Reversibility
+);

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/DTOs/StreakDtos.cs

@@ -0,0 +1,18 @@
+namespace Taskdeck.Application.DTOs;
+
+/// <summary>
+/// Response DTO for a single day in the streak grid.
+/// </summary>
+public sealed record StreakDayResponse(
+    DateOnly Date,
+    bool IsSealed,
+    int IntensityBucket);
+
+/// <summary>
+/// Response DTO for the full streak query result.
+/// </summary>
+public sealed record StreakResponse(
+    IReadOnlyList<StreakDayResponse> Days,
+    int CurrentStreakLength,
+    int LongestStreakLength,
+    int DayCount);

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

@@ -3,6 +3,12 @@
 
 namespace Taskdeck.Application.Interfaces;
 
+/// <summary>
+/// Lightweight projection record for per-day audit entry counts.
+/// Used by <see cref="IAuditLogRepository.CountByDateAsync"/> to avoid loading full entities.
+/// </summary>
+public sealed record DailyAuditCount(DateOnly Date, int Count);
+
 public interface IAuditLogRepository : IRepository<AuditLog>
 {
     Task<IEnumerable<AuditLog>> GetByEntityAsync(string entityType, Guid entityId, int limit = 100, CancellationToken cancellationToken = default);
@@ -18,6 +24,21 @@ Task<IEnumerable<AuditLog>> QueryAsync(
         int limit = 100,
         CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Returns per-day entry counts for a user within a time range.
+    /// Uses a server-side GROUP BY projection to avoid loading full entities into memory.
+    /// </summary>
+    /// <param name="from">Start of the time range (inclusive).</param>
+    /// <param name="to">End of the time range (inclusive).</param>
+    /// <param name="userId">The user whose entries to count.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A list of (Date, Count) pairs for days with at least one entry.</returns>
+    Task<IReadOnlyList<DailyAuditCount>> CountByDateAsync(
+        DateTimeOffset from,
+        DateTimeOffset to,
+        Guid userId,
+        CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Deletes audit log entries older than the specified cutoff date in batches.
     /// Uses direct SQL DELETE for efficiency (does not load entities into memory).

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/ISideEffectAnalyzer.cs

@@ -0,0 +1,16 @@
+using Taskdeck.Application.DTOs;
+using Taskdeck.Domain.Common;
+
+namespace Taskdeck.Application.Services;
+
+/// <summary>
+/// Analyzes a proposal's operations to produce a 7-category side-effect breakdown
+/// and a reversibility posture.
+/// </summary>
+public interface ISideEffectAnalyzer
+{
+    /// <summary>
+    /// Analyzes the side effects of the specified proposal.
+    /// </summary>
+    Task<Result<ProposalSideEffectsDto>> AnalyzeAsync(Guid proposalId, 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);
+}