feat: add task event tracking for creation, assignment, and movement

app/Http/Controllers/TaskController.php

@@ -39,6 +39,7 @@ public function index(Request $request): Response
                         'comments' => fn($query) => $query
                             ->whereNull('parent_id')
                             ->with(['user:id,name', 'replies']),
+                        'events.actor:id,name',
                     ])
                     ->orderBy('order')
                     ->paginate(10)
@@ -69,7 +70,7 @@ public function update(TaskUpdateRequest $request, Task $task): RedirectResponse
             abort(403, 'You are not authorized to update this task.');
         }
 
-        $this->taskService->updateTask($task, $request->validated());
+        $this->taskService->updateTask($task, $request->validated(), $request->user());
 
         return back();
     }

app/Http/Controllers/TaskSequenceController.php

@@ -21,7 +21,7 @@ public function update(TaskSequenceUpdateRequest $request, Task $task): Redirect
 
         $validated = $request->validated();
 
-        $this->taskService->updateSequence($task, $validated['column_id'], $validated['order']);
+        $this->taskService->updateSequence($task, $validated['column_id'], $validated['order'], $request->user());
 
         return back();
     }

app/Http/Resources/TaskResource.php

@@ -69,6 +69,21 @@ public function toArray(Request $request): array
                     ->map(fn($comment) => $this->serializeComment($comment))
                     ->values()
             ),
+            'events' => $this->whenLoaded(
+                'events',
+                fn() => $this->events->map(fn($event) => [
+                    'id' => $event->id,
+                    'type' => $event->type,
+                    'created_at' => $event->created_at?->toIso8601String(),
+                    'actor' => $event->relationLoaded('actor') && $event->actor
+                        ? [
+                            'id' => $event->actor->id,
+                            'name' => $event->actor->name,
+                        ]
+                        : null,
+                    'metadata' => $event->metadata ?? [],
+                ])->values(),
+            ),
         ];
     }
 }

app/Models/Task.php

@@ -82,4 +82,12 @@ public function comments(): HasMany
     {
         return $this->hasMany(TaskComment::class)->orderBy('created_at');
     }
+
+    /**
+     * Get the activity events for the task.
+     */
+    public function events(): HasMany
+    {
+        return $this->hasMany(TaskEvent::class)->orderBy('created_at');
+    }
 }

app/Models/TaskEvent.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class TaskEvent extends Model
+{
+    /** @use HasFactory<\Database\Factories\TaskEventFactory> */
+    use HasFactory;
+
+    /**
+     * The attributes that are mass assignable.
+     *
+     * @var list<string>
+     */
+    protected $fillable = [
+        'task_id',
+        'team_id',
+        'actor_id',
+        'type',
+        'metadata',
+    ];
+
+    /**
+     * Get the attributes that should be cast.
+     *
+     * @return array<string, string>
+     */
+    protected function casts(): array
+    {
+        return [
+            'metadata' => 'array',
+        ];
+    }
+
+    /**
+     * Get the task that owns the event.
+     */
+    public function task(): BelongsTo
+    {
+        return $this->belongsTo(Task::class);
+    }
+
+    /**
+     * Get the user who performed the event.
+     */
+    public function actor(): BelongsTo
+    {
+        return $this->belongsTo(User::class, 'actor_id');
+    }
+}

app/Services/TaskService.php

@@ -25,33 +25,90 @@ public function createTask(array $data, User $user): Task
 
         unset($data['column_id']);
 
-        return Task::create(array_merge($data, [
-            'team_id' => $user->team_id,
-            'created_by' => $user->id,
-            'column_id' => $columnId,
-            'order' => $order,
-            'column_updated_at' => now(), // Initialize column timing
-        ]));
+        $columnName = Column::query()->where('id', $columnId)->value('name');
+
+        return DB::transaction(function () use ($data, $user, $columnId, $order, $columnName) {
+            $task = Task::create(array_merge($data, [
+                'team_id' => $user->team_id,
+                'created_by' => $user->id,
+                'column_id' => $columnId,
+                'order' => $order,
+                'column_updated_at' => now(), // Initialize column timing
+            ]));
+
+            $task->events()->create([
+                'team_id' => $task->team_id,
+                'actor_id' => $user->id,
+                'type' => 'created',
+                'metadata' => [
+                    'column_id' => $columnId,
+                    'column_name' => $columnName,
+                ],
+            ]);
+
+            if (!empty($task->assigned_to)) {
+                $assignedUserName = User::query()->where('id', $task->assigned_to)->value('name');
+
+                $task->events()->create([
+                    'team_id' => $task->team_id,
+                    'actor_id' => $user->id,
+                    'type' => 'assigned',
+                    'metadata' => [
+                        'assigned_to' => $task->assigned_to,
+                        'assigned_to_name' => $assignedUserName,
+                    ],
+                ]);
+            }
+
+            return $task;
+        });
     }
 
     /**
      * Update an existing task.
      */
-    public function updateTask(Task $task, array $data): bool
+    public function updateTask(Task $task, array $data, User $actor): bool
     {
-        return $task->update($data);
+        $oldAssignedTo = $task->assigned_to;
+        $updated = $task->update($data);
+
+        if (!$updated) {
+            return false;
+        }
+
+        if (array_key_exists('assigned_to', $data) && $oldAssignedTo !== $task->assigned_to) {
+            $assignedUserName = $task->assigned_to
+                ? User::query()->where('id', $task->assigned_to)->value('name')
+                : null;
+
+            $task->events()->create([
+                'team_id' => $task->team_id,
+                'actor_id' => $actor->id,
+                'type' => 'assigned',
+                'metadata' => [
+                    'assigned_to' => $task->assigned_to,
+                    'assigned_to_name' => $assignedUserName,
+                    'previous_assigned_to' => $oldAssignedTo,
+                ],
+            ]);
+        }
+
+        return true;
     }
 
     /**
      * Update the sequence and column of a task inside the Kanban board.
      */
-    public function updateSequence(Task $task, int $newColumnId, int $newOrder): void
+    public function updateSequence(Task $task, int $newColumnId, int $newOrder, User $actor): void
     {
         $oldColumnId = $task->column_id;
         $oldOrder = $task->order;
         $isDifferentColumn = $oldColumnId != $newColumnId;
+        $columnNames = Column::query()
+            ->whereIn('id', [$oldColumnId, $newColumnId])
+            ->pluck('name', 'id');
 
-        DB::transaction(function () use ($task, $newColumnId, $newOrder, $oldColumnId, $oldOrder, $isDifferentColumn) {
+        DB::transaction(function () use ($task, $newColumnId, $newOrder, $oldColumnId, $oldOrder, $isDifferentColumn, $actor, $columnNames) {
             if (!$isDifferentColumn) {
                 // Moving within the same column
                 if ($oldOrder < $newOrder) {
@@ -90,6 +147,20 @@ public function updateSequence(Task $task, int $newColumnId, int $newOrder): voi
             }
 
             $task->update($updateData);
+
+            if ($isDifferentColumn) {
+                $task->events()->create([
+                    'team_id' => $task->team_id,
+                    'actor_id' => $actor->id,
+                    'type' => 'moved',
+                    'metadata' => [
+                        'from_column_id' => $oldColumnId,
+                        'from_column_name' => $columnNames[$oldColumnId] ?? null,
+                        'to_column_id' => $newColumnId,
+                        'to_column_name' => $columnNames[$newColumnId] ?? null,
+                    ],
+                ]);
+            }
         });
     }
 

database/migrations/2026_04_14_090000_create_task_events_table.php

@@ -0,0 +1,34 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('task_events', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('task_id')->constrained()->cascadeOnDelete();
+            $table->foreignId('team_id')->constrained()->cascadeOnDelete();
+            $table->foreignId('actor_id')->nullable()->constrained('users')->nullOnDelete();
+            $table->string('type', 50);
+            $table->json('metadata')->nullable();
+            $table->timestamps();
+
+            $table->index(['task_id', 'created_at']);
+            $table->index(['team_id', 'type']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('task_events');
+    }
+};