profclaw 2.0.0 → 2.3.0

package/dist/chat/execution/tools/multi-patch.js

@@ -0,0 +1,373 @@
+/**
+ * Multi-File Patch Tool
+ *
+ * Applies OpenAI-style multi-file patches that can add, update, and delete
+ * multiple files in a single operation.
+ *
+ * Format:
+ *   *** Begin Patch
+ *   *** Add File: path/to/new.ts
+ *   [file content]
+ *   *** Update File: path/to/existing.ts
+ *   @@ context @@
+ *   -old line
+ *   +new line
+ *   *** Delete File: path/to/remove.ts
+ *   *** End Patch
+ */
+import { z } from 'zod';
+import fs from 'fs/promises';
+import path from 'path';
+import { getFsGuard } from '../../../security/fs-guard.js';
+import { logger } from '../../../utils/logger.js';
+// ---- Schema ----------------------------------------------------------------
+const MultiPatchParamsSchema = z.object({
+    patch: z.string().min(1).describe('Multi-file patch in OpenAI patch format. Must start with "*** Begin Patch" and end with "*** End Patch".'),
+    workdir: z.string().optional().describe('Override workspace root for path resolution. Defaults to the session workdir.'),
+});
+// ---- Parsing ---------------------------------------------------------------
+const BEGIN_MARKER = '*** Begin Patch';
+const END_MARKER = '*** End Patch';
+const ADD_PREFIX = '*** Add File: ';
+const UPDATE_PREFIX = '*** Update File: ';
+const DELETE_PREFIX = '*** Delete File: ';
+/**
+ * Parse the multi-file patch string into ordered segments.
+ * Throws with a descriptive message on format errors.
+ */
+function parsePatch(patch) {
+    const lines = patch.split('\n');
+    // Find begin/end markers
+    const beginIdx = lines.findIndex((l) => l.trim() === BEGIN_MARKER);
+    const endIdx = lines.findIndex((l) => l.trim() === END_MARKER);
+    if (beginIdx === -1) {
+        throw new Error(`Patch must start with "${BEGIN_MARKER}"`);
+    }
+    if (endIdx === -1) {
+        throw new Error(`Patch must end with "${END_MARKER}"`);
+    }
+    if (endIdx <= beginIdx) {
+        throw new Error(`"${END_MARKER}" must appear after "${BEGIN_MARKER}"`);
+    }
+    const body = lines.slice(beginIdx + 1, endIdx);
+    const segments = [];
+    let current = null;
+    for (const line of body) {
+        if (line.startsWith(ADD_PREFIX)) {
+            if (current)
+                segments.push(current);
+            current = { operation: 'add', filePath: line.slice(ADD_PREFIX.length).trim(), lines: [] };
+        }
+        else if (line.startsWith(UPDATE_PREFIX)) {
+            if (current)
+                segments.push(current);
+            current = { operation: 'update', filePath: line.slice(UPDATE_PREFIX.length).trim(), lines: [] };
+        }
+        else if (line.startsWith(DELETE_PREFIX)) {
+            if (current)
+                segments.push(current);
+            // Delete segments have no body lines - push immediately.
+            segments.push({ operation: 'delete', filePath: line.slice(DELETE_PREFIX.length).trim(), lines: [] });
+            current = null;
+        }
+        else if (current) {
+            current.lines.push(line);
+        }
+        // Lines before the first directive are ignored (e.g. blank lines after Begin Patch).
+    }
+    if (current)
+        segments.push(current);
+    if (segments.length === 0) {
+        throw new Error('Patch contains no file operations');
+    }
+    return segments;
+}
+// ---- Unified diff application ----------------------------------------------
+/**
+ * Apply unified-diff hunks to file content.
+ * Supports the @@ -L,N +L,N @@ header format used in standard and OpenAI patches.
+ */
+function applyHunks(content, diffLines) {
+    const fileLines = content.split('\n');
+    let hunks = 0;
+    let offset = 0;
+    for (let i = 0; i < diffLines.length; i++) {
+        const line = diffLines[i];
+        const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+        if (!hunkMatch)
+            continue;
+        hunks++;
+        const startLine = parseInt(hunkMatch[1], 10) - 1 + offset;
+        const removals = [];
+        const additions = [];
+        for (let j = i + 1; j < diffLines.length; j++) {
+            const dl = diffLines[j];
+            // Next hunk header - stop consuming, back up so outer loop sees it
+            if (dl.match(/^@@ -\d/)) {
+                i = j - 1;
+                break;
+            }
+            const prefix = dl[0];
+            const text = dl.slice(1);
+            if (prefix === '-') {
+                // Find this line near the expected position
+                const searchStart = startLine + removals.length + additions.length;
+                let found = -1;
+                for (let s = Math.max(0, searchStart - 3); s < Math.min(fileLines.length, searchStart + 4); s++) {
+                    if (fileLines[s] === text && !removals.includes(s)) {
+                        found = s;
+                        break;
+                    }
+                }
+                if (found === -1) {
+                    throw new Error(`Hunk failed: could not find line "${text}" near line ${searchStart + 1}`);
+                }
+                removals.push(found);
+            }
+            else if (prefix === '+') {
+                additions.push(text);
+            }
+            // Context lines (space or no prefix) are skipped
+        }
+        // Remove in reverse order to preserve indices, then insert
+        removals.sort((a, b) => b - a);
+        for (const idx of removals) {
+            fileLines.splice(idx, 1);
+        }
+        const insertAt = removals.length > 0 ? Math.min(...removals) : startLine;
+        fileLines.splice(insertAt, 0, ...additions);
+        offset += additions.length - removals.length;
+    }
+    if (hunks === 0) {
+        throw new Error('No valid hunks found in update segment');
+    }
+    return { result: fileLines.join('\n'), hunks };
+}
+// ---- Security helpers ------------------------------------------------------
+const BLOCKED_PATH_FRAGMENTS = [
+    '/etc/passwd',
+    '/etc/shadow',
+    '.ssh',
+    '.gnupg',
+    '.env',
+];
+function isBlockedPath(filePath) {
+    const normalized = filePath.toLowerCase();
+    return BLOCKED_PATH_FRAGMENTS.some((fragment) => normalized.includes(fragment.toLowerCase()));
+}
+function resolveSafePath(inputPath, workdir) {
+    const resolved = path.isAbsolute(inputPath)
+        ? inputPath
+        : path.resolve(workdir, inputPath);
+    // Ensure the resolved path stays within the workspace root
+    const relative = path.relative(workdir, resolved);
+    if (relative.startsWith('..')) {
+        throw new Error(`Path "${inputPath}" resolves outside the workspace root`);
+    }
+    return resolved;
+}
+// ---- Segment execution -----------------------------------------------------
+async function applySegment(segment, workdir) {
+    let filePath;
+    try {
+        filePath = resolveSafePath(segment.filePath, workdir);
+    }
+    catch (err) {
+        return {
+            path: segment.filePath,
+            operation: segment.operation,
+            success: false,
+            error: err instanceof Error ? err.message : 'Path resolution failed',
+        };
+    }
+    // Blocked path check (FsGuard with fallback)
+    const fsGuard = getFsGuard();
+    if (fsGuard) {
+        const mode = segment.operation === 'delete' ? 'delete' : 'write';
+        const guardResult = await fsGuard.validatePath(filePath, mode);
+        if (!guardResult.allowed) {
+            return {
+                path: segment.filePath,
+                operation: segment.operation,
+                success: false,
+                error: guardResult.reason ?? 'Path access denied',
+            };
+        }
+    }
+    else if (isBlockedPath(filePath)) {
+        return {
+            path: segment.filePath,
+            operation: segment.operation,
+            success: false,
+            error: 'Access to this path is not allowed',
+        };
+    }
+    try {
+        switch (segment.operation) {
+            case 'add': {
+                // Fail if file already exists to prevent accidental overwrites
+                try {
+                    await fs.stat(filePath);
+                    return {
+                        path: segment.filePath,
+                        operation: 'add',
+                        success: false,
+                        error: 'File already exists - use Update File to modify existing files',
+                    };
+                }
+                catch {
+                    // Expected: file does not exist
+                }
+                await fs.mkdir(path.dirname(filePath), { recursive: true });
+                // Strip trailing blank line added by patch format if present
+                const content = segment.lines.join('\n').replace(/\n$/, '');
+                await fs.writeFile(filePath, content, 'utf-8');
+                logger.debug(`[MultiPatch] Added ${segment.filePath}`, { component: 'MultiPatch' });
+                return { path: segment.filePath, operation: 'add', success: true };
+            }
+            case 'update': {
+                let existing;
+                try {
+                    existing = await fs.readFile(filePath, 'utf-8');
+                }
+                catch {
+                    return {
+                        path: segment.filePath,
+                        operation: 'update',
+                        success: false,
+                        error: 'File does not exist - use Add File to create new files',
+                    };
+                }
+                const { result, hunks } = applyHunks(existing, segment.lines);
+                await fs.writeFile(filePath, result, 'utf-8');
+                logger.debug(`[MultiPatch] Updated ${segment.filePath} (${hunks} hunk(s))`, { component: 'MultiPatch' });
+                return { path: segment.filePath, operation: 'update', success: true, hunks };
+            }
+            case 'delete': {
+                try {
+                    await fs.unlink(filePath);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : 'Unknown error';
+                    return {
+                        path: segment.filePath,
+                        operation: 'delete',
+                        success: false,
+                        error: `Could not delete file: ${msg}`,
+                    };
+                }
+                logger.debug(`[MultiPatch] Deleted ${segment.filePath}`, { component: 'MultiPatch' });
+                return { path: segment.filePath, operation: 'delete', success: true };
+            }
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            path: segment.filePath,
+            operation: segment.operation,
+            success: false,
+            error: message,
+        };
+    }
+}
+// ---- Tool definition -------------------------------------------------------
+export const multiPatchTool = {
+    name: 'multi_patch',
+    description: `Apply a multi-file patch in OpenAI patch format. Supports adding new files,
+updating existing files (unified diff hunks), and deleting files in a single operation.
+
+Format:
+  *** Begin Patch
+  *** Add File: path/to/new.ts
+  [full file content]
+  *** Update File: path/to/existing.ts
+  @@ -10,7 +10,7 @@
+   context line
+  -removed line
+  +added line
+   context line
+  *** Delete File: path/to/obsolete.ts
+  *** End Patch
+
+All paths are resolved relative to the workspace root. Paths that escape the workspace
+root or match blocked patterns (e.g. .env, .ssh) are rejected.`,
+    category: 'filesystem',
+    securityLevel: 'moderate',
+    requiresApproval: true,
+    allowedHosts: ['sandbox', 'gateway', 'local'],
+    parameters: MultiPatchParamsSchema,
+    examples: [
+        {
+            description: 'Add a new file and update an existing one',
+            params: {
+                patch: [
+                    '*** Begin Patch',
+                    '*** Add File: src/utils/helper.ts',
+                    'export function add(a: number, b: number): number {',
+                    '  return a + b;',
+                    '}',
+                    '*** Update File: src/index.ts',
+                    '@@ -1,3 +1,4 @@',
+                    ' import { something } from "./other.js";',
+                    "+import { add } from './utils/helper.js';",
+                    ' ',
+                    ' export default {};',
+                    '*** End Patch',
+                ].join('\n'),
+            },
+        },
+    ],
+    async execute(context, params) {
+        const workdir = params.workdir ?? context.workdir;
+        // Parse the patch
+        let segments;
+        try {
+            segments = parsePatch(params.patch);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                success: false,
+                error: { code: 'PARSE_ERROR', message: `Failed to parse patch: ${message}` },
+            };
+        }
+        // Apply each segment (sequentially - order matters for dependencies)
+        const results = [];
+        for (const segment of segments) {
+            const result = await applySegment(segment, workdir);
+            results.push(result);
+        }
+        const applied = results.filter((r) => r.success).length;
+        const failed = results.filter((r) => !r.success).length;
+        // Build a human-readable summary
+        const summaryLines = [
+            `Multi-patch applied: ${applied} succeeded, ${failed} failed`,
+            '',
+        ];
+        for (const r of results) {
+            const icon = r.success ? '+' : 'x';
+            const opLabel = r.operation.toUpperCase().padEnd(6);
+            const detail = r.hunks !== undefined ? ` (${r.hunks} hunk${r.hunks !== 1 ? 's' : ''})` : '';
+            const errorNote = r.error ? ` - ${r.error}` : '';
+            summaryLines.push(`  [${icon}] ${opLabel} ${r.path}${detail}${errorNote}`);
+        }
+        const output = summaryLines.join('\n');
+        if (failed > 0 && applied === 0) {
+            return {
+                success: false,
+                data: { files: results, applied, failed },
+                error: {
+                    code: 'PATCH_FAILED',
+                    message: `All ${failed} operation(s) failed. See data.files for details.`,
+                },
+            };
+        }
+        return {
+            success: true,
+            data: { files: results, applied, failed },
+            output,
+        };
+    },
+};
+//# sourceMappingURL=multi-patch.js.map

package/dist/chat/execution/tools/openai-image-gen.d.ts

@@ -15,14 +15,14 @@ declare const ImageGenParamsSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     prompt: string;
     model: "dall-e-3" | "dall-e-2";
-    quality: "standard" | "hd";
     size: "1024x1024" | "1792x1024" | "1024x1792";
+    quality: "standard" | "hd";
     style: "vivid" | "natural";
 }, {
     prompt: string;
     model?: "dall-e-3" | "dall-e-2" | undefined;
-    quality?: "standard" | "hd" | undefined;
     size?: "1024x1024" | "1792x1024" | "1024x1792" | undefined;
+    quality?: "standard" | "hd" | undefined;
     style?: "vivid" | "natural" | undefined;
 }>;
 export type ImageGenParams = z.infer<typeof ImageGenParamsSchema>;

package/dist/chat/execution/tools/plan-tools.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Plan Mode Tools
+ *
+ * Two tools the agent can call to create a plan and mark steps as completed.
+ * Plans go through a draft → approved/rejected → in_progress → completed lifecycle.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+declare const CreatePlanParamsSchema: z.ZodObject<{
+    title: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        estimatedEffort: z.ZodOptional<z.ZodEnum<["small", "medium", "large"]>>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        files?: string[] | undefined;
+        estimatedEffort?: "small" | "medium" | "large" | undefined;
+    }, {
+        description: string;
+        files?: string[] | undefined;
+        estimatedEffort?: "small" | "medium" | "large" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    steps: {
+        description: string;
+        files?: string[] | undefined;
+        estimatedEffort?: "small" | "medium" | "large" | undefined;
+    }[];
+}, {
+    title: string;
+    steps: {
+        description: string;
+        files?: string[] | undefined;
+        estimatedEffort?: "small" | "medium" | "large" | undefined;
+    }[];
+}>;
+export type CreatePlanParams = z.infer<typeof CreatePlanParamsSchema>;
+interface CreatePlanResult {
+    planId: string;
+    status: 'awaiting_approval';
+    message: string;
+    stepCount: number;
+}
+export declare const createPlanTool: ToolDefinition<CreatePlanParams, CreatePlanResult>;
+declare const CompletePlanStepParamsSchema: z.ZodObject<{
+    stepIndex: z.ZodNumber;
+    summary: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    stepIndex: number;
+    summary?: string | undefined;
+}, {
+    stepIndex: number;
+    summary?: string | undefined;
+}>;
+export type CompletePlanStepParams = z.infer<typeof CompletePlanStepParamsSchema>;
+interface CompletePlanStepResult {
+    status: 'step_completed' | 'plan_completed';
+    completedStep: number;
+    nextStep?: {
+        index: number;
+        description: string;
+    };
+    planId: string;
+}
+export declare const completePlanStepTool: ToolDefinition<CompletePlanStepParams, CompletePlanStepResult>;
+export declare const planTools: readonly [ToolDefinition<{
+    title: string;
+    steps: {
+        description: string;
+        files?: string[] | undefined;
+        estimatedEffort?: "small" | "medium" | "large" | undefined;
+    }[];
+}, CreatePlanResult>, ToolDefinition<{
+    stepIndex: number;
+    summary?: string | undefined;
+}, CompletePlanStepResult>];
+export {};
+//# sourceMappingURL=plan-tools.d.ts.map

package/dist/chat/execution/tools/plan-tools.js

@@ -0,0 +1,134 @@
+/**
+ * Plan Mode Tools
+ *
+ * Two tools the agent can call to create a plan and mark steps as completed.
+ * Plans go through a draft → approved/rejected → in_progress → completed lifecycle.
+ */
+import { z } from 'zod';
+import { planManager } from '../../../agents/plan-mode.js';
+import { logger } from '../../../utils/logger.js';
+// ─── create_plan ────────────────────────────────────────────────────────────
+const CreatePlanParamsSchema = z.object({
+    title: z.string().min(1).describe('Short title for the plan'),
+    steps: z
+        .array(z.object({
+        description: z.string().min(1).describe('What this step does'),
+        files: z.array(z.string()).optional().describe('Files this step will touch'),
+        estimatedEffort: z
+            .enum(['small', 'medium', 'large'])
+            .optional()
+            .describe('Rough effort estimate'),
+    }))
+        .min(1)
+        .describe('Ordered list of implementation steps'),
+});
+export const createPlanTool = {
+    name: 'create_plan',
+    description: `Create an implementation plan before making changes.
+
+Use this for any multi-step task. Write out every discrete step you intend to
+take. The user will review the plan and approve or reject it before you begin
+any implementation.
+
+**When to call this:**
+- Task requires changes to 2 or more files
+- Task has distinct phases (e.g., data model → API → tests)
+- User asks you to plan before coding
+
+**After calling this tool, STOP and wait.** Do not proceed until the user runs
+\`profclaw plan approve <id>\` or tells you the plan is approved.`,
+    category: 'profclaw',
+    securityLevel: 'safe',
+    allowedHosts: ['sandbox', 'gateway', 'local'],
+    parameters: CreatePlanParamsSchema,
+    examples: [
+        {
+            description: 'Plan a feature implementation',
+            params: {
+                title: 'Add rate limiting to API endpoints',
+                steps: [
+                    { description: 'Add rate-limit middleware in src/middleware/rate-limit.ts', estimatedEffort: 'medium', files: ['src/middleware/rate-limit.ts'] },
+                    { description: 'Apply middleware to all /api/* routes in src/routes/index.ts', estimatedEffort: 'small', files: ['src/routes/index.ts'] },
+                    { description: 'Write unit tests for rate-limit middleware', estimatedEffort: 'medium', files: ['src/middleware/rate-limit.test.ts'] },
+                ],
+            },
+        },
+    ],
+    async execute(_context, params) {
+        logger.info('[PlanTool] Creating plan:', { title: params.title, stepCount: params.steps.length });
+        const stepsWithIndex = params.steps.map((s, i) => ({
+            index: i + 1,
+            description: s.description,
+            files: s.files,
+            estimatedEffort: s.estimatedEffort,
+        }));
+        const plan = planManager.create(params.title, stepsWithIndex);
+        return {
+            success: true,
+            data: {
+                planId: plan.id,
+                status: 'awaiting_approval',
+                message: `Plan created with ${plan.steps.length} step(s). Waiting for user approval. Run: profclaw plan approve ${plan.id}`,
+                stepCount: plan.steps.length,
+            },
+        };
+    },
+};
+// ─── complete_plan_step ─────────────────────────────────────────────────────
+const CompletePlanStepParamsSchema = z.object({
+    stepIndex: z.number().int().min(1).describe('The 1-based index of the completed step'),
+    summary: z.string().optional().describe('Optional summary of what was done in this step'),
+});
+export const completePlanStepTool = {
+    name: 'complete_plan_step',
+    description: `Mark a plan step as completed after implementing it.
+
+Call this after finishing each step in an approved plan. The tool will tell you
+what the next pending step is so you can proceed in order.
+
+**When to call this:**
+- You have fully implemented the current step
+- All files for the step are written/edited and working
+
+**Do not call this:**
+- Before the step is actually done
+- If there is no active plan`,
+    category: 'profclaw',
+    securityLevel: 'safe',
+    allowedHosts: ['sandbox', 'gateway', 'local'],
+    parameters: CompletePlanStepParamsSchema,
+    async execute(_context, params) {
+        const plan = planManager.getActive();
+        if (!plan) {
+            return {
+                success: false,
+                error: {
+                    code: 'NO_ACTIVE_PLAN',
+                    message: 'No active (in_progress) plan found. Approve a plan first.',
+                },
+            };
+        }
+        logger.info('[PlanTool] Completing step:', {
+            planId: plan.id,
+            stepIndex: params.stepIndex,
+            summary: params.summary,
+        });
+        const updated = planManager.updateStep(plan.id, params.stepIndex, 'completed');
+        const nextStep = updated.steps.find((s) => s.status === 'pending');
+        const planDone = updated.status === 'completed';
+        return {
+            success: true,
+            data: {
+                status: planDone ? 'plan_completed' : 'step_completed',
+                completedStep: params.stepIndex,
+                nextStep: nextStep
+                    ? { index: nextStep.index, description: nextStep.description }
+                    : undefined,
+                planId: plan.id,
+            },
+        };
+    },
+};
+// ─── Exports ─────────────────────────────────────────────────────────────────
+export const planTools = [createPlanTool, completePlanStepTool];
+//# sourceMappingURL=plan-tools.js.map

package/dist/chat/execution/tools/profclaw-ops.d.ts

@@ -18,7 +18,7 @@ declare const CreateTicketParamsSchema: z.ZodObject<{
     storyPoints: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     title: string;
-    priority: "critical" | "medium" | "none" | "high" | "low";
+    priority: "critical" | "medium" | "none" | "low" | "high";
     type: "task" | "feature" | "bug" | "story" | "epic" | "subtask" | "improvement";
     projectKey: string;
     description?: string | undefined;
@@ -28,7 +28,7 @@ declare const CreateTicketParamsSchema: z.ZodObject<{
     title: string;
     projectKey: string;
     description?: string | undefined;
-    priority?: "critical" | "medium" | "none" | "high" | "low" | undefined;
+    priority?: "critical" | "medium" | "none" | "low" | "high" | undefined;
     type?: "task" | "feature" | "bug" | "story" | "epic" | "subtask" | "improvement" | undefined;
     labels?: string[] | undefined;
     storyPoints?: number | undefined;
@@ -94,7 +94,7 @@ declare const UpdateTicketParamsSchema: z.ZodObject<{
     ticketKey: string;
     title?: string | undefined;
     description?: string | undefined;
-    priority?: "critical" | "medium" | "none" | "high" | "low" | undefined;
+    priority?: "critical" | "medium" | "none" | "low" | "high" | undefined;
     type?: "task" | "feature" | "bug" | "story" | "epic" | "subtask" | "improvement" | undefined;
     status?: "in_progress" | "cancelled" | "backlog" | "done" | "todo" | "in_review" | undefined;
     labels?: string[] | undefined;
@@ -103,7 +103,7 @@ declare const UpdateTicketParamsSchema: z.ZodObject<{
     ticketKey: string;
     title?: string | undefined;
     description?: string | undefined;
-    priority?: "critical" | "medium" | "none" | "high" | "low" | undefined;
+    priority?: "critical" | "medium" | "none" | "low" | "high" | undefined;
     type?: "task" | "feature" | "bug" | "story" | "epic" | "subtask" | "improvement" | undefined;
     status?: "in_progress" | "cancelled" | "backlog" | "done" | "todo" | "in_review" | undefined;
     labels?: string[] | undefined;
@@ -161,7 +161,7 @@ export declare const updateTicketTool: ToolDefinition<UpdateTicketParams, Ticket
 export declare const getTicketTool: ToolDefinition<GetTicketParams, TicketResult>;
 export declare const profclawTools: (ToolDefinition<{
     title: string;
-    priority: "critical" | "medium" | "none" | "high" | "low";
+    priority: "critical" | "medium" | "none" | "low" | "high";
     type: "task" | "feature" | "bug" | "story" | "epic" | "subtask" | "improvement";
     projectKey: string;
     description?: string | undefined;
@@ -192,7 +192,7 @@ export declare const profclawTools: (ToolDefinition<{
     ticketKey: string;
     title?: string | undefined;
     description?: string | undefined;
-    priority?: "critical" | "medium" | "none" | "high" | "low" | undefined;
+    priority?: "critical" | "medium" | "none" | "low" | "high" | undefined;
     type?: "task" | "feature" | "bug" | "story" | "epic" | "subtask" | "improvement" | undefined;
     status?: "in_progress" | "cancelled" | "backlog" | "done" | "todo" | "in_review" | undefined;
     labels?: string[] | undefined;