@visorcraft/idlehands 1.0.3 → 1.0.5

package/dist/agent.js

@@ -178,6 +178,19 @@ function formatDurationMs(ms) {
         return '0.0s';
     return `${(ms / 1000).toFixed(1)}s`;
 }
+function looksLikePlanningNarration(text, finishReason) {
+    const s = String(text ?? '').trim().toLowerCase();
+    if (!s)
+        return false;
+    // Incomplete streamed answer: likely still needs another turn.
+    if (finishReason === 'length')
+        return true;
+    // Strong completion cues: treat as final answer.
+    if (/(^|\n)\s*(done|completed|finished|final answer|summary:)\b/.test(s))
+        return false;
+    // Typical "thinking out loud"/plan chatter that should continue with tools.
+    return /\b(let me|i(?:'|’)ll|i will|i'm going to|i am going to|next i(?:'|’)ll|first i(?:'|’)ll|i need to|i should|checking|reviewing|exploring|starting by)\b/.test(s);
+}
 function approxTokenCharCap(maxTokens) {
     const safe = Math.max(64, Math.floor(maxTokens));
     return safe * 4;
@@ -829,7 +842,7 @@ export async function createSession(opts) {
     const harnessVaultMode = harness.defaults?.trifecta?.vaultMode || 'off';
     const vaultMode = (cfg.trifecta?.vault?.mode || harnessVaultMode);
     const vaultEnabled = cfg.trifecta?.enabled !== false && cfg.trifecta?.vault?.enabled !== false;
-    const activeVaultTools = vaultEnabled && vaultMode === 'active';
+    let activeVaultTools = vaultEnabled && vaultMode === 'active';
     const lensEnabled = cfg.trifecta?.enabled !== false && cfg.trifecta?.lens?.enabled !== false;
     const spawnTaskEnabled = opts.allowSpawnTask !== false && cfg.sub_agents?.enabled !== false;
     const mcpServers = Array.isArray(cfg.mcp?.servers) ? cfg.mcp.servers : [];
@@ -903,8 +916,18 @@ export async function createSession(opts) {
     }
     if (vaultEnabled && !opts.runtime?.vault) {
         await vault?.init().catch((e) => {
+            // If vault storage is unavailable (e.g., sandboxed FS / disk I/O),
+            // degrade gracefully by disabling active vault tools for this run.
+            activeVaultTools = false;
+            const msg = String(e?.message ?? e ?? 'unknown error');
+            const isDiskLike = /disk i\/o|sqlite|readonly|read-only|permission denied/i.test(msg);
             if (!process.env.IDLEHANDS_QUIET_WARNINGS) {
-                console.warn(`[warn] vault init failed: ${e?.message ?? e}`);
+                if (isDiskLike) {
+                    console.warn('[warn] vault disabled for this session (storage unavailable).');
+                }
+                else {
+                    console.warn(`[warn] vault init failed: ${msg}`);
+                }
             }
         });
     }
@@ -1094,6 +1117,12 @@ export async function createSession(opts) {
         if (!task) {
             throw new Error('spawn_task: missing task');
         }
+        // Prevent using delegation to bypass package-install confirmation restrictions.
+        const taskSafety = checkExecSafety(task);
+        if (!cfg.no_confirm && taskSafety.tier === 'cautious' && taskSafety.reason === 'package install/remove') {
+            throw new Error('spawn_task: blocked — package install/remove is restricted in the current approval mode. ' +
+                'Do not delegate this to bypass confirmation requirements; ask the user to run with --no-confirm/--yolo instead.');
+        }
         const defaults = cfg.sub_agents ?? {};
         const taskId = ++subTaskSeq;
         const emitStatus = options?.emitStatus ?? (() => { });
@@ -1732,6 +1761,12 @@ export async function createSession(opts) {
         const consecutiveCounts = new Map();
         let lastPassiveVaultQuery = '';
         let malformedCount = 0;
+        let noProgressTurns = 0;
+        const NO_PROGRESS_TURN_CAP = 3;
+        let noToolTurns = 0;
+        const NO_TOOL_REPROMPT_THRESHOLD = 2;
+        let repromptUsed = false;
+        let blockedPackageInstallAttempts = 0;
         const maybeInjectVaultContext = async () => {
             if (!vault || vaultMode !== 'passive')
                 return;
@@ -1948,7 +1983,19 @@ export async function createSession(opts) {
                     tgTokensPerSec: tgTps,
                     health: healthSnapshot,
                 };
-                const msg = resp.choices?.[0]?.message;
+                const legacyChoice = resp?.role
+                    ? {
+                        finish_reason: resp?.finish_reason ?? 'stop',
+                        message: {
+                            role: resp?.role ?? 'assistant',
+                            content: resp?.content ?? '',
+                            tool_calls: resp?.tool_calls,
+                        },
+                    }
+                    : undefined;
+                const choice0 = resp.choices?.[0] ?? legacyChoice;
+                const finishReason = choice0?.finish_reason ?? 'unknown';
+                const msg = choice0?.message;
                 const content = msg?.content ?? '';
                 // Conditionally strip thinking blocks based on harness config (§4i).
                 // Non-reasoning models (thinking.strip === false) never emit <think> blocks,
@@ -1996,7 +2043,40 @@ export async function createSession(opts) {
                         }
                     }
                 }
+                if (cfg.verbose) {
+                    console.warn(`[turn ${turns}] finish_reason=${finishReason} content_chars=${content.length} visible_chars=${visible.length} tool_calls=${toolCallsArr?.length ?? 0}`);
+                }
+                const narration = (visible || content || '').trim();
+                if ((!toolCallsArr || !toolCallsArr.length) && narration.length === 0) {
+                    noProgressTurns += 1;
+                    if (cfg.verbose) {
+                        console.warn(`[loop] no-progress turn ${noProgressTurns}/${NO_PROGRESS_TURN_CAP} (empty response)`);
+                    }
+                    if (noProgressTurns >= NO_PROGRESS_TURN_CAP) {
+                        throw new Error(`no progress for ${NO_PROGRESS_TURN_CAP} consecutive turns (empty responses with no tool calls). ` +
+                            `Likely malformed/empty model output loop; stopping early.`);
+                    }
+                    messages.push({
+                        role: 'user',
+                        content: '[system] Your previous response was empty (no text, no tool calls). Continue by either calling a tool with valid JSON arguments or giving a final answer.',
+                    });
+                    await hookObj.onTurnEnd?.({
+                        turn: turns,
+                        toolCalls,
+                        promptTokens: cumulativeUsage.prompt,
+                        completionTokens: cumulativeUsage.completion,
+                        promptTokensTurn,
+                        completionTokensTurn,
+                        ttftMs,
+                        ttcMs,
+                        ppTps,
+                        tgTps,
+                    });
+                    continue;
+                }
+                noProgressTurns = 0;
                 if (toolCallsArr && toolCallsArr.length) {
+                    noToolTurns = 0;
                     // Deduplicate ghost tool calls: if llama-server's XML parser splits one
                     // tool call into two entries (one with full args, one empty/partial),
                     // drop the empty one. Only removes entries where a richer version of the
@@ -2282,6 +2362,9 @@ export async function createSession(opts) {
                         else if (builtInFn) {
                             const value = await builtInFn(ctx, args);
                             content = typeof value === 'string' ? value : JSON.stringify(value);
+                            if (name === 'exec') {
+                                blockedPackageInstallAttempts = 0;
+                            }
                         }
                         else if (isLspTool && lspManager) {
                             // LSP tool dispatch
@@ -2383,6 +2466,16 @@ export async function createSession(opts) {
                         if (e instanceof AgentLoopBreak)
                             throw e;
                         const msg = e?.message ?? String(e);
+                        // Fast-fail package-install bypass loops in non-yolo modes.
+                        // Applies to direct exec attempts and spawn_task delegation attempts.
+                        if ((tc.function.name === 'exec' || tc.function.name === 'spawn_task') &&
+                            /package install\/remove.*(?:blocked|restricted)|without --no-confirm\/--yolo/i.test(msg)) {
+                            blockedPackageInstallAttempts += 1;
+                            if (blockedPackageInstallAttempts >= 2) {
+                                throw new AgentLoopBreak(`${tc.function.name}: repeated blocked package-install attempts in current approval mode. ` +
+                                    'Do not retry or delegate this. Continue with a zero-dependency path, or ask the user to restart with --no-confirm/--yolo.');
+                            }
+                        }
                         // Hook: onToolResult for errors (Phase 8.5)
                         const callId = resolveCallId(tc);
                         hookObj.onToolResult?.({ id: callId, name: tc.function.name, success: false, summary: msg || 'unknown error', result: `ERROR: ${msg || 'unknown error'}` });
@@ -2483,8 +2576,61 @@ export async function createSession(opts) {
                     });
                     continue;
                 }
+                const assistantText = visible || content || '';
+                // Recovery fuse: if the model keeps narrating/planning without tool use,
+                // nudge it once with the original task. Never resend more than once per ask().
+                if (looksLikePlanningNarration(assistantText, finishReason)) {
+                    noToolTurns += 1;
+                    messages.push({ role: 'assistant', content: assistantText });
+                    if (noToolTurns >= NO_TOOL_REPROMPT_THRESHOLD) {
+                        if (!repromptUsed) {
+                            repromptUsed = true;
+                            noToolTurns = 0;
+                            const reminder = userContentToText(instruction).trim();
+                            const clippedReminder = reminder.length > 4000 ? `${reminder.slice(0, 4000)}\n[truncated]` : reminder;
+                            messages.push({
+                                role: 'user',
+                                content: `[system] You seem to be stuck narrating without using tools. Resume execution now.\n` +
+                                    `Original task:\n${clippedReminder}\n\n` +
+                                    `Call the needed tools directly. If everything is truly complete, provide the final answer.`
+                            });
+                            await hookObj.onTurnEnd?.({
+                                turn: turns,
+                                toolCalls,
+                                promptTokens: cumulativeUsage.prompt,
+                                completionTokens: cumulativeUsage.completion,
+                                promptTokensTurn,
+                                completionTokensTurn,
+                                ttftMs,
+                                ttcMs,
+                                ppTps,
+                                tgTps,
+                            });
+                            continue;
+                        }
+                        throw new Error(`no-tool loop detected: model produced planning/narration without tool calls for ${NO_TOOL_REPROMPT_THRESHOLD} turns even after one recovery reprompt`);
+                    }
+                    messages.push({
+                        role: 'user',
+                        content: '[system] Continue executing the task. Use tools now (do not just narrate plans). If complete, give the final answer.'
+                    });
+                    await hookObj.onTurnEnd?.({
+                        turn: turns,
+                        toolCalls,
+                        promptTokens: cumulativeUsage.prompt,
+                        completionTokens: cumulativeUsage.completion,
+                        promptTokensTurn,
+                        completionTokensTurn,
+                        ttftMs,
+                        ttcMs,
+                        ppTps,
+                        tgTps,
+                    });
+                    continue;
+                }
+                noToolTurns = 0;
                 // final assistant message
-                messages.push({ role: 'assistant', content: visible || content || '' });
+                messages.push({ role: 'assistant', content: assistantText });
                 await hookObj.onTurnEnd?.({
                     turn: turns,
                     toolCalls,
@@ -2497,7 +2643,7 @@ export async function createSession(opts) {
                     ppTps,
                     tgTps,
                 });
-                return { text: visible || content || '', turns, toolCalls };
+                return { text: assistantText, turns, toolCalls };
             }
             const reason = `max iterations exceeded (${maxIters})`;
             throw new Error(reason);