@markjaquith/agency 3.5.1 → 3.6.0

package/src/commands/work.ts

@@ -37,6 +37,7 @@ import {
 	readValidationEvidence,
 } from "../workbase/execution-contract"
 import { ValidationFailedError } from "./validate"
+import { prepareOpenCodeLaunch } from "../workbase/opencode-launch"
 
 export interface WorkOptions extends BaseCommandOptions {
 	readonly directory?: string
@@ -386,12 +387,22 @@ export const work = (
 			...agentEnvironment(agent, variables),
 		}
 		if (writablePath) environment.AGENCY_WRITABLE_CHECKOUT = writablePath
+		const managedOpenCodeAuto =
+			options.auto &&
+			(agent === "opencode" || agent === "opencode2") &&
+			!config.agents?.[agent]
 		if (options.printCommand) {
 			log(
 				JSON.stringify(
 					{
 						cwd: launchPath,
 						argv: resolved.argv,
+						...(managedOpenCodeAuto
+							? {
+									startup:
+										"OpenCode V2: submit via API, then attach with --session; V1: use argv",
+								}
+							: {}),
 						environment: printableEnvironment(environment),
 					},
 					null,
@@ -449,14 +460,17 @@ export const work = (
 				)
 			}
 		}
+		const launchArgv = managedOpenCodeAuto
+			? yield* prepareOpenCodeLaunch(resolved.argv, launchPath, environment)
+			: resolved.argv
 		for (const [key, value] of Object.entries(environment)) {
 			process.env[key] = value
 		}
 		verboseLog(
-			`Launching command: ${formatCommand(resolved.argv)} (cwd: ${launchPath})`,
+			`Launching command: ${formatCommand(launchArgv)} (cwd: ${launchPath})`,
 		)
 		try {
-			launch(cli, resolved.argv, launchPath, environment)
+			launch(cli, launchArgv, launchPath, environment)
 		} finally {
 			for (const key of Object.keys(environment)) {
 				const previous = previousEnvironment[key]

package/src/utils/chooser.ts

@@ -6,6 +6,7 @@ export interface Choice<T> {
 	readonly plainLabel?: string
 	readonly depth?: number
 	readonly segments?: readonly ChoiceSegment[]
+	readonly details?: ChoiceDetails
 	readonly value: T
 }
 
@@ -14,6 +15,12 @@ export interface ChoiceSegment {
 	readonly color?: string
 }
 
+export interface ChoiceDetails {
+	readonly title: readonly ChoiceSegment[]
+	readonly metadata: readonly ChoiceSegment[]
+	readonly description: string
+}
+
 export type ChooserErrorReason =
 	| "invalid-choices"
 	| "input-unavailable"

package/src/utils/exec.ts

@@ -1,7 +1,7 @@
 import { dlopen, FFIType, ptr } from "bun:ffi"
 
 /**
- * Native exec implementation using Bun FFI to call POSIX execvp.
+ * PATH-resolving native exec using POSIX execve and an explicit environment.
  * This completely replaces the current process with the specified command.
  *
  * IMPORTANT: This function will never return if successful. The process
@@ -12,12 +12,18 @@ import { dlopen, FFIType, ptr } from "bun:ffi"
  * @throws Error if exec fails (e.g., command not found)
  */
 export function execvp(file: string, args: string[]): never {
-	// Open libc to access execvp (platform-specific library paths)
+	const executable = Bun.which(file)
+	if (!executable) throw new Error(`Unable to find executable '${file}'`)
+	// Bun's process.env mutations are not reflected in libc's environ. Passing
+	// envp explicitly preserves launch identity and deletions across replacement.
+	const variables = Object.entries(process.env)
+		.filter((entry): entry is [string, string] => entry[1] !== undefined)
+		.map(([key, value]) => `${key}=${value}`)
 	const libcPath =
 		process.platform === "darwin" ? "/usr/lib/libSystem.B.dylib" : "libc.so.6"
 	const libc = dlopen(libcPath, {
-		execvp: {
-			args: [FFIType.cstring, FFIType.ptr],
+		execve: {
+			args: [FFIType.cstring, FFIType.ptr, FFIType.ptr],
 			returns: FFIType.int,
 		},
 	})
@@ -36,10 +42,19 @@ export function execvp(file: string, args: string[]): never {
 	}
 	// Null-terminate the pointer array
 	ptrs[args.length] = 0n
+	const environmentStrings = variables.map((value) => Buffer.from(value + "\0"))
+	const environmentPointers = new BigUint64Array(environmentStrings.length + 1)
+	for (let i = 0; i < environmentStrings.length; i++) {
+		environmentPointers[i] = BigInt(ptr(environmentStrings[i]!))
+	}
 
 	// Call execvp - this will replace the current process if successful
-	const fileBuffer = Buffer.from(file + "\0")
-	const result = libc.symbols.execvp(ptr(fileBuffer), ptr(ptrs))
+	const fileBuffer = Buffer.from(executable + "\0")
+	const result = libc.symbols.execve(
+		ptr(fileBuffer),
+		ptr(ptrs),
+		ptr(environmentPointers),
+	)
 
 	// If we reach here, exec failed
 	throw new Error(