Merge origin/main into paper/1019-provenance

Resolve conflicts from #1032 (streak), #1033 (side-effects), and
#1038 (similar-past) merges into main.

- AutomationProposalsController: keep provenance endpoint from this
  branch alongside side-effects and similar-past endpoints from main;
  inject both IProvenanceQueryService and ISideEffectAnalyzer.
- ApplicationServiceRegistration: register both IProvenanceQueryService
  and ISideEffectAnalyzer in the DI container.
- smoke.spec.ts: take main's improved addColumn helper that waits for
  the POST response and dialog close.

Author: Chris0Jeky

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

@@ -26,20 +26,26 @@ public class AutomationProposalsController : AuthenticatedControllerBase
 
     private readonly IAutomationProposalService _proposalService;
     private readonly IAutomationExecutorService _executorService;
+    private readonly ISimilarDecisionService _similarDecisionService;
     private readonly BoardAuthorizationService _authorizationService;
     private readonly IProvenanceQueryService _provenanceQueryService;
+    private readonly ISideEffectAnalyzer _sideEffectAnalyzer;
 
     public AutomationProposalsController(
         IAutomationProposalService proposalService,
         IAutomationExecutorService executorService,
+        ISimilarDecisionService similarDecisionService,
         BoardAuthorizationService authorizationService,
         IProvenanceQueryService provenanceQueryService,
+        ISideEffectAnalyzer sideEffectAnalyzer,
         IUserContext userContext) : base(userContext)
     {
         _proposalService = proposalService;
         _executorService = executorService;
+        _similarDecisionService = similarDecisionService;
         _authorizationService = authorizationService;
         _provenanceQueryService = provenanceQueryService;
+        _sideEffectAnalyzer = sideEffectAnalyzer;
     }
 
     /// <summary>
@@ -264,6 +270,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>
@@ -299,6 +323,24 @@ public async Task<IActionResult> GetProposalProvenance(Guid id, CancellationToke
         return result.IsSuccess ? Ok(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

@@ -0,0 +1,105 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Taskdeck.Api.Contracts;
+using Taskdeck.Api.Extensions;
+using Taskdeck.Application.DTOs;
+using Taskdeck.Application.Interfaces;
+using Taskdeck.Application.Services;
+
+namespace Taskdeck.Api.Controllers;
+
+/// <summary>
+/// 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;
+
+    public TodayController(
+        IStreakService streakService,
+        ICadenceService cadenceService,
+        IUserContext userContext)
+        : base(userContext)
+    {
+        _streakService = streakService;
+        _cadenceService = cadenceService;
+    }
+
+    /// <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.
+    /// </summary>
+    /// <param name="date">Date to aggregate (ISO 8601). Defaults to today (UTC).</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>Cadence snapshot for the day.</returns>
+    /// <response code="200">Cadence snapshot returned successfully.</response>
+    /// <response code="400">Invalid date parameter.</response>
+    /// <response code="401">Authentication required.</response>
+    [HttpGet("cadence")]
+    [ProducesResponseType(typeof(CadenceResponse), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiErrorResponse), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ApiErrorResponse), StatusCodes.Status401Unauthorized)]
+    public async Task<IActionResult> GetCadence(
+        [FromQuery] DateTimeOffset? date,
+        CancellationToken cancellationToken)
+    {
+        if (!TryGetCurrentUserId(out var userId, out var errorResult))
+            return errorResult!;
+
+        var targetDate = date ?? DateTimeOffset.UtcNow;
+
+        var result = await _cadenceService.GetDailyCadenceAsync(userId, targetDate, cancellationToken);
+
+        if (!result.IsSuccess)
+            return result.ToErrorActionResult();
+
+        var snapshot = result.Value;
+        var response = new CadenceResponse(
+            Buckets: snapshot.Buckets.Select(b => new CadenceBucketDto(b.Hour, b.EventCount)).ToList(),
+            FirstActionAt: snapshot.FirstActionAt,
+            PeakHour: snapshot.PeakHour,
+            LastActionAt: snapshot.LastActionAt);
+
+        return Ok(response);
+    }
+}

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

@@ -48,7 +48,9 @@ public static IServiceCollection AddApplicationServices(this IServiceCollection
         services.AddScoped<IHistoryService>(sp => sp.GetRequiredService<HistoryService>());
         services.AddScoped<IAutomationProposalService, AutomationProposalService>();
         services.AddScoped<IProvenanceQueryService, ProvenanceQueryService>();
+        services.AddScoped<ISideEffectAnalyzer, SideEffectAnalyzer>();
         services.AddScoped<IProposalRevisionService, ProposalRevisionService>();
+        services.AddScoped<ISimilarDecisionService, SimilarDecisionService>();
         services.AddScoped<IAutomationPolicyEngine, AutomationPolicyEngine>();
         services.AddScoped<IAutomationPlannerService, AutomationPlannerService>();
         services.AddScoped<IAutomationExecutorService, AutomationExecutorService>();
@@ -57,6 +59,8 @@ public static IServiceCollection AddApplicationServices(this IServiceCollection
         services.AddScoped<IBoardContextBuilder, BoardContextBuilder>();
         services.AddScoped<IChatService, ChatService>();
         services.AddScoped<ILogQueryService, LogQueryService>();
+        services.AddScoped<ICadenceService>(sp =>
+            new CadenceService(sp.GetRequiredService<IUnitOfWork>().AuditLogs));
         services.AddScoped<INotificationService, NotificationService>();
         services.AddScoped<IKnowledgeService, KnowledgeService>();
         services.AddScoped<IWorkspaceService, WorkspaceService>();
@@ -74,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/CadenceDtos.cs

@@ -0,0 +1,16 @@
+namespace Taskdeck.Application.DTOs;
+
+/// <summary>
+/// A single hour bucket in the cadence response.
+/// </summary>
+public sealed record CadenceBucketDto(int Hour, int EventCount);
+
+/// <summary>
+/// API response DTO for daily cadence aggregation.
+/// Contains 24 per-hour buckets and first/peak/last action metadata.
+/// </summary>
+public sealed record CadenceResponse(
+    IReadOnlyList<CadenceBucketDto> Buckets,
+    DateTimeOffset? FirstActionAt,
+    int? PeakHour,
+    DateTimeOffset? LastActionAt);

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/Interfaces/ICadenceService.cs

@@ -0,0 +1,23 @@
+using Taskdeck.Domain.Common;
+
+namespace Taskdeck.Application.Interfaces;
+
+/// <summary>
+/// Provides daily cadence aggregation: per-hour activity buckets
+/// derived from audit log entries for a given user and day.
+/// </summary>
+public interface ICadenceService
+{
+    /// <summary>
+    /// Compute the per-hour cadence snapshot for the given user on the specified date.
+    /// Returns 24 buckets (hours 0-23) with event counts, plus first/peak/last timestamps.
+    /// </summary>
+    /// <param name="userId">The user whose activity to aggregate.</param>
+    /// <param name="date">The date to aggregate (only the date portion is used).</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A cadence snapshot for the day, or an empty snapshot if no activity.</returns>
+    Task<Result<CadenceSnapshot>> GetDailyCadenceAsync(
+        Guid userId,
+        DateTimeOffset date,
+        CancellationToken cancellationToken = default);
+}