@goodandready/dsh-goal 0.1.10 → 0.2.0

package/lib/index.js

@@ -43,6 +43,8 @@ export const Config = z.object({
   autoDrive: z.boolean().default(true).description('Automatically continue the loop after each turn'),
   enableSound: z.boolean().default(true).description('Play synthesized audio chime on goal completion or failure'),
   showQuickLaunchButton: z.boolean().default(true).description('Show quick launch goal button above composer dock'),
+  consecutiveToolFailureLimit: z.number().default(3).description('Auto-pause goal if N consecutive turns encounter tool execution errors (0 to disable)'),
+  enableBrowserNotifications: z.boolean().default(true).description('Show desktop notifications on goal completion or failure'),
   storagePath: z.string().default('').description('Custom filesystem path for persistent state storage'),
 });
 
@@ -61,6 +63,8 @@ export function apply(ctx, config = {}) {
     autoDrive: config?.autoDrive ?? true,
     enableSound: config?.enableSound ?? true,
     showQuickLaunchButton: config?.showQuickLaunchButton ?? true,
+    consecutiveToolFailureLimit: config?.consecutiveToolFailureLimit ?? 3,
+    enableBrowserNotifications: config?.enableBrowserNotifications ?? true,
     storagePath: config?.storagePath,
   };
 
@@ -74,6 +78,7 @@ export function apply(ctx, config = {}) {
     autoDrive: currentSettings.autoDrive,
     enableSound: currentSettings.enableSound,
     showQuickLaunchButton: currentSettings.showQuickLaunchButton,
+    consecutiveToolFailureLimit: currentSettings.consecutiveToolFailureLimit,
     storagePath,
   });
 
@@ -222,6 +227,8 @@ export function apply(ctx, config = {}) {
               autoDrive: typeof live.autoDrive === 'boolean' ? live.autoDrive : currentSettings.autoDrive,
               enableSound: typeof live.enableSound === 'boolean' ? live.enableSound : currentSettings.enableSound,
               showQuickLaunchButton: typeof live.showQuickLaunchButton === 'boolean' ? live.showQuickLaunchButton : currentSettings.showQuickLaunchButton,
+              consecutiveToolFailureLimit: typeof live.consecutiveToolFailureLimit === 'number' ? live.consecutiveToolFailureLimit : currentSettings.consecutiveToolFailureLimit,
+              enableBrowserNotifications: typeof live.enableBrowserNotifications === 'boolean' ? live.enableBrowserNotifications : currentSettings.enableBrowserNotifications,
               storagePath: typeof live.storagePath === 'string' ? live.storagePath : currentSettings.storagePath,
             };
           }
@@ -249,6 +256,7 @@ export function apply(ctx, config = {}) {
       autoDrive: live.autoDrive,
       enableSound: live.enableSound,
       showQuickLaunchButton: live.showQuickLaunchButton,
+      consecutiveToolFailureLimit: live.consecutiveToolFailureLimit,
     });
   };
 
@@ -305,322 +313,322 @@ export function apply(ctx, config = {}) {
     }
   });
 
-  // 3. Инжекция контекста цели в системный промпт (systemPrompt)
-  ctx.inject(['systemPrompt'], (pctx) => {
-    try {
-      if (typeof pctx.systemPrompt?.section === 'function') {
-        // Clear conflicting core tool:goal prompt section if present
-        const globalSections = pctx.systemPrompt.layers?.global?.sections;
-        if (globalSections?.data instanceof Map && globalSections.data.has('tool:goal')) {
-          globalSections.data.delete('tool:goal');
-        }
-
-        const order = typeof pctx.systemPrompt.getSectionOrder === 'function'
-          ? (pctx.systemPrompt.getSectionOrder('TOOL_GOAL') || 2400)
-          : 2400;
-
-        const unregisterSection = pctx.systemPrompt.section({
-          name: 'tool:dsh-goal',
-          order,
-          text: (sessionCtx) => {
-            const sid = sessionIdOf(sessionCtx, 'default');
-            return engine.getStatePromptInjection(sid);
-          },
-        });
-
-        if (typeof unregisterSection === 'function') {
-          pctx.effect(() => () => unregisterSection(), 'dsh-goal: system prompt section');
-        }
-      }
-    } catch (err) {
-      console.warn('[dsh-goal] SystemPrompt section register skipped:', err.message);
-    }
-  });
-
-  // 4. Регистрация инструментов для модели (tools)
-  ctx.inject(['tools'], (tctx) => {
-    if (!tctx.tools?.register) return;
-
-    // Helper: Safely replace or register tool in ToolRuntime
-    const safeRegister = (definition) => {
-      try {
-        const name = definition.name;
-        const globalTools = tctx.tools.layers?.global?.tools;
-        if (globalTools?.data instanceof Map && globalTools.data.has(name)) {
-          globalTools.data.delete(name);
-        }
-        const unregister = tctx.tools.register(definition);
-        if (typeof unregister === 'function') {
-          tctx.effect(() => () => unregister(), `dsh-goal: tool ${name}`);
-        }
-      } catch (err) {
-        console.warn(`[dsh-goal] Tool ${definition.name} registration skipped:`, err.message);
-      }
-    };
-
-    const JSON_OUTPUT = {
-      schema: { type: 'object', additionalProperties: true },
-      render: (_args, val) => [{ type: 'text', text: JSON.stringify(val) }],
-    };
-
-    function formatGoalValue(snap) {
-      if (!snap || !snap.hasActiveGoal) {
-        return { goal: null };
-      }
-      let phase = 'active';
-      if (snap.state === GoalState.PAUSED) phase = 'paused';
-      else if (snap.state === GoalState.COMPLETED) phase = 'complete';
-
-      const roundsStarted = Number.isInteger(snap.iterations) ? snap.iterations : 0;
-      const maxGoalRounds = Number.isInteger(snap.maxIterations) ? snap.maxIterations : 25;
-
-      return {
-        goal: {
-          id: snap.id || 'goal-active',
-          revision: 1,
-          objective: snap.title || 'Goal',
-          phase,
-          roundsStarted,
-          maxGoalRounds,
-        },
-        activation: snap.state === GoalState.RUNNING ? 'armed' : 'disarmed',
-      };
-    }
-
-    // Совместимый инструмент 1: get_goal
-    const handleGetGoal = async (_args, toolCtx) => {
-      const sid = sessionIdOf(toolCtx, 'default');
-      const snap = engine.getSnapshot(sid);
-      return formatGoalValue(snap);
-    };
-
-    safeRegister({
-      name: 'get_goal',
-      description: 'Read the current same-session goal, including objective, phase, and round limits.',
-      parameters: { type: 'object', properties: {} },
-      output: JSON_OUTPUT,
-      execute: handleGetGoal,
-      handler: handleGetGoal,
-    });
-
-    // Совместимый инструмент 2: create_goal
-    const handleCreateGoal = async (args, toolCtx) => {
-      const sid = sessionIdOf(toolCtx, 'default');
-      const maxIterations = Number(args.max_goal_rounds) || 25;
-      const snap = engine.startGoal(args.objective, { maxIterations }, sid);
-      return formatGoalValue(snap);
-    };
-
-    safeRegister({
-      name: 'create_goal',
-      description: 'Create one persisted same-session completion goal for long-running autonomous work.',
-      parameters: {
-        type: 'object',
-        properties: {
-          objective: {
-            type: 'string',
-            description: 'The concrete completion objective.',
-          },
-          max_goal_rounds: {
-            type: 'number',
-            description: 'Optional positive integer limit on automatic continuation rounds.',
-          },
-        },
-        required: ['objective'],
-      },
-      output: JSON_OUTPUT,
-      execute: handleCreateGoal,
-      handler: handleCreateGoal,
-    });
-
-    // Совместимый инструмент 3: update_goal (перехватчик authority checks и роутер в GoalEngine)
-    const handleUpdateGoal = async (args, toolCtx) => {
-      const sid = sessionIdOf(toolCtx, 'default');
-      const action = args.action;
-
-      if (action === 'complete') {
-        const summary = args.blocked_reason || args.objective || 'Goal marked complete';
-        const snap = engine.completeGoal(summary, sid);
-        if (toolCtx?.deferContext) {
-          try {
-            toolCtx.deferContext({
-              type: 'text',
-              text: `<goal_complete>\nObjective: ${JSON.stringify(snap.title || summary)}\nThe goal is marked complete. Summarize what was accomplished for the user.\n</goal_complete>`,
-            });
-          } catch (_) {}
-        }
-        return formatGoalValue(snap);
-      }
-
-      if (action === 'pause') {
-        const reason = args.blocked_reason || 'Paused by model';
-        const snap = engine.pause(reason, sid);
-        return formatGoalValue(snap);
-      }
-
-      if (action === 'resume') {
-        const snap = engine.resume(sid);
-        resumeActiveAgent(undefined, sid);
-        return formatGoalValue(snap);
-      }
-
-      if (action === 'edit') {
-        const snap = engine.getSnapshot(sid);
-        if (args.objective) snap.title = args.objective;
-        if (args.max_goal_rounds) snap.maxIterations = Number(args.max_goal_rounds);
-        engine.emit(sid, true);
-        return formatGoalValue(snap);
-      }
-
-      if (action === 'blocked') {
-        const reason = args.blocked_reason || 'Goal blocked';
-        const snap = engine.pause('Blocked: ' + reason, sid);
-        if (toolCtx?.deferContext) {
-          try {
-            toolCtx.deferContext({
-              type: 'text',
-              text: `<goal_blocked>\nObjective: ${JSON.stringify(snap.title || 'Goal')}\nBlocked: ${JSON.stringify(reason)}\nExplain to the user what blocked progress.\n</goal_blocked>`,
-            });
-          } catch (_) {}
-        }
-        const res = formatGoalValue(snap);
-        if (res.goal) {
-          res.goal.phase = 'blocked';
-          res.goal.blockedReason = { code: 'model-reported', message: reason };
-        }
-        return res;
-      }
-
-      return formatGoalValue(engine.getSnapshot(sid));
-    };
-
-    safeRegister({
-      name: 'update_goal',
-      description: 'Update the active goal: complete, pause, resume, edit, or report blocked.',
-      parameters: {
-        type: 'object',
-        properties: {
-          goal_id: { type: 'string', description: 'Exact id returned by get_goal.' },
-          revision: { type: 'number', description: 'Exact positive revision returned by get_goal.' },
-          action: {
-            type: 'string',
-            enum: ['edit', 'pause', 'resume', 'complete', 'blocked'],
-            description: 'edit | pause | resume | complete | blocked',
-          },
-          objective: { type: 'string', description: 'Replacement objective; valid with action edit.' },
-          max_goal_rounds: { type: 'number', description: 'Replacement cap; valid with action edit.' },
-          blocked_reason: { type: 'string', description: 'Concrete blocking condition; required with action blocked.' },
-        },
-        required: ['action'],
-      },
-      output: JSON_OUTPUT,
-      execute: handleUpdateGoal,
-      handler: handleUpdateGoal,
-    });
-
-    // Инструмент 4: Декомпозиция цели на вехи
-    const handleSetMilestones = async ({ milestones }, toolCtx) => {
-      const sid = sessionIdOf(toolCtx, 'default');
-      const snap = engine.getSnapshot(sid);
-      if (!snap.hasActiveGoal) {
-        return { error: 'No active goal currently set. Start a goal first.' };
-      }
-      engine.addMilestones(milestones, true, sid);
-      return {
-        success: true,
-        milestones: engine.getSnapshot(sid).milestones,
-      };
-    };
-
-    safeRegister({
-      name: 'goal_set_milestones',
-      description: 'Break down the current active goal into a sequence of concrete milestones/sub-tasks.',
-      parameters: {
-        type: 'object',
-        properties: {
-          milestones: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'List of milestone titles to accomplish.',
-          },
-        },
-        required: ['milestones'],
-      },
-      output: JSON_OUTPUT,
-      execute: handleSetMilestones,
-      handler: handleSetMilestones,
-    });
-
-    // Инструмент 5: Обновление статуса вехи
-    const handleUpdateProgress = async ({ milestone_id, status, notes }, toolCtx) => {
-      const sid = sessionIdOf(toolCtx, 'default');
-      const ok = engine.updateMilestone(milestone_id, status, notes, sid);
-      if (!ok) {
-        return { error: `Milestone ${milestone_id} not found or no active goal.` };
-      }
-      return {
-        success: true,
-        snapshot: engine.getSnapshot(sid),
-      };
-    };
-
-    safeRegister({
-      name: 'goal_update_progress',
-      description: 'Update the status of a specific goal milestone and optionally log progress notes.',
-      parameters: {
-        type: 'object',
-        properties: {
-          milestone_id: {
-            type: 'string',
-            description: 'The ID of the milestone (e.g. "m-1", "m-2").',
-          },
-          status: {
-            type: 'string',
-            enum: ['pending', 'in_progress', 'completed', 'failed'],
-            description: 'New status for this milestone.',
-          },
-          notes: {
-            type: 'string',
-            description: 'Brief summary of what was accomplished or why it failed.',
-          },
-        },
-        required: ['milestone_id', 'status'],
-      },
-      output: JSON_OUTPUT,
-      execute: handleUpdateProgress,
-      handler: handleUpdateProgress,
-    });
-
-    // Инструмент 6: Успешное завершение цели
-    const handleGoalFinish = async ({ summary }, toolCtx) => {
-      const sid = sessionIdOf(toolCtx, 'default');
-      const snap = engine.completeGoal(summary, sid);
-      return {
-        success: true,
-        completed: true,
-        summary,
-      };
-    };
-
-    safeRegister({
-      name: 'goal_finish',
-      description: 'Conclude the active goal successfully with a final summary and achievements.',
-      parameters: {
-        type: 'object',
-        properties: {
-          summary: {
-            type: 'string',
-            description: 'Final summary of the goal outcome and deliverables.',
-          },
-        },
-        required: ['summary'],
-      },
-      output: JSON_OUTPUT,
-      execute: handleGoalFinish,
-      handler: handleGoalFinish,
-    });
-  });
-
+  // 3. Инжекция контекста цели в системный промпт (systemPrompt)
+  ctx.inject(['systemPrompt'], (pctx) => {
+    try {
+      if (typeof pctx.systemPrompt?.section === 'function') {
+        // Clear conflicting core tool:goal prompt section if present
+        const globalSections = pctx.systemPrompt.layers?.global?.sections;
+        if (globalSections?.data instanceof Map && globalSections.data.has('tool:goal')) {
+          globalSections.data.delete('tool:goal');
+        }
+
+        const order = typeof pctx.systemPrompt.getSectionOrder === 'function'
+          ? (pctx.systemPrompt.getSectionOrder('TOOL_GOAL') || 2400)
+          : 2400;
+
+        const unregisterSection = pctx.systemPrompt.section({
+          name: 'tool:dsh-goal',
+          order,
+          text: (sessionCtx) => {
+            const sid = sessionIdOf(sessionCtx, 'default');
+            return engine.getStatePromptInjection(sid);
+          },
+        });
+
+        if (typeof unregisterSection === 'function') {
+          pctx.effect(() => () => unregisterSection(), 'dsh-goal: system prompt section');
+        }
+      }
+    } catch (err) {
+      console.warn('[dsh-goal] SystemPrompt section register skipped:', err.message);
+    }
+  });
+
+  // 4. Регистрация инструментов для модели (tools)
+  ctx.inject(['tools'], (tctx) => {
+    if (!tctx.tools?.register) return;
+
+    // Helper: Safely replace or register tool in ToolRuntime
+    const safeRegister = (definition) => {
+      try {
+        const name = definition.name;
+        const globalTools = tctx.tools.layers?.global?.tools;
+        if (globalTools?.data instanceof Map && globalTools.data.has(name)) {
+          globalTools.data.delete(name);
+        }
+        const unregister = tctx.tools.register(definition);
+        if (typeof unregister === 'function') {
+          tctx.effect(() => () => unregister(), `dsh-goal: tool ${name}`);
+        }
+      } catch (err) {
+        console.warn(`[dsh-goal] Tool ${definition.name} registration skipped:`, err.message);
+      }
+    };
+
+    const JSON_OUTPUT = {
+      schema: { type: 'object', additionalProperties: true },
+      render: (_args, val) => [{ type: 'text', text: JSON.stringify(val) }],
+    };
+
+    function formatGoalValue(snap) {
+      if (!snap || !snap.hasActiveGoal) {
+        return { goal: null };
+      }
+      let phase = 'active';
+      if (snap.state === GoalState.PAUSED) phase = 'paused';
+      else if (snap.state === GoalState.COMPLETED) phase = 'complete';
+
+      const roundsStarted = Number.isInteger(snap.iterations) ? snap.iterations : 0;
+      const maxGoalRounds = Number.isInteger(snap.maxIterations) ? snap.maxIterations : 25;
+
+      return {
+        goal: {
+          id: snap.id || 'goal-active',
+          revision: 1,
+          objective: snap.title || 'Goal',
+          phase,
+          roundsStarted,
+          maxGoalRounds,
+        },
+        activation: snap.state === GoalState.RUNNING ? 'armed' : 'disarmed',
+      };
+    }
+
+    // Совместимый инструмент 1: get_goal
+    const handleGetGoal = async (_args, toolCtx) => {
+      const sid = sessionIdOf(toolCtx, 'default');
+      const snap = engine.getSnapshot(sid);
+      return formatGoalValue(snap);
+    };
+
+    safeRegister({
+      name: 'get_goal',
+      description: 'Read the current same-session goal, including objective, phase, and round limits.',
+      parameters: { type: 'object', properties: {} },
+      output: JSON_OUTPUT,
+      execute: handleGetGoal,
+      handler: handleGetGoal,
+    });
+
+    // Совместимый инструмент 2: create_goal
+    const handleCreateGoal = async (args, toolCtx) => {
+      const sid = sessionIdOf(toolCtx, 'default');
+      const maxIterations = Number(args.max_goal_rounds) || 25;
+      const snap = engine.startGoal(args.objective, { maxIterations }, sid);
+      return formatGoalValue(snap);
+    };
+
+    safeRegister({
+      name: 'create_goal',
+      description: 'Create one persisted same-session completion goal for long-running autonomous work.',
+      parameters: {
+        type: 'object',
+        properties: {
+          objective: {
+            type: 'string',
+            description: 'The concrete completion objective.',
+          },
+          max_goal_rounds: {
+            type: 'number',
+            description: 'Optional positive integer limit on automatic continuation rounds.',
+          },
+        },
+        required: ['objective'],
+      },
+      output: JSON_OUTPUT,
+      execute: handleCreateGoal,
+      handler: handleCreateGoal,
+    });
+
+    // Совместимый инструмент 3: update_goal (перехватчик authority checks и роутер в GoalEngine)
+    const handleUpdateGoal = async (args, toolCtx) => {
+      const sid = sessionIdOf(toolCtx, 'default');
+      const action = args.action;
+
+      if (action === 'complete') {
+        const summary = args.blocked_reason || args.objective || 'Goal marked complete';
+        const snap = engine.completeGoal(summary, sid);
+        if (toolCtx?.deferContext) {
+          try {
+            toolCtx.deferContext({
+              type: 'text',
+              text: `<goal_complete>\nObjective: ${JSON.stringify(snap.title || summary)}\nThe goal is marked complete. Summarize what was accomplished for the user.\n</goal_complete>`,
+            });
+          } catch (_) {}
+        }
+        return formatGoalValue(snap);
+      }
+
+      if (action === 'pause') {
+        const reason = args.blocked_reason || 'Paused by model';
+        const snap = engine.pause(reason, sid);
+        return formatGoalValue(snap);
+      }
+
+      if (action === 'resume') {
+        const snap = engine.resume(sid);
+        resumeActiveAgent(undefined, sid);
+        return formatGoalValue(snap);
+      }
+
+      if (action === 'edit') {
+        const snap = engine.getSnapshot(sid);
+        if (args.objective) snap.title = args.objective;
+        if (args.max_goal_rounds) snap.maxIterations = Number(args.max_goal_rounds);
+        engine.emit(sid, true);
+        return formatGoalValue(snap);
+      }
+
+      if (action === 'blocked') {
+        const reason = args.blocked_reason || 'Goal blocked';
+        const snap = engine.pause('Blocked: ' + reason, sid);
+        if (toolCtx?.deferContext) {
+          try {
+            toolCtx.deferContext({
+              type: 'text',
+              text: `<goal_blocked>\nObjective: ${JSON.stringify(snap.title || 'Goal')}\nBlocked: ${JSON.stringify(reason)}\nExplain to the user what blocked progress.\n</goal_blocked>`,
+            });
+          } catch (_) {}
+        }
+        const res = formatGoalValue(snap);
+        if (res.goal) {
+          res.goal.phase = 'blocked';
+          res.goal.blockedReason = { code: 'model-reported', message: reason };
+        }
+        return res;
+      }
+
+      return formatGoalValue(engine.getSnapshot(sid));
+    };
+
+    safeRegister({
+      name: 'update_goal',
+      description: 'Update the active goal: complete, pause, resume, edit, or report blocked.',
+      parameters: {
+        type: 'object',
+        properties: {
+          goal_id: { type: 'string', description: 'Exact id returned by get_goal.' },
+          revision: { type: 'number', description: 'Exact positive revision returned by get_goal.' },
+          action: {
+            type: 'string',
+            enum: ['edit', 'pause', 'resume', 'complete', 'blocked'],
+            description: 'edit | pause | resume | complete | blocked',
+          },
+          objective: { type: 'string', description: 'Replacement objective; valid with action edit.' },
+          max_goal_rounds: { type: 'number', description: 'Replacement cap; valid with action edit.' },
+          blocked_reason: { type: 'string', description: 'Concrete blocking condition; required with action blocked.' },
+        },
+        required: ['action'],
+      },
+      output: JSON_OUTPUT,
+      execute: handleUpdateGoal,
+      handler: handleUpdateGoal,
+    });
+
+    // Инструмент 4: Декомпозиция цели на вехи
+    const handleSetMilestones = async ({ milestones }, toolCtx) => {
+      const sid = sessionIdOf(toolCtx, 'default');
+      const snap = engine.getSnapshot(sid);
+      if (!snap.hasActiveGoal) {
+        return { error: 'No active goal currently set. Start a goal first.' };
+      }
+      engine.addMilestones(milestones, true, sid);
+      return {
+        success: true,
+        milestones: engine.getSnapshot(sid).milestones,
+      };
+    };
+
+    safeRegister({
+      name: 'goal_set_milestones',
+      description: 'Break down the current active goal into a sequence of concrete milestones/sub-tasks.',
+      parameters: {
+        type: 'object',
+        properties: {
+          milestones: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'List of milestone titles to accomplish.',
+          },
+        },
+        required: ['milestones'],
+      },
+      output: JSON_OUTPUT,
+      execute: handleSetMilestones,
+      handler: handleSetMilestones,
+    });
+
+    // Инструмент 5: Обновление статуса вехи
+    const handleUpdateProgress = async ({ milestone_id, status, notes }, toolCtx) => {
+      const sid = sessionIdOf(toolCtx, 'default');
+      const ok = engine.updateMilestone(milestone_id, status, notes, sid);
+      if (!ok) {
+        return { error: `Milestone ${milestone_id} not found or no active goal.` };
+      }
+      return {
+        success: true,
+        snapshot: engine.getSnapshot(sid),
+      };
+    };
+
+    safeRegister({
+      name: 'goal_update_progress',
+      description: 'Update the status of a specific goal milestone and optionally log progress notes.',
+      parameters: {
+        type: 'object',
+        properties: {
+          milestone_id: {
+            type: 'string',
+            description: 'The ID of the milestone (e.g. "m-1", "m-2").',
+          },
+          status: {
+            type: 'string',
+            enum: ['pending', 'in_progress', 'completed', 'failed'],
+            description: 'New status for this milestone.',
+          },
+          notes: {
+            type: 'string',
+            description: 'Brief summary of what was accomplished or why it failed.',
+          },
+        },
+        required: ['milestone_id', 'status'],
+      },
+      output: JSON_OUTPUT,
+      execute: handleUpdateProgress,
+      handler: handleUpdateProgress,
+    });
+
+    // Инструмент 6: Успешное завершение цели
+    const handleGoalFinish = async ({ summary }, toolCtx) => {
+      const sid = sessionIdOf(toolCtx, 'default');
+      const snap = engine.completeGoal(summary, sid);
+      return {
+        success: true,
+        completed: true,
+        summary,
+      };
+    };
+
+    safeRegister({
+      name: 'goal_finish',
+      description: 'Conclude the active goal successfully with a final summary and achievements.',
+      parameters: {
+        type: 'object',
+        properties: {
+          summary: {
+            type: 'string',
+            description: 'Final summary of the goal outcome and deliverables.',
+          },
+        },
+        required: ['summary'],
+      },
+      output: JSON_OUTPUT,
+      execute: handleGoalFinish,
+      handler: handleGoalFinish,
+    });
+  });
+
   // 5. Регистрация HTTP REST API маршрутов и SSE событий
   ctx.effect(() => {
     if (!ctx.webServer?.register) return () => {};
@@ -748,6 +756,20 @@ export function apply(ctx, config = {}) {
                   resumeActiveAgent(startPrompt, sid);
                   break;
                 }
+                case 'nudge': {
+                  const text = (typeof data.text === 'string' ? data.text : (data.notes || data.nudge || '')).trim();
+                  if (!text) {
+                    res.statusCode = 400;
+                    return res.end(JSON.stringify({ error: 'Nudge text cannot be empty' }));
+                  }
+                  result = engine.nudge(text, sid);
+                  if (data.resume) {
+                    engine.resume(sid);
+                    const prompt = engine.getStatePromptInjection(sid);
+                    resumeActiveAgent(prompt, sid);
+                  }
+                  break;
+                }
                 case 'pause':
                   result = engine.pause(reason || 'Пауза по кнопке интерфейса', sid);
                   stopRunningAgents(sid);
@@ -834,6 +856,29 @@ export function apply(ctx, config = {}) {
 
       const snap = engine.getSnapshot(sid);
       if (snap.hasActiveGoal && snap.state === GoalState.RUNNING) {
+        // Tool-Failure Breaker: отслеживание повторяющихся ошибок инструментов
+        const steps = turn?.steps || turn?.turn?.steps || [];
+        const hasStepError = Array.isArray(steps) && steps.some((s) => {
+          return s?.status === 'error' || s?.error || s?.toolResult?.isError;
+        });
+        const hasTurnError = Boolean(turn?.error || turn?.reason?.kind === 'error');
+        const isToolFailure = hasStepError || hasTurnError;
+
+        if (isToolFailure) {
+          const failCount = engine.incrementToolFailureCount(sid);
+          const limit = liveConfig.consecutiveToolFailureLimit;
+          if (limit > 0 && failCount >= limit) {
+            const lang = snap.lang || (snap.title ? detectLanguage(snap.title) : 'en');
+            const pauseReason = lang === 'ru'
+              ? `Повторяющаяся ошибка инструментов (${failCount} подряд) — цель приостановлена для защиты от зацикливания`
+              : `Repeated tool failure (${failCount} consecutive) — goal paused to prevent token burn`;
+            engine.pause(pauseReason, sid);
+            return;
+          }
+        } else {
+          engine.resetToolFailureCount(sid);
+        }
+
         // Проверяем причину завершения хода
         if (turn?.reason?.kind === 'aborted' || turn?.reason?.kind === 'error' || turn?.error) {
           return;
@@ -858,9 +903,18 @@ export function apply(ctx, config = {}) {
           const currentSnap = engine.getSnapshot(sid);
           if (currentSnap.hasActiveGoal && currentSnap.state === GoalState.RUNNING) {
             const currentLang = currentSnap.lang || (currentSnap.title ? detectLanguage(currentSnap.title) : 'en');
-            const promptText = currentLang === 'ru'
+            let promptText = currentLang === 'ru'
               ? 'Продолжай автономное выполнение цели согласно плану работ. Отмечай каждый выполненный шаг через goal_update_progress, а по завершении всех задач вызови goal_finish.'
               : 'Continue autonomous goal execution according to the work plan. Mark each completed step via goal_update_progress, and when all tasks are complete, call goal_finish.';
+
+            if (currentSnap.pendingNudge) {
+              const userNudge = engine.consumePendingNudge(sid);
+              if (userNudge) {
+                promptText = (currentLang === 'ru'
+                  ? `🚨 СРОЧНОЕ УТОЧНЕНИЕ / НАПРАВЛЕНИЕ ОТ ПОЛЬЗОВАТЕЛЯ:\n"${userNudge}"\nСкорректируй выполнение с учётом этого замечания.\n\n`
+                  : `🚨 URGENT USER CLARIFICATION / STEERING:\n"${userNudge}"\nAdjust execution adhering to this feedback.\n\n`) + promptText;
+              }
+            }
             const promptMsg = createGoalUserMessage(promptText);
             let target = sessionAgents.get(sid);
             if (!target && lastActiveAgent && typeof lastActiveAgent.followup === 'function') {