tak: Fix created_at and switch to numeric IDs with installation suffix

Bug fixes:
1. Store actual creation timestamp in created_at field (was showing 1970)
2. Switch from ULID to numeric IDs: tak-<number>-<suffix> format
   - Each installation gets a unique random 6-char suffix
   - Suffix is stored in database metadata and reused
   - Allows parallel installations with same numeric ID but different suffixes

Changes:
- Add created_at timestamp to Event struct and database
- Store creation time from time.Now() instead of converting Lamport TS
- Add metadata table for installation suffix storage
- Add task_counter table for numeric ID sequence
- Generate IDs like tak-1-abc123, tak-2-abc123, etc.
- Update all tests to use new ID format and include CreatedAt

Co-authored-by: neongreen <1523306+neongreen@users.noreply.github.com>

Author: Copilot

tak/db.go

@@ -1,11 +1,14 @@
 package main
 
 import (
+	"crypto/rand"
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"math/big"
 	"os"
 	"path/filepath"
+	"time"
 
 	_ "modernc.org/sqlite"
 )
@@ -47,12 +50,13 @@ func OpenDB(path string) (*DB, error) {
 	return &DB{db: db}, nil
 }
 
-// InitDB creates the events table
+// InitDB creates the events table and metadata table
 func (d *DB) InitDB() error {
 	schema := `
 	CREATE TABLE IF NOT EXISTS events (
 		id TEXT PRIMARY KEY,
 		ts INTEGER NOT NULL,
+		created_at INTEGER NOT NULL,
 		actor TEXT NOT NULL,
 		role TEXT NOT NULL,
 		kind TEXT NOT NULL,
@@ -65,23 +69,44 @@ func (d *DB) InitDB() error {
 	);
 	CREATE INDEX IF NOT EXISTS idx_events_ts ON events(ts, id);
 	CREATE INDEX IF NOT EXISTS idx_events_kind ON events(kind);
+	
+	CREATE TABLE IF NOT EXISTS metadata (
+		key TEXT PRIMARY KEY,
+		value TEXT NOT NULL
+	);
+	
+	CREATE TABLE IF NOT EXISTS task_counter (
+		last_id INTEGER NOT NULL
+	);
 	`
 
 	if _, err := d.db.Exec(schema); err != nil {
 		return fmt.Errorf("failed to create schema: %w", err)
 	}
 
+	// Initialize counter if it doesn't exist
+	var count int
+	err := d.db.QueryRow("SELECT COUNT(*) FROM task_counter").Scan(&count)
+	if err != nil {
+		return fmt.Errorf("failed to check counter: %w", err)
+	}
+	if count == 0 {
+		if _, err := d.db.Exec("INSERT INTO task_counter (last_id) VALUES (0)"); err != nil {
+			return fmt.Errorf("failed to initialize counter: %w", err)
+		}
+	}
+
 	return nil
 }
 
 // InsertEvent adds an event to the database
 func (d *DB) InsertEvent(e Event) error {
 	query := `
-		INSERT INTO events (id, ts, actor, role, kind, payload, ctx, repo_uuid, branch, commit_sha, jj_op_id)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		INSERT INTO events (id, ts, created_at, actor, role, kind, payload, ctx, repo_uuid, branch, commit_sha, jj_op_id)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 	`
 
-	_, err := d.db.Exec(query, e.ID, e.TS, e.Actor, e.Role, e.Kind, e.Payload, e.Ctx, e.RepoUUID, e.Branch, e.Commit, e.JJOpID)
+	_, err := d.db.Exec(query, e.ID, e.TS, e.CreatedAt.UnixNano(), e.Actor, e.Role, e.Kind, e.Payload, e.Ctx, e.RepoUUID, e.Branch, e.Commit, e.JJOpID)
 	if err != nil {
 		return fmt.Errorf("failed to insert event: %w", err)
 	}
@@ -91,7 +116,7 @@ func (d *DB) InsertEvent(e Event) error {
 
 // GetEvents retrieves all events in chronological order
 func (d *DB) GetEvents() ([]Event, error) {
-	query := `SELECT id, ts, actor, role, kind, payload, ctx, repo_uuid, branch, commit_sha, jj_op_id
+	query := `SELECT id, ts, created_at, actor, role, kind, payload, ctx, repo_uuid, branch, commit_sha, jj_op_id
 	          FROM events ORDER BY ts, id`
 
 	rows, err := d.db.Query(query)
@@ -104,12 +129,14 @@ func (d *DB) GetEvents() ([]Event, error) {
 	for rows.Next() {
 		var e Event
 		var ctx, repoUUID, branch, commit, jjOpID sql.NullString
+		var createdAtNano int64
 
-		err := rows.Scan(&e.ID, &e.TS, &e.Actor, &e.Role, &e.Kind, &e.Payload, &ctx, &repoUUID, &branch, &commit, &jjOpID)
+		err := rows.Scan(&e.ID, &e.TS, &createdAtNano, &e.Actor, &e.Role, &e.Kind, &e.Payload, &ctx, &repoUUID, &branch, &commit, &jjOpID)
 		if err != nil {
 			return nil, fmt.Errorf("failed to scan event row: %w", err)
 		}
 
+		e.CreatedAt = time.Unix(0, createdAtNano)
 		if ctx.Valid {
 			e.Ctx = json.RawMessage(ctx.String)
 		}
@@ -135,7 +162,7 @@ func (d *DB) GetEvents() ([]Event, error) {
 // GetEventsByTaskID retrieves events for a specific task
 func (d *DB) GetEventsByTaskID(taskID string) ([]Event, error) {
 	query := `
-		SELECT id, ts, actor, role, kind, payload, ctx, repo_uuid, branch, commit_sha, jj_op_id
+		SELECT id, ts, created_at, actor, role, kind, payload, ctx, repo_uuid, branch, commit_sha, jj_op_id
 		FROM events
 		WHERE json_extract(payload, '$.task_id') = ?
 		ORDER BY ts, id
@@ -151,12 +178,14 @@ func (d *DB) GetEventsByTaskID(taskID string) ([]Event, error) {
 	for rows.Next() {
 		var e Event
 		var ctx, repoUUID, branch, commit, jjOpID sql.NullString
+		var createdAtNano int64
 
-		err := rows.Scan(&e.ID, &e.TS, &e.Actor, &e.Role, &e.Kind, &e.Payload, &ctx, &repoUUID, &branch, &commit, &jjOpID)
+		err := rows.Scan(&e.ID, &e.TS, &createdAtNano, &e.Actor, &e.Role, &e.Kind, &e.Payload, &ctx, &repoUUID, &branch, &commit, &jjOpID)
 		if err != nil {
 			return nil, fmt.Errorf("failed to scan event row: %w", err)
 		}
 
+		e.CreatedAt = time.Unix(0, createdAtNano)
 		if ctx.Valid {
 			e.Ctx = json.RawMessage(ctx.String)
 		}
@@ -200,3 +229,68 @@ func DBExists(path string) bool {
 	_, err := os.Stat(path)
 	return err == nil
 }
+
+// GetOrCreateInstallationSuffix gets the installation suffix or creates one if it doesn't exist
+func (d *DB) GetOrCreateInstallationSuffix() (string, error) {
+	// Try to get existing suffix
+	var suffix string
+	err := d.db.QueryRow("SELECT value FROM metadata WHERE key = 'installation_suffix'").Scan(&suffix)
+	if err == nil {
+		return suffix, nil
+	}
+	if err != sql.ErrNoRows {
+		return "", fmt.Errorf("failed to query installation suffix: %w", err)
+	}
+
+	// Generate new suffix (6 random alphanumeric characters)
+	suffix = generateRandomSuffix(6)
+
+	// Store it
+	_, err = d.db.Exec("INSERT INTO metadata (key, value) VALUES ('installation_suffix', ?)", suffix)
+	if err != nil {
+		return "", fmt.Errorf("failed to store installation suffix: %w", err)
+	}
+
+	return suffix, nil
+}
+
+// GetNextTaskNumber gets the next task number and increments the counter
+func (d *DB) GetNextTaskNumber() (int64, error) {
+	tx, err := d.db.Begin()
+	if err != nil {
+		return 0, fmt.Errorf("failed to begin transaction: %w", err)
+	}
+	defer tx.Rollback()
+
+	var lastID int64
+	err = tx.QueryRow("SELECT last_id FROM task_counter").Scan(&lastID)
+	if err != nil {
+		return 0, fmt.Errorf("failed to get last task ID: %w", err)
+	}
+
+	nextID := lastID + 1
+	_, err = tx.Exec("UPDATE task_counter SET last_id = ?", nextID)
+	if err != nil {
+		return 0, fmt.Errorf("failed to update task counter: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return 0, fmt.Errorf("failed to commit transaction: %w", err)
+	}
+
+	return nextID, nil
+}
+
+// generateRandomSuffix generates a random alphanumeric suffix
+func generateRandomSuffix(length int) string {
+	const charset = "abcdefghijklmnopqrstuvwxyz0123456789"
+	b := make([]byte, length)
+	for i := range b {
+		n, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
+		if err != nil {
+			panic(err)
+		}
+		b[i] = charset[n.Int64()]
+	}
+	return string(b)
+}

tak/main.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/user"
 	"strings"
+	"time"
 
 	"github.com/spf13/cobra"
 )
@@ -86,7 +87,10 @@ var newCmd = &cobra.Command{
 			return err
 		}
 
-		taskID := GenerateULID("tak")
+		taskID, err := GenerateTaskID(db)
+		if err != nil {
+			return err
+		}
 		eventID := GenerateEventID()
 
 		payload := TaskCreatedPayload{
@@ -99,13 +103,15 @@ var newCmd = &cobra.Command{
 			return fmt.Errorf("failed to marshal payload: %w", err)
 		}
 
+		now := time.Now()
 		event := Event{
-			ID:      eventID,
-			TS:      GetNextLamportTS(),
-			Actor:   currentUser,
-			Role:    "human",
-			Kind:    "task.created",
-			Payload: payloadJSON,
+			ID:        eventID,
+			TS:        GetNextLamportTS(),
+			CreatedAt: now,
+			Actor:     currentUser,
+			Role:      "human",
+			Kind:      "task.created",
+			Payload:   payloadJSON,
 		}
 
 		if err := db.InsertEvent(event); err != nil {
@@ -157,13 +163,15 @@ var statusSetCmd = &cobra.Command{
 			return fmt.Errorf("failed to marshal payload: %w", err)
 		}
 
+		now := time.Now()
 		event := Event{
-			ID:      eventID,
-			TS:      GetNextLamportTS(),
-			Actor:   currentUser,
-			Role:    role,
-			Kind:    "task.status.set",
-			Payload: payloadJSON,
+			ID:        eventID,
+			TS:        GetNextLamportTS(),
+			CreatedAt: now,
+			Actor:     currentUser,
+			Role:      role,
+			Kind:      "task.status.set",
+			Payload:   payloadJSON,
 		}
 
 		if err := db.InsertEvent(event); err != nil {
@@ -205,13 +213,15 @@ var noteCmd = &cobra.Command{
 			return fmt.Errorf("failed to marshal payload: %w", err)
 		}
 
+		now := time.Now()
 		event := Event{
-			ID:      eventID,
-			TS:      GetNextLamportTS(),
-			Actor:   currentUser,
-			Role:    "human",
-			Kind:    "task.note.add",
-			Payload: payloadJSON,
+			ID:        eventID,
+			TS:        GetNextLamportTS(),
+			CreatedAt: now,
+			Actor:     currentUser,
+			Role:      "human",
+			Kind:      "task.note.add",
+			Payload:   payloadJSON,
 		}
 
 		if err := db.InsertEvent(event); err != nil {

tak/reducer.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"sort"
-	"time"
 )
 
 // Reducer reconstructs task state from events
@@ -45,7 +44,7 @@ func (r *Reducer) applyTaskCreated(e Event) error {
 		Axes:      make(map[string]AxisStatus),
 		Notes:     []Note{},
 		CreatedBy: payload.CreatedBy,
-		CreatedAt: time.Unix(0, e.TS*1e6), // Convert Lamport TS to approximate time
+		CreatedAt: e.CreatedAt, // Use actual creation time from event
 	}
 
 	return nil
@@ -101,7 +100,7 @@ func (r *Reducer) applyTaskNoteAdd(e Event) error {
 	note := Note{
 		Markdown:  payload.Markdown,
 		Actor:     e.Actor,
-		Timestamp: time.Unix(0, e.TS*1e6),
+		Timestamp: e.CreatedAt, // Use actual creation time from event
 	}
 	task.Notes = append(task.Notes, note)