@proletariat/cli 0.3.35 → 0.3.40

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

@@ -3,6 +3,8 @@
  */
 import { z } from 'zod';
 import { formatTicket, errorResponse, strictTool } from '../helpers.js';
+import { spawnAgentForTicket } from '../../execution/spawner.js';
+import { createEphemeralAgent } from '../../agents/commands.js';
 export function registerWorkTools(server, ctx) {
     strictTool(server, 'work_status', 'Get current work status (in-progress tickets)', {}, async () => {
         try {
@@ -31,7 +33,7 @@ export function registerWorkTools(server, ctx) {
             return errorResponse(error);
         }
     });
-    strictTool(server, 'work_start', 'Start working on a ticket (moves to In Progress)', {
+    strictTool(server, 'work_assign', 'Assign a ticket to someone for work preparation (does NOT move to In Progress — use the CLI "work start" command to actually start work with an agent/session)', {
         ticket_id: z.string().describe('Ticket ID'),
         assignee: z.string().optional().describe('Who is working'),
     }, async (params) => {
@@ -42,16 +44,14 @@ export function registerWorkTools(server, ctx) {
             if (params.assignee) {
                 await ctx.storage.updateTicket(params.ticket_id, { assignee: params.assignee });
             }
-            const columns = ctx.storage.getColumnNames(ticket.projectId);
-            const progressCol = columns.find((c) => c.toLowerCase().includes('progress') || c.toLowerCase().includes('doing')) || columns[Math.min(1, columns.length - 1)];
-            const moved = await ctx.storage.moveTicket(ticket.projectId, params.ticket_id, progressCol);
+            const updated = await ctx.storage.getTicket(params.ticket_id);
             return {
                 content: [{
                         type: 'text',
                         text: JSON.stringify({
                             success: true,
-                            ticket: formatTicket(moved),
-                            message: `Started ${moved.id}: ${moved.title}`,
+                            ticket: formatTicket(updated),
+                            message: `Assigned ${updated.id}: ${updated.title}${params.assignee ? ` to ${params.assignee}` : ''}`,
                         }, null, 2),
                     }],
             };
@@ -129,4 +129,146 @@ export function registerWorkTools(server, ctx) {
             return errorResponse(error);
         }
     });
+    strictTool(server, 'work_start', 'Start work on a ticket — spawns an agent with a running container/session, creates a git branch, and moves ticket to In Progress only after successful spawn', {
+        ticket_id: z.string().describe('Ticket ID to start work on'),
+        agent: z.string().optional().describe('Agent name to assign (defaults to creating an ephemeral agent)'),
+        environment: z.enum(['devcontainer', 'host']).optional().describe('Execution environment (default: devcontainer if available)'),
+        display_mode: z.enum(['background', 'terminal']).optional().describe('Display mode (default: background — MCP runs headless)'),
+        skip_permissions: z.boolean().optional().describe('Skip permission prompts (danger mode, default: false)'),
+        create_pr: z.boolean().optional().describe('Create PR when work is ready (default: false)'),
+    }, async (params) => {
+        try {
+            // Require workspace context for spawn operations
+            if (!ctx.getWorkspaceContext) {
+                throw new Error('Workspace not initialized. work_start requires a workspace with agents. Run "prlt init" first.');
+            }
+            const { workspaceInfo, executionStorage, db, pmoPath } = ctx.getWorkspaceContext();
+            // Validate ticket exists
+            const ticket = await ctx.storage.getTicket(params.ticket_id);
+            if (!ticket)
+                throw new Error(`Ticket not found: ${params.ticket_id}`);
+            // Check ticket is not blocked
+            if (ticket.blockedBy && ticket.blockedBy.length > 0) {
+                throw new Error(`Ticket ${ticket.id} is blocked by: ${ticket.blockedBy.join(', ')}. Resolve blockers first.`);
+            }
+            // Check for existing running execution
+            const runningExec = executionStorage.getRunningExecution(ticket.id);
+            if (runningExec) {
+                throw new Error(`Ticket ${ticket.id} already has a running execution: ${runningExec.id} (agent: ${runningExec.agentName})`);
+            }
+            // Select or create agent
+            let agentName;
+            if (params.agent) {
+                // Use specified agent — verify it exists
+                const agentExists = workspaceInfo.agents.some(a => a.name === params.agent);
+                if (!agentExists) {
+                    throw new Error(`Agent "${params.agent}" not found. Available agents: ${workspaceInfo.agents.map(a => a.name).join(', ') || 'none'}`);
+                }
+                agentName = params.agent;
+            }
+            else {
+                // Create an ephemeral agent (default for MCP)
+                const ephemeralResult = await createEphemeralAgent(workspaceInfo);
+                agentName = ephemeralResult.name;
+            }
+            // Spawn the agent with background mode (MCP is headless)
+            const displayMode = params.display_mode || 'background';
+            const environment = params.environment;
+            const result = await spawnAgentForTicket(ticket, agentName, ctx.storage, executionStorage, workspaceInfo, db, pmoPath, {
+                environment,
+                displayMode,
+                skipPermissions: params.skip_permissions ?? false,
+                createPR: params.create_pr ?? false,
+                skipRemoteCheck: false,
+            });
+            if (result.success) {
+                // Fetch updated ticket to return current state
+                const updatedTicket = await ctx.storage.getTicket(params.ticket_id);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                executionId: result.executionId,
+                                ticketId: result.ticketId,
+                                agent: result.agentName,
+                                status: 'running',
+                                ticket: updatedTicket ? formatTicket(updatedTicket) : undefined,
+                                message: `Started work on ${ticket.id}: ${ticket.title} (agent: ${agentName})`,
+                            }, null, 2),
+                        }],
+                };
+            }
+            else {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                ticketId: result.ticketId,
+                                agent: result.agentName,
+                                error: result.error || 'Spawn failed',
+                                message: `Failed to start work on ${ticket.id}: ${result.error}`,
+                            }, null, 2),
+                        }],
+                    isError: true,
+                };
+            }
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'work_spawn', 'Spawn work on a ticket using the full CLI pipeline (agent selection, Docker build, container creation, branch setup, tmux session). Shells out to "prlt work spawn" — works whenever prlt is installed, no workspace context needed in-process.', {
+        ticket_id: z.string().describe('Ticket ID to spawn work for'),
+        action: z.string().optional().describe('Action to perform (e.g., implement, groom, review, custom). Defaults to implement.'),
+        display_mode: z.enum(['terminal', 'background']).optional().describe('Display mode (default: background)'),
+        skip_permissions: z.boolean().optional().describe('Skip permission prompts — danger mode (default: false)'),
+        create_pr: z.boolean().optional().describe('Create PR when work is ready (default: false)'),
+        agent: z.string().optional().describe('Agent name to use (default: ephemeral agent created on-demand)'),
+        environment: z.enum(['devcontainer', 'host']).optional().describe('Execution environment (default: devcontainer if available)'),
+    }, async (params) => {
+        try {
+            // Build the prlt work spawn command
+            const args = [params.ticket_id];
+            // Add flags
+            if (params.action) {
+                args.push('--action', params.action);
+            }
+            if (params.display_mode) {
+                args.push('--display', params.display_mode);
+            }
+            else {
+                args.push('--display', 'background');
+            }
+            if (params.skip_permissions) {
+                args.push('--skip-permissions');
+            }
+            if (params.create_pr) {
+                args.push('--create-pr');
+            }
+            if (params.environment === 'host') {
+                args.push('--run-on-host');
+            }
+            // Always skip confirmation in MCP context
+            args.push('--yes');
+            const cmd = `prlt work spawn ${args.join(' ')}`;
+            const output = ctx.runCommand(cmd);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            ticketId: params.ticket_id,
+                            command: cmd,
+                            output,
+                            message: `Spawned work for ${params.ticket_id} via CLI pipeline`,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
 }

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

@@ -3,9 +3,19 @@
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { SQLiteStorage } from '../pmo/storage/index.js';
+import type Database from 'better-sqlite3';
+import type { WorkspaceInfo } from '../agents/commands.js';
+import type { ExecutionStorage } from '../execution/storage.js';
 export interface McpToolContext {
     storage: SQLiteStorage;
     runCommand: (cmd: string) => string;
+    /** Workspace info — available when running in a workspace with agents */
+    getWorkspaceContext?: () => {
+        workspaceInfo: WorkspaceInfo;
+        executionStorage: ExecutionStorage;
+        db: Database.Database;
+        pmoPath: string;
+    };
 }
 export type McpToolResult = {
     content: Array<{

package/dist/lib/multiline-input.js

@@ -15,6 +15,7 @@
  */
 import * as readline from 'node:readline';
 import chalk from 'chalk';
+import { isNonTTY } from './prompt-json.js';
 // ANSI escape codes for terminal control
 const ESC = '\u001B';
 const CSI = `${ESC}[`;
@@ -83,7 +84,7 @@ function showCursor() {
 export async function multiLineInput(options) {
     const { message, default: defaultValue = '', hint = 'Ctrl+D to finish, Ctrl+C to cancel', required = false, validate, } = options;
     // If not a TTY, return the default value
-    if (!process.stdin.isTTY) {
+    if (isNonTTY()) {
         return { value: defaultValue, cancelled: false };
     }
     return new Promise((resolve) => {

package/dist/lib/pmo/base-command.js

@@ -3,7 +3,7 @@ import inquirer from 'inquirer';
 import { getPMOContext } from './pmo-context.js';
 import { styles } from '../styles.js';
 import { PromptCommand } from '../prompt-command.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, } from '../prompt-json.js';
+import { shouldOutputJson, isNonTTY, outputPromptAsJson, outputErrorAsJson, createMetadata, } from '../prompt-json.js';
 /**
  * Base flags for JSON/agent mode support
  * Include these in your command's flags by spreading: ...jsonModeFlags
@@ -168,7 +168,7 @@ export class PMOCommand extends PromptCommand {
             return numA - numB;
         });
         // Auto-detect non-TTY: switch to JSON mode when no TTY present
-        const effectiveJsonMode = options?.jsonMode ?? (!process.stdin.isTTY
+        const effectiveJsonMode = options?.jsonMode ?? (isNonTTY()
             ? {
                 flags: { json: true },
                 commandName: this.id ?? 'unknown',
@@ -234,7 +234,7 @@ export class PMOCommand extends PromptCommand {
     async selectFromList(options) {
         const { message, items, getName, getValue, getCommand, jsonMode, allowCancel = false, cancelValue, } = options;
         // Auto-detect non-TTY: switch to JSON mode when no TTY present
-        const effectiveJsonMode = jsonMode ?? (!process.stdin.isTTY
+        const effectiveJsonMode = jsonMode ?? (isNonTTY()
             ? { flags: { json: true }, commandName: this.id ?? 'unknown' }
             : null);
         // Build choices with command field
@@ -285,7 +285,7 @@ export class PMOCommand extends PromptCommand {
     async promptForInput(options) {
         const { message, fieldName, defaultValue, validate, jsonMode } = options;
         // Auto-detect non-TTY: switch to JSON mode when no TTY present
-        const effectiveJsonMode = jsonMode ?? (!process.stdin.isTTY
+        const effectiveJsonMode = jsonMode ?? (isNonTTY()
             ? { flags: { json: true }, commandName: this.id ?? 'unknown', commandHint: '', example: undefined }
             : null);
         // Check for JSON mode

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

@@ -66,7 +66,7 @@ export declare const PMO_TABLE_SCHEMAS: {
     readonly project_specs: "\n    CREATE TABLE IF NOT EXISTS pmo_project_specs (\n      project_id TEXT NOT NULL REFERENCES pmo_projects(id) ON DELETE CASCADE,\n      spec_id TEXT NOT NULL REFERENCES pmo_specs(id) ON DELETE CASCADE,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      PRIMARY KEY (project_id, spec_id)\n    )";
     readonly cache_metadata: "\n    CREATE TABLE IF NOT EXISTS pmo_cache_metadata (\n      key TEXT PRIMARY KEY,\n      value TEXT NOT NULL\n    )";
     readonly settings: "\n    CREATE TABLE IF NOT EXISTS pmo_settings (\n      key TEXT PRIMARY KEY,\n      value TEXT NOT NULL\n    )";
-    readonly agent_work: "\n    CREATE TABLE IF NOT EXISTS agent_work (\n      id TEXT PRIMARY KEY,\n      ticket_id TEXT NOT NULL,\n      agent_name TEXT NOT NULL,\n      executor TEXT NOT NULL,\n      environment TEXT NOT NULL DEFAULT 'host',\n      display_mode TEXT NOT NULL DEFAULT 'terminal',\n      sandboxed INTEGER NOT NULL DEFAULT 0,\n      status TEXT NOT NULL DEFAULT 'starting',\n      branch TEXT,\n      pid TEXT,\n      container_id TEXT,\n      session_id TEXT,\n      host TEXT,\n      log_path TEXT,\n      started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      completed_at TIMESTAMP,\n      exit_code INTEGER,\n      FOREIGN KEY (ticket_id) REFERENCES pmo_tickets(id) ON DELETE CASCADE\n    )";
+    readonly agent_work: "\n    CREATE TABLE IF NOT EXISTS agent_work (\n      id TEXT PRIMARY KEY,\n      ticket_id TEXT NOT NULL,\n      agent_name TEXT NOT NULL,\n      executor TEXT NOT NULL,\n      environment TEXT NOT NULL DEFAULT 'host',\n      display_mode TEXT NOT NULL DEFAULT 'terminal',\n      sandboxed INTEGER NOT NULL DEFAULT 0,\n      status TEXT NOT NULL DEFAULT 'starting',\n      branch TEXT,\n      pid TEXT,\n      container_id TEXT,\n      session_id TEXT,\n      host TEXT,\n      log_path TEXT,\n      started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      completed_at TIMESTAMP,\n      exit_code INTEGER,\n      error_message TEXT,\n      FOREIGN KEY (ticket_id) REFERENCES pmo_tickets(id) ON DELETE CASCADE\n    )";
     readonly containers: "\n    CREATE TABLE IF NOT EXISTS containers (\n      id TEXT PRIMARY KEY,\n      agent_name TEXT NOT NULL,\n      docker_id TEXT NOT NULL,\n      docker_name TEXT,\n      image TEXT,\n      status TEXT NOT NULL DEFAULT 'unknown',\n      current_execution_id TEXT,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      last_seen_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      FOREIGN KEY (agent_name) REFERENCES agents(name) ON DELETE CASCADE,\n      FOREIGN KEY (current_execution_id) REFERENCES agent_work(id) ON DELETE SET NULL\n    )";
     readonly id_sequences: "\n    CREATE TABLE IF NOT EXISTS id_sequences (\n      table_name TEXT PRIMARY KEY,\n      next_id INTEGER NOT NULL DEFAULT 1\n    )";
     readonly statuses: "\n    CREATE TABLE IF NOT EXISTS pmo_statuses (\n      id TEXT PRIMARY KEY,\n      project_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 (project_id) REFERENCES pmo_projects(id) ON DELETE CASCADE,\n      UNIQUE(project_id, name)\n    )";

package/dist/lib/pmo/schema.js

@@ -337,6 +337,7 @@ export const PMO_TABLE_SCHEMAS = {
       started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
       completed_at TIMESTAMP,
       exit_code INTEGER,
+      error_message TEXT,
       FOREIGN KEY (ticket_id) REFERENCES ${PMO_TABLES.tickets}(id) ON DELETE CASCADE
     )`,
     // Docker containers (per-agent, reused across executions)

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

@@ -169,7 +169,7 @@ export class ActionStorage {
                 ? JSON.parse(row.default_category)
                 : undefined,
             defaultMoveToCategory: row.default_category,
-            modifiesCode: row.is_builtin === 1,
+            modifiesCode: row.modifies_code === 1,
             isBuiltin: row.is_builtin === 1,
             createdAt: new Date(row.created_at),
         };