gekto 0.0.10 → 0.0.12

package/dist/agents/agentPool.js

@@ -5,6 +5,7 @@ import { randomUUID } from 'crypto';
 import { tmpdir } from 'os';
 import { HeadlessAgent } from './HeadlessAgent.js';
 import { getState, mutate, broadcastFileChange, broadcastAgent } from '../state.js';
+import { BASH_SAFETY_RULES } from './bashSafetyRules.js';
 // Per-lizard sessions
 const sessions = new Map();
 // Summarize tool input for display
@@ -21,20 +22,15 @@ function summarizeInput(input) {
 }
 const DEFAULT_SYSTEM_PROMPT = `You are a helpful coding assistant. Be concise and direct in your responses.
 
-IMPORTANT RESTRICTIONS - You MUST follow these rules:
-1. DO NOT use Bash or shell commands - you cannot run terminal commands
-2. DO NOT try to build, compile, or bundle the project
-3. DO NOT try to start, restart, or run any servers or dev environments
-4. DO NOT run tests, linters, or any CLI tools
-5. DO NOT install packages or run npm/yarn/pnpm commands
+You can use Bash for running tests, installing packages, building, and other shell operations.
+${BASH_SAFETY_RULES}
 
-Your job is ONLY to:
+Your job is to:
 - Read and understand code using Read, Glob, Grep tools
 - Write and edit code using Write and Edit tools
+- Use Bash for running tests, installing packages, git operations, and build commands
 - Make the requested code changes
 
-After making changes, simply report what you did. The user will handle building, testing, and running the code themselves.
-
 STATUS MARKER - At the END of EVERY response, you MUST include exactly one of these markers:
 - [STATUS:DONE] - Use when the task is complete and you have no questions for the user
 - [STATUS:PENDING] - Use when you need user input, confirmation, clarification, or approval to proceed
@@ -44,7 +40,7 @@ Examples:
 - When asking a question: "Which approach would you prefer? [STATUS:PENDING]"
 - After answering a simple question: "The file is located at src/utils.ts [STATUS:DONE]"`;
 // Tools that agents are not allowed to use
-const DISALLOWED_TOOLS = ['Bash', 'Task'];
+const DISALLOWED_TOOLS = ['Task'];
 function getOrCreateSession(lizardId, ws) {
     let session = sessions.get(lizardId);
     if (!session) {

package/dist/agents/agentWebSocket.js

@@ -2,7 +2,7 @@ import { WebSocketServer } from 'ws';
 import { sendMessage, resumeSession, resetSession, getWorkingDir, getActiveSessions, killSession, killAllSessions, attachWebSocket, revertFiles, saveImagesToTempFiles } from './agentPool.js';
 import { processWithTools, generateTasksFromAbstract } from './gektoTools.js';
 import { initGekto, getGektoState, abortGekto, setStateCallback, resetGektoSession, restoreGektoSession, getGektoSessionId } from './gektoPersistent.js';
-import { getState, mutate, mutateBatch, addClient, removeClient, sendSnapshot, getClients, broadcastActivePlans, broadcastSinglePlan, broadcastTask, broadcastAgent, broadcastVisuals, broadcastVisualDelete, broadcastForPath } from '../state.js';
+import { getState, mutate, mutateBatch, addClient, removeClient, sendSnapshot, getClients, broadcastActivePlans, broadcastActivePlanId, broadcastSinglePlan, broadcastTask, broadcastAgent, broadcastVisuals, broadcastVisualDelete, broadcastForPath } from '../state.js';
 import { persistEntity } from '../entityStore.js';
 import fs from 'fs';
 import nodePath from 'path';
@@ -190,7 +190,14 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         // Clear tasks and plans
                         mutate('tasks', {});
                         mutate('activePlans', {});
+                        mutate('activePlanId', null);
                         broadcastActivePlans();
+                        broadcastActivePlanId();
+                        return;
+                    }
+                    case 'set_active_plan': {
+                        mutate('activePlanId', msg.planId ?? null);
+                        broadcastActivePlanId();
                         return;
                     }
                     case 'create_plan': {
@@ -208,6 +215,31 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         if (planImages && planImages.length > 0) {
                             planImagePaths = saveImagesToTempFiles(planImages);
                         }
+                        // Remember the plan's state before processing so we can restore it
+                        // if Gekto replies with chat/delegate/error instead of a plan update.
+                        // Only delete plans that were created as temporary 'planning' entries.
+                        const planBeforeProcessing = getState().activePlans[msg.planId] ?? null;
+                        const planExistedBefore = planBeforeProcessing !== null;
+                        const previousStatus = planBeforeProcessing?.status;
+                        // Set plan status to 'planning' on the server side (authoritative)
+                        // so we don't race with the client's save_state message
+                        if (planBeforeProcessing) {
+                            mutate(`activePlans.${msg.planId}.status`, 'planning');
+                        }
+                        else {
+                            // Create temporary plan entry for new plans
+                            mutate(`activePlans.${msg.planId}`, {
+                                id: msg.planId,
+                                status: 'planning',
+                                originalPrompt: msg.prompt ?? '',
+                                taskIds: [],
+                                createdAt: new Date().toISOString(),
+                            });
+                        }
+                        broadcastSinglePlan(msg.planId);
+                        // Set as active plan
+                        mutate('activePlanId', msg.planId);
+                        broadcastActivePlanId();
                         try {
                             // Server-side accumulators and block counter
                             let accThinking = '';
@@ -308,6 +340,9 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                         broadcastTask(task.id);
                                     }
                                 }
+                                // Set the newly created/updated plan as active
+                                mutate('activePlanId', planResult.plan.id);
+                                broadcastActivePlanId();
                                 ws.send(JSON.stringify({
                                     type: 'plan_created',
                                     planId: msg.planId,
@@ -336,21 +371,27 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                 }));
                             }
                             else if (planResult.type === 'delegate' && planResult.delegateAgentId) {
-                                // Clear stale planning state — delegate doesn't create a plan
-                                const currentState = getState();
-                                if (msg.planId && currentState.activePlans[msg.planId]?.status === 'planning') {
-                                    mutate(`activePlans.${msg.planId}`, undefined);
-                                    broadcastSinglePlan(msg.planId);
+                                // Restore plan state — only delete if it was a temporary entry
+                                if (msg.planId && getState().activePlans[msg.planId]?.status === 'planning') {
+                                    if (planExistedBefore && previousStatus) {
+                                        mutate(`activePlans.${msg.planId}.status`, previousStatus);
+                                        broadcastSinglePlan(msg.planId);
+                                    }
+                                    else {
+                                        mutate(`activePlans.${msg.planId}`, undefined);
+                                        broadcastSinglePlan(msg.planId);
+                                    }
                                 }
                                 // Send instruction to existing agent
                                 const targetAgentId = planResult.delegateAgentId;
-                                const targetAgent = currentState.agents[targetAgentId];
+                                const delegateState = getState();
+                                const targetAgent = delegateState.agents[targetAgentId];
                                 if (targetAgent) {
                                     // Update agent status to working
                                     mutate(`agents.${targetAgentId}.status`, 'working');
                                     broadcastAgent(targetAgentId);
                                     // Notify client about delegation
-                                    const delegateTask = targetAgent.taskId ? currentState.tasks[targetAgent.taskId] : null;
+                                    const delegateTask = targetAgent.taskId ? delegateState.tasks[targetAgent.taskId] : null;
                                     ws.send(JSON.stringify({
                                         type: 'gekto_delegate',
                                         planId: msg.planId,
@@ -372,11 +413,16 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                 }
                             }
                             else if (planResult.type === 'chat') {
-                                // Chat reply — clear the temporary 'planning' plan state
-                                const currentState = getState();
-                                if (msg.planId && currentState.activePlans[msg.planId]?.status === 'planning') {
-                                    mutate(`activePlans.${msg.planId}`, undefined);
-                                    broadcastSinglePlan(msg.planId);
+                                // Restore plan state — only delete if it was a temporary entry
+                                if (msg.planId && getState().activePlans[msg.planId]?.status === 'planning') {
+                                    if (planExistedBefore && previousStatus) {
+                                        mutate(`activePlans.${msg.planId}.status`, previousStatus);
+                                        broadcastSinglePlan(msg.planId);
+                                    }
+                                    else {
+                                        mutate(`activePlans.${msg.planId}`, undefined);
+                                        broadcastSinglePlan(msg.planId);
+                                    }
                                 }
                             }
                             // Persist Gekto session ID on current master so it survives restart
@@ -400,11 +446,16 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                 planId: msg.planId,
                                 message: `Error: ${err instanceof Error ? err.message : 'Processing failed'}`,
                             }));
-                            // Clear stale planning state on error
-                            const currentState = getState();
-                            if (msg.planId && currentState.activePlans[msg.planId]?.status === 'planning') {
-                                mutate(`activePlans.${msg.planId}`, undefined);
-                                broadcastSinglePlan(msg.planId);
+                            // Restore plan state on error — only delete if it was a temporary entry
+                            if (msg.planId && getState().activePlans[msg.planId]?.status === 'planning') {
+                                if (planExistedBefore && previousStatus) {
+                                    mutate(`activePlans.${msg.planId}.status`, previousStatus);
+                                    broadcastSinglePlan(msg.planId);
+                                }
+                                else {
+                                    mutate(`activePlans.${msg.planId}`, undefined);
+                                    broadcastSinglePlan(msg.planId);
+                                }
                             }
                             ws.send(JSON.stringify({ type: 'gekto_done', planId: msg.planId }));
                             ws.send(JSON.stringify({ type: 'state', lizardId: 'master', state: 'ready' }));

package/dist/agents/gektoPersistent.js

@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import { randomUUID } from 'crypto';
 import { CLAUDE_PATH } from '../claudePath.js';
+import { BASH_SAFETY_RULES } from './bashSafetyRules.js';
 // === JSON Schema for structured output ===
 export const GEKTO_OUTPUT_SCHEMA = JSON.stringify({
     type: 'object',
@@ -36,7 +37,7 @@ How you act:
 - If the user's request is ambiguous, use "clarify" with a focused question in "message".
 - IMPORTANT: Before creating a new plan, ALWAYS check [CURRENT STATE] first. If an existing agent has context about the relevant files, use "delegate" instead. Only use "create_plan" when no existing agent can handle the request.
 - If the user wants to build something and no existing agent is relevant, use "create_plan" with a short "title" (2-4 words), an abstract plan description, and a short "message" (1-2 sentences) for the chat — this is a brief confirmation shown to the user, NOT a copy of the abstract.
-- If the user wants to modify an existing plan abstract, use "update_plan" with the updated abstract. You MUST also include a short "message" for the chat confirming what changed.
+- If the user wants to modify the active plan (marked [ACTIVE] in CURRENT STATE), use "update_plan" with the updated abstract. "update_plan" ALWAYS applies to the active plan. You MUST also include a short "message" for the chat confirming what changed.
 - If the user wants to remove agents, use "remove_agents" with a target.
 - If there is an existing agent that has context about the relevant files or task, use "delegate" with "agentId" (the agent's ID from CURRENT STATE) and "message" (a clear instruction). The agent already has session context — delegating is faster than creating a new plan. Always include a short "message" for the chat confirming what you delegated.
 - ALWAYS research the codebase first (Read, Glob, Grep) before creating plans. Understand the project structure, frameworks, and conventions.
@@ -44,6 +45,7 @@ How you act:
 Conflict awareness:
 - Before creating or updating a plan, check the [CURRENT STATE] context for running agents, active tasks, and files being modified.
 - If the user's request would modify files that are currently being worked on by other agents, WARN the user about the conflict. Use "clarify" to explain which files/tasks overlap and suggest waiting or adjusting scope.
+- The [ACTIVE] plan in CURRENT STATE is the one the user is currently viewing. When the user asks to change "the plan", they mean the active plan — use "update_plan".
 - If there is already an active plan with similar goals, point it out and ask whether to update the existing plan or start a new one.
 - Never schedule tasks that write to the same files as currently running agents — this causes merge conflicts and lost work.
 
@@ -61,7 +63,8 @@ Abstract plan rules for create_plan / update_plan:
 - Include a "buildPrompt" explaining how to wire everything together after individual tasks complete.
 - Work items should be parallelizable — no item should depend on another item's output.
 
-You can ONLY use Read, Glob, and Grep tools. Bash and Task are disabled.
+You can use Read, Glob, Grep, and Bash tools. Task is disabled.
+${BASH_SAFETY_RULES}
 
 Your response MUST be valid JSON matching this schema. Output ONLY the JSON object, nothing else.
 ${GEKTO_OUTPUT_SCHEMA}`;
@@ -130,7 +133,7 @@ function spawnOpus() {
         '--model', 'claude-opus-4-5-20251101',
         '--system-prompt', GEKTO_SYSTEM_PROMPT,
         '--dangerously-skip-permissions',
-        '--disallowed-tools', 'Bash', 'Task',
+        '--disallowed-tools', 'Task',
         '--session-id', gektoSessionId,
     ];
     console.log(`[GektoPersistent] Spawning with session ${gektoSessionId}`);
@@ -315,13 +318,6 @@ async function sendToOpus(prompt, callbacks, retries = 3) {
             }
             return;
         }
-        // Timeout after 5 min for complex tasks
-        setTimeout(() => {
-            if (opusPendingResolve) {
-                opusPendingResolve('Task timed out. Please try breaking it into smaller steps.');
-                opusPendingResolve = null;
-            }
-        }, 300000);
     });
 }
 // === Planning API (reuses warm persistent process) ===

package/dist/agents/gektoTools.js

@@ -114,13 +114,15 @@ export async function processWithTools(prompt, planId, _workingDir, activeAgents
         });
         contextParts.push(`Active agents:\n${agentLines.join('\n')}`);
     }
-    // Active plans and their tasks
+    // Active plans and their tasks — mark which one is the active plan
     const planEntries = Object.values(serverState.activePlans);
     if (planEntries.length > 0) {
+        const activePlanId = serverState.activePlanId;
         const planLines = planEntries.map(plan => {
+            const isActive = plan.id === activePlanId;
             const tasks = plan.taskIds.map(id => serverState.tasks[id]).filter(Boolean);
             const taskSummary = tasks.map(t => `    - "${t.name}" (${t.status})${t.files?.length ? ` files=[${t.files.join(', ')}]` : ''}`).join('\n');
-            return `  Plan "${plan.title || plan.id}" (${plan.status}):\n${taskSummary || '    (no tasks yet)'}`;
+            return `  ${isActive ? '[ACTIVE] ' : ''}Plan "${plan.title || plan.id}" (${plan.status}):\n${taskSummary || '    (no tasks yet)'}`;
         });
         contextParts.push(`Active plans:\n${planLines.join('\n')}`);
     }
@@ -139,12 +141,15 @@ export async function processWithTools(prompt, planId, _workingDir, activeAgents
         contextPrompt += `\n\n[CURRENT STATE:\n${contextParts.join('\n\n')}]`;
     }
     // Add existing plan context for modifications
-    if (existingPlan?.abstract) {
-        contextPrompt += `\n\n[EXISTING PLAN ABSTRACT - User wants to modify this plan:
+    // Use server-side activePlanId as the authoritative source
+    const activePlan = serverState.activePlanId ? serverState.activePlans[serverState.activePlanId] : null;
+    const planAbstract = existingPlan?.abstract || activePlan?.abstract;
+    if (planAbstract) {
+        contextPrompt += `\n\n[ACTIVE PLAN ABSTRACT — "${activePlan?.title || 'Untitled'}" (${activePlan?.status || 'unknown'}):
 
-${existingPlan.abstract}
+${planAbstract}
 
-The user's message above is a modification request. Respond with "update_plan" and the FULL updated abstract (not just the changes). Keep the same structure and style.]`;
+If the user wants to change this plan, respond with "update_plan" and the FULL updated abstract (not just the changes). Keep the same structure and style.]`;
     }
     // Append image file paths to prompt so Gekto can reference them
     if (imagePaths && imagePaths.length > 0) {
@@ -168,16 +173,22 @@ The user's message above is a modification request. Respond with "update_plan" a
     switch (parsed.action) {
         case 'create_plan':
         case 'update_plan': {
+            // For update_plan, always target the server's active plan
+            const effectivePlanId = parsed.action === 'update_plan' && serverState.activePlanId
+                ? serverState.activePlanId
+                : planId;
+            // Preserve createdAt when updating an existing plan
+            const existingCreatedAt = serverState.activePlans[effectivePlanId]?.createdAt;
             // Create a draft plan with abstract — tasks are generated later
             const plan = {
-                id: planId,
+                id: effectivePlanId,
                 status: 'draft',
                 title: parsed.title,
                 originalPrompt: prompt,
                 abstract: parsed.abstract || parsed.message || '',
                 buildPrompt: parsed.buildPrompt,
                 taskIds: [],
-                createdAt: new Date().toISOString(),
+                createdAt: existingCreatedAt || new Date().toISOString(),
             };
             return {
                 type: 'build',

package/dist/entityStore.js

@@ -221,6 +221,7 @@ export function loadFromEntityStore(workingDir) {
         }
         const state = {
             activePlans,
+            activePlanId: null,
             tasks: activeTasks,
             agents: activeAgents,
             visuals: visuals || {},

package/dist/state.js

@@ -16,6 +16,7 @@ function createMasterId() {
 function createEmptyState() {
     return {
         activePlans: {},
+        activePlanId: null,
         tasks: {},
         agents: {},
         visuals: {},
@@ -136,6 +137,10 @@ export function broadcast(action) {
 export function broadcastActivePlans() {
     broadcast({ type: 'active_plans_set', activePlans: state.activePlans });
 }
+/** Broadcast active plan ID to all clients. */
+export function broadcastActivePlanId() {
+    broadcast({ type: 'active_plan_id_set', activePlanId: state.activePlanId });
+}
 /** Broadcast a single plan (or deletion) to all clients. */
 export function broadcastSinglePlan(planId) {
     broadcast({ type: 'plan_set', planId, plan: state.activePlans[planId] ?? null });
@@ -190,6 +195,9 @@ export function broadcastForPath(dotPath) {
     const parts = dotPath.split('.');
     const root = parts[0];
     switch (root) {
+        case 'activePlanId':
+            broadcastActivePlanId();
+            break;
         case 'activePlans':
             if (parts[1]) {
                 broadcastSinglePlan(parts[1]);