@markjaquith/agency 2.73.2 → 3.0.0

package/README.md

@@ -9,7 +9,6 @@ read or write.
 
 - [Bun](https://bun.sh) 1.0 or newer
 - Git
-- [Jujutsu](https://jj-vcs.github.io/jj/) is preferred when available
 - [GitHub CLI](https://cli.github.com/) for `agency pr`
 - OpenCode, Claude Code, or a configured agent for `agency work`
 
@@ -151,15 +150,16 @@ the writable checkout's `.claude/skills`, `.agents/skills`,
 `.opencode/{skill,skills}`, and `.pi/skills` directories. `agency context`
 remains the authority for writes; reference checkouts remain read-only.
 
-Repository aliases, the version-control backend, and canonical fetch remotes are
-declared in tracked `agency.json`; local clones and symlinks remain ignored under
-`repos/{alias}`. A declaration contains no local path, symlink target, checkout,
-or credential:
+Repository aliases and canonical fetch remotes are declared in tracked
+`agency.json`; local Git clones and symlinks remain ignored under
+`repos/{alias}`. A declaration contains no local path, symlink target, worktree,
+or credential. The optional `vcs` field accepts only `"git"`; omitting it also
+selects Git:
 
 ```json
 {
 	"version": 2,
-	"vcs": "jj",
+	"vcs": "git",
 	"repositories": {
 		"frontend": {
 			"remote": "git@example.com:team/frontend.git"
@@ -168,39 +168,9 @@ 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 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:
-
-```bash
-agency vcs status
-agency vcs migrate jj          # dry-run
-agency vcs migrate jj --apply
-agency vcs migrate git --apply
-```
-
-Migration is workbase-wide and transactional. Agency locks every execution
-unit, requires clean registered workspaces, blocks active claims and working or
-delegated units, converts repository metadata, recreates checkout paths with the
-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.
+Agency materializes declared remotes as bare Git repositories and creates
+managed Git worktrees for execution units. Linked aliases remain symlinks to
+existing Git repositories.
 
 Existing version 2 workbases without `repositories` remain valid. Run
 `agency repo setup` to preview deterministic adoption of legacy local aliases;
@@ -274,63 +244,13 @@ Agency also reconciles known tool-owned artifacts such as Worktrunk's
 new and existing managed worktrees clean without changing the repository's
 tracked ignore configuration or overwriting user-maintained local excludes.
 
-The configured command applies only to the writable checkout of a Git workbase.
+The configured command applies only to the writable checkout.
 Supplemental read-only repositories remain detached Git worktrees at their
-declared refs so they do not acquire writable branches. Jj workbases always use
-jj workspaces and ignore this Git-specific customization.
-
-### Custom Jj Workspace Command
-
-Jj workbases normally create managed workspaces with `jj workspace add`. Set
-`workspaceCreateCommand` to an argv template when another tool should create or
-adopt a prepared workspace directly at Agency's destination:
-
-```json
-{
-	"version": 2,
-	"vcs": "jj",
-	"workspaceCreateCommand": [
-		"my-prewarm-tool",
-		"adopt",
-		"--repo",
-		"{repo}",
-		"--destination",
-		"{workspace}",
-		"--name",
-		"{name}",
-		"--revision",
-		"{revision}"
-	]
-}
-```
-
-Available placeholders are:
-
-- `{repo}`: absolute repository alias path under `repos/`
-- `{workspace}`: absolute managed workspace path Agency requires
-- `{name}`: unique jj workspace name Agency requires
-- `{revision}`: exact commit the new working copy must be based on
-- `{kind}`: `writable` or `reference`
-- `{requestedRef}`: configured branch, reference, or review commit
-
-`{repo}`, `{workspace}`, `{name}`, and `{revision}` are required. Agency invokes
-the command directly without a shell and sets matching `AGENCY_REPO`,
-`AGENCY_WORKSPACE`, `AGENCY_WORKSPACE_NAME`, `AGENCY_REVISION`,
-`AGENCY_CHECKOUT_KIND`, and `AGENCY_REQUESTED_REF` environment variables. The
-command applies to each new jj checkout and must leave `{workspace}` registered
-under `{name}` with its working-copy parent at `{revision}`. This lets a prewarm
-tool move or adopt a prepared workspace without first paying for Agency's normal
-full checkout.
-
-Agency validates the registration, name, path, and revision before running any
-`postCheckoutCommand`. A failed command or validation removes a partially
-created workspace when possible and otherwise reports manual recovery. Resume
-restoration continues to use Agency's built-in exact-target recovery path.
-Git workbases ignore this jj-specific customization.
+declared refs so they do not acquire writable branches.
 
 ### Post-checkout Commands
 
-Each repository declaration may provide a VCS-neutral `postCheckoutCommand` argv
+Each repository declaration may provide a `postCheckoutCommand` argv
 template for repository-specific setup. Agency invokes it directly, without a
 shell, with the new checkout as its working directory:
 
@@ -346,11 +266,10 @@ shell, with the new checkout as its working directory:
 }
 ```
 
-The hook runs for each newly created managed checkout, including writable and
-reference checkouts, after Git worktree or jj workspace creation has completed
-and Agency has validated the checkout. It does not run for a reused checkout or
-for inspection-only commands. A custom `worktreeCreateCommand` or
-`workspaceCreateCommand` completes and is validated before this hook runs.
+The hook runs for each newly created managed Git worktree, including writable
+and reference worktrees, after Agency has validated it. It does not run for a
+reused worktree or for inspection-only commands. A custom
+`worktreeCreateCommand` completes and is validated before this hook runs.
 
 Available placeholders and matching environment variables are:
 
@@ -362,7 +281,7 @@ Available placeholders and matching environment variables are:
 | `{checkoutKind}`   | `AGENCY_CHECKOUT_KIND`   | `writable` or `reference`                      |
 | `{requestedRef}`   | `AGENCY_REQUESTED_REF`   | Requested branch, reference, or review commit  |
 | `{base}`           | `AGENCY_BASE`            | Configured execution base                      |
-| `{vcs}`            | `AGENCY_VCS`             | `git` or `jj`                                  |
+| `{vcs}`            | `AGENCY_VCS`             | `git`                                          |
 | `{workbaseRoot}`   | `AGENCY_WORKBASE_ROOT`   | Absolute workbase root                         |
 | `{taskId}`         | `AGENCY_TASK_ID`         | Task ID                                        |
 | `{phaseId}`        | `AGENCY_PHASE_ID`        | Phase ID                                       |
@@ -631,7 +550,7 @@ included in generated or executed pull request commands.
 
 ### Target Context
 
-`agency context [target] --json` returns complete bootstrap context without
+`agency context [target] --json` returns compact bootstrap context without
 modifying the workbase or fetching repositories. At the workbase root it returns
 a discovery catalog of all epics, tasks, and phases, including frontmatter,
 paths, and document revisions. Elsewhere it returns context for an epic, task,
@@ -642,15 +561,15 @@ explicitly marked with `target.archived: true` and never grants writable
 document, repository checkout, or reference authority; restore the item before
 attempting mutation or execution.
 
-Root discovery is compact by default and includes a hint to run `agency context
-. --full --json` when document prose is needed. Entity context remains complete
-by default. `--compact` explicitly requests compact entity context.
+Root discovery and entity context are compact by default. Root discovery includes
+a hint to run `agency context . --full --json` when document prose is needed.
+`--compact` remains available as an explicit request for the compact projection.
 
-The result includes workbase and target identity, ancestor frontmatter and prose
-with SHA-256 hashes, dependency and readiness state, aggregate status, writable
-and reference authority, local checkout and resolved-commit state, recorded PR
-state, and validation warnings. Only `done` satisfies a dependency; `dropped` is
-terminal but remains a blocker.
+The result includes workbase and target identity, ancestor frontmatter with
+SHA-256 hashes, dependency and readiness state, aggregate status, writable and
+reference authority, local materialization state, recorded PR state, and
+validation warnings. Only `done` satisfies a dependency; `dropped` is terminal
+but remains a blocker.
 
 `authority.writable` identifies the writable repository checkout, while
 `authority.documents.writable` lists the absolute paths of Agency documents the
@@ -658,10 +577,9 @@ target may maintain. A single-phase task lists its `TASK.md`; a phase lists its
 owning `TASK.md` and active `PHASE.md`; orchestration targets list none. Use
 Agency commands rather than direct edits for structural frontmatter mutations.
 
-Complete output is the default for entity targets. Pass `--compact` explicitly
-to omit document prose and low-level Git details while retaining identity,
-hashes, authority, paths, graph state, materialization state, and validation
-warnings.
+Pass `--full` to include document prose and low-level VCS details. Compact output
+retains identity, hashes, authority, paths, graph state, materialization state,
+recorded PR state, and validation warnings.
 
 ### Workbase Graph
 
@@ -1163,15 +1081,6 @@ conflicting worktrees. Repair is deliberately conservative: it repairs safe Git
 registration issues and materializes missing checkouts, but never switches a
 branch, resets a commit, or discards uncommitted work.
 
-For jj, explicit removal is a suspend operation. Agency records each workspace's
-exact `@` commit and stable change ID in `.agency-jj-resume.json`, roots that
-commit with an internal local bookmark, and only then forgets the workspace.
-The next `work prepare` validates all three identities, restores the workspace by
-editing the recorded commit, and consumes the resume metadata and bookmarks.
-Missing, ambiguous, or conflicting resume state stops instead of falling back to
-the declared delivery bookmark, `@-`, or the base. Unknown checkout cleanliness
-also stops removal. Git worktree removal and preparation are unchanged.
-
 Agency launches every agent beside its epic or task document. Single-phase tasks
 and phases first fetch repositories and create or reuse worktrees under `code/`,
 then launch the execution agent from the task directory with absolute context
@@ -1196,18 +1105,11 @@ that the declared base is in the publication history, validates every outgoing
 commit's description, author, and conflict state, and refuses non-fast-forward
 updates.
 
-For Git, YAML `branch` must exactly match the checked-out local branch, the
-worktree must be clean, and `HEAD` is pushed with upstream tracking. For jj, YAML
-`branch` is the authoritative delivery bookmark and need not exist before
-publication. Agency publishes `@` unless it is the canonical empty, undescribed
-post-commit working copy, in which case it publishes `@-`; described empty
-changes remain intentional publication tips. Missing descriptions or authors
-stop with exact change IDs and remediation commands. Agency creates or safely
-advances only the declared bookmark and never invents a `push-*` bookmark.
-If the fetched remote base advanced outside the local stack, Agency prints the
-exact `jj rebase` command needed to move the stack onto `<base>@<remote>`. Push
-reports deterministic fetch, inspection, validation, and publication progress
-on stderr, including while `--json` reserves stdout for one machine result.
+YAML `branch` must exactly match the checked-out local branch, the worktree must
+be clean, and `HEAD` is pushed with upstream tracking. Missing commit descriptions
+or authors stop publication with exact commits and remediation commands. Push
+reports deterministic fetch, inspection, validation, and publication progress on
+stderr, including while `--json` reserves stdout for one machine result.
 
 Task-aware `agency pr create <task-id> [phase-id]` uses Agency's delivery flow,
 including readiness checks and durable PR recording. It accepts draft, title,
@@ -1217,8 +1119,7 @@ Other `agency pr`
 invocations forward every argument to `gh pr`. From an execution task or phase
 directory, including descendants, passthrough runs in that execution unit's
 authoritative writable checkout. Otherwise it runs in the caller's current
-directory. In jj workbases, Agency also supplies the repository and the work
-item's declared branch to subcommands that would otherwise infer Git context.
+directory.
 
 ### Status and Validation
 

package/cli-main.ts

@@ -48,12 +48,9 @@ import { DoctorService } from "./src/services/DoctorService"
 import { ReviewService } from "./src/services/ReviewService"
 import {
 	GitVersionControlService,
-	JjVersionControlService,
 	VersionControlService,
 } from "./src/services/VersionControlService"
 import { review, help as reviewHelp } from "./src/commands/review"
-import { vcs, help as vcsHelp } from "./src/commands/vcs"
-import { VcsMigrationService } from "./src/services/VcsMigrationService"
 import { act, help as actHelp } from "./src/commands/act"
 import {
 	claimCommand,
@@ -74,9 +71,7 @@ const CliLayer = Layer.mergeAll(
 	FileSystemService.Default,
 	WorkbaseService.Default,
 	GitVersionControlService.Default,
-	JjVersionControlService.Default,
 	VersionControlService.Default,
-	VcsMigrationService.Default,
 	RepositoryService.Default,
 	EpicService.Default,
 	TaskService.Default,
@@ -623,26 +618,6 @@ const commands: Record<string, Command> = {
 			)
 		},
 	},
-	vcs: {
-		run: async (args: string[], options: Record<string, any>) => {
-			if (options.help) {
-				console.log(vcsHelp)
-				return
-			}
-			await runCommand(
-				vcs({
-					subcommand: args[0],
-					target: args[1],
-					apply: options.apply,
-					dryRun: options["dry-run"],
-					json: options.json,
-					silent: options.silent,
-					verbose: options.verbose,
-					cwd: options.cwd,
-				}),
-			)
-		},
-	},
 	next: {
 		run: async (_args: string[], options: Record<string, any>) => {
 			if (options.help) return console.log(nextHelp)
@@ -802,7 +777,6 @@ Commands:
   task <subcommand>      Manage tasks
   work [directory|task]  Work on an epic, task, or phase
   worktree <subcommand>  Inspect and maintain managed workspaces
-  vcs <subcommand>       Inspect or migrate the version-control backend
   next                   List or select ready execution units
   pr create / pr [...]  Create an Agency PR or run gh pr with repository focus
   push                   Validate and publish the current execution unit

package/cli.ts

@@ -1,19 +1,3 @@
 #!/usr/bin/env bun
 
-const args = Bun.argv.slice(2)
-const fastVcsStatus =
-	args[0] === "vcs" &&
-	args[1] === "status" &&
-	(args.length === 2 || (args.length === 3 && args[2] === "--json"))
-
-if (fastVcsStatus) {
-	try {
-		const { runVcsStatusFast } = await import("./src/vcs-status-fast")
-		if (!(await runVcsStatusFast(args[2] === "--json")))
-			await import("./cli-main")
-	} catch {
-		await import("./cli-main")
-	}
-} else {
-	await import("./cli-main")
-}
+await import("./cli-main")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.73.2",
+  "version": "3.0.0",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -83,7 +83,6 @@
     "benchmark:graph": "bun scripts/benchmark-graph.ts",
     "benchmark:push": "bun scripts/benchmark-push.ts",
     "benchmark:archive": "bun scripts/benchmark-archive.ts",
-    "benchmark:vcs": "bun scripts/benchmark-vcs.ts",
     "benchmark:sync": "bun scripts/benchmark-sync.ts",
     "benchmark:task": "bun scripts/benchmark-task.ts",
     "benchmark:validate": "bun scripts/benchmark-validate.ts",

package/schemas/agency-graph-v1.schema.json

@@ -22,7 +22,7 @@
       "required": ["version"],
       "properties": {
         "version": { "const": 2 },
-        "vcs": { "enum": ["git", "jj"] },
+        "vcs": { "enum": ["git"] },
         "root": { "type": "string" }
       }
     },

package/src/cli-parser.test.ts

@@ -674,25 +674,6 @@ describe("strict CLI parsing", () => {
 		)
 	})
 
-	test("parses VCS status and migration commands", () => {
-		expect(parseCli(["vcs", "status", "--json"])).toMatchObject({
-			commandName: "vcs",
-			args: ["status"],
-			values: { json: true },
-		})
-		expect(
-			parseCli(["vcs", "migrate", "jj", "--apply", "--json"]),
-		).toMatchObject({
-			commandName: "vcs",
-			args: ["migrate", "jj"],
-			values: { apply: true, json: true },
-		})
-		expectUsageError(["vcs", "migrate"], "agency vcs migrate")
-		expect(() =>
-			parseCli(["vcs", "migrate", "jj", "--dry-run", "--apply"]),
-		).toThrow("cannot be combined")
-	})
-
 	test("parses push without accepting an alternate target", () => {
 		expect(parseCli(["push", "--json"])).toMatchObject({
 			commandName: "push",

package/src/cli-parser.ts

@@ -908,29 +908,6 @@ const commands = {
 			},
 		},
 	},
-	vcs: {
-		usage: "agency vcs <status|migrate>",
-		options: {
-			...outputOptions,
-			apply: { type: "boolean" },
-			"dry-run": { type: "boolean" },
-		},
-		subcommands: {
-			status: {
-				usage: "agency vcs status [--json]",
-				minArgs: 0,
-				maxArgs: 0,
-				options: ["json"],
-			},
-			migrate: {
-				usage: "agency vcs migrate <git|jj> [--dry-run | --apply] [--json]",
-				minArgs: 1,
-				maxArgs: 1,
-				options: ["apply", "dry-run", "json"],
-				conflicts: [["apply", "dry-run"]],
-			},
-		},
-	},
 	work: {
 		usage:
 			"agency work [<directory-or-task-id> | --epic <epic-id>] [--agent <name>] [--auto] | agency work prepare [target] [--dry-run] [--json]",

package/src/cli.test.ts

@@ -1929,9 +1929,9 @@ status: open
 				alias: "agency",
 				status: "applied",
 			})
-			expect(
-				(await stat(join(restored, "repos/agency/.jj"))).isDirectory(),
-			).toBe(true)
+			expect((await stat(join(restored, "repos/agency/HEAD"))).isFile()).toBe(
+				true,
+			)
 
 			const prepared = parseJson(
 				await runCli(["work", "prepare", "portable", "--json"], restored),

package/src/commands/context.test.ts

@@ -161,9 +161,9 @@ Phase prose.
 		await cleanupTempDir(root)
 	})
 
-	test("returns complete phase context with graph, authority, Git, and validation state", async () => {
+	test("returns full phase context with graph, authority, Git, and validation state", async () => {
 		const target = "tasks/agent-contract/phases/context-command"
-		const result = await readContext(root, target)
+		const result = await readContext(root, target, false, true)
 
 		expect(result).toMatchObject({
 			projection: "complete",
@@ -219,81 +219,19 @@ Phase prose.
 		)
 	})
 
-	test("reports the current jj change without inventing a missing bookmark", async () => {
-		if (!Bun.which("jj")) return
-		await cleanupTempDir(root)
-		root = await createTempDir()
-		const remote = join(root, "remote.git")
-		const seed = join(root, "seed")
-		const repository = join(root, "repos/agency")
-		const checkout = join(root, "tasks/example/code/agency")
-		await mkdir(join(root, "repos"), { recursive: true })
-		await write(root, "agency.json", '{"version":2,"vcs":"jj"}\n')
-		await run(root, ["git", "init", "--bare", "--initial-branch=main", remote])
-		await run(root, ["git", "init", "--initial-branch=main", seed])
-		await run(seed, ["git", "config", "user.email", "test@example.com"])
-		await run(seed, ["git", "config", "user.name", "Test"])
-		await Bun.write(join(seed, "README.md"), "example\n")
-		await run(seed, ["git", "add", "README.md"])
-		await run(seed, ["git", "commit", "-m", "initial"])
-		await run(seed, ["git", "remote", "add", "origin", remote])
-		await run(seed, ["git", "push", "origin", "main"])
-		await run(root, ["jj", "git", "clone", "--no-colocate", remote, repository])
-		await write(
+	test("defaults to compact while preserving explicit compact compatibility", async () => {
+		const result = await readContext(
 			root,
-			"tasks/example/TASK.md",
-			`---
-ticketUrl: null
-repo: agency
-branch: task/example
-base: main
-pr: null
-status: working
----
-
-# Example
-`,
-		)
-		await mkdir(dirname(checkout), { recursive: true })
-		await run(repository, [
-			"jj",
-			"workspace",
-			"add",
-			"--name",
-			"task-example",
-			"-r",
-			"main",
-			checkout,
-		])
-		await Bun.write(join(checkout, "feature.txt"), "current change\n")
-		const current = Bun.spawn(
-			["jj", "log", "--no-graph", "-r", "@", "-T", "commit_id"],
-			{ cwd: checkout, stdout: "pipe", stderr: "pipe" },
-		)
-		const currentCommit = (await new Response(current.stdout).text()).trim()
-		expect(await current.exited).toBe(0)
-
-		const result = await readContext(root, "tasks/example")
-		expect(result.workspace.writable).toMatchObject({
-			branchCommit: null,
-			checkoutCommit: currentCommit,
-			checkoutBranch: null,
-			detached: true,
-			dirty: false,
-		})
-		expect(result.workspace.warnings).toContain(
-			`Unable to resolve branch 'task/example' in ${repository}`,
+			"tasks/agent-contract/phases/context-command/code/agency",
 		)
-	})
-
-	test("makes compact projection explicit without omitting essential identity", async () => {
-		const result = await readContext(
+		const explicit = await readContext(
 			root,
 			"tasks/agent-contract/phases/context-command/code/agency",
 			true,
 		)
 
 		expect(result.projection).toBe("compact")
+		expect(explicit).toEqual(result)
 		expect(result.target.kind).toBe("phase")
 		expect(result.documents.phase.body).toBeUndefined()
 		expect(result.documents.phase.data.branch).toBe("feat/context")
@@ -441,7 +379,7 @@ status: dropped
 			join(root, "archive/tasks/foundations"),
 		)
 
-		const result = await readContext(root, "foundations")
+		const result = await readContext(root, "foundations", false, true)
 
 		expect(result.target).toMatchObject({
 			kind: "task",
@@ -488,6 +426,8 @@ status: dropped
 		const result = await readContext(
 			root,
 			"archive/tasks/agent-contract/phases/context-command",
+			false,
+			true,
 		)
 
 		expect(result.target).toMatchObject({
@@ -529,7 +469,7 @@ status: dropped
 			)
 		}
 
-		const result = await readContext(root, "epics/contract")
+		const result = await readContext(root, "epics/contract", false, true)
 
 		expect(result.target).toMatchObject({
 			kind: "epic",

package/src/commands/context.ts

@@ -21,16 +21,16 @@ export const context = (options: ContextOptions = {}) =>
 export const help = `
 Usage: agency context [target] [options]
 
-Return complete, read-only context for a workbase, epic, task, or phase. The
-target defaults to the current directory and may be the workbase root, an entity
-path, or a task ID. Archived entities are inspectable but never receive mutation
-or execution authority. Workbase context catalogs all active epics, tasks, and
-phases.
+Return read-only context for a workbase, epic, task, or phase. Compact output is
+the default. The target defaults to the current directory and may be the workbase
+root, an entity path, or a task ID. Archived entities are inspectable but never
+receive mutation or execution authority. Workbase context catalogs all active
+epics, tasks, and phases.
 
 Options:
   --json              Output a versioned machine result
-  --compact           Omit prose bodies and low-level Git details
-  --full              Include prose bodies in root workbase context
+  --compact           Use compact output (default)
+  --full              Include prose bodies and low-level VCS details
   --epic <id>         Select an epic
   --task <id>         Select a task
   --phase <id>        Select a phase together with --task

package/src/commands/init.test.ts

@@ -8,7 +8,6 @@ import {
 	runTestEffect,
 } from "../test-utils"
 import { init } from "./init"
-import { preferredVersionControl } from "../workbase/version-control"
 
 describe("init command", () => {
 	let parent: string
@@ -27,7 +26,7 @@ describe("init command", () => {
 
 		expect(await Bun.file(join(root, "agency.json")).json()).toEqual({
 			version: 2,
-			vcs: preferredVersionControl(),
+			vcs: "git",
 		})
 		for (const directory of ["repos", "epics", "tasks"]) {
 			expect((await stat(join(root, directory))).isDirectory()).toBe(true)