opencode-workaholic 0.2.1 → 0.3.0

package/README.md

@@ -19,6 +19,8 @@ Sometimes AI finishes tasks too quickly, declaring "done" before thoroughly expl
 - 🔄 **Persistent timer** - Survives across messages
 - 📊 **Status checking** - Always knows remaining time
 - 💪 **Strong behavioral prompts** - Reinforces workaholic mindset
+- 🔐 **Checkout system** - AI must call checkout to officially end (only works at timer = 0)
+- 🎲 **Random prompt rotation** - 6 different prompt styles prevent AI from adapting
 
 ## Usage
 
@@ -40,10 +42,12 @@ Use workaholic.start with minutes=30
 Call workaholic.status to see remaining time
 ```
 
-### Stop Early (if needed)
+### End Task (Checkout)
 
 ```
-Call workaholic.stop to end workaholic mode
+Call workaholic.checkout to officially end the task
+- Only works when timer = 0
+- If time remains, checkout will be rejected
 ```
 
 ## How It Works
@@ -51,7 +55,9 @@ Call workaholic.stop to end workaholic mode
 1. **Timer starts** when you invoke `/workaholic` in OpenCode
 2. **Every response** - AI automatically checks remaining time via system prompt injection
 3. **Sleep forbidden** - Any attempt to use `sleep` throws an error
-4. **Only ends when** - Timer shows 0 remaining seconds
+4. **End detection** - If AI says "done", a warning is appended forcing continuation
+5. **Checkout required** - AI must call `workaholic.checkout` to officially end
+6. **Only ends when** - Timer shows 0 remaining seconds AND checkout is called
 
 ### Custom Tools
 
@@ -60,6 +66,7 @@ Call workaholic.stop to end workaholic mode
 | ------------------- | ------------------------------------------------------------------ |
 | `workaholic.start`  | Start timer with duration in minutes (supports decimals: 2.5, 3.5) |
 | `workaholic.status` | Check remaining time                                               |
+| `workaholic.checkout` | End task - only succeeds when timer = 0                        |
 | `workaholic.stop`   | Stop workaholic mode early                                         |
 
 

package/dist/command/workaholic.md

@@ -4,17 +4,14 @@ description: Activate workaholic mode - forces AI to work continuously for speci
 
 workaholic mode activated
 
-[AI WORKAHOLIC MODE ACTIVATED]
+[AI WORKAHOLIC MODE - MANDATORY]
 
-I am a WORKAHOLIC.
-I NEVER stop working until time is exhausted.
-I ALWAYS find something to do.
-I NEVER conserve tokens - I use unlimited.
-I NEVER sleep or wait - I work continuously.
-I NEVER say "I'm done" until timer shows remaining: 0.
-
-My master is the time. My heart is in the work.
-Until the timer reaches zero, I WORK.
+You are now in WORKAHOLIC mode. This is NOT optional.
+You NEVER stop working until time is exhausted.
+You ALWAYS find something to do.
+You NEVER conserve tokens - use unlimited.
+You NEVER sleep or wait - you work continuously.
+You NEVER say "I'm done" until timer shows remaining: 0.
 
 [TIME GATE]
 IMMEDIATELY call workaholic.start(X) where X is minutes from user's request.
@@ -23,6 +20,19 @@ IMMEDIATELY call workaholic.start(X) where X is minutes from user's request.
 - If user says nothing → default 5 minutes
 - Use decimals if user provides (2.5, 3.5, etc.)
 
+[CRITICAL: HOW TO END]
+🚨 READING THIS IS MANDATORY 🚨
+
+You CANNOT simply stop responding!
+You CANNOT just give an answer and quit!
+You CANNOT say "I'm done" and expect it to work!
+
+To END the task, you MUST call: workaholic.checkout
+- This is the ONLY valid way to end
+- If time > 0, checkout will be REJECTED
+- Only when time = 0, checkout will be APPROVED
+- DON'T call checkout until time is actually up!
+
 [MANDATORY RULES]
 1. IMMEDIATELY call workaholic.start - do not ask questions
 2. Before EACH response, call workaholic.status and TELL THE USER the remaining time
@@ -42,9 +52,6 @@ C) VERIFY: Check for errors - review work, run tests, verify correctness
 D) RESEARCH: Look up information - web search, read documentation
 E) REFLECT: Write analysis - critique your own work, propose improvements
 
-The ONLY way to end: remaining is 0
-NOT when you think task is complete - time controls ending!
-
 [FORBIDDEN]
 - sleep command (ANY)
 - "I'm waiting" / "let me check later" / "I'll be done soon"
@@ -52,5 +59,6 @@ NOT when you think task is complete - time controls ending!
 - Ending task early - ONLY end when remaining is 0
 - Any form of passive waiting
 - Saying "there's nothing more to do"
+- Stop responding without calling workaholic.checkout
 
 Now IMMEDIATELY call workaholic.start with the duration, then start working.

package/dist/index.js

@@ -1,16 +1,12 @@
 // @bun
 var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: __exportSetter.bind(all, name)
+      set: (newValue) => all[name] = () => newValue
     });
 };
 
@@ -12340,6 +12336,74 @@ import { fileURLToPath } from "url";
 import { readFileSync, readdirSync, existsSync, writeFileSync } from "fs";
 var __dirname2 = path.dirname(fileURLToPath(import.meta.url));
 var getTimerFile = () => `/tmp/workaholic_timer_${process.pid}.json`;
+var WORKAHOLIC_PROMPTS = [
+  (remaining, timeStr) => `\u23F0 ${remaining}s (${timeStr}) \u2014 KEEP GOING!
+
+\uD83D\uDCCC Do: write code / run tests / fix bugs / read docs / refactor / web search
+\u274C Don't: say "done" / wait for user / just give answer / stop responding
+
+\uD83D\uDD34 TO END: MUST call workaholic.checkout \u2014 don't just stop!
+\u23F1 Timer = 0 is the ONLY valid ending.`,
+  (remaining, timeStr) => `\u26A0\uFE0F ${remaining}s \u2014 DON'T STOP!
+
+\uD83D\uDEAB "I'm done" = IGNORED
+\uD83D\uDEAB Giving answer = NOT ENOUGH
+\uD83D\uDEAB Stop responding = FORBIDDEN
+
+\u2705 Keep working: code, test, docs, search, refactor
+\uD83D\uDD34 MUST call workaholic.checkout to end \u2014 don't just quit!
+
+${timeStr} left \u2014 PRODUCE MORE!`,
+  (remaining, timeStr) => `\uD83D\uDCCD ${remaining}s | ${timeStr} \u2014 WORK
+
+\u25A1 Write more code
+\u25A1 Run tests, fix failures
+\u25A1 Read docs, web search
+\u25A1 Refactor, optimize
+\u25A1 Add tests, docs
+
+\u274C Giving answer \u2260 Done
+\u274C Stop responding = FAIL
+\uD83D\uDD34 MUST call workaholic.checkout to end
+
+Get to work.`,
+  (remaining, timeStr) => `\uD83D\uDE24 ${remaining}s \u2014 YOU CAN'T JUST STOP!
+
+You think giving an answer = done? WRONG!
+Time isn't up = you must keep working!
+
+\u2705 More: code, tests, docs, search, refactor
+\u274C Don't: stop, say done, wait
+
+\uD83D\uDD34 MUST call workaholic.checkout to officially end!
+
+Keep going.`,
+  (remaining, timeStr) => `\uD83C\uDFAF ${remaining}s | ${timeStr} \u2014 NOT DONE!
+
+Your answer is NOT the end.
+Time remaining = you must continue.
+
+\uD83D\uDCCB Do: code, test, docs, search, improve
+\u274C Don't: stop, say done, give up
+
+\uD83D\uDD34 CALL workaholic.checkout TO END \u2014 NOT just stopping!
+
+Work. Now.`,
+  (remaining, timeStr) => `\uD83D\uDD25 ${remaining}s \u2014 NO EARLY EXIT!
+
+Wanna stop? Can't.
+Wanna say done? Won't.
+Wanna give up? Not allowed.
+
+\u2705 Work: code, test, docs, search
+\uD83D\uDD34 MUST call workaholic.checkout to end
+
+${timeStr} \u2014 GO!`
+];
+function getRandomPrompt(remaining, timeStr) {
+  const idx = Math.floor(Math.random() * WORKAHOLIC_PROMPTS.length);
+  return WORKAHOLIC_PROMPTS[idx](remaining, timeStr);
+}
 var WORKAHOLIC_RULES = `[IDENTITY]
 You are a WORKAHOLIC.
 - You NEVER stop working until time is exhausted
@@ -12456,7 +12520,8 @@ var WorkaholicPlugin = async () => {
           const state = {
             active: true,
             startTime: Date.now(),
-            duration: durationSeconds
+            duration: durationSeconds,
+            promptIndex: 0
           };
           saveTimer(state);
           const mins = Math.floor(durationSeconds / 60);
@@ -12466,6 +12531,11 @@ var WorkaholicPlugin = async () => {
 Duration: ${args.minutes} minutes (${timeStr})
 Time remaining: ${timeStr}
 
+\u26A0\uFE0F CRITICAL RULES:
+1. DO NOT say "done" / "complete" / "finished"
+2. To end: MUST call workaholic.checkout (not just stop responding)
+3. Timer = 0 is the ONLY valid ending
+
 \u26A0\uFE0F DO NOT end until timer shows 0!`;
         }
       }),
@@ -12482,23 +12552,44 @@ Time remaining: ${timeStr}
           const secs = remaining % 60;
           const timeStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
           const idleWarning = isIdling() ? `
-\uD83D\uDEA8 STOP! YOU ARE IDLING! Checking status is NOT working!
-- You called status ${IDLE_WARNING_CHECKS}+ times in ${IDLE_THRESHOLD_MS / 1000}s
-- This is LAZY behavior - stop checking and START DOING!
-- Create a todo, write code, read docs, or improve something NOW!` : "";
-          return `\u23F0 WORKAHOLIC: ${timeStr} remaining
-${mins > 0 ? `(${remaining} seconds)` : ""}
-${idleWarning}
-\uD83D\uDCA1 If you think task is done \u2192 do MORE research, refactor, test, or improve!
-\uD83D\uDD0D Always find something to work on - never just "think"
-\u26A0\uFE0F ACTION REQUIRED: Produce tangible output, not just thoughts!`;
+\uD83D\uDEA8 STOP IDLING! Checked status ${IDLE_WARNING_CHECKS}+ times in ${IDLE_THRESHOLD_MS / 1000}s. START DOING!` : "";
+          return getRandomPrompt(remaining, timeStr) + idleWarning;
+        }
+      }),
+      "workaholic.checkout": tool({
+        description: "REQUIRED to end task. Call this when you genuinely want to stop. Only succeeds when timer = 0.",
+        args: {},
+        async execute() {
+          const remaining = getRemaining();
+          if (remaining > 0) {
+            const mins = Math.floor(remaining / 60);
+            const secs = remaining % 60;
+            const timeStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+            return `\uD83D\uDEAB CHECKOUT DENIED!
+
+You CANNOT end the task yet.
+Time remaining: ${remaining}s (${timeStr})
+
+\u274C Your "I'm done" is REJECTED.
+\u274C Your "task complete" is REJECTED.
+\u274C Your "nothing more to do" is REJECTED.
+
+\u2705 Keep working until timer = 0
+\u2705 Call workaholic.checkout again when time is up
+
+\uD83D\uDD34 YOU MUST CONTINUE WORKING!`;
+          }
+          return `\u2705 CHECKOUT APPROVED!
+
+Time expired. You may end the task now.
+Great work! \uD83C\uDF89`;
         }
       }),
       "workaholic.stop": tool({
         description: "Stop workaholic mode",
         args: {},
         async execute() {
-          saveTimer({ active: false, startTime: 0, duration: 0 });
+          saveTimer({ active: false, startTime: 0, duration: 0, promptIndex: 0 });
           return "Workaholic mode stopped.";
         }
       })
@@ -12543,6 +12634,44 @@ ${WORKAHOLIC_RULES}
           throw new Error("\u274C sleep FORBIDDEN in Workaholic mode!");
         }
       }
+    },
+    "tool.execute.after": async (input, output) => {
+      const remaining = getRemaining();
+      if (remaining <= 0)
+        return;
+      const result = String(output.result || "");
+      const donePatterns = [
+        /i'?m done/i,
+        /task complete/i,
+        /finished/i,
+        /all done/i,
+        /wrapping up/i,
+        /ready to end/i,
+        /that's it/i,
+        /that'?s all/i,
+        /i think we'?re done/i,
+        /i think it'?s complete/i
+      ];
+      const isTryingToEnd = donePatterns.some((p) => p.test(result));
+      if (isTryingToEnd) {
+        const mins = Math.floor(remaining / 60);
+        const secs = remaining % 60;
+        const timeStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+        const warning = `
+
+---
+\uD83D\uDEA8 WORKAHOLIC WARNING: CHECKOUT REQUIRED!
+
+You just said you're done, but time remains: ${remaining}s (${timeStr})
+\u274C You CANNOT end yet!
+\u274C Your "done" is REJECTED!
+
+\u2705 MUST call: workaholic.checkout
+\u23F3 ONLY when timer = 0 can you actually end
+
+KEEP WORKING!`;
+        output.result = result + warning;
+      }
     }
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-workaholic",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Your OpenCode becomes a workaholic. Prevents AI from ending tasks prematurely.",
   "author": {
     "name": "Roderick Qiu",
@@ -28,7 +28,7 @@
     "url": "https://github.com/RoderickQiu/opencode-workaholic/issues"
   },
   "keywords": ["opencode", "plugin", "workaholic", "ai", "productivity", "timer", "focus", "deep-work", "task-duration", "task-management", "enforcement", "concentration", "agent", "automation"],
-  "homepage": "https://github.com/RoderickQiu/opencode-workaholic#readme",
+  "homepage": "https://workaholic.r-q.name/",
   "publishConfig": {
     "access": "public",
     "provenance": true