@markjaquith/agency 3.5.0 → 3.5.1

package/README.md

@@ -326,8 +326,10 @@ which open a fresh TUI session so the generated continuation prompt cannot be
 routed to an unrelated prior session. By default Agency opens the agent without
 a prompt. `--auto` uses its autonomous command and sends the generated task,
 phase, or epic prompt. OpenCode V2 receives a launch-only environment marker;
-Agency's managed TUI companion waits for the populated composer and dispatches
-its native submit command once.
+Agency's managed TUI companion retries the native submit command until the exact
+prompt appears as a persisted user message. It records whether OpenCode submitted
+the prompt natively or submission followed a companion dispatch, and shows a
+bounded error with a manual recovery instruction when delivery is not observed.
 
 Custom agents are direct argv commands, never shell snippets:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "3.5.0",
+  "version": "3.5.1",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",

package/src/workbase/opencode-v2-tui-plugin-file.ts

@@ -35,16 +35,37 @@ export default plugin
 `
 
 const tuiBody = `const autosubmitTimeoutMs = 10_000
-const autosubmitRetryMs = 25
+const autosubmitRetryMs = 100
+
+type AutosubmitObservation = {
+  event: "marker" | "dispatch" | "submitted" | "timeout" | "error"
+  detail?: string
+  dispatches: number
+}
+
+type AutosubmitMessage = {
+  type?: string
+  text?: string
+  info?: { role?: string }
+  role?: string
+  parts?: readonly { type?: string; text?: string }[]
+}
 
 type AutosubmitContext = {
   keymap: {
     commands(): readonly { id?: string }[]
     dispatch(id: string): unknown
   }
-  renderer: { currentFocusedEditor?: unknown }
+  data?: {
+    session?: {
+      message?: {
+        sync?(sessionID: string): Promise<unknown>
+        list?(sessionID: string): readonly AutosubmitMessage[] | undefined
+      }
+    }
+  }
   ui: {
-    router: { current(): { type: string } }
+    router: { current(): { type: string; sessionID?: string } }
     toast: {
       show(input: {
         variant: "error"
@@ -57,7 +78,11 @@ type AutosubmitContext = {
 }
 
 export const createAgencyAutosubmit = (
-  options: { timeoutMs?: number; retryMs?: number } = {},
+  options: {
+    timeoutMs?: number
+    retryMs?: number
+    observe?: (observation: AutosubmitObservation) => void
+  } = {},
 ) => {
   let started = false
 
@@ -66,49 +91,111 @@ export const createAgencyAutosubmit = (
     if (process.env.AGENCY_TUI_AUTOSUBMIT !== "1") return () => {}
     if (!process.env.AGENCY_PROMPT) return () => {}
     started = true
-    delete process.env.AGENCY_TUI_AUTOSUBMIT
 
     const timeoutMs = options.timeoutMs ?? autosubmitTimeoutMs
     const retryMs = options.retryMs ?? autosubmitRetryMs
     const deadline = Date.now() + timeoutMs
+    const prompt = process.env.AGENCY_PROMPT
     let timer: ReturnType<typeof setTimeout> | undefined
     let stopped = false
+    let dispatches = 0
+    let lastRoute = "unknown"
+
+    const observe = (event: AutosubmitObservation["event"], detail?: string) => {
+      const observation = { event, detail, dispatches }
+      options.observe?.(observation)
+      if (
+        !options.observe &&
+        (event !== "dispatch" || dispatches === 1 || dispatches % 10 === 0)
+      ) {
+        const suffix = detail ? ": " + detail : ""
+        console.info("[agency.tui] autosubmit " + event + suffix)
+      }
+    }
 
     const stop = () => {
       stopped = true
       if (timer) clearTimeout(timer)
     }
 
-    const attempt = () => {
-      if (stopped) return
-      if (context.ui.router.current().type !== "home") {
-        stop()
-        return
+    const submitted = async (sessionID: string) => {
+      const messages = context.data?.session?.message
+      if (!messages?.list) return false
+      try {
+        await messages.sync?.(sessionID)
+      } catch (error) {
+        observe("error", "message sync failed: " + String(error))
+        return false
       }
+      return (messages.list(sessionID) ?? []).some((message) => {
+        const role = message.type === "user" ? "user" : message.info?.role ?? message.role
+        const text =
+          message.text ??
+          (message.parts ?? [])
+            .filter((part) => part.type === "text")
+            .map((part) => part.text ?? "")
+            .join("")
+        return role === "user" && text === prompt
+      })
+    }
 
-      const submitReady = context.keymap
-        .commands()
-        .some((command) => command.id === "prompt.submit")
-      if (context.renderer.currentFocusedEditor && submitReady) {
-        stop()
-        context.keymap.dispatch("prompt.submit")
-        return
+    const finish = (event: "submitted" | "timeout", detail: string) => {
+      stop()
+      delete process.env.AGENCY_TUI_AUTOSUBMIT
+      observe(event, detail)
+    }
+
+    const attempt = async () => {
+      if (stopped) return
+      const route = context.ui.router.current()
+      lastRoute = route.type
+      if (route.type === "session" && route.sessionID) {
+        if (await submitted(route.sessionID)) {
+          finish(
+            "submitted",
+            dispatches === 0
+              ? "native OpenCode submission observed"
+              : "submitted message observed after companion dispatch",
+          )
+          return
+        }
       }
 
+      if (stopped) return
       if (Date.now() >= deadline) {
-        stop()
+        finish(
+          "timeout",
+          "route=" + lastRoute + ", dispatches=" + String(dispatches),
+        )
         context.ui.toast.show({
           variant: "error",
           title: "Agency launch",
-          message: "The task prompt is ready but could not be submitted automatically.",
+          message:
+            "The task prompt was not observed as submitted after " +
+            String(dispatches) +
+            " automatic attempt(s). Press Enter to submit it manually.",
           duration: 8_000,
         })
         return
       }
-      timer = setTimeout(attempt, retryMs)
+
+      const submitReady = context.keymap
+        .commands()
+        .some((command) => command.id === "prompt.submit")
+      if (route.type === "home" && submitReady) {
+        dispatches += 1
+        observe("dispatch", "prompt.submit")
+        try {
+          await context.keymap.dispatch("prompt.submit")
+        } catch (error) {
+          observe("error", "dispatch failed: " + String(error))
+        }
+      }
+      if (!stopped) timer = setTimeout(() => void attempt(), retryMs)
     }
 
-    attempt()
+    observe("marker", "autonomous prompt detected")
+    void attempt()
     return stop
   }
 }