@visorcraft/idlehands 1.3.2 → 1.3.4

package/README.md

@@ -25,10 +25,12 @@ Idle Hands is built for people who want an agent that can actually ship work, no
 
 Trifecta is the integrated core of Idle Hands:
 
-- **Vault** → persistent memory + notes (`/vault`, `/note`, `/notes`)
+- **Vault** → persistent memory + notes (`/vault`, `/note`, `/notes`) + automatic turn action summaries
 - **Replay** → file checkpoints and rewind/diff (`/checkpoints`, `/rewind`, `/diff`, `/undo`)
 - **Lens** → structural compression/indexing for better context usage
 
+Every tool-using turn is automatically summarized and persisted to the Vault, so the model can recall what it did — even after context compaction drops earlier messages. This is especially useful for local models with limited context windows.
+
 Runtime controls:
 
 ```bash
@@ -222,6 +224,31 @@ idlehands health --scan-ports 8000-8100
 idlehands health --scan-ports 8080,8081,9000
 ```
 
+## Tool loop auto-continue
+
+When the agent hits a critical tool loop (repeated identical tool calls with no progress), Idle Hands now automatically retries instead of stopping and waiting for a manual "Continue" message.
+
+- **All surfaces**: TUI, Telegram bot, Discord bot, and Anton all support auto-continue
+- **User notification**: each retry sends a visible notice with error details and attempt count
+- **Configurable**: up to 5 retries by default (max 10), fully disableable
+
+```json
+{
+  "tool_loop_auto_continue": {
+    "enabled": true,
+    "max_retries": 5
+  }
+}
+```
+
+On each retry the user sees:
+> ⚠️ Tool loop detected: {error details}
+> 🔄 Automatically continuing the task. (retry 1 of 5)
+
+After exhausting all retries, the error surfaces normally. Anton handles this internally without orchestrator involvement.
+
+---
+
 ## Documentation map
 
 - [Getting Started](https://visorcraft.github.io/IdleHands/guide/getting-started)

package/dist/agent.js

@@ -1879,6 +1879,26 @@ export async function createSession(opts) {
         };
         const finalizeAsk = async (text) => {
             const finalText = ensureInformativeAssistantText(text, { toolCalls, turns });
+            // Auto-persist turn action summary to Vault so the model can recall what it did.
+            if (vault && toolCalls > 0) {
+                try {
+                    const actions = [];
+                    for (const [callId, name] of toolNameByCallId) {
+                        const args = toolArgsByCallId.get(callId) ?? {};
+                        actions.push(planModeSummary(name, args));
+                    }
+                    if (actions.length) {
+                        const userPromptSnippet = rawInstructionText.length > 120
+                            ? rawInstructionText.slice(0, 120) + '…'
+                            : rawInstructionText;
+                        const summary = `User asked: ${userPromptSnippet}\nActions (${actions.length} tool calls, ${turns} turns):\n${actions.map(a => `- ${a}`).join('\n')}\nResult: ${finalText.length > 200 ? finalText.slice(0, 200) + '…' : finalText}`;
+                        await vault.upsertNote(`turn_summary_${askId}`, summary, 'system');
+                    }
+                }
+                catch {
+                    // best-effort — never block ask completion for summary persistence
+                }
+            }
             await hookManager.emit('ask_end', { askId, text: finalText, turns, toolCalls });
             return { text: finalText, turns, toolCalls };
         };
@@ -2192,6 +2212,7 @@ export async function createSession(opts) {
                         }
                     }
                     messages = compacted;
+                    let summaryUsed = false;
                     if (dropped.length) {
                         const droppedTokens = estimateTokensFromMessages(dropped);
                         if (cfg.compact_summary !== false && droppedTokens > 200) {
@@ -2210,6 +2231,7 @@ export async function createSession(opts) {
                                 });
                                 const summary = resp.choices?.[0]?.message?.content ?? '';
                                 if (summary.trim()) {
+                                    summaryUsed = true;
                                     messages.push({
                                         role: 'system',
                                         content: `[Compacted ${dropped.length} messages (~${droppedTokens} tokens). Progress summary:]\n${summary.trim()}\n[Continue from where you left off. Do not repeat completed work.]`,
@@ -2230,10 +2252,19 @@ export async function createSession(opts) {
                     // Update token count AFTER injections so downstream reads are accurate
                     currentContextTokens = estimateTokensFromMessages(messages);
                     const afterTokens = estimateTokensFromMessages(compacted);
+                    const freedTokens = Math.max(0, beforeTokens - afterTokens);
+                    // Emit compaction event for callers (e.g. Anton controller → Discord)
+                    if (dropped.length) {
+                        try {
+                            await hookObj.onCompaction?.({ droppedMessages: dropped.length, freedTokens, summaryUsed });
+                        }
+                        catch { /* best effort */ }
+                        console.error(`[compaction] auto: dropped=${dropped.length} msgs, freed=~${freedTokens} tokens, summary=${summaryUsed}, remaining=${messages.length} msgs (~${currentContextTokens} tokens)`);
+                    }
                     return {
                         beforeMessages: beforeMsgs.length,
                         afterMessages: compacted.length,
-                        freedTokens: Math.max(0, beforeTokens - afterTokens),
+                        freedTokens,
                         archivedToolMessages: dropped.filter((m) => m.role === 'tool').length,
                         droppedMessages: dropped.length,
                         dryRun: false,
@@ -2579,6 +2610,8 @@ export async function createSession(opts) {
                             const warningKey = `${warning.level}:${warning.detector}:${detected.signature}`;
                             if (!toolLoopWarningKeys.has(warningKey)) {
                                 toolLoopWarningKeys.add(warningKey);
+                                const argsSnippet = JSON.stringify(args).slice(0, 300);
+                                console.error(`[tool-loop] ${warning.level}: ${warning.toolName} (${warning.detector}, count=${warning.count}) args=${argsSnippet}`);
                                 await emitToolLoop({
                                     level: warning.level,
                                     detector: warning.detector,
@@ -2748,6 +2781,7 @@ export async function createSession(opts) {
                     lastTurnSigs = turnSigs;
                     if (shouldForceToollessRecovery) {
                         if (!toollessRecoveryUsed) {
+                            console.error(`[tool-loop] Disabling tools for one recovery turn (turn=${turns})`);
                             forceToollessRecoveryTurn = true;
                             toollessRecoveryUsed = true;
                             messages.push({
@@ -2768,6 +2802,7 @@ export async function createSession(opts) {
                             });
                             continue;
                         }
+                        console.error(`[tool-loop] Recovery failed — model resumed looping after tools-disabled turn (turn=${turns})`);
                         throw new AgentLoopBreak('critical tool-loop persisted after one tools-disabled recovery turn. Stopping to avoid infinite loop.');
                     }
                     const runOne = async (tc) => {