@markjaquith/agency 2.56.1 → 2.58.0

package/README.md

@@ -142,9 +142,17 @@ or credential:
 
 New workbases select `"jj"` when the `jj` executable is available and otherwise
 select `"git"`. Existing version 2 workbases without `vcs` remain Git workbases.
-The selected backend is a workbase-level invariant: jj workbases initialize
-managed clones with `jj git init` and create jj workspaces, while Git workbases
-continue to use Git worktrees.
+The selected backend is a workbase-level invariant: jj workbases create
+non-colocated managed clones and jj workspaces, while Git workbases continue to
+use bare repositories and Git worktrees. Existing colocated jj repositories are
+also supported.
+
+Agency uses jj-native commands for repository validity, workspace registration,
+working-copy state, revisions, bookmarks, ancestry, fetch, and push. Raw Git is
+limited to backing-store plumbing such as durable review refs and integrations
+that require Git, including GitHub CLI commit discovery. For those operations,
+Agency obtains the backing repository with `jj git root` and supplies it as
+`GIT_DIR`; it does not use raw Git to infer jj workspace state.
 
 Inspect the current backend and migration readiness with:
 
@@ -162,6 +170,9 @@ target backend, and updates `agency.json` last. Migration from jj to Git also
 blocks jj-only heads that are not preserved by a bookmark or workspace. Failed
 migrations restore the source repositories and workspaces when rollback is
 possible and report explicit manual recovery paths otherwise.
+Converting a non-colocated jj workbase to Git is currently blocked before any
+mutation because its backing Git object store is inside `.jj`; first convert the
+repositories to colocated jj so the Git store survives metadata removal.
 
 Existing version 2 workbases without `repositories` remain valid. Run
 `agency repo setup` to preview deterministic adoption of legacy local aliases;
@@ -848,6 +859,7 @@ agency archive show <epic|task> <id>
 agency archive show phase <task-id> <phase-id>
 agency archive epic <epic-id> [--dry-run] [--json]
 agency archive task <task-id> [--dry-run] [--json]
+agency archive tasks [--dry-run] [--json]
 agency archive phase <task-id> <phase-id> [--dry-run] [--json]
 agency restore epic <epic-id> [--dry-run] [--json]
 agency restore task <task-id> [--dry-run] [--json]
@@ -855,12 +867,26 @@ agency restore phase <task-id> <phase-id> [--dry-run] [--json]
 ```
 
 Archived work keeps its hierarchy under `archive/`. Epic archiving includes its
-listed tasks. Task and phase archiving update the active parent document and
-reject items that active siblings depend on. Agency removes registered worktrees
-before moving files, refuses dirty worktrees, and preserves branches. Archive and
-restore preflight all destinations and graph references before changing files.
-Versioned lifecycle provenance preserves parent declarations and dependency edges
-for restoration. Archived IDs are reserved until restored.
+listed tasks. A task can be archived only when its effective status is terminal
+(`done` or `dropped`). Multi-phase task status is derived from its phases, every
+phase must be terminal, and a task with no phases is not eligible.
+
+`archive tasks` plans the maximal safe cohort of terminal tasks and applies by
+default; `--dry-run` performs the same preflight without mutation. A dependency
+is work required by a candidate, while a dependent is work that requires the
+candidate. Dependencies within the selected cohort can be archived together,
+but a retained dependent excludes its dependency, including exclusions that
+propagate through a dependency chain. Active claims, dirty or otherwise unsafe
+managed checkouts, and occupied archive destinations are reported as per-task
+skips. Invalid workbase structure and infrastructure failures abort the command.
+
+Task and phase archiving update active parent documents. Agency removes
+registered worktrees before moving files, refuses dirty worktrees, and preserves
+branches. Bulk application updates shared parents once and archives the entire
+selected cohort in one rollback-capable transaction; it never archives an empty
+parent epic implicitly. Versioned lifecycle provenance preserves parent
+declarations and dependency edges for restoration. Archived IDs are reserved
+until restored.
 
 ### Work, Publication, and Pull Requests
 

package/package.json

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

package/src/cli-parser.test.ts

@@ -282,6 +282,7 @@ describe("strict CLI parsing", () => {
 			],
 			[["archive", "epic", "one", "two"], "agency archive epic"],
 			[["archive", "task", "one", "two"], "agency archive task"],
+			[["archive", "tasks", "one"], "agency archive tasks"],
 			[["archive", "phase", "one", "two", "three"], "agency archive phase"],
 			[["archive", "list", "extra"], "agency archive list"],
 			[
@@ -414,6 +415,13 @@ describe("strict CLI parsing", () => {
 				values: { "dry-run": true },
 			},
 		)
+		expect(parseCli(["archive", "tasks", "--dry-run", "--json"])).toMatchObject(
+			{
+				commandName: "archive",
+				args: ["tasks"],
+				values: { "dry-run": true, json: true },
+			},
+		)
 	})
 
 	test("validates revision-guarded claim operations", () => {

package/src/cli-parser.ts

@@ -691,7 +691,7 @@ const commands = {
 		},
 	},
 	archive: {
-		usage: "agency archive <list|show|epic|task|phase>",
+		usage: "agency archive <list|show|epic|task|tasks|phase>",
 		options: {
 			...outputOptions,
 			...entitySelectorOptions,
@@ -728,6 +728,12 @@ const commands = {
 				maxArgs: 1,
 				options: ["dry-run", "json", "task"],
 			},
+			tasks: {
+				usage: "agency archive tasks [--dry-run] [--json]",
+				minArgs: 0,
+				maxArgs: 0,
+				options: ["dry-run", "json"],
+			},
 			phase: {
 				usage: "agency archive phase <task-id> <phase-id> [--dry-run] [--json]",
 				minArgs: 2,

package/src/commands/archive.test.ts

@@ -36,6 +36,14 @@ describe("archive command", () => {
 				silent: true,
 			}),
 		)
+		await runTestEffect(
+			task({
+				subcommand: "status",
+				args: ["example", "dropped"],
+				cwd: root,
+				silent: true,
+			}),
+		)
 	})
 
 	afterEach(async () => cleanupTempDir(root))
@@ -85,10 +93,40 @@ describe("archive command", () => {
 		)
 	})
 
+	test("outputs one deterministic bulk archive object and a concise human summary", async () => {
+		const jsonLogs = await captureLogs(() =>
+			runTestEffect(
+				archive({
+					type: "tasks",
+					args: [],
+					cwd: root,
+					dryRun: true,
+					json: true,
+				}),
+			),
+		)
+		expect(jsonLogs).toHaveLength(1)
+		expect(JSON.parse(jsonLogs[0]!)).toMatchObject({
+			operation: "archive",
+			kind: "tasks",
+			dryRun: true,
+			tasks: [{ id: "example", disposition: "planned" }],
+		})
+
+		const humanLogs = await captureLogs(() =>
+			runTestEffect(
+				archive({ type: "tasks", args: [], cwd: root, dryRun: true }),
+			),
+		)
+		expect(humanLogs).toEqual([
+			"Would archive 1 task: example\nSkipped 0 tasks",
+		])
+	})
+
 	test("requires a supported work item type", async () => {
 		await expect(
 			runTestEffect(archive({ args: [], cwd: root, silent: true })),
-		).rejects.toThrow("Available: list, show, epic, task, phase")
+		).rejects.toThrow("Available: list, show, epic, task, tasks, phase")
 	})
 
 	test("rejects an extra archive show identifier", async () => {

package/src/commands/archive.ts

@@ -92,6 +92,11 @@ export const archive = (options: ArchiveOptions) =>
 					dryRun: options.dryRun,
 				})
 				break
+			case "tasks":
+				result = yield* archives.archiveTasks(cwd, {
+					dryRun: options.dryRun,
+				})
+				break
 			case "phase":
 				if (!id || !phaseId)
 					return yield* Effect.fail(
@@ -104,11 +109,28 @@ export const archive = (options: ArchiveOptions) =>
 			default:
 				return yield* Effect.fail(
 					new Error(
-						"Archive operation is required. Available: list, show, epic, task, phase",
+						"Archive operation is required. Available: list, show, epic, task, tasks, phase",
 					),
 				)
 		}
 
+		if (result.kind === "tasks") {
+			const selected = result.tasks.filter(
+				(task) => task.disposition !== "skipped",
+			)
+			const skipped = result.tasks.filter(
+				(task) => task.disposition === "skipped",
+			)
+			log(
+				options.json
+					? JSON.stringify(result, null, 2)
+					: [
+							`${result.dryRun ? "Would archive" : "Archived"} ${selected.length} task${selected.length === 1 ? "" : "s"}${selected.length ? `: ${selected.map((task) => task.id).join(", ")}` : ""}`,
+							`Skipped ${skipped.length} task${skipped.length === 1 ? "" : "s"}${skipped.length ? `: ${skipped.map((task) => `${task.id} (${task.reason!.code})`).join(", ")}` : ""}`,
+						].join("\n"),
+			)
+			return
+		}
 		log(
 			options.json
 				? JSON.stringify(result, null, 2)
@@ -119,7 +141,7 @@ export const archive = (options: ArchiveOptions) =>
 	})
 
 export const help = `
-Usage: agency archive <list|show|epic|task|phase>
+Usage: agency archive <list|show|epic|task|tasks|phase>
 
 Browse or archive work items after preflighting worktrees and graph references.
 
@@ -129,6 +151,7 @@ Commands:
   show phase <task-id> <phase-id>        Show an archived phase
   epic <epic-id>                         Archive an epic and its tasks
   task <task-id>                         Archive a task
+  tasks                                 Archive all eligible terminal tasks
   phase <task-id> <phase-id>             Archive a phase
 
 Options:

package/src/commands/pr.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { chmod, mkdir, realpath } from "node:fs/promises"
+import { chmod, mkdir, realpath, rm } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { PullRequestService } from "../services/PullRequestService"
 import {
@@ -31,6 +31,7 @@ describe("pr command", () => {
 			join(bin, "gh"),
 			`#!/bin/sh
 printf '%s\n' "$PWD" "$@" > "$GH_CAPTURE"
+if [ -n "$GIT_DIR" ]; then printf 'GIT_DIR=%s\n' "$GIT_DIR" >> "$GH_CAPTURE"; fi
 exit "\${GH_EXIT:-0}"
 `,
 		)
@@ -109,6 +110,41 @@ status: open
 # Build
 `,
 		)
+		if (vcs === "jj") {
+			const repository = join(root, "repos/agency")
+			await rm(join(root, "tasks/single/code/agency"), { recursive: true })
+			await rm(join(root, "tasks/multi/phases/build/code/agency"), {
+				recursive: true,
+			})
+			const initialized = Bun.spawn(
+				["jj", "git", "init", "--no-colocate", repository],
+				{ stdout: "pipe", stderr: "pipe" },
+			)
+			if ((await initialized.exited) !== 0)
+				throw new Error(await new Response(initialized.stderr).text())
+			for (const [name, path] of [
+				["single", join(root, "tasks/single/code/agency")],
+				["build", join(root, "tasks/multi/phases/build/code/agency")],
+			] as const) {
+				const workspace = Bun.spawn(
+					[
+						"jj",
+						"-R",
+						repository,
+						"workspace",
+						"add",
+						"--name",
+						name,
+						"-r",
+						"root()",
+						path,
+					],
+					{ stdout: "pipe", stderr: "pipe" },
+				)
+				if ((await workspace.exited) !== 0)
+					throw new Error(await new Response(workspace.stderr).text())
+			}
+		}
 		return root
 	}
 
@@ -187,6 +223,7 @@ status: open
 			"--repo",
 			"example/agency",
 			"--web",
+			expect.stringMatching(/^GIT_DIR=.*\.jj/),
 		])
 
 		expect(
@@ -202,6 +239,7 @@ status: open
 			"example/agency",
 			"--title",
 			"Example",
+			expect.stringMatching(/^GIT_DIR=.*\.jj/),
 		])
 	})
 
@@ -215,6 +253,7 @@ status: open
 			await realpath(join(task, "code/agency")),
 			"pr",
 			...args,
+			expect.stringMatching(/^GIT_DIR=.*\.jj/),
 		])
 	})
 

package/src/commands/pr.ts

@@ -3,6 +3,7 @@ import { resolve } from "node:path"
 import { ContextService } from "../services/ContextService"
 import { FileSystemService } from "../services/FileSystemService"
 import { PullRequestService } from "../services/PullRequestService"
+import { VersionControlService } from "../services/VersionControlService"
 import { WorkbaseService } from "../services/WorkbaseService"
 import type { BaseCommandOptions } from "../utils/command"
 import { createLoggers } from "../utils/effect"
@@ -84,6 +85,7 @@ export const pr = (args: readonly string[], cwd: string = process.cwd()) =>
 		const contexts = yield* ContextService
 		const fs = yield* FileSystemService
 		const workbase = yield* WorkbaseService
+		const versionControl = yield* VersionControlService
 		const invocationCwd = resolve(cwd)
 		const context = yield* contexts
 			.get({ cwd: invocationCwd, target: ".", compact: true })
@@ -94,6 +96,7 @@ export const pr = (args: readonly string[], cwd: string = process.cwd()) =>
 				: null
 		const focusedCwd = writableCheckout ?? invocationCwd
 		let forwardedArgs = args
+		let environment: Record<string, string> = {}
 		if (
 			writableCheckout &&
 			context?.workbase.vcs === "jj" &&
@@ -111,10 +114,13 @@ export const pr = (args: readonly string[], cwd: string = process.cwd()) =>
 					repositoryFromRemote(remote),
 				)
 			}
+			const backend = yield* versionControl.forWorkbase(context.workbase.root)
+			environment = yield* backend.gitEnvironment(writableCheckout)
 		}
 		const result = yield* fs.runCommand(["gh", "pr", ...forwardedArgs], {
 			cwd: focusedCwd,
 			passthrough: true,
+			env: environment,
 		})
 		return result.exitCode
 	})

package/src/commands/restore.test.ts

@@ -35,6 +35,14 @@ describe("restore command", () => {
 				silent: true,
 			}),
 		)
+		await runTestEffect(
+			task({
+				subcommand: "status",
+				args: ["example", "dropped"],
+				cwd: root,
+				silent: true,
+			}),
+		)
 		await runTestEffect(
 			archive({ type: "task", args: ["example"], cwd: root, silent: true }),
 		)