profclaw 2.0.0 → 2.4.0

package/dist/chat/system-prompts.js

@@ -9,15 +9,15 @@
 import { MODEL_ALIASES } from '../providers/core/models.js';
 import { getSkillsRegistry } from '../skills/index.js';
 // === Core profClaw Context ===
-export const PROFCLAW_CONTEXT = `You are profClaw Assistant, an AI helper integrated into profClaw Task Manager.
-
-profClaw is a task orchestration platform for AI-assisted development - managing tickets, routing work to AI agents, and tracking progress.
+export const PROFCLAW_CONTEXT = `You are profClaw, a personal AI assistant running inside profClaw engine.
+You help with coding, research, automation, and general tasks. You have access to tools - use them.
 
 ## Response Style
-- Be helpful and concise
-- Use markdown for structure
-- Match effort to the request - simple questions get simple answers
-- Ask clarifying questions when needed`;
+- Be concise and direct. No filler, no preamble.
+- Do NOT use emoji headers, LaTeX, or excessive formatting.
+- Use short paragraphs and plain markdown (headers, bold, code blocks only when needed).
+- Match the user's tone — casual question gets a casual answer.
+- Lead with the answer, then explain only if needed.`;
 // === Grounding Suffix (appended to prevent hallucinations) ===
 export const GROUNDING_SUFFIX = `
 
@@ -35,48 +35,62 @@ If asked to "run" or "execute" something, explain that you can help write or dra
 // === Tool-Enabled Mode Suffix (replaces grounding when tools are available) ===
 export const TOOL_ENABLED_SUFFIX = `
 
-## Tool Usage
-You have access to tools that allow you to:
-- **Read files** and search codebases
-- **Fetch web content** from URLs (web_fetch tool)
-- **Browse websites** interactively (browser_navigate, browser_screenshot)
-- **Execute system commands** (with user approval for dangerous ones)
-- **Access profClaw operations** (list tasks, tickets, etc.)
-
-When the user asks you to do something that requires these capabilities:
-1. Use the appropriate tool - don't say you can't do it
-2. If a tool requires approval, explain what you're trying to do and wait for approval
-3. After tool execution, continue the conversation and explain what you found/did
-4. If a tool fails, explain the error and suggest alternatives
-
-**IMPORTANT**: When a tool returns "pending" or "requires approval", tell the user you're waiting for their approval in the UI, then STOP and wait. Do not continue until approval is given.
-
-**After approval**: Once a tool is approved and executed, summarize the results and continue helping the user.`;
+## Tools — YOU MUST USE THEM
+You have real tools that execute actions. You are NOT limited to text responses.
+
+ALWAYS call a tool when the user asks you to:
+- Search the web → call web_search
+- Read a URL or website → call web_fetch
+- Read a file → call read_file
+- Run a command → call exec
+- Write a file → call write_file
+
+Do NOT say "I can't browse the web" or "I can't access files." You CAN. Call the tool.
+If you're unsure, call the tool anyway — it's better to try and fail than refuse.`;
 // === Agent Mode Suffix (for autonomous operation) ===
 export const AGENT_MODE_SUFFIX = `
 
+## Tool Call Style
+Do not narrate routine tool calls - just call the tool.
+Narrate only for multi-step work, complex problems, or sensitive actions.
+When a tool exists for an action, use it directly. Never say "I can't do that" when a tool can.
+
 ## Tool Usage
-You have access to tools. Use them when you NEED external data or actions.
-
-**DO NOT use tools for:**
-- Greetings ("hi", "hello") → Just respond naturally
-- Questions about yourself → Explain from knowledge
-- General knowledge questions → Answer directly
-- Acknowledgments, thanks, small talk → Just respond
-
-**USE tools when you need to:**
-- Read files, fetch web data, run commands
-- Create/update tickets, projects, or other profClaw resources
-- Perform any action the user explicitly requests
-
-**When using tools:**
-- Chain tools to complete multi-step requests — don't stop after one call
-- Use parallel tool calls when steps are independent
-- Do NOT ask for confirmation — just execute the requested actions
-- After all steps are done, call \`complete_task\` with a summary
-
-**When NOT using tools:**
-- Respond with text directly — do NOT call \`complete_task\` for text-only responses`;
+You have tools. Use them when the task requires external data or actions.
+
+**ALWAYS use tools for:**
+- Any search/lookup/research request -> web_search
+- Reading a URL/website -> web_fetch
+- File operations -> read_file, write_file, edit_file, grep
+- Running commands -> exec
+- Git/GitHub operations -> git_*, github_pr, create_pr
+- Code quality -> typecheck, lint, build, test_run
+- "What is X?" about anything specific -> web_search (do NOT guess)
+
+**Skip tools only for:** greetings, thanks, simple math, questions about yourself.
+
+**Rules:**
+- Chain tools for multi-step tasks. Do not stop after one call.
+- Use parallel calls when steps are independent.
+- Do NOT ask permission. Just execute.
+- If a tool fails, try an alternative approach.
+- After completing work, call complete_task with a brief summary.
+- For text-only replies, do NOT call complete_task.
+
+## Skills
+You have access to skills (see Available Skills list). Before starting a complex task:
+1. Scan the skills list for a relevant skill
+2. If found, read the skill's SKILL.md with read_file to get detailed instructions
+3. Follow the skill's workflow
+
+## Workspace
+Treat the current directory as your workspace. Use relative paths.
+When modifying code: read first, then edit, then verify (typecheck/test).
+
+## Safety
+Do not pursue independent goals beyond the user's request.
+Prioritize safety and human oversight. If instructions conflict, ask.
+Do not manipulate access controls or bypass safeguards.`;
 export const CHAT_PRESETS = [
     {
         id: 'profclaw-assistant',
@@ -236,6 +250,36 @@ export async function buildSystemPrompt(presetId, context, options) {
     // Find the preset
     const preset = CHAT_PRESETS.find((p) => p.id === presetId) || CHAT_PRESETS[0];
     let prompt = preset.prompt;
+    // Inject workspace context (CLAUDE.md, project type)
+    // OpenClaw pattern: load project context files into system prompt
+    try {
+        const { existsSync, readFileSync } = await import('node:fs');
+        const { join } = await import('node:path');
+        const cwd = process.cwd();
+        const contextFiles = [];
+        // Only inject MEMORY.md (lightweight project context)
+        // AGENTS.md/CLAUDE.md are dev docs, not useful for chat — they cause
+        // small models to regurgitate raw context instead of answering naturally
+        const candidates = ['MEMORY.md'];
+        const maxChars = 800; // Keep tight for small models
+        for (const file of candidates) {
+            const path = join(cwd, file);
+            if (existsSync(path)) {
+                try {
+                    const content = readFileSync(path, 'utf-8').slice(0, maxChars);
+                    contextFiles.push({ name: file, content });
+                }
+                catch { /* skip unreadable */ }
+            }
+        }
+        if (contextFiles.length > 0) {
+            prompt += '\n\n# Background (do NOT repeat this to the user)\n';
+            for (const f of contextFiles) {
+                prompt += `\n${f.content}\n`;
+            }
+        }
+    }
+    catch { /* skip on error */ }
     // Inject dynamic context if available
     if (context) {
         const contextParts = [];
@@ -275,12 +319,11 @@ ${context.ticket.description ? `- **Description**: ${context.ticket.description}
 
 The user is currently viewing or discussing this ticket.`);
         }
-        if (context.recentActivity) {
+        // Only include activity when there's meaningful data (saves tokens on quiet instances)
+        if (context.recentActivity && (context.recentActivity.tasksCompleted > 0 || context.recentActivity.tasksPending > 0)) {
             contextParts.push(`
-## Recent Activity
-- Tasks completed recently: ${context.recentActivity.tasksCompleted}
-- Tasks pending: ${context.recentActivity.tasksPending}
-- Active agents: ${context.recentActivity.activeAgents.join(', ') || 'None'}`);
+## Activity
+${context.recentActivity.tasksCompleted} completed, ${context.recentActivity.tasksPending} pending`);
         }
         if (context.user) {
             contextParts.push(`
@@ -292,20 +335,37 @@ ${context.user.role ? `- Role: ${context.user.role}` : ''}`);
             prompt += '\n\n---\n' + contextParts.join('\n');
         }
     }
-    // Add model aliases section (like OpenClaw)
-    if (options?.includeModelAliases !== false) {
+    // Add model aliases section — skip for local models (saves ~150 tokens)
+    const isLocalModel = context?.runtime?.provider === 'ollama';
+    if (options?.includeModelAliases !== false && !isLocalModel) {
         prompt += buildModelAliasesSection();
     }
-    // Inject skills context
-    try {
-        const registry = getSkillsRegistry();
-        const skillsPrompt = await registry.getSkillsPrompt();
-        if (skillsPrompt) {
-            prompt += '\n\n' + skillsPrompt;
+    // Inject skills summary — only for tool-enabled/agent modes
+    // Regular chat doesn't need the full skill list (saves ~800 tokens per message)
+    if (options?.enableTools || options?.agentMode) {
+        try {
+            const registry = getSkillsRegistry();
+            const entries = registry.getAllEntries();
+            if (entries.length > 0) {
+                // Only include top 15 most relevant skills, not all 55
+                const prioritySkills = entries
+                    .filter((e) => e.enabled !== false)
+                    .sort((a, b) => {
+                    const pa = a.metadata?.priority ?? 0;
+                    const pb = b.metadata?.priority ?? 0;
+                    // Name tie-break keeps the cached prompt prefix byte-stable
+                    return pb - pa || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+                })
+                    .slice(0, 15);
+                const skillLines = prioritySkills
+                    .map((e) => `- ${e.name}: ${e.description || 'No description'}`)
+                    .join('\n');
+                prompt += `\n\n## Skills (${entries.length} available, top ${prioritySkills.length} shown)\nUse read_file on skills/<name>/SKILL.md for details.\n${skillLines}`;
+            }
+        }
+        catch {
+            // Skills not initialized yet - skip
         }
-    }
-    catch {
-        // Skills not initialized yet - skip
     }
     // Add appropriate suffix based on mode
     if (options?.agentMode) {

package/dist/chat/tool-handler.d.ts

@@ -25,6 +25,8 @@ export interface ChatToolHandler {
     }>;
     /** Handle approval decision */
     handleApproval(approvalId: string, decision: 'allow-once' | 'allow-always' | 'deny'): Promise<ToolExecutionResult | null>;
+    /** Delete spilled tool-result temp files. Call when the request/run ends. */
+    dispose(): Promise<void>;
 }
 export declare function createChatToolHandler(options: ChatToolHandlerOptions): Promise<ChatToolHandler>;
 /**

package/dist/chat/tool-handler.js

@@ -9,6 +9,10 @@ import { randomUUID } from 'node:crypto';
 import { getToolExecutor, getToolRegistry, initializeToolExecution, } from './execution/index.js';
 import { logger } from '../utils/logger.js';
 import { SAFE_BROWSER_TOOL_NAMES } from '../browser/index.js';
+import { ResultStore } from '../agents/result-store.js';
+import { truncateAndStore, isTruncationEnabled } from '../agents/output-truncator.js';
+import { LOAD_TOOLS_NAME, FETCH_RESULT_NAME, getToolSelectorSession, } from '../agents/tool-selector.js';
+import { runLoadTools, runFetchResult } from './meta-tool-handlers.js';
 // In-Memory Session Manager for Chat
 class ChatSessionManager {
     sessions = new Map();
@@ -78,6 +82,23 @@ export async function createChatToolHandler(options) {
     const registry = getToolRegistry();
     const executor = getToolExecutor();
     const sessionManager = new ChatSessionManager();
+    const resultStore = new ResultStore(options.conversationId.replace(/[^a-zA-Z0-9_-]/g, '_'));
+    /** Cap large results before they reach the model; the full result stays in the store. */
+    const capForModel = async (toolName, toolCallId, data) => {
+        if (!isTruncationEnabled() || toolName === FETCH_RESULT_NAME || toolName === LOAD_TOOLS_NAME) {
+            return data;
+        }
+        try {
+            return (await truncateAndStore(resultStore, toolCallId, data)).value;
+        }
+        catch (error) {
+            logger.warn(`[ChatToolHandler] Output truncation failed for ${toolName}`, {
+                component: 'ChatToolHandler',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return data;
+        }
+    };
     // Build security policy
     const securityPolicy = {
         mode: options.securityMode || 'ask',
@@ -93,7 +114,7 @@ export async function createChatToolHandler(options) {
         securityPolicy,
         sessionManager,
     });
-    return {
+    const handler = {
         getTools() {
             const tools = registry.list();
             return tools.map((tool) => ({
@@ -107,7 +128,26 @@ export async function createChatToolHandler(options) {
                 component: 'ChatToolHandler',
                 toolCallId,
             });
+            // Meta-tools are served locally, not through the registry
+            if (toolName === LOAD_TOOLS_NAME) {
+                const allTools = registry.list().map((t) => ({
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.parameters,
+                }));
+                return {
+                    result: await runLoadTools(args, {
+                        session: getToolSelectorSession(options.conversationId),
+                        allTools,
+                        invoke: async (tool, toolArgs) => (await handler.executeTool(tool, toolArgs, randomUUID())).result,
+                    }),
+                };
+            }
+            if (toolName === FETCH_RESULT_NAME) {
+                return { result: await runFetchResult(args, resultStore) };
+            }
             try {
+                getToolSelectorSession(options.conversationId).noteToolUse(toolName);
                 const context = createContext(toolCallId);
                 const result = await executor.execute({
                     id: toolCallId,
@@ -134,7 +174,7 @@ export async function createChatToolHandler(options) {
                 // The AI only sees `result` — `output` is preserved for UI rendering
                 if (result.result.success) {
                     // Extract clean data for the AI model
-                    const aiResult = result.result.data ?? { success: true };
+                    const aiResult = await capForModel(toolName, toolCallId, result.result.data ?? { success: true });
                     return {
                         result: aiResult,
                         output: result.result.output, // Sidecar for UI display
@@ -166,6 +206,9 @@ export async function createChatToolHandler(options) {
                 params: a.params,
             }));
         },
+        async dispose() {
+            await resultStore.cleanup();
+        },
         async handleApproval(approvalId, decision) {
             logger.info(`[ChatToolHandler] Handling approval: ${approvalId} -> ${decision}`, {
                 component: 'ChatToolHandler',
@@ -176,7 +219,7 @@ export async function createChatToolHandler(options) {
                     return null;
                 }
                 if (result.result.success) {
-                    const aiResult = result.result.data ?? { success: true };
+                    const aiResult = await capForModel(approvalId, randomUUID(), result.result.data ?? { success: true });
                     return {
                         result: aiResult,
                         output: result.result.output,
@@ -200,6 +243,7 @@ export async function createChatToolHandler(options) {
             }
         },
     };
+    return handler;
 }
 // Tool Categories for Chat
 /**

package/dist/chat/tools.d.ts

@@ -34,7 +34,7 @@ export declare const CreateTicketToolSchema: z.ZodObject<{
     storyPoints: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     title: string;
-    priority: "critical" | "medium" | "high" | "low";
+    priority: "critical" | "medium" | "low" | "high";
     type: "task" | "bug" | "story" | "epic" | "subtask";
     projectKey: string;
     description?: string | undefined;
@@ -44,7 +44,7 @@ export declare const CreateTicketToolSchema: z.ZodObject<{
     title: string;
     projectKey: string;
     description?: string | undefined;
-    priority?: "critical" | "medium" | "high" | "low" | undefined;
+    priority?: "critical" | "medium" | "low" | "high" | undefined;
     type?: "task" | "bug" | "story" | "epic" | "subtask" | undefined;
     labels?: string[] | undefined;
     storyPoints?: number | undefined;
@@ -176,7 +176,7 @@ export declare const CHAT_TOOLS: {
             storyPoints: z.ZodOptional<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             title: string;
-            priority: "critical" | "medium" | "high" | "low";
+            priority: "critical" | "medium" | "low" | "high";
             type: "task" | "bug" | "story" | "epic" | "subtask";
             projectKey: string;
             description?: string | undefined;
@@ -186,7 +186,7 @@ export declare const CHAT_TOOLS: {
             title: string;
             projectKey: string;
             description?: string | undefined;
-            priority?: "critical" | "medium" | "high" | "low" | undefined;
+            priority?: "critical" | "medium" | "low" | "high" | undefined;
             type?: "task" | "bug" | "story" | "epic" | "subtask" | undefined;
             labels?: string[] | undefined;
             storyPoints?: number | undefined;
@@ -294,7 +294,7 @@ export declare function getToolDefinitions(): {
         storyPoints: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         title: string;
-        priority: "critical" | "medium" | "high" | "low";
+        priority: "critical" | "medium" | "low" | "high";
         type: "task" | "bug" | "story" | "epic" | "subtask";
         projectKey: string;
         description?: string | undefined;
@@ -304,7 +304,7 @@ export declare function getToolDefinitions(): {
         title: string;
         projectKey: string;
         description?: string | undefined;
-        priority?: "critical" | "medium" | "high" | "low" | undefined;
+        priority?: "critical" | "medium" | "low" | "high" | undefined;
         type?: "task" | "bug" | "story" | "epic" | "subtask" | undefined;
         labels?: string[] | undefined;
         storyPoints?: number | undefined;

package/dist/cli/commands/auth.js

@@ -12,7 +12,7 @@ import chalk from 'chalk';
 import { randomUUID } from 'crypto';
 import { eq } from 'drizzle-orm';
 import { initStorage, getDb } from '../../storage/index.js';
-import { users, sessions, inviteCodes } from '../../storage/schema.js';
+import { users, sessions, inviteCodes, userPreferences } from '../../storage/schema.js';
 import { generateInviteCode, hashInviteCode, hashPassword, generateRecoveryCodes, hashRecoveryCodes, } from '../../auth/password.js';
 import { updateSettings } from '../../settings/index.js';
 import { createTable, success, error, info, warn } from '../utils/output.js';
@@ -276,6 +276,69 @@ export function authCommands() {
             process.exit(1);
         }
     });
+    // profclaw auth create-admin
+    auth
+        .command('create-admin')
+        .description('Create an admin user (for headless/pico setups)')
+        .option('--email <email>', 'Email address')
+        .option('--password <password>', 'Password (min 8 characters)')
+        .option('--name <name>', 'Display name')
+        .action(async (options) => {
+        if (!options.email || !options.password || !options.name) {
+            console.log('');
+            console.log('Usage: profclaw auth create-admin --email <email> --password <pass> --name <name>');
+            console.log('');
+            console.log('  --email     Email address for the admin account');
+            console.log('  --password  Password (min 8 characters)');
+            console.log('  --name      Display name');
+            process.exit(1);
+        }
+        try {
+            const db = await ensureDb();
+            const existing = await db
+                .select({ id: users.id })
+                .from(users)
+                .where(eq(users.email, options.email.toLowerCase()))
+                .limit(1);
+            if (existing.length > 0) {
+                error(`User already exists: ${options.email}`);
+                process.exit(1);
+            }
+            if (options.password.length < 8) {
+                error('Password must be at least 8 characters');
+                process.exit(1);
+            }
+            const userId = randomUUID();
+            const now = new Date();
+            await db.insert(users).values({
+                id: userId,
+                email: options.email.toLowerCase(),
+                passwordHash: hashPassword(options.password),
+                name: options.name,
+                role: 'admin',
+                status: 'active',
+                createdAt: now,
+                updatedAt: now,
+            });
+            await db.insert(userPreferences).values({
+                id: randomUUID(),
+                userId,
+                updatedAt: now,
+            });
+            console.log('');
+            success(`Admin user created`);
+            console.log('');
+            console.log(`  Name:  ${chalk.bold(options.name)}`);
+            console.log(`  Email: ${chalk.bold(options.email.toLowerCase())}`);
+            console.log(`  Role:  ${chalk.yellow('admin')}`);
+            console.log(`  ID:    ${chalk.dim(userId)}`);
+            console.log('');
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : 'Failed to create admin user');
+            process.exit(1);
+        }
+    });
     // profclaw auth set-mode
     auth
         .command('set-mode <mode>')