@proletariat/cli 0.3.29 → 0.3.31

package/dist/commands/work/start.js

@@ -8,7 +8,7 @@ import { shouldOutputJson, outputErrorAsJson, createMetadata, outputConfirmation
 import { FlagResolver } from '../../lib/flags/index.js';
 import { getWorkColumnSetting, findColumnByName } from '../../lib/pmo/utils.js';
 import { styles } from '../../lib/styles.js';
-import { getWorkspaceInfo, createEphemeralAgent, getTicketTmuxSession, killTmuxSession, } from '../../lib/agents/commands.js';
+import { getWorkspaceInfo, createEphemeralAgent, getTicketTmuxSession, killTmuxSession, findWorktreeForBranch, } from '../../lib/agents/commands.js';
 import { generateBranchName, DEFAULT_EXECUTION_CONFIG, } from '../../lib/execution/types.js';
 import { runExecution, isDockerRunning, isGitHubTokenAvailable, isDevcontainerCliInstalled, dockerCredentialsExist, getDockerCredentialInfo } from '../../lib/execution/runners.js';
 import { ExecutionStorage, ContainerStorage } from '../../lib/execution/storage.js';
@@ -397,11 +397,33 @@ export default class WorkStart extends PMOCommand {
                 }
                 // For 'spawn', we continue with creating a new agent
             }
+            // Check for existing worktree with ticket's branch (dead agent recovery)
+            let reusingWorktree = false;
+            if (ticket.branch && !flags.agent) {
+                const existingWorktree = findWorktreeForBranch(workspaceInfo, ticket.branch);
+                if (existingWorktree) {
+                    reusingWorktree = true;
+                    if (!jsonMode) {
+                        this.log(styles.muted(`Found existing worktree for branch in dead agent "${existingWorktree.agentName}"`));
+                        this.log(styles.muted(`Reusing worktree at: ${existingWorktree.agentDir}`));
+                    }
+                }
+            }
             // Agent selection: ephemeral flag, agent flag, ticket assignee, or prompt
             let agentName;
             let agentWorktreePath;
             let isEphemeralAgent = flags.ephemeral;
-            if (flags.ephemeral) {
+            if (reusingWorktree) {
+                // Reuse dead agent's worktree — skip creating a new agent
+                const existingWorktree = findWorktreeForBranch(workspaceInfo, ticket.branch);
+                agentName = existingWorktree.agentName;
+                agentWorktreePath = existingWorktree.agentDir;
+                isEphemeralAgent = true;
+                if (!jsonMode) {
+                    this.log(styles.success(`Reusing agent: ${agentName} (worktree recovery)`));
+                }
+            }
+            else if (flags.ephemeral) {
                 // Create ephemeral agent on-demand
                 if (!jsonMode) {
                     this.log(styles.muted('Creating ephemeral agent...'));
@@ -1301,8 +1323,12 @@ export default class WorkStart extends PMOCommand {
                     }
                     // Note: fetch already happened above (unconditionally for all action types)
                     try {
-                        // Check if branch exists and checkout
-                        if (tryGitCommand(`git rev-parse --verify ${finalBranch}`, repoPath)) {
+                        if (reusingWorktree) {
+                            // Branch already checked out in this worktree — just fetch latest
+                            this.log(styles.muted(`   ${repoName}: reusing existing branch (worktree recovery)`));
+                        }
+                        else if (tryGitCommand(`git rev-parse --verify ${finalBranch}`, repoPath)) {
+                            // Check if branch exists and checkout
                             execSync(`git checkout ${finalBranch}`, { cwd: repoPath, stdio: 'pipe' });
                             this.log(styles.muted(`   ${repoName}: checked out branch`));
                         }

package/dist/lib/agents/commands.d.ts

@@ -177,6 +177,20 @@ export interface CleanupResult {
  * Get tmux sessions associated with an agent
  */
 export declare function getAgentTmuxSessions(agentName: string): string[];
+export interface ExistingWorktreeInfo {
+    agentName: string;
+    agentDir: string;
+    worktreePath: string;
+    branch: string;
+}
+/**
+ * Find an existing worktree that has a specific branch checked out.
+ * Used to detect dead agents whose worktrees still hold a branch,
+ * allowing worktree reuse instead of creating a fresh agent.
+ *
+ * Returns null if no worktree has the branch, or if the agent is still alive.
+ */
+export declare function findWorktreeForBranch(workspaceInfo: WorkspaceInfo, branch: string): ExistingWorktreeInfo | null;
 /**
  * Check git status for all worktrees in an agent directory.
  * Returns info about uncommitted changes and unpushed commits.

package/dist/lib/agents/commands.js

@@ -604,6 +604,64 @@ export function getAgentTmuxSessions(agentName) {
         .filter(s => s.agent === agentName)
         .map(s => s.name);
 }
+/**
+ * Find an existing worktree that has a specific branch checked out.
+ * Used to detect dead agents whose worktrees still hold a branch,
+ * allowing worktree reuse instead of creating a fresh agent.
+ *
+ * Returns null if no worktree has the branch, or if the agent is still alive.
+ */
+export function findWorktreeForBranch(workspaceInfo, branch) {
+    for (const repo of workspaceInfo.repositories) {
+        const sourceRepoPath = path.join(workspaceInfo.path, 'repos', repo.name);
+        if (!fs.existsSync(sourceRepoPath))
+            continue;
+        try {
+            const output = execSync('git worktree list --porcelain', {
+                cwd: sourceRepoPath,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const blocks = output.split('\n\n').filter(Boolean);
+            for (const block of blocks) {
+                const lines = block.split('\n');
+                const worktreeLine = lines.find(l => l.startsWith('worktree '));
+                const branchLine = lines.find(l => l.startsWith('branch '));
+                const isPrunable = lines.some(l => l.startsWith('prunable'));
+                if (!worktreeLine || !branchLine || isPrunable)
+                    continue;
+                const worktreeFullPath = worktreeLine.replace('worktree ', '');
+                const branchRef = branchLine.replace('branch refs/heads/', '');
+                if (branchRef !== branch)
+                    continue;
+                // Found a worktree with this branch — confirm it's inside agents/
+                const relativePath = path.relative(workspaceInfo.path, worktreeFullPath);
+                if (!relativePath.startsWith('agents/'))
+                    continue;
+                // Extract agent name: agents/{subdir}/{agentName}/{repoName}
+                const parts = relativePath.split(path.sep);
+                if (parts.length < 4)
+                    continue;
+                const agentName = parts[parts.length - 2];
+                const agentDir = path.dirname(worktreeFullPath);
+                // Confirm agent has no active tmux sessions (it's dead)
+                const agentSessions = getAgentTmuxSessions(agentName);
+                if (agentSessions.length > 0)
+                    continue;
+                return {
+                    agentName,
+                    agentDir,
+                    worktreePath: worktreeFullPath,
+                    branch: branchRef,
+                };
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
 /**
  * Get docker containers associated with an agent directory
  */

package/dist/lib/database/drizzle-schema.d.ts

@@ -2503,6 +2503,23 @@ export declare const pmoTickets: import("drizzle-orm/sqlite-core").SQLiteTableWi
             identity: undefined;
             generated: undefined;
         }, object>;
+        position: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "position";
+            tableName: "pmo_tickets";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, object>;
         createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "created_at";
             tableName: "pmo_tickets";

package/dist/lib/database/drizzle-schema.js

@@ -284,6 +284,7 @@ export const pmoTickets = sqliteTable('pmo_tickets', {
     specId: text('spec_id'),
     epicId: text('epic_id'),
     labels: text('labels').notNull().default('[]'),
+    position: integer('position').notNull().default(0),
     createdAt: text('created_at').default(sql `CURRENT_TIMESTAMP`),
     updatedAt: text('updated_at').default(sql `CURRENT_TIMESTAMP`),
     lastSyncedFromSpec: text('last_synced_from_spec'),
@@ -298,6 +299,7 @@ export const pmoTickets = sqliteTable('pmo_tickets', {
     idxPriority: index('idx_pmo_tickets_priority').on(table.priority),
     idxCategory: index('idx_pmo_tickets_category').on(table.category),
     idxStatusId: index('idx_pmo_tickets_status_id').on(table.statusId),
+    idxStatusPosition: index('idx_pmo_tickets_status_position').on(table.statusId, table.position),
 }));
 /**
  * Board views (saved filter/display configurations)

package/dist/lib/database/index.js

@@ -195,6 +195,45 @@ export function openWorkspaceDatabase(workspacePath) {
     catch {
         // Ignore migration errors - table might not exist yet or column already exists
     }
+    // Migration: add position column to pmo_tickets table (TKT-965)
+    try {
+        const ticketsTableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='pmo_tickets'").get();
+        if (ticketsTableExists) {
+            const ticketsTableInfo = db.prepare("PRAGMA table_info(pmo_tickets)").all();
+            if (!ticketsTableInfo.some(col => col.name === 'position')) {
+                db.exec("ALTER TABLE pmo_tickets ADD COLUMN position INTEGER NOT NULL DEFAULT 0");
+                db.exec("CREATE INDEX IF NOT EXISTS idx_pmo_tickets_status_position ON pmo_tickets(status_id, position)");
+                // Backfill existing tickets with gapped positions (1000, 2000, ...) per status,
+                // ordered by priority then created_at
+                const statuses = db.prepare("SELECT DISTINCT status_id FROM pmo_tickets WHERE status_id IS NOT NULL").all();
+                const getTicketsForStatus = db.prepare(`
+          SELECT id FROM pmo_tickets WHERE status_id = ?
+          ORDER BY
+            CASE priority
+              WHEN 'P0' THEN 0
+              WHEN 'P1' THEN 1
+              WHEN 'P2' THEN 2
+              WHEN 'P3' THEN 3
+              ELSE 4
+            END,
+            created_at ASC
+        `);
+                const updatePosition = db.prepare("UPDATE pmo_tickets SET position = ? WHERE id = ?");
+                const backfill = db.transaction(() => {
+                    for (const { status_id } of statuses) {
+                        const tickets = getTicketsForStatus.all(status_id);
+                        tickets.forEach((ticket, idx) => {
+                            updatePosition.run((idx + 1) * 1000, ticket.id);
+                        });
+                    }
+                });
+                backfill();
+            }
+        }
+    }
+    catch {
+        // Ignore migration errors - table might not exist yet
+    }
     return db;
 }
 /**

package/dist/lib/execution/runners.js

@@ -865,10 +865,10 @@ function runContainerSetup(containerId, sandboxed = true) {
         }
         const tips = settings.tipsHistory;
         tips['new-user-warmup'] = tips['new-user-warmup'] || 1;
-        // Base64 encode to avoid shell escaping issues
-        const base64Content = Buffer.from(JSON.stringify(settings)).toString('base64');
-        // Write to container at /home/node/.claude.json
-        execSync(`docker exec ${containerId} bash -c 'echo "${base64Content}" | base64 -d > /home/node/.claude.json'`, { stdio: 'pipe' });
+        // Pipe settings via stdin to avoid ARG_MAX limits with large .claude.json files
+        const settingsJson = JSON.stringify(settings);
+        // Write to container at /home/node/.claude.json using stdin piping
+        execSync(`docker exec -i ${containerId} bash -c 'cat > /home/node/.claude.json'`, { input: settingsJson, stdio: ['pipe', 'pipe', 'pipe'] });
         console.debug(`[runners:docker] Copied .claude.json settings to container (bypassPermissionsModeAccepted=${!sandboxed})`);
     }
     catch (error) {
@@ -1459,7 +1459,6 @@ echo ""
 echo "✅ Agent work complete. Press Enter to close or run more commands."
 exec bash
 `;
-        const base64Script = Buffer.from(tmuxScript).toString('base64');
         const scriptPath = `/tmp/prlt-${sessionName}.sh`;
         // Write script and start tmux session inside container
         // IMPORTANT: We create the session with bash first, then send keys to run the script.
@@ -1470,10 +1469,12 @@ exec bash
         // Only enable mouse mode if NOT using control mode (control mode lets iTerm handle mouse natively)
         // set-titles on + set-titles-string: makes tmux set terminal title to window name
         const mouseOption = buildTmuxMouseOption(useControlMode);
-        // Step 1: Write the script to the container
-        const writeScriptCmd = `echo ${base64Script} | base64 -d > ${scriptPath} && chmod +x ${scriptPath}`;
+        // Step 1: Write the script to the container via stdin piping to avoid ARG_MAX limits
         try {
-            execSync(`docker exec ${actualContainerId} bash -c '${writeScriptCmd}'`, { stdio: 'pipe' });
+            execSync(`docker exec -i ${actualContainerId} bash -c 'cat > ${scriptPath} && chmod +x ${scriptPath}'`, {
+                input: tmuxScript,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
         }
         catch (error) {
             return {

package/dist/lib/mcp/helpers.d.ts

@@ -30,6 +30,7 @@ export declare function formatTicket(t: Ticket): {
     owner: string | undefined;
     branch: string | undefined;
     epicId: string | undefined;
+    position: number | undefined;
 };
 export declare function formatTicketFull(t: Ticket): {
     description: string | undefined;
@@ -52,6 +53,7 @@ export declare function formatTicketFull(t: Ticket): {
     owner: string | undefined;
     branch: string | undefined;
     epicId: string | undefined;
+    position: number | undefined;
 };
 export declare function successResponse(data: Record<string, unknown>): McpToolResult;
 export declare function errorResponse(error: unknown): McpToolResult;

package/dist/lib/mcp/helpers.js

@@ -29,6 +29,7 @@ export function formatTicket(t) {
         owner: t.owner,
         branch: t.branch,
         epicId: t.epicId,
+        position: t.position,
     };
 }
 export function formatTicketFull(t) {

package/dist/lib/mcp/tools/ticket.js

@@ -45,6 +45,7 @@ export function registerTicketTools(server, ctx) {
                                 owner: t.owner,
                                 epicId: t.epicId,
                                 branch: t.branch,
+                                position: t.position,
                                 createdAt: t.createdAt.toISOString(),
                                 updatedAt: t.updatedAt.toISOString(),
                             })),
@@ -206,6 +207,30 @@ export function registerTicketTools(server, ctx) {
             return errorResponse(error);
         }
     });
+    strictTool(server, 'ticket_reorder', 'Reorder a ticket within its current status. Provide either a direct position value or place it after another ticket.', {
+        id: z.string().describe('Ticket ID to reorder'),
+        position: z.number().optional().describe('Direct position value (gapped integers, e.g. 1000, 2000)'),
+        after_ticket_id: z.string().optional().describe('Place this ticket after the specified ticket ID'),
+    }, async (params) => {
+        try {
+            if (!params.position && !params.after_ticket_id) {
+                throw new Error('Must provide either position or after_ticket_id');
+            }
+            const ticket = await ctx.storage.reorderTicket(params.id, {
+                position: params.position,
+                afterTicketId: params.after_ticket_id,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, ticket: formatTicket(ticket) }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
     strictTool(server, 'ticket_add_subtask', 'Add a subtask to a ticket', {
         ticket_id: z.string().describe('Ticket ID'),
         title: z.string().describe('Subtask title'),

package/dist/lib/pmo/schema.d.ts

@@ -46,7 +46,7 @@ export declare const PMO_TABLE_SCHEMAS: {
     readonly workflows: "\n    CREATE TABLE IF NOT EXISTS pmo_workflows (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL UNIQUE,\n      description TEXT,\n      is_builtin INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n    )";
     readonly workflow_statuses: "\n    CREATE TABLE IF NOT EXISTS pmo_workflow_statuses (\n      id TEXT PRIMARY KEY,\n      workflow_id TEXT NOT NULL,\n      name TEXT NOT NULL,\n      category TEXT NOT NULL,\n      position INTEGER NOT NULL DEFAULT 0,\n      color TEXT,\n      description TEXT,\n      is_default INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      FOREIGN KEY (workflow_id) REFERENCES pmo_workflows(id) ON DELETE CASCADE,\n      UNIQUE(workflow_id, name)\n    )";
     readonly columns: "\n    CREATE TABLE IF NOT EXISTS pmo_columns (\n      id TEXT NOT NULL,\n      project_id TEXT NOT NULL DEFAULT 'default',\n      name TEXT NOT NULL,\n      position INTEGER NOT NULL,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      PRIMARY KEY (project_id, id)\n    )";
-    readonly tickets: "\n    CREATE TABLE IF NOT EXISTS pmo_tickets (\n      id TEXT PRIMARY KEY,\n      project_id TEXT NOT NULL DEFAULT 'default',\n      title TEXT NOT NULL,\n      description TEXT,\n      priority TEXT,\n      category TEXT,\n      status TEXT NOT NULL DEFAULT 'backlog',\n      status_id TEXT,\n      owner TEXT,\n      assignee TEXT,\n      branch TEXT,\n      spec_id TEXT,\n      epic_id TEXT,\n      labels TEXT NOT NULL DEFAULT '[]',\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      last_synced_from_spec TIMESTAMP,\n      last_synced_from_board TIMESTAMP,\n      FOREIGN KEY (project_id) REFERENCES pmo_projects(id) ON DELETE CASCADE,\n      FOREIGN KEY (spec_id) REFERENCES pmo_specs(id) ON DELETE SET NULL,\n      FOREIGN KEY (epic_id) REFERENCES pmo_epics(id) ON DELETE SET NULL,\n      FOREIGN KEY (status_id) REFERENCES pmo_workflow_statuses(id) ON DELETE SET NULL\n    )";
+    readonly tickets: "\n    CREATE TABLE IF NOT EXISTS pmo_tickets (\n      id TEXT PRIMARY KEY,\n      project_id TEXT NOT NULL DEFAULT 'default',\n      title TEXT NOT NULL,\n      description TEXT,\n      priority TEXT,\n      category TEXT,\n      status TEXT NOT NULL DEFAULT 'backlog',\n      status_id TEXT,\n      owner TEXT,\n      assignee TEXT,\n      branch TEXT,\n      spec_id TEXT,\n      epic_id TEXT,\n      labels TEXT NOT NULL DEFAULT '[]',\n      position INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      last_synced_from_spec TIMESTAMP,\n      last_synced_from_board TIMESTAMP,\n      FOREIGN KEY (project_id) REFERENCES pmo_projects(id) ON DELETE CASCADE,\n      FOREIGN KEY (spec_id) REFERENCES pmo_specs(id) ON DELETE SET NULL,\n      FOREIGN KEY (epic_id) REFERENCES pmo_epics(id) ON DELETE SET NULL,\n      FOREIGN KEY (status_id) REFERENCES pmo_workflow_statuses(id) ON DELETE SET NULL\n    )";
     readonly board_tickets: "\n    CREATE TABLE IF NOT EXISTS pmo_board_tickets (\n      project_id TEXT NOT NULL,\n      ticket_id TEXT NOT NULL,\n      column_id TEXT NOT NULL,\n      position INTEGER NOT NULL,\n      PRIMARY KEY (project_id, ticket_id),\n      FOREIGN KEY (project_id) REFERENCES pmo_projects(id) ON DELETE CASCADE,\n      FOREIGN KEY (ticket_id) REFERENCES pmo_tickets(id) ON DELETE CASCADE,\n      FOREIGN KEY (project_id, column_id) REFERENCES pmo_columns(project_id, id) ON DELETE CASCADE\n    )";
     readonly board_views: "\n    CREATE TABLE IF NOT EXISTS pmo_board_views (\n      id TEXT PRIMARY KEY,\n      project_id TEXT NOT NULL,\n      name TEXT NOT NULL,\n      description TEXT,\n      is_default INTEGER NOT NULL DEFAULT 0,\n      filters TEXT NOT NULL DEFAULT '{}',\n      group_by TEXT,\n      sort_by TEXT,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      FOREIGN KEY (project_id) REFERENCES pmo_projects(id) ON DELETE CASCADE,\n      UNIQUE(project_id, name)\n    )";
     readonly subtasks: "\n    CREATE TABLE IF NOT EXISTS pmo_subtasks (\n      id TEXT NOT NULL,\n      ticket_id TEXT NOT NULL REFERENCES pmo_tickets(id) ON DELETE CASCADE,\n      title TEXT NOT NULL,\n      done INTEGER DEFAULT 0,\n      position INTEGER NOT NULL,\n      PRIMARY KEY (ticket_id, id)\n    )";
@@ -80,7 +80,7 @@ export declare const PMO_INDEXES: string;
  * Order matters due to foreign key dependencies.
  */
 export declare const PMO_SCHEMA_SQL: string;
-export declare const EXPECTED_TICKET_COLUMNS: readonly ["id", "project_id", "title", "description", "priority", "category", "status", "status_id", "owner", "assignee", "branch", "spec_id", "epic_id", "labels", "created_at", "updated_at", "last_synced_from_spec", "last_synced_from_board"];
+export declare const EXPECTED_TICKET_COLUMNS: readonly ["id", "project_id", "title", "description", "priority", "category", "status", "status_id", "owner", "assignee", "branch", "spec_id", "epic_id", "labels", "position", "created_at", "updated_at", "last_synced_from_spec", "last_synced_from_board"];
 /**
  * Validate that pmo_tickets table has all expected columns.
  * Throws if columns are missing (indicates schema mismatch).

package/dist/lib/pmo/schema.js

@@ -141,6 +141,7 @@ export const PMO_TABLE_SCHEMAS = {
       spec_id TEXT,
       epic_id TEXT,
       labels TEXT NOT NULL DEFAULT '[]',
+      position INTEGER NOT NULL DEFAULT 0,
       created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
       updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
       last_synced_from_spec TIMESTAMP,
@@ -459,6 +460,7 @@ export const PMO_INDEXES = `
   CREATE INDEX IF NOT EXISTS idx_pmo_tickets_priority ON ${PMO_TABLES.tickets}(priority);
   CREATE INDEX IF NOT EXISTS idx_pmo_tickets_category ON ${PMO_TABLES.tickets}(category);
   CREATE INDEX IF NOT EXISTS idx_pmo_tickets_status_id ON ${PMO_TABLES.tickets}(status_id);
+  CREATE INDEX IF NOT EXISTS idx_pmo_tickets_status_position ON ${PMO_TABLES.tickets}(status_id, position);
   CREATE INDEX IF NOT EXISTS idx_pmo_subtasks_ticket ON ${PMO_TABLES.subtasks}(ticket_id);
   CREATE INDEX IF NOT EXISTS idx_pmo_ticket_specs_spec ON ${PMO_TABLES.ticket_specs}(spec_id);
   CREATE INDEX IF NOT EXISTS idx_pmo_assignments_agent ON ${PMO_TABLES.ticket_assignments}(agent_name);
@@ -564,6 +566,7 @@ export const EXPECTED_TICKET_COLUMNS = [
     'spec_id',
     'epic_id',
     'labels',
+    'position',
     'created_at',
     'updated_at',
     'last_synced_from_spec',

package/dist/lib/pmo/storage/base.js

@@ -218,6 +218,37 @@ export function runMigrations(db) {
             // Table may already be dropped
         }
     }
+    // Migration: Add position column to tickets table (TKT-965)
+    if (!ticketsColumnNames.has('position')) {
+        try {
+            db.exec(`ALTER TABLE ${T.tickets} ADD COLUMN position INTEGER NOT NULL DEFAULT 0`);
+            db.exec(`CREATE INDEX IF NOT EXISTS idx_pmo_tickets_status_position ON ${T.tickets}(status_id, position)`);
+            // Backfill existing tickets with gapped positions (1000, 2000, ...) per status
+            const statuses = db.prepare(`SELECT DISTINCT status_id FROM ${T.tickets} WHERE status_id IS NOT NULL`).all();
+            const getTicketsForStatus = db.prepare(`
+        SELECT id FROM ${T.tickets} WHERE status_id = ?
+        ORDER BY
+          CASE priority
+            WHEN 'P0' THEN 0
+            WHEN 'P1' THEN 1
+            WHEN 'P2' THEN 2
+            WHEN 'P3' THEN 3
+            ELSE 4
+          END,
+          created_at ASC
+      `);
+            const updatePosition = db.prepare(`UPDATE ${T.tickets} SET position = ? WHERE id = ?`);
+            for (const { status_id } of statuses) {
+                const tickets = getTicketsForStatus.all(status_id);
+                for (let i = 0; i < tickets.length; i++) {
+                    updatePosition.run((i + 1) * 1000, tickets[i].id);
+                }
+            }
+        }
+        catch {
+            // Column may already exist
+        }
+    }
     // Migration: Reassign orphaned tickets (TKT-940)
     // Tickets with project_id that doesn't match any existing project are "orphaned".
     // This can happen when a 'default' project never existed or was deleted.

package/dist/lib/pmo/storage/dependencies.js

@@ -86,7 +86,7 @@ export class DependencyStorage {
       SELECT t.*,
              ws.id as column_id,
              ws.name as column_name,
-             ws.position as position
+             t.position as position
       FROM ${T.tickets} t
       JOIN ${T.ticket_dependencies} d ON t.id = d.depends_on_ticket_id
       LEFT JOIN ${T.workflow_statuses} ws ON t.status_id = ws.id
@@ -102,7 +102,7 @@ export class DependencyStorage {
       SELECT t.*,
              ws.id as column_id,
              ws.name as column_name,
-             ws.position as position
+             t.position as position
       FROM ${T.tickets} t
       JOIN ${T.ticket_dependencies} d ON t.id = d.ticket_id
       LEFT JOIN ${T.workflow_statuses} ws ON t.status_id = ws.id

package/dist/lib/pmo/storage/epics.js

@@ -179,20 +179,12 @@ export class EpicStorage {
         const rows = this.ctx.db.prepare(`
       SELECT t.*,
              ws.id as column_id,
-             ws.position as position,
+             t.position as position,
              ws.name as column_name
       FROM ${T.tickets} t
       LEFT JOIN ${T.workflow_statuses} ws ON t.status_id = ws.id
       WHERE t.project_id = ? AND t.epic_id = ?
-      ORDER BY ws.position,
-        CASE t.priority
-          WHEN 'P0' THEN 0
-          WHEN 'P1' THEN 1
-          WHEN 'P2' THEN 2
-          WHEN 'P3' THEN 3
-          ELSE 4
-        END,
-        t.created_at ASC
+      ORDER BY ws.position, t.position ASC, t.created_at ASC
     `).all(projectId, epicId);
         return Promise.all(rows.map((row) => rowToTicket(this.ctx.db, row)));
     }

package/dist/lib/pmo/storage/index.d.ts

@@ -55,6 +55,10 @@ export declare class SQLiteStorage implements PMOStorage {
     getTicketById(id: string): Promise<Ticket | null>;
     updateTicket(id: string, changes: Partial<Ticket>): Promise<Ticket>;
     moveTicket(projectId: string, id: string, column: string, position?: number): Promise<Ticket>;
+    reorderTicket(id: string, opts: {
+        position?: number;
+        afterTicketId?: string;
+    }): Promise<Ticket>;
     moveTicketToProject(ticketId: string, newProjectId: string): Promise<Ticket>;
     deleteTicket(id: string): Promise<void>;
     listTickets(projectId: string | undefined, filter?: TicketFilter): Promise<Ticket[]>;

package/dist/lib/pmo/storage/index.js

@@ -193,6 +193,9 @@ export class SQLiteStorage {
     async moveTicket(projectId, id, column, position) {
         return this.ticketStorage.moveTicket(projectId, id, column, position);
     }
+    async reorderTicket(id, opts) {
+        return this.ticketStorage.reorderTicket(id, opts);
+    }
     async moveTicketToProject(ticketId, newProjectId) {
         return this.ticketStorage.moveTicketToProject(ticketId, newProjectId);
     }

package/dist/lib/pmo/storage/projects.d.ts

@@ -53,7 +53,7 @@ export declare class ProjectStorage {
     getProjectBoard(projectIdOrName: string): Promise<Board | null>;
     /**
      * Get tickets for a status (column).
-     * Tickets are sorted by priority (P0 first) then created_at (oldest first).
+     * Tickets are sorted by position (force-ranked) then created_at as tiebreaker.
      */
     private getTicketsForStatus;
     /**

package/dist/lib/pmo/storage/projects.js

@@ -193,7 +193,7 @@ export class ProjectStorage {
     }
     /**
      * Get tickets for a status (column).
-     * Tickets are sorted by priority (P0 first) then created_at (oldest first).
+     * Tickets are sorted by position (force-ranked) then created_at as tiebreaker.
      */
     async getTicketsForStatus(statusId, projectId) {
         const ticketRows = this.ctx.db.prepare(`
@@ -203,15 +203,7 @@ export class ProjectStorage {
       FROM ${T.tickets} t
       LEFT JOIN ${T.workflow_statuses} ws ON t.status_id = ws.id
       WHERE t.status_id = ? AND t.project_id = ?
-      ORDER BY
-        CASE t.priority
-          WHEN 'P0' THEN 0
-          WHEN 'P1' THEN 1
-          WHEN 'P2' THEN 2
-          WHEN 'P3' THEN 3
-          ELSE 4
-        END,
-        t.created_at ASC
+      ORDER BY t.position ASC, t.created_at ASC
     `).all(statusId, projectId);
         return Promise.all(ticketRows.map((row) => rowToTicket(this.ctx.db, row)));
     }

package/dist/lib/pmo/storage/specs.js

@@ -236,20 +236,12 @@ export class SpecStorage {
         const rows = this.ctx.db.prepare(`
       SELECT t.*,
              ws.id as column_id,
-             ws.position as position,
+             t.position as position,
              ws.name as column_name
       FROM ${T.tickets} t
       LEFT JOIN ${T.workflow_statuses} ws ON t.status_id = ws.id
       WHERE t.project_id = ? AND t.spec_id = ?
-      ORDER BY ws.position,
-        CASE t.priority
-          WHEN 'P0' THEN 0
-          WHEN 'P1' THEN 1
-          WHEN 'P2' THEN 2
-          WHEN 'P3' THEN 3
-          ELSE 4
-        END,
-        t.created_at ASC
+      ORDER BY ws.position, t.position ASC, t.created_at ASC
     `).all(projectId, specId);
         return Promise.all(rows.map((row) => rowToTicket(this.ctx.db, row)));
     }

package/dist/lib/pmo/storage/tickets.d.ts

@@ -1,7 +1,8 @@
 /**
  * Ticket operations for PMO.
  * Tickets reference workflow statuses directly via status_id.
- * Board position is derived from priority and created_at (no separate board_tickets table).
+ * Tickets have a position column for force-ranked ordering within a status.
+ * Positions use gapped integers (1000, 2000, 3000...) for stable reordering.
  */
 import { CreateTicketInput, Ticket, TicketFilter } from '../types.js';
 import { StorageContext } from './types.js';
@@ -50,9 +51,25 @@ export declare class TicketStorage {
     /**
      * Move a ticket to a different status (column).
      * In the workflow-based system, columns ARE statuses.
-     * The position parameter is ignored - tickets are sorted by priority then created_at.
+     * If position is provided, the ticket is placed at that position.
+     * Otherwise, the ticket is appended to the end of the target status.
      */
-    moveTicket(projectId: string, id: string, column: string, _position?: number): Promise<Ticket>;
+    moveTicket(projectId: string, id: string, column: string, position?: number): Promise<Ticket>;
+    /**
+     * Reorder a ticket within its current status.
+     * Supports two modes:
+     * 1. Direct position: set ticket to a specific position value
+     * 2. After ticket: place ticket immediately after another ticket
+     */
+    reorderTicket(id: string, opts: {
+        position?: number;
+        afterTicketId?: string;
+    }): Promise<Ticket>;
+    /**
+     * Re-gap positions for all tickets in a status using 1000-gaps.
+     * Optionally excludes a ticket (e.g., the one being moved).
+     */
+    private regapPositions;
     /**
      * Delete a ticket.
      * Works with ticket ID only - no project context required since ticket IDs are globally unique.