@markjaquith/agency 3.4.2 → 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.4.2",
+  "version": "3.5.1",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",

package/src/cli-parser.ts

@@ -665,14 +665,14 @@ const commands = {
 		},
 	},
 	sync: {
-		usage: "agency sync [<task-id> [phase-id]] [--dry-run] [--json]",
+		usage: "agency sync [<task-id|path> [phase-id]] [--dry-run] [--json]",
 		options: {
 			...outputOptions,
 			...entitySelectorOptions,
 			"dry-run": { type: "boolean" },
 		},
 		command: {
-			usage: "agency sync [<task-id> [phase-id]] [--dry-run] [--json]",
+			usage: "agency sync [<task-id|path> [phase-id]] [--dry-run] [--json]",
 			minArgs: 0,
 			maxArgs: 2,
 			options: ["dry-run", "json", "task", "phase"],

package/src/commands/sync.ts

@@ -122,13 +122,14 @@ export const sync = (
 	})
 
 export const help = `
-Usage: agency sync [<task-id> [phase-id]] [--dry-run] [--json]
+Usage: agency sync [<task-id|path> [phase-id]] [--dry-run] [--json]
 
 Compare portable repository declarations and execution state with local Git
 repositories, worktrees, branches, references, and pull requests.
 Safe reconciliation transitions are applied by default.
-When a task or phase is provided, only that target and its repositories are
-queried or reconciled. Task scope includes all phases of a multi-phase task.
+When a task, phase, or item path is provided, only that target and its
+repositories are queried or reconciled. Task and epic scopes include their
+child execution units.
 
 Options:
   --dry-run                 Report planned safe transitions without changing state

package/src/services/SyncService.ts

@@ -1,5 +1,5 @@
 import { Data, Effect, Either } from "effect"
-import { dirname, join, resolve } from "node:path"
+import { dirname, join, relative, resolve, sep } from "node:path"
 import type {
 	PhaseFrontmatter,
 	RepositoryReference,
@@ -228,7 +228,17 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 				const worktrees = yield* WorktreeService
 				const repositories = yield* RepositoryService
 				const versionControl = yield* VersionControlService
-				const { root, config } = yield* workbase.loadConfig(options.cwd)
+				const cwd = resolve(options.cwd ?? process.cwd())
+				const candidate = options.taskId
+					? resolve(cwd, options.taskId)
+					: undefined
+				const candidateExists =
+					candidate !== undefined && !options.phaseId
+						? yield* fs.exists(candidate)
+						: false
+				const { root, config } = yield* workbase.loadConfig(
+					candidateExists ? candidate : cwd,
+				)
 				const backend = yield* versionControl.forWorkbase(root)
 				const validation = yield* workbase.validate(root, {
 					includeDocuments: true,
@@ -246,20 +256,49 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 					})
 				}
 				const documents = validation.documents!
+				let taskId = options.taskId
+				let phaseId = options.phaseId
+				let epicId: string | undefined
+				const existingTaskSelector =
+					options.taskId !== undefined &&
+					documents.tasks.some((task) => task.id === options.taskId)
+				if (candidateExists && candidate && !existingTaskSelector) {
+					const canonicalPath = yield* fs.realPath(candidate)
+					const canonicalRoot = yield* fs.realPath(root)
+					const parts = relative(canonicalRoot, canonicalPath).split(sep)
+					if (parts[0] === "epics" && parts[1]) {
+						epicId = parts[1]
+						taskId = undefined
+					} else if (parts[0] === "tasks" && parts[1]) {
+						taskId = parts[1]
+						phaseId = parts[2] === "phases" && parts[3] ? parts[3] : undefined
+					} else {
+						return yield* new SyncError({
+							message: `Sync path does not identify an active task, phase, or epic: ${canonicalPath}`,
+						})
+					}
+				}
+				if (epicId && !documents.epics.some((epic) => epic.id === epicId)) {
+					return yield* new SyncError({
+						message: `Epic '${epicId}' does not exist`,
+					})
+				}
 				const allTaskRecords = documents.tasks
-				const taskRecords = options.taskId
-					? allTaskRecords.filter((task) => task.id === options.taskId)
-					: allTaskRecords
-				if (options.taskId && taskRecords.length === 0) {
+				const taskRecords = taskId
+					? allTaskRecords.filter((task) => task.id === taskId)
+					: epicId
+						? allTaskRecords.filter((task) => task.data.epic === epicId)
+						: allTaskRecords
+				if (taskId && taskRecords.length === 0) {
 					return yield* new SyncError({
-						message: `Task '${options.taskId}' does not exist`,
+						message: `Task '${taskId}' does not exist`,
 					})
 				}
 				const records: ExecutionRecord[] = []
 				for (const task of taskRecords) {
 					if ("phases" in task.data) {
 						for (const phase of documents.phasesByTask.get(task.id) ?? []) {
-							if (options.phaseId && phase.id !== options.phaseId) continue
+							if (phaseId && phase.id !== phaseId) continue
 							records.push({
 								key: `phase:${task.id}/${phase.id}`,
 								taskId: task.id,
@@ -270,7 +309,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 								data: phase.data,
 							})
 						}
-					} else if (!options.phaseId && !("review" in task.data)) {
+					} else if (!phaseId && !("review" in task.data)) {
 						records.push({
 							key: `task:${task.id}`,
 							taskId: task.id,
@@ -281,12 +320,12 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						})
 					}
 				}
-				const reviewRecords = options.phaseId
+				const reviewRecords = phaseId
 					? []
 					: taskRecords.filter((task) => "review" in task.data)
-				if (options.phaseId && records.length === 0) {
+				if (phaseId && records.length === 0) {
 					return yield* new SyncError({
-						message: `Phase '${options.taskId}/${options.phaseId}' does not exist`,
+						message: `Phase '${taskId}/${phaseId}' does not exist`,
 					})
 				}
 				const repositoryAliases = new Set<string>()
@@ -299,10 +338,15 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 					if ("review" in task.data)
 						repositoryAliases.add(task.data.review.repo)
 				}
+				if (epicId) {
+					const epic = documents.epics.find((record) => record.id === epicId)!
+					for (const reference of epic.data.repos)
+						repositoryAliases.add(reference.repo)
+				}
 				const repositorySetup = yield* repositories.setup({
 					cwd: root,
 					apply: options.apply === true,
-					...(options.taskId ? { aliases: [...repositoryAliases] } : {}),
+					...(taskId || epicId ? { aliases: [...repositoryAliases] } : {}),
 				})
 				options.onProgress?.({
 					stage: "repositories",

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
   }
 }