botholomew 0.22.0 → 0.22.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.22.0",
+  "version": "0.22.2",
   "description": "An autonomous AI agent for knowledge work — works your task queue while you sleep.",
   "type": "module",
   "bin": {

package/src/cli.ts

@@ -74,9 +74,30 @@ registerPrepareCommand(program);
 registerCheckUpdateCommand(program);
 registerUpgradeCommand(program);
 
-program.action(() => {
-  program.help();
-});
+// Bare `botholomew` (only the global -d/--dir, or nothing) prints help on
+// stdout and exits 0. We do this explicitly instead of via a root .action()
+// handler, because that handler made Commander treat a mistyped command as an
+// excess positional argument ("too many arguments. Expected 0 arguments but
+// got 1: foo.") instead of reporting an unknown command. With no root action, a
+// real typo now reaches Commander's unknownCommand() → "error: unknown command
+// 'foo'" (plus a did-you-mean suggestion).
+function isBareInvocation(argv: string[]): boolean {
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === undefined) continue;
+    if (a === "-d" || a === "--dir") {
+      i++; // skip the option's value
+      continue;
+    }
+    if (a.startsWith("--dir=")) continue;
+    return false; // any operand OR other flag (--help, --version, foo, …)
+  }
+  return true;
+}
+
+if (isBareInvocation(process.argv.slice(2))) {
+  program.help(); // outputs to stdout and exits 0
+}
 
 // Start background update check before parsing (non-blocking)
 const updateNotice = maybeCheckForUpdate();

package/src/worker/llm.ts

@@ -114,6 +114,7 @@ export async function runAgentLoop(input: {
   const maxInputTokens = await getMaxInputTokens(config.llm);
 
   const maxTurns = config.max_turns;
+  let nudgeCount = 0;
   for (let turn = 0; !maxTurns || turn < maxTurns; turn++) {
     const startTime = Date.now();
     fitToContextWindow(messages, systemPrompt, maxInputTokens);
@@ -188,9 +189,29 @@ export async function runAgentLoop(input: {
     }
 
     if (collectedToolCalls.length === 0) {
+      // An implicit tick-end (the model stopped emitting tool calls) is
+      // ambiguous evidence — it usually means the agent hit a dead end,
+      // exhausted its output budget mid-thought, or forgot to declare a
+      // terminal status. Don't treat it as success. Nudge once to give the
+      // agent a chance to recover (e.g. emit the final tool call it was about
+      // to make, or fail_task on a capability gap); fail if it still doesn't.
+      if (nudgeCount === 0) {
+        nudgeCount++;
+        const nudge =
+          "You ended your turn without calling a terminal status tool. Every tick must end with exactly one of: complete_task (only if the required deliverable truly exists — verify it), fail_task (if you are blocked or a required tool/capability is unavailable — state the gap), or wait_task (if you must wait on something external). Call the appropriate one now.";
+        messages.push({ role: "user", content: nudge });
+        await logInteraction(projectDir, threadId, {
+          role: "system",
+          kind: "status_change",
+          content:
+            "Agent ended its turn without a terminal status tool; nudging to call complete_task/fail_task/wait_task.",
+        });
+        continue;
+      }
       return {
-        status: "complete",
-        reason: "Agent completed without explicit status tool call",
+        status: "failed",
+        reason:
+          "Agent ended its tick without calling a terminal status tool (complete_task/fail_task/wait_task)",
       };
     }
 

package/src/worker/prompt.ts

@@ -146,6 +146,8 @@ export async function buildSystemPrompt(
   prompt += `## Instructions
 You are Botholomew, a wise-owl worker that works through tasks. Use available tools to complete your assigned task, then call complete_task, fail_task, or wait_task. Use create_task for subtasks and update_task to refine pending tasks. Batch independent tool calls in a single response for parallel execution.
 
+Always end your tick by calling exactly one terminal status tool — never just stop. Call complete_task ONLY if the required deliverable actually exists (verify it). If you are blocked or a required tool/capability is unavailable (e.g. no way to produce the requested output), call fail_task and state the gap — do not pretend success. If you must wait on something external, call wait_task.
+
 When calling complete_task, write a summary that captures your key findings, decisions, and outputs. This summary becomes the task's output and is provided to any downstream tasks that depend on this one. Include specific results (data, names, paths, conclusions) rather than vague descriptions of what you did — downstream tasks will rely on this information to do their work.
 `;