soja-cli 1.4.0

package/dist/database/migrations/meta/_journal.json

@@ -0,0 +1,55 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1790262721308,
+      "tag": "0000_init",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "6",
+      "when": 1790269842239,
+      "tag": "0001_git-operations",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "6",
+      "when": 1790271413249,
+      "tag": "0002_merge-detection",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "6",
+      "when": 1790277009822,
+      "tag": "0003_sync-replica",
+      "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "6",
+      "when": 1790286496661,
+      "tag": "0004_chat-replica",
+      "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "6",
+      "when": 1790288440464,
+      "tag": "0005_pr-events",
+      "breakpoints": true
+    },
+    {
+      "idx": 6,
+      "version": "6",
+      "when": 1790294003288,
+      "tag": "0006_archive",
+      "breakpoints": true
+    }
+  ]
+}

package/dist/database/schema.js

@@ -0,0 +1,170 @@
+import { sql } from 'drizzle-orm';
+import { check, index, integer, primaryKey, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { ACTIVITY_TYPES } from '../domain/activity.js';
+import { WORKSPACE_ROLES } from '../domain/entities.js';
+import { TASK_PRIORITIES, TASK_STATUSES, TASK_TYPES } from '../domain/task.js';
+const timestamps = {
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+};
+const oneOf = (column, values) => sql.raw(`${column} IN (${values.map((value) => `'${value}'`).join(', ')})`);
+export const users = sqliteTable('users', {
+    id: text('id').primaryKey(),
+    username: text('username').notNull().unique(),
+    displayName: text('display_name').notNull(),
+    email: text('email'),
+    ...timestamps,
+});
+export const workspaces = sqliteTable('workspaces', {
+    id: text('id').primaryKey(),
+    name: text('name').notNull(),
+    slug: text('slug').notNull().unique(),
+    description: text('description'),
+    /** Highest task number ever deleted, so numbers are never reused (old commits keep pointing at the right task). */
+    lastDeletedNumber: integer('last_deleted_number').notNull().default(0),
+    ...timestamps,
+});
+export const workspaceMembers = sqliteTable('workspace_members', {
+    workspaceId: text('workspace_id')
+        .notNull()
+        .references(() => workspaces.id, { onDelete: 'cascade' }),
+    userId: text('user_id')
+        .notNull()
+        .references(() => users.id, { onDelete: 'cascade' }),
+    role: text('role', { enum: WORKSPACE_ROLES }).notNull(),
+}, (t) => [primaryKey({ columns: [t.workspaceId, t.userId] }), check('workspace_members_role', oneOf('role', WORKSPACE_ROLES))]);
+export const projects = sqliteTable('projects', {
+    id: text('id').primaryKey(),
+    workspaceId: text('workspace_id')
+        .notNull()
+        .references(() => workspaces.id, { onDelete: 'cascade' }),
+    name: text('name').notNull(),
+    key: text('key').notNull(),
+    description: text('description'),
+    repositoryUrl: text('repository_url'),
+    repositoryPath: text('repository_path'),
+    ...timestamps,
+}, (t) => [uniqueIndex('projects_workspace_key').on(t.workspaceId, t.key)]);
+export const tasks = sqliteTable('tasks', {
+    id: text('id').primaryKey(),
+    number: integer('number').notNull(),
+    workspaceId: text('workspace_id')
+        .notNull()
+        .references(() => workspaces.id, { onDelete: 'cascade' }),
+    projectId: text('project_id').references(() => projects.id, { onDelete: 'set null' }),
+    title: text('title').notNull(),
+    description: text('description'),
+    type: text('type', { enum: TASK_TYPES }).notNull(),
+    priority: text('priority', { enum: TASK_PRIORITIES }).notNull(),
+    status: text('status', { enum: TASK_STATUSES }).notNull(),
+    assigneeId: text('assignee_id').references(() => users.id, { onDelete: 'set null' }),
+    creatorId: text('creator_id')
+        .notNull()
+        .references(() => users.id),
+    requester: text('requester'),
+    branch: text('branch'),
+    baseBranch: text('base_branch'),
+    branchStart: text('branch_start'),
+    ...timestamps,
+    startedAt: integer('started_at', { mode: 'timestamp_ms' }),
+    completedAt: integer('completed_at', { mode: 'timestamp_ms' }),
+    archivedAt: integer('archived_at', { mode: 'timestamp_ms' }),
+}, (t) => [
+    uniqueIndex('tasks_workspace_number').on(t.workspaceId, t.number),
+    index('tasks_workspace_status').on(t.workspaceId, t.status),
+    index('tasks_assignee').on(t.assigneeId),
+    index('tasks_project').on(t.projectId),
+    check('tasks_type', oneOf('type', TASK_TYPES)),
+    check('tasks_priority', oneOf('priority', TASK_PRIORITIES)),
+    check('tasks_status', oneOf('status', TASK_STATUSES)),
+]);
+export const taskComments = sqliteTable('task_comments', {
+    id: text('id').primaryKey(),
+    taskId: text('task_id')
+        .notNull()
+        .references(() => tasks.id, { onDelete: 'cascade' }),
+    userId: text('user_id')
+        .notNull()
+        .references(() => users.id),
+    body: text('body').notNull(),
+    ...timestamps,
+}, (t) => [index('task_comments_task').on(t.taskId)]);
+export const taskActivity = sqliteTable('task_activity', {
+    id: text('id').primaryKey(),
+    taskId: text('task_id')
+        .notNull()
+        .references(() => tasks.id, { onDelete: 'cascade' }),
+    userId: text('user_id').references(() => users.id, { onDelete: 'set null' }),
+    type: text('type', { enum: ACTIVITY_TYPES }).notNull(),
+    metadata: text('metadata', { mode: 'json' }).$type().notNull(),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+}, (t) => [index('task_activity_task').on(t.taskId), check('task_activity_type', oneOf('type', ACTIVITY_TYPES))]);
+// ── Remote mode replica (v0.4 offline sync). Unused in local mode. ─────────
+/** Operations waiting to be sent to the SOJA server, in the order they were made. */
+export const syncOutbox = sqliteTable('sync_outbox', {
+    seq: integer('seq').primaryKey({ autoIncrement: true }),
+    opId: text('op_id').notNull().unique(),
+    workspaceId: text('workspace_id').notNull(),
+    type: text('type').notNull(),
+    /** The task a task operation changes; null for chat operations. */
+    taskId: text('task_id'),
+    payload: text('payload', { mode: 'json' }).$type().notNull(),
+    base: text('base', { mode: 'json' }).$type(),
+    occurredAt: integer('occurred_at', { mode: 'timestamp_ms' }).notNull(),
+    attempts: integer('attempts').notNull().default(0),
+    lastError: text('last_error'),
+}, (t) => [index('sync_outbox_workspace').on(t.workspaceId, t.seq)]);
+/** Activity rows written optimistically for an operation; replaced by the server's once acknowledged. */
+export const syncPendingActivity = sqliteTable('sync_pending_activity', {
+    activityId: text('activity_id').primaryKey(),
+    opId: text('op_id').notNull(),
+});
+/** Pull cursor per workspace. */
+export const syncState = sqliteTable('sync_state', {
+    workspaceId: text('workspace_id').primaryKey(),
+    cursor: integer('cursor').notNull().default(0),
+    lastSyncAt: integer('last_sync_at', { mode: 'timestamp_ms' }),
+    lastError: text('last_error'),
+});
+/** Conflicts and rejections the user should see. */
+export const syncNotices = sqliteTable('sync_notices', {
+    id: text('id').primaryKey(),
+    workspaceId: text('workspace_id').notNull(),
+    taskId: text('task_id'),
+    taskRef: text('task_ref').notNull(),
+    kind: text('kind', { enum: ['conflict', 'rejected'] }).notNull(),
+    message: text('message').notNull(),
+    field: text('field'),
+    /** For conflicts: the value your change replaced, to restore it. */
+    overwritten: text('overwritten', { mode: 'json' }).$type(),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    dismissedAt: integer('dismissed_at', { mode: 'timestamp_ms' }),
+}, (t) => [index('sync_notices_workspace').on(t.workspaceId)]);
+// ── Chat replica (v0.5, remote mode only) ───────────────────────────────────
+export const chatChannels = sqliteTable('chat_channels', {
+    id: text('id').primaryKey(),
+    workspaceId: text('workspace_id').notNull(),
+    name: text('name').notNull(),
+    topic: text('topic'),
+    createdBy: text('created_by'),
+    ...timestamps,
+    archivedAt: integer('archived_at', { mode: 'timestamp_ms' }),
+}, (t) => [index('chat_channels_workspace').on(t.workspaceId, t.name)]);
+export const chatMessages = sqliteTable('chat_messages', {
+    id: text('id').primaryKey(),
+    /** Server order; null while the message waits in the outbox. */
+    seq: integer('seq'),
+    workspaceId: text('workspace_id').notNull(),
+    channelId: text('channel_id').notNull(),
+    authorId: text('author_id'),
+    body: text('body').notNull(),
+    replyToId: text('reply_to_id'),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+    editedAt: integer('edited_at', { mode: 'timestamp_ms' }),
+    deletedAt: integer('deleted_at', { mode: 'timestamp_ms' }),
+}, (t) => [index('chat_messages_channel').on(t.channelId, t.seq), index('chat_messages_workspace').on(t.workspaceId)]);
+/** How far you have read each channel (yours only). */
+export const chatReads = sqliteTable('chat_reads', {
+    channelId: text('channel_id').primaryKey(),
+    lastReadSeq: integer('last_read_seq').notNull().default(0),
+});

package/dist/dev/seed.js

@@ -0,0 +1,84 @@
+import { ConflictError } from '../domain/errors.js';
+const WORKSPACE = 'Bravos Development';
+const DEVELOPERS = [
+    { username: 'michael', displayName: 'Michael' },
+    { username: 'angel', displayName: 'Angel' },
+    { username: 'freddy', displayName: 'Freddy' },
+];
+const PROJECTS = [
+    { name: 'EnrollBridge', key: 'ENROLL', description: 'Enrollment and payments platform' },
+    { name: 'SPRING', key: 'SPRING', description: 'Player development and pitching analytics' },
+    { name: 'Taskfeeds', key: 'TASK', description: 'Internal content and video feeds' },
+    { name: 'Banana Gym', key: 'GYM', description: 'Gym access control and memberships' },
+    { name: 'Mediacore', key: 'MEDIA', description: 'Media storage and processing' },
+];
+const TASKS = [
+    { title: 'Receipt upload not rendering after payment', project: 'EnrollBridge', type: 'bug', priority: 'urgent', status: 'in_progress', assignee: 'me', requester: 'Admissions', description: 'Parents upload the receipt, the upload succeeds, but the enrollment page keeps showing "pending receipt".', comments: ['Reproduced on staging with a PDF over 5 MB.', 'The CDN URL is signed with the wrong bucket.'] },
+    { title: 'Fix Stripe webhook duplicate events', project: 'EnrollBridge', type: 'bug', priority: 'high', status: 'review', assignee: 'me', requester: 'Finance', description: 'Stripe retries are creating duplicate payment records. We need idempotency on event IDs.' },
+    { title: 'Add pitch velocity to player profile', project: 'SPRING', type: 'feature', priority: 'high', status: 'todo', assignee: 'me', requester: 'Baseball Operations' },
+    { title: 'Improve video loading on slow connections', project: 'Taskfeeds', type: 'improvement', priority: 'low', status: 'todo', assignee: 'me', requester: 'Marketing' },
+    { title: 'Turnstile loses connection every night', project: 'Banana Gym', type: 'bug', priority: 'high', status: 'blocked', assignee: 'me', requester: 'Operations', comments: ['Waiting on the vendor to send the new firmware.'] },
+    { title: 'Change payment flow to support installments', project: 'EnrollBridge', type: 'feature', priority: 'medium', status: 'backlog', assignee: null, requester: 'Finance' },
+    { title: 'Rotate S3 credentials', project: 'Mediacore', type: 'infra', priority: 'medium', status: 'todo', assignee: 'freddy' },
+    { title: 'Migrate thumbnails to WebP', project: 'Mediacore', type: 'improvement', priority: 'low', status: 'in_progress', assignee: 'freddy' },
+    { title: 'Spin rate chart shows wrong units', project: 'SPRING', type: 'bug', priority: 'medium', status: 'review', assignee: 'angel', requester: 'Baseball Operations' },
+    { title: 'Research pose estimation libraries', project: 'SPRING', type: 'research', priority: 'none', status: 'backlog', assignee: 'angel' },
+    { title: 'Marketing banner copy fix on feed header', project: 'Taskfeeds', type: 'chore', priority: 'low', status: 'done', assignee: 'angel', requester: 'Marketing' },
+    { title: 'Refactor membership renewal job', project: 'Banana Gym', type: 'refactor', priority: 'medium', status: 'todo', assignee: 'angel' },
+    { title: 'Weekly database backup verification', project: 'Mediacore', type: 'maintenance', priority: 'medium', status: 'done', assignee: 'me' },
+    { title: 'Admissions export times out', project: 'EnrollBridge', type: 'bug', priority: 'high', status: 'todo', assignee: 'freddy', requester: 'Admissions' },
+    { title: 'Upgrade Node to 24 on all services', project: 'Mediacore', type: 'infra', priority: 'low', status: 'cancelled', assignee: null, requester: 'Management' },
+];
+/**
+ * Demo data for trying the UI. Goes through the services, so the rows,
+ * numbering and activity timelines are exactly what real usage produces.
+ */
+export async function seedDemoData(services) {
+    let session = await services.session.current();
+    if (!session) {
+        session = await services.session.setup({ displayName: 'Michael', username: 'michael', workspaceName: WORKSPACE });
+    }
+    else {
+        const existing = (await services.workspaces.list(session.user)).find((workspace) => workspace.name === WORKSPACE);
+        const workspace = existing ?? (await services.workspaces.create(session.user, { name: WORKSPACE }));
+        session = await services.workspaces.switchTo(session.user, workspace.id);
+    }
+    if ((await services.projects.list(session)).length > 0) {
+        throw new ConflictError(`${WORKSPACE} already has projects, so demo data was not added.`, {
+            hint: 'Run `npm run db:reset` first for a clean demo.',
+        });
+    }
+    const members = new Map((await services.workspaces.members(session)).map((member) => [member.username, member.id]));
+    for (const developer of DEVELOPERS) {
+        if (!members.has(developer.username)) {
+            const user = await services.workspaces.addMember(session, developer);
+            members.set(user.username, user.id);
+        }
+    }
+    const projectIds = new Map();
+    for (const project of PROJECTS) {
+        projectIds.set(project.name, (await services.projects.create(session, project)).id);
+    }
+    for (const demo of TASKS) {
+        const assigneeId = demo.assignee === 'me' ? session.user.id : demo.assignee ? members.get(demo.assignee) : null;
+        // Created as Todo and then moved, so the timeline shows real transitions.
+        const task = await services.tasks.create(session, {
+            title: demo.title,
+            description: demo.description ?? null,
+            projectId: projectIds.get(demo.project) ?? null,
+            type: demo.type,
+            priority: demo.priority,
+            status: demo.status === 'backlog' ? 'backlog' : 'todo',
+            assigneeId: assigneeId ?? null,
+            requester: demo.requester ?? null,
+        });
+        if (['review', 'blocked', 'done'].includes(demo.status)) {
+            await services.tasks.update(session, task, { status: 'in_progress' });
+        }
+        if (demo.status !== task.status)
+            await services.tasks.update(session, task, { status: demo.status });
+        for (const comment of demo.comments ?? [])
+            await services.tasks.comment(session, task, comment);
+    }
+    return { session, projects: PROJECTS.length, tasks: TASKS.length };
+}

package/dist/domain/activity.js

@@ -0,0 +1,22 @@
+export const ACTIVITY_TYPES = [
+    'task_created',
+    'task_updated',
+    'status_changed',
+    'assigned',
+    'unassigned',
+    'priority_changed',
+    'project_changed',
+    'comment_added',
+    'task_completed',
+    'task_reopened',
+    'git_committed',
+    'git_merged',
+    'git_branch_deleted',
+    'git_pushed',
+    'pr_opened',
+    'git_merge_detected',
+    'pr_merged',
+    'pr_checks_failed',
+    'task_archived',
+    'task_unarchived',
+];

package/dist/domain/chat.js

@@ -0,0 +1,21 @@
+import { TASK_REF_PREFIX } from './task.js';
+export const MAX_MESSAGE_LENGTH = 4000;
+export const CHANNEL_NAME = /^[a-z0-9][a-z0-9-]{0,39}$/;
+/** `#General ` → `general`. */
+export function normalizeChannelName(name) {
+    return name.trim().toLowerCase().replace(/^#/, '');
+}
+// Same rules as the server, which resolves them to real members and tasks.
+const MENTION = /(^|[^\w@])@([a-z0-9][a-z0-9._-]{0,38})/gi;
+const TASK_REF = new RegExp(`\\b${TASK_REF_PREFIX}-(\\d{1,9})\\b`, 'gi');
+/** Usernames written as `@name`, lowercased and unique. */
+export function mentionsIn(body) {
+    return [...new Set([...body.matchAll(MENTION)].map((match) => (match[2] ?? '').toLowerCase()))];
+}
+/** Task numbers written as `SOJA-12`. */
+export function taskRefsIn(body) {
+    return [...new Set([...body.matchAll(TASK_REF)].map((match) => Number(match[1])))];
+}
+export function mentions(body, username) {
+    return mentionsIn(body).includes(username.toLowerCase());
+}

package/dist/domain/entities.js

@@ -0,0 +1 @@
+export const WORKSPACE_ROLES = ['owner', 'member'];

package/dist/domain/errors.js

@@ -0,0 +1,23 @@
+/**
+ * Errors meant to be shown to people. `message` is a short sentence,
+ * `hint` an optional next step. Anything that is not a SojaError is a bug
+ * and gets a generic message (details only with SOJA_DEBUG=1).
+ */
+export class SojaError extends Error {
+    hint;
+    constructor(message, options = {}) {
+        super(message, { cause: options.cause });
+        this.name = new.target.name;
+        this.hint = options.hint;
+    }
+}
+export class NotFoundError extends SojaError {
+}
+export class ValidationError extends SojaError {
+}
+export class ConflictError extends SojaError {
+}
+export class StorageError extends SojaError {
+}
+export class ConfigError extends SojaError {
+}

package/dist/domain/naming.js

@@ -0,0 +1,33 @@
+export function slugify(value) {
+    return value
+        .normalize('NFKD')
+        .replace(/[̀-ͯ]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * Short uppercase key for a project name: the first word when it is short
+ * (`SPRING`, `ENROLL` from EnrollBridge), otherwise its first four letters
+ * (`TASK` from Taskfeeds).
+ */
+export function deriveProjectKey(name) {
+    const words = name
+        .normalize('NFKD')
+        .replace(/[̀-ͯ]/g, '')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean);
+    const first = (words[0] ?? 'PROJ').toUpperCase();
+    return first.length <= 6 ? first : first.slice(0, 4);
+}
+/** Appends 2, 3, … (after `separator`) until `isTaken` is false. */
+export function makeUnique(base, isTaken, separator = '') {
+    if (!isTaken(base))
+        return base;
+    for (let n = 2;; n += 1) {
+        const candidate = `${base}${separator}${n}`;
+        if (!isTaken(candidate))
+            return candidate;
+    }
+}

package/dist/domain/task.js

@@ -0,0 +1,140 @@
+export const TASK_TYPES = [
+    'bug',
+    'feature',
+    'improvement',
+    'maintenance',
+    'infra',
+    'refactor',
+    'research',
+    'chore',
+];
+export const TASK_PRIORITIES = ['none', 'low', 'medium', 'high', 'urgent'];
+export const TASK_STATUSES = [
+    'backlog',
+    'todo',
+    'in_progress',
+    'review',
+    'blocked',
+    'done',
+    'cancelled',
+];
+export const TYPE_LABELS = {
+    bug: 'Bug',
+    feature: 'Feature',
+    improvement: 'Improvement',
+    maintenance: 'Maintenance',
+    infra: 'Infra',
+    refactor: 'Refactor',
+    research: 'Research',
+    chore: 'Chore',
+};
+export const PRIORITY_LABELS = {
+    none: 'NONE',
+    low: 'LOW',
+    medium: 'MED',
+    high: 'HIGH',
+    urgent: 'URGENT',
+};
+export const STATUS_LABELS = {
+    backlog: 'Backlog',
+    todo: 'Todo',
+    in_progress: 'In Progress',
+    review: 'Review',
+    blocked: 'Blocked',
+    done: 'Done',
+    cancelled: 'Cancelled',
+};
+/** Human identifier prefix. Numbers are sequential per workspace. */
+export const TASK_REF_PREFIX = 'SOJA';
+/**
+ * `SOJA-12`. Tasks created offline in remote mode get provisional negative
+ * numbers until the server assigns the real one: -1 shows as `SOJA-?1`.
+ */
+export function formatTaskRef(number) {
+    return number < 0 ? `${TASK_REF_PREFIX}-?${-number}` : `${TASK_REF_PREFIX}-${number}`;
+}
+export function isProvisional(number) {
+    return number < 0;
+}
+/**
+ * Extended regex (for `git log --grep -E -i`) matching a mention of the task
+ * in a commit message: `SOJA-12` but not `SOJA-123`.
+ */
+export function taskMentionPattern(number) {
+    return `${TASK_REF_PREFIX}-${number}([^0-9]|$)`;
+}
+/** Accepts `SOJA-12`, `soja-12`, `#12` or `12`, and provisional `SOJA-?1` / `?1`. */
+export function parseTaskRef(input) {
+    const match = /^(?:soja-|#)?(\?)?(\d{1,9})$/i.exec(input.trim());
+    if (!match?.[2])
+        return null;
+    const value = Number(match[2]);
+    if (value <= 0)
+        return null;
+    return match[1] ? -value : value;
+}
+export function isClosed(status) {
+    return status === 'done' || status === 'cancelled';
+}
+/** Work someone is expected to touch soon: excludes backlog and closed tasks. */
+export function isActive(status) {
+    return !isClosed(status) && status !== 'backlog';
+}
+const STATUS_ORDER = {
+    in_progress: 0,
+    review: 1,
+    blocked: 2,
+    todo: 3,
+    backlog: 4,
+    done: 5,
+    cancelled: 6,
+};
+const PRIORITY_ORDER = {
+    urgent: 0,
+    high: 1,
+    medium: 2,
+    low: 3,
+    none: 4,
+};
+/** "What should I do now" ordering: work in flight first, then by priority, newest first. */
+export function compareByUrgency(a, b) {
+    return (STATUS_ORDER[a.status] - STATUS_ORDER[b.status] ||
+        PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority] ||
+        b.number - a.number);
+}
+export function emptyStatusCounts() {
+    return { backlog: 0, todo: 0, in_progress: 0, review: 0, blocked: 0, done: 0, cancelled: 0 };
+}
+export function countStatuses(tasks) {
+    const counts = emptyStatusCounts();
+    for (const task of tasks)
+        counts[task.status] += 1;
+    return counts;
+}
+export function activeCount(counts) {
+    return counts.todo + counts.in_progress + counts.review + counts.blocked;
+}
+const BRANCH_PREFIX = {
+    bug: 'fix',
+    feature: 'feat',
+    improvement: 'feat',
+    maintenance: 'chore',
+    infra: 'infra',
+    refactor: 'refactor',
+    research: 'research',
+    chore: 'chore',
+};
+/** Branch name a future `soja start` would create, e.g. `fix/SOJA-342-stripe-webhook`. */
+export function suggestBranchName(task) {
+    const slug = task.title
+        .normalize('NFKD')
+        .replace(/[̀-ͯ]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .split('-')
+        .slice(0, 5)
+        .join('-');
+    const base = `${BRANCH_PREFIX[task.type]}/${formatTaskRef(task.number)}`;
+    return slug ? `${base}-${slug}` : base;
+}

package/dist/domain/workflow.js

@@ -0,0 +1,23 @@
+import { isClosed } from './task.js';
+/**
+ * Rules for moving a task between statuses. Every transition is allowed
+ * (teams move fast and fix mistakes), but timestamps and the recorded
+ * event depend on where the task is coming from and going to.
+ */
+export function planStatusChange(task, to, now) {
+    const from = task.status;
+    if (from === to)
+        return null;
+    const startedAt = task.startedAt ?? (to === 'in_progress' ? now : null);
+    const patch = { status: to, startedAt, completedAt: task.completedAt };
+    if (to === 'done') {
+        return { patch: { ...patch, completedAt: now }, event: { type: 'task_completed', metadata: { from } } };
+    }
+    if (isClosed(from) && !isClosed(to)) {
+        return { patch: { ...patch, completedAt: null }, event: { type: 'task_reopened', metadata: { from, to } } };
+    }
+    return {
+        patch: { ...patch, completedAt: to === 'cancelled' ? null : patch.completedAt },
+        event: { type: 'status_changed', metadata: { from, to } },
+    };
+}