feat(hooks): add /stop-continuation command to halt all continuation mechanisms (#1316)

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)

Co-authored-by: justsisyphus <justsisyphus@users.noreply.github.com>
Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

src/hooks/index.ts

@@ -34,3 +34,4 @@ export { createAtlasHook } from "./atlas";
 export { createDelegateTaskRetryHook } from "./delegate-task-retry";
 export { createQuestionLabelTruncatorHook } from "./question-label-truncator";
 export { createSubagentQuestionBlockerHook } from "./subagent-question-blocker";
+export { createStopContinuationGuardHook, type StopContinuationGuard } from "./stop-continuation-guard";

src/hooks/stop-continuation-guard/index.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test } from "bun:test"
+import { createStopContinuationGuardHook } from "./index"
+
+describe("stop-continuation-guard", () => {
+  function createMockPluginInput() {
+    return {
+      client: {
+        tui: {
+          showToast: async () => ({}),
+        },
+      },
+      directory: "/tmp/test",
+    } as never
+  }
+
+  test("should mark session as stopped", () => {
+    // #given - a guard hook with no stopped sessions
+    const guard = createStopContinuationGuardHook(createMockPluginInput())
+    const sessionID = "test-session-1"
+
+    // #when - we stop continuation for the session
+    guard.stop(sessionID)
+
+    // #then - session should be marked as stopped
+    expect(guard.isStopped(sessionID)).toBe(true)
+  })
+
+  test("should return false for non-stopped sessions", () => {
+    // #given - a guard hook with no stopped sessions
+    const guard = createStopContinuationGuardHook(createMockPluginInput())
+
+    // #when - we check a session that was never stopped
+
+    // #then - it should return false
+    expect(guard.isStopped("non-existent-session")).toBe(false)
+  })
+
+  test("should clear stopped state for a session", () => {
+    // #given - a session that was stopped
+    const guard = createStopContinuationGuardHook(createMockPluginInput())
+    const sessionID = "test-session-2"
+    guard.stop(sessionID)
+
+    // #when - we clear the session
+    guard.clear(sessionID)
+
+    // #then - session should no longer be stopped
+    expect(guard.isStopped(sessionID)).toBe(false)
+  })
+
+  test("should handle multiple sessions independently", () => {
+    // #given - multiple sessions with different stop states
+    const guard = createStopContinuationGuardHook(createMockPluginInput())
+    const session1 = "session-1"
+    const session2 = "session-2"
+    const session3 = "session-3"
+
+    // #when - we stop some sessions but not others
+    guard.stop(session1)
+    guard.stop(session2)
+
+    // #then - each session has its own state
+    expect(guard.isStopped(session1)).toBe(true)
+    expect(guard.isStopped(session2)).toBe(true)
+    expect(guard.isStopped(session3)).toBe(false)
+  })
+
+  test("should clear session on session.deleted event", async () => {
+    // #given - a session that was stopped
+    const guard = createStopContinuationGuardHook(createMockPluginInput())
+    const sessionID = "test-session-3"
+    guard.stop(sessionID)
+
+    // #when - session is deleted
+    await guard.event({
+      event: {
+        type: "session.deleted",
+        properties: { info: { id: sessionID } },
+      },
+    })
+
+    // #then - session should no longer be stopped (cleaned up)
+    expect(guard.isStopped(sessionID)).toBe(false)
+  })
+
+  test("should not affect other sessions on session.deleted", async () => {
+    // #given - multiple stopped sessions
+    const guard = createStopContinuationGuardHook(createMockPluginInput())
+    const session1 = "session-keep"
+    const session2 = "session-delete"
+    guard.stop(session1)
+    guard.stop(session2)
+
+    // #when - one session is deleted
+    await guard.event({
+      event: {
+        type: "session.deleted",
+        properties: { info: { id: session2 } },
+      },
+    })
+
+    // #then - other session should remain stopped
+    expect(guard.isStopped(session1)).toBe(true)
+    expect(guard.isStopped(session2)).toBe(false)
+  })
+})

src/hooks/stop-continuation-guard/index.ts

@@ -0,0 +1,54 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import { log } from "../../shared/logger"
+
+const HOOK_NAME = "stop-continuation-guard"
+
+export interface StopContinuationGuard {
+  event: (input: { event: { type: string; properties?: unknown } }) => Promise<void>
+  stop: (sessionID: string) => void
+  isStopped: (sessionID: string) => boolean
+  clear: (sessionID: string) => void
+}
+
+export function createStopContinuationGuardHook(
+  _ctx: PluginInput
+): StopContinuationGuard {
+  const stoppedSessions = new Set<string>()
+
+  const stop = (sessionID: string): void => {
+    stoppedSessions.add(sessionID)
+    log(`[${HOOK_NAME}] Continuation stopped for session`, { sessionID })
+  }
+
+  const isStopped = (sessionID: string): boolean => {
+    return stoppedSessions.has(sessionID)
+  }
+
+  const clear = (sessionID: string): void => {
+    stoppedSessions.delete(sessionID)
+    log(`[${HOOK_NAME}] Continuation guard cleared for session`, { sessionID })
+  }
+
+  const event = async ({
+    event,
+  }: {
+    event: { type: string; properties?: unknown }
+  }): Promise<void> => {
+    const props = event.properties as Record<string, unknown> | undefined
+
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info as { id?: string } | undefined
+      if (sessionInfo?.id) {
+        clear(sessionInfo.id)
+        log(`[${HOOK_NAME}] Session deleted: cleaned up`, { sessionID: sessionInfo.id })
+      }
+    }
+  }
+
+  return {
+    event,
+    stop,
+    isStopped,
+    clear,
+  }
+}

src/hooks/todo-continuation-enforcer.test.ts

@@ -1178,4 +1178,68 @@ describe("todo-continuation-enforcer", () => {
     // #then - continuation injected (no agents to skip)
     expect(promptCalls.length).toBe(1)
   })
+
+  test("should not inject when isContinuationStopped returns true", async () => {
+    // #given - session with continuation stopped
+    const sessionID = "main-stopped"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {
+      isContinuationStopped: (id) => id === sessionID,
+    })
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    await fakeTimers.advanceBy(3000)
+
+    // #then - no continuation injected (stopped flag is true)
+    expect(promptCalls).toHaveLength(0)
+  })
+
+  test("should inject when isContinuationStopped returns false", async () => {
+    // #given - session with continuation not stopped
+    const sessionID = "main-not-stopped"
+    setMainSession(sessionID)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {
+      isContinuationStopped: () => false,
+    })
+
+    // #when - session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID } },
+    })
+
+    await fakeTimers.advanceBy(3000)
+
+    // #then - continuation injected (stopped flag is false)
+    expect(promptCalls.length).toBe(1)
+  })
+
+  test("should cancel all countdowns via cancelAllCountdowns", async () => {
+    // #given - multiple sessions with running countdowns
+    const session1 = "main-cancel-all-1"
+    const session2 = "main-cancel-all-2"
+    setMainSession(session1)
+
+    const hook = createTodoContinuationEnforcer(createMockPluginInput(), {})
+
+    // #when - first session goes idle
+    await hook.handler({
+      event: { type: "session.idle", properties: { sessionID: session1 } },
+    })
+    await fakeTimers.advanceBy(500)
+
+    // #when - cancel all countdowns
+    hook.cancelAllCountdowns()
+
+    // #when - advance past countdown time
+    await fakeTimers.advanceBy(3000)
+
+    // #then - no continuation injected (all countdowns cancelled)
+    expect(promptCalls).toHaveLength(0)
+  })
 })

src/hooks/todo-continuation-enforcer.ts

@@ -18,12 +18,14 @@ const DEFAULT_SKIP_AGENTS = ["prometheus", "compaction"]
 export interface TodoContinuationEnforcerOptions {
   backgroundManager?: BackgroundManager
   skipAgents?: string[]
+  isContinuationStopped?: (sessionID: string) => boolean
 }
 
 export interface TodoContinuationEnforcer {
   handler: (input: { event: { type: string; properties?: unknown } }) => Promise<void>
   markRecovering: (sessionID: string) => void
   markRecoveryComplete: (sessionID: string) => void
+  cancelAllCountdowns: () => void
 }
 
 interface Todo {
@@ -95,7 +97,7 @@ export function createTodoContinuationEnforcer(
   ctx: PluginInput,
   options: TodoContinuationEnforcerOptions = {}
 ): TodoContinuationEnforcer {
-  const { backgroundManager, skipAgents = DEFAULT_SKIP_AGENTS } = options
+  const { backgroundManager, skipAgents = DEFAULT_SKIP_AGENTS, isContinuationStopped } = options
   const sessions = new Map<string, SessionState>()
 
   function getState(sessionID: string): SessionState {
@@ -420,6 +422,11 @@ export function createTodoContinuationEnforcer(
         return
       }
 
+      if (isContinuationStopped?.(sessionID)) {
+        log(`[${HOOK_NAME}] Skipped: continuation stopped for session`, { sessionID })
+        return
+      }
+
       startCountdown(sessionID, incompleteCount, todos.length, resolvedInfo)
       return
     }
@@ -485,9 +492,17 @@ export function createTodoContinuationEnforcer(
     }
   }
 
+  const cancelAllCountdowns = (): void => {
+    for (const sessionID of sessions.keys()) {
+      cancelCountdown(sessionID)
+    }
+    log(`[${HOOK_NAME}] All countdowns cancelled`)
+  }
+
   return {
     handler,
     markRecovering,
     markRecoveryComplete,
+    cancelAllCountdowns,
   }
 }