@markjaquith/agency 2.71.27 → 2.73.0

package/README.md

@@ -441,7 +441,7 @@ variables. A worker must verify either signal against `agency context . --json`
 before acting; a matching worker performs the task directly and must not invoke
 `agency work` for the same target. Managed guidance also fails safe for older
 generated prompts when their document paths, current directory, and active valid
-context all agree. Herdr is not part of this identity contract.
+context all agree. External session state is not part of this identity contract.
 The managed OpenCode plugin validates the marker against Agency context, binds it
 to the receiving OpenCode session, injects an explicit active-worker system
 instruction, and restores Agency identity for that session's shell environment.
@@ -752,6 +752,7 @@ agency integration sync [--json]
 agency repo setup [--dry-run | --apply] [--json]
 agency repo add <alias> <remote> [--json]
 agency repo link <alias> <path> [--json]
+agency repo materialize <alias> [--json]
 agency repo list [--json]
 agency repo show <alias> [--json]
 agency repo fetch <alias> [--json]
@@ -784,7 +785,11 @@ Each registration has a stable ID and may have a unique name. A default workbase
 is used when the current directory is outside every workbase. `prune` removes
 registrations whose workbase configuration no longer exists.
 `repo add` creates a bare clone. `repo link` creates a symlink to an existing Git
-repository. Alias names are then used by all documents and commands. Remove,
+repository. For Git workbases, `repo materialize` replaces a linked alias with a
+managed bare clone while migrating its registered worktrees in place; active
+Agency references continue to use the same alias. The command refuses remote
+drift and stale worktree registrations. Alias names are then used by all
+documents and commands. Remove,
 unlink, and rename refuse aliases referenced by active work or backed by linked
 worktrees, and report each blocker.
 
@@ -855,13 +860,13 @@ includes `selector`, absolute `documentPath`, the document `revision`, full
 `validation`, normalized `recalledContext`, and `evidence`. Evidence version 1 is
 an auditable local payload containing the canonical workbase root, target and
 document identities, aggregate workbase revision, configuration revision,
-repository-mapping revision, kickoff-contract version, validity result, recalled
+repository-mapping revision, execution-contract version, validity result, recalled
 context, and a digest over those fields. It is not a signature or an authority
 grant. A different workbase, target, document revision, document set,
 configuration, repository mapping, contract version, or payload digest
 invalidates reuse. Older creation output without evidence remains compatible;
 preflight simply validates again. The published machine schema is
-`schemas/agency-kickoff-v1.schema.json`.
+`schemas/agency-execution-v1.schema.json`.
 
 Create investigation-only work with the existing task architecture:
 
@@ -1123,12 +1128,18 @@ promptless by default; use `--auto` to send Agency's generated context prompt.
 `agency work prepare` resolves an execution unit and creates or reuses its
 writable and reference worktrees, or its single pinned review checkout, without
 launching an agent or changing status.
+Managed workbase guidance provides exact fast paths for 15 common intents:
+single-phase creation; create-and-start; materialization; remote PR sync; phase
+conversion; archive; review creation and start; status inspection; drop;
+continuation; publication and PR creation; non-PR completion; initial multi-phase
+setup; investigation handoff; and review refresh.
 Its JSON result includes the workspace, validation result, whether supplied
 evidence was `reused` or `refreshed` with stable reason strings, refreshed
-evidence, and a versioned `agency-kickoff-v1` orchestration plan. The plan has a
-deterministic idempotency key and ordered, retry-safe actions for worktree
-preflight/preparation, a background tab, side-by-side task document,
-`agency work . --auto`, and exactly one final `agency context <document> --json`.
+evidence, and a versioned `agency-execution-v1` contract. The contract reports
+whether preparation was previewed or applied, a stable target identity, prepared
+workspace and document paths, and canonical Agency-native commands for starting
+work and reading context. It does not prescribe how callers present or execute
+prepared work.
 The evidence argument may be an evidence object, task-creation JSON, or a path to
 either. Use `--dry-run` to report planned fetch, branch, and worktree changes
 without applying them. Validation reuse never skips readiness, active-claim,
@@ -1137,7 +1148,7 @@ checks.
 
 The authoritative implementation locations for this contract are
 `src/commands/task.ts` (creation output),
-`src/workbase/kickoff-contract.ts` (evidence and orchestration schemas),
+`src/workbase/execution-contract.ts` (evidence and execution schemas),
 `src/commands/work.ts` (launch preflight),
 `src/services/WorktreeService.ts` (workspace safety), and
 `src/workbase/AGENTS.md` (generated OpenCode guidance). These paths are the

package/index.ts

@@ -2,4 +2,4 @@ export * from "./src/workbase/schemas"
 export * from "./src/protocol"
 export * from "./src/graph-schema"
 export * from "./src/readiness"
-export * from "./src/workbase/kickoff-contract"
+export * from "./src/workbase/execution-contract"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.27",
+  "version": "2.73.0",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -46,8 +46,8 @@
     "./schemas/agency-graph-v1.json": {
       "default": "./schemas/agency-graph-v1.schema.json"
     },
-    "./schemas/agency-kickoff-v1.json": {
-      "default": "./schemas/agency-kickoff-v1.schema.json"
+    "./schemas/agency-execution-v1.json": {
+      "default": "./schemas/agency-execution-v1.schema.json"
     },
     "./fixtures/protocol/success.json": {
       "default": "./fixtures/protocol/success.json"

package/schemas/{agency-kickoff-v1.schema.json → agency-execution-v1.schema.json}

@@ -1,10 +1,10 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://github.com/markjaquith/agency/schemas/agency-kickoff-v1.schema.json",
-  "title": "Agency kickoff contract v1",
+  "$id": "https://github.com/markjaquith/agency/schemas/agency-execution-v1.schema.json",
+  "title": "Agency execution contract v1",
   "oneOf": [
     { "$ref": "#/$defs/validationEvidence" },
-    { "$ref": "#/$defs/kickoffPlan" }
+    { "$ref": "#/$defs/executionContract" }
   ],
   "$defs": {
     "recalledContext": {
@@ -54,69 +54,93 @@
       },
       "additionalProperties": false
     },
-    "kickoffPlan": {
+    "command": {
+      "type": "object",
+      "required": ["cwd", "argv"],
+      "properties": {
+        "cwd": { "type": "string" },
+        "argv": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "type": "string" }
+        }
+      },
+      "additionalProperties": false
+    },
+    "executionContract": {
       "type": "object",
       "required": [
         "version",
-        "idempotencyKey",
+        "capability",
+        "mode",
+        "executionIdentity",
         "workbaseRoot",
-        "target",
-        "documentRevision",
         "sourceLocations",
-        "taskDirectory",
-        "taskDocument",
-        "phaseDocument",
-        "preparedCheckout",
-        "orchestrator",
-        "steps",
-        "successFields"
+        "workspace",
+        "commands"
       ],
       "properties": {
         "version": { "const": 1 },
-        "idempotencyKey": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "capability": { "const": "agency-execution-v1" },
+        "mode": { "enum": ["preview", "applied"] },
+        "executionIdentity": {
+          "type": "object",
+          "required": ["key", "target", "documentRevision"],
+          "properties": {
+            "key": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+            "target": { "type": "string" },
+            "documentRevision": {
+              "type": "string",
+              "pattern": "^[a-f0-9]{64}$"
+            }
+          },
+          "additionalProperties": false
+        },
         "workbaseRoot": { "type": "string" },
-        "target": { "type": "string" },
-        "documentRevision": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
-        "sourceLocations": { "type": "array", "items": { "type": "string" } },
-        "taskDirectory": { "type": "string" },
-        "taskDocument": { "type": "string" },
-        "phaseDocument": { "type": ["string", "null"] },
-        "preparedCheckout": { "type": ["string", "null"] },
-        "orchestrator": {
+        "sourceLocations": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "workspace": {
           "type": "object",
           "required": [
-            "capability",
-            "knownCurrentCommandsBypassDiscovery",
-            "fallback"
+            "state",
+            "executionDirectory",
+            "taskDocument",
+            "phaseDocument",
+            "checkoutPath"
           ],
           "properties": {
-            "capability": { "const": "agency-kickoff-v1" },
-            "knownCurrentCommandsBypassDiscovery": { "const": true },
-            "fallback": { "type": "string" }
+            "state": { "enum": ["planned", "materialized"] },
+            "executionDirectory": { "type": "string" },
+            "taskDocument": { "type": "string" },
+            "phaseDocument": { "type": ["string", "null"] },
+            "checkoutPath": { "type": ["string", "null"] }
           },
           "additionalProperties": false
         },
-        "steps": {
+        "plannedActions": {
           "type": "array",
-          "minItems": 6,
           "items": {
             "type": "object",
-            "required": ["id"],
+            "required": ["kind", "target", "checkoutPath"],
             "properties": {
-              "id": { "type": "string" },
-              "argv": { "type": "array", "items": { "type": "string" } },
-              "cwd": { "type": "string" },
-              "action": { "type": "string" },
-              "path": { "type": "string" },
-              "retry": { "type": "string" },
-              "recovery": { "type": "string" },
-              "idempotencyKey": { "type": "string" },
-              "exactlyOnce": { "type": "boolean" }
+              "kind": { "const": "workspace-materialization" },
+              "target": { "type": "string" },
+              "checkoutPath": { "type": ["string", "null"] }
             },
             "additionalProperties": false
           }
         },
-        "successFields": { "type": "array", "items": { "type": "string" } }
+        "commands": {
+          "type": "object",
+          "required": ["work", "context"],
+          "properties": {
+            "work": { "$ref": "#/$defs/command" },
+            "context": { "$ref": "#/$defs/command" }
+          },
+          "additionalProperties": false
+        }
       },
       "additionalProperties": false
     }

package/src/commands/repo.test.ts

@@ -23,7 +23,9 @@ describe("repo command", () => {
 	test("requires a subcommand", async () => {
 		await expect(
 			runTestEffect(repo({ args: [], silent: true })),
-		).rejects.toThrow("Available subcommands: setup, add, link, list")
+		).rejects.toThrow(
+			"Available subcommands: setup, add, link, materialize, list",
+		)
 	})
 
 	test("requires add arguments", async () => {
@@ -34,6 +36,14 @@ describe("repo command", () => {
 		).rejects.toThrow("Usage: agency repo add")
 	})
 
+	test("requires a materialize alias", async () => {
+		await expect(
+			runTestEffect(
+				repo({ subcommand: "materialize", args: [], silent: true }),
+			),
+		).rejects.toThrow("Usage: agency repo materialize <alias>")
+	})
+
 	test("lists repository metadata as JSON", async () => {
 		const logs = await captureLogs(() =>
 			runTestEffect(

package/src/commands/repo.ts

@@ -74,6 +74,21 @@ export const repo = (options: RepoOptions) =>
 				return
 			}
 
+			case "materialize": {
+				const alias = yield* requireArg(
+					options.args,
+					0,
+					"Usage: agency repo materialize <alias>",
+				)
+				const item = yield* repositories.materialize(alias, cwd)
+				log(
+					options.json
+						? JSON.stringify(item, null, 2)
+						: `Materialized repository '${alias}'`,
+				)
+				return
+			}
+
 			case "list": {
 				const items = yield* repositories.list(cwd)
 				if (options.json) {
@@ -187,7 +202,7 @@ export const repo = (options: RepoOptions) =>
 			default:
 				return yield* Effect.fail(
 					new Error(
-						"Subcommand is required. Available subcommands: setup, add, link, list, show, fetch, remove, unlink, rename, remote, verify",
+						"Subcommand is required. Available subcommands: setup, add, link, materialize, list, show, fetch, remove, unlink, rename, remote, verify",
 					),
 				)
 		}
@@ -200,6 +215,7 @@ Subcommands:
   setup                 Plan or apply portable repository setup
   add <alias> <remote>  Create a bare clone
   link <alias> <path>   Link an existing Git repository
+  materialize <alias>   Replace a linked alias with a managed bare clone
   list                  List repository aliases
   show <alias>          Show a repository alias
   fetch <alias>         Fetch and prune a repository

package/src/commands/task.ts

@@ -15,7 +15,7 @@ import { ReviewService } from "../services/ReviewService"
 import {
 	buildValidationEvidence,
 	normalizeRecalledContext,
-} from "../workbase/kickoff-contract"
+} from "../workbase/execution-contract"
 
 interface TaskOptions extends BaseCommandOptions {
 	readonly subcommand?: string

package/src/commands/work.test.ts

@@ -532,12 +532,15 @@ describe("work command", () => {
 		const result = JSON.parse(output!)
 		expect(result.validationEvidence.status).toBe("refreshed")
 		expect(result.validationEvidence.reasons).toEqual(["not-supplied"])
-		expect(result.kickoff.target).toBe("execution-unit:task/example")
-		expect(
-			result.kickoff.steps.filter(
-				({ id }: { id: string }) => id === "final-context-verification",
-			),
-		).toHaveLength(1)
+		expect(result.execution).toMatchObject({
+			capability: "agency-execution-v1",
+			mode: "preview",
+			executionIdentity: { target: "execution-unit:task/example" },
+			workspace: { state: "planned" },
+			commands: {
+				work: { argv: ["agency", "work", ".", "--auto"] },
+			},
+		})
 
 		const [reusedOutput] = await captureLogs(() =>
 			harness.runPrepare({

package/src/commands/work.ts

@@ -31,11 +31,11 @@ import {
 } from "../workbase/agent-command"
 import {
 	assessValidationEvidence,
-	buildKickoffPlan,
+	buildExecutionContract,
 	buildValidationEvidence,
 	normalizeRecalledContext,
 	readValidationEvidence,
-} from "../workbase/kickoff-contract"
+} from "../workbase/execution-contract"
 
 export interface WorkOptions extends BaseCommandOptions {
 	readonly directory?: string
@@ -556,22 +556,21 @@ export const workPrepare = (options: WorkOptions = {}) =>
 			workspace,
 			validation,
 			validationEvidence: { ...assessment.disposition, evidence },
-			kickoff: buildKickoffPlan({
+			execution: buildExecutionContract({
 				workbaseRoot: root,
 				target,
-				taskId,
-				phaseId: phase?.id,
 				taskPath: task.path,
 				phasePath: phase?.path,
 				checkoutPath: workspace.writablePath ?? workspace.reviewPath,
 				documentRevision: document.revision,
+				dryRun: options.dryRun === true,
 			}),
 		}
 		if (options.json) {
 			log(JSON.stringify(result, null, 2))
 		} else {
 			log(
-				`${workspace.dryRun ? "Kickoff plan" : "Workspace ready"}: ${workspace.writablePath ?? workspace.reviewPath}`,
+				`${workspace.dryRun ? "Workspace plan" : "Workspace ready"}: ${workspace.writablePath ?? workspace.reviewPath}`,
 			)
 		}
 	})

package/src/services/IntegrationService.test.ts

@@ -156,19 +156,46 @@ describe("IntegrationService", () => {
 		])
 	})
 
-	test("generates the canonical Agency kickoff recipe with precedence", () => {
-		expect(managedWorkbaseAgents).toContain(
-			"takes precedence over generic Herdr defaults",
+	test("generates the complete Agency command fast paths with precedence", () => {
+		const body = managedBody(managedWorkbaseAgents)
+
+		expect(body.indexOf("## Command Fast Paths")).toBeLessThan(
+			body.indexOf("## Bootstrap"),
 		)
 		expect(managedWorkbaseAgents).toContain(
+			"take precedence over separately installed Agency skill guidance",
+		)
+		for (const recipe of [
+			"Create a single-phase task only",
 			"agency work prepare <slug> --evidence",
+			"Materialize an existing execution unit without starting it",
+			"agency sync <task> [phase] --json",
+			"agency phase create <task> <new-phase> --first-phase <existing-phase>",
+			"agency archive task <task> --dry-run --json",
+			"agency task create <slug> --review <alias>",
+			"agency status --json",
+			"agency task status <task> dropped --if-revision <revision> --json",
+			"Continue already materialized work",
+			"agency pr create <task> [phase]",
+			"agency finish <task> [phase] --session-id <id>",
+			"agency task create <slug> --multi-phase",
+			"agency task handoff <investigation-task> <new-task>",
+			"agency review refresh <task> --if-revision <revision> --json",
+		]) {
+			expect(managedWorkbaseAgents).toContain(recipe)
+		}
+		expect(managedWorkbaseAgents).toContain("agency push --json")
+		expect(managedWorkbaseAgents).toContain("agency-execution-v1")
+		expect(managedWorkbaseAgents).toContain(
+			"Never pass `--work` or `--auto` to `agency task create`",
 		)
-		expect(managedWorkbaseAgents).toContain("agency-kickoff-v1")
 		expect(managedWorkbaseAgents).toContain(
-			"call Herdr help, skill, or CLI discovery",
+			"Use `agency <command> --help` only as a recovery",
+		)
+		expect(managedWorkbaseAgents).not.toContain("`agency --help`")
+		expect(managedWorkbaseAgents).not.toContain(
+			"`agency worktree prepare <task>",
 		)
-		expect(managedWorkbaseAgents).toContain("exactly one final")
-		expect(managedWorkbaseAgents).toContain("leave the agent in the")
 	})
 
 	test("generates a dynamic workbase plugin", () => {
@@ -597,8 +624,10 @@ describe("IntegrationService", () => {
 		expect(body).toContain("Agency worker launch target: <target>.")
 		expect(body).toContain("environment variables and a generated")
 		expect(body).toContain("the initial instruction is a generated")
-		expect(body).toContain("Herdr state is never part of worker identity")
-		expect(body).toMatch(/If the prompt\s+and context disagree/)
+		expect(body).toContain(
+			"External session state is never part of worker identity",
+		)
+		expect(body).toMatch(/If\s+the prompt\s+and context disagree/)
 		expect(body).toContain("marks execution work")
 		expect(body).toContain("without creating a claim")
 		expect(body).toContain("formatting, type checks, build, dead-code checks")
@@ -657,7 +686,9 @@ describe("IntegrationService", () => {
 				description:
 					"Handles Agency workbase orchestration and workflow operations with the Agency CLI",
 				mode: "subagent",
-				prompt: expect.stringContaining("agency context . --json"),
+				prompt: expect.stringMatching(
+					/agency context \. --json[\s\S]+agency work prepare[\s\S]+never pass `--work` or `--auto`/,
+				),
 			},
 			plan: {
 				disable: true,
@@ -689,10 +720,7 @@ describe("IntegrationService", () => {
 		expect(config.agent.agency.hidden).toBeUndefined()
 		expect(config.agent.agency.steps).toBeUndefined()
 		expect(config.agent.agency.prompt).toContain(
-			"verify that the agent started successfully",
-		)
-		expect(config.agent.agency.prompt).toContain(
-			"return without waiting for the task to finish",
+			"Return the prepared execution contract to the caller",
 		)
 		expect(config.agent["agency-plan"].prompt).toContain(
 			"Start with `agency context . --json`",

package/src/services/RepositoryService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { mkdir, stat } from "node:fs/promises"
+import { mkdir, realpath, stat } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { RepositoryService } from "./RepositoryService"
@@ -16,6 +16,18 @@ const runGit = async (args: string[]) => {
 	}
 }
 
+const gitOutput = async (args: string[]) => {
+	const process = Bun.spawn(["git", ...args], {
+		stdout: "pipe",
+		stderr: "pipe",
+	})
+	await process.exited
+	if (process.exitCode !== 0) {
+		throw new Error(await new Response(process.stderr).text())
+	}
+	return (await new Response(process.stdout).text()).trim()
+}
+
 const portableRemote = (name: string) =>
 	`https://example.com/agency-tests/${name}.git`
 
@@ -159,6 +171,143 @@ describe("RepositoryService", () => {
 		})
 	})
 
+	test("materializes a linked alias without invalidating active worktrees", async () => {
+		const target = join(root, "linked-repository")
+		const checkout = join(root, "tasks/active/code/linked")
+		await mkdir(target, { recursive: true })
+		await runGit(["init", "--initial-branch=main", target])
+		await runGit(["-C", target, "config", "user.email", "test@example.com"])
+		await runGit(["-C", target, "config", "user.name", "Test"])
+		await Bun.write(join(target, "README.md"), "linked\n")
+		await runGit(["-C", target, "add", "README.md"])
+		await runGit(["-C", target, "commit", "-m", "initial"])
+		await setPortableOrigin(target, "materialized")
+		await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.link("linked", target, root)),
+			),
+		)
+		await write(
+			root,
+			"tasks/active/TASK.md",
+			`---
+ticketUrl: null
+repo: linked
+branch: task/active
+base: main
+pr: null
+status: working
+---
+`,
+		)
+		await mkdir(dirname(checkout), { recursive: true })
+		await runGit([
+			"-C",
+			target,
+			"worktree",
+			"add",
+			"-b",
+			"task/active",
+			checkout,
+			"main",
+		])
+		await Bun.write(join(checkout, "dirty.txt"), "preserved\n")
+
+		const result = await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.materialize("linked", root)),
+			),
+		)
+
+		expect(result.kind).toBe("bare")
+		expect(result.target).toBeNull()
+		expect(result.states).toEqual(["declared", "materialized"])
+		expect(await Bun.file(join(checkout, "dirty.txt")).text()).toBe(
+			"preserved\n",
+		)
+		expect(await gitOutput(["-C", checkout, "branch", "--show-current"])).toBe(
+			"task/active",
+		)
+		expect(
+			await gitOutput(["-C", checkout, "rev-parse", "--git-common-dir"]),
+		).toBe(await realpath(join(root, "repos/linked")))
+		expect(
+			await gitOutput(["-C", target, "worktree", "list", "--porcelain"]),
+		).not.toContain(checkout)
+		expect(await Bun.file(join(target, ".git/HEAD")).exists()).toBe(true)
+		expect(await Bun.file(join(root, "tasks/active/TASK.md")).text()).toContain(
+			"repo: linked",
+		)
+	})
+
+	test("materializes an alias linked through an existing worktree", async () => {
+		const primary = join(root, "primary-repository")
+		const linkedWorktree = join(root, "linked-worktree")
+		await mkdir(primary, { recursive: true })
+		await runGit(["init", "--initial-branch=main", primary])
+		await runGit(["-C", primary, "config", "user.email", "test@example.com"])
+		await runGit(["-C", primary, "config", "user.name", "Test"])
+		await Bun.write(join(primary, "README.md"), "linked worktree\n")
+		await runGit(["-C", primary, "add", "README.md"])
+		await runGit(["-C", primary, "commit", "-m", "initial"])
+		await setPortableOrigin(primary, "linked-worktree")
+		await runGit([
+			"-C",
+			primary,
+			"worktree",
+			"add",
+			"-b",
+			"linked-branch",
+			linkedWorktree,
+			"main",
+		])
+		await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) =>
+					service.link("linked", linkedWorktree, root),
+				),
+			),
+		)
+
+		await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.materialize("linked", root)),
+			),
+		)
+
+		expect(
+			await gitOutput(["-C", linkedWorktree, "rev-parse", "--git-common-dir"]),
+		).toBe(await realpath(join(root, "repos/linked")))
+		expect(
+			await gitOutput(["-C", primary, "worktree", "list", "--porcelain"]),
+		).not.toContain(linkedWorktree)
+	})
+
+	test("refuses to materialize linked aliases in jj workbases", async () => {
+		if (!Bun.which("jj")) return
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({ version: 2, vcs: "jj" }),
+		)
+		const target = join(root, "linked-jj-repository")
+		await mkdir(target, { recursive: true })
+		await runGit(["init", "--initial-branch=main", target])
+		await setPortableOrigin(target, "linked-jj")
+		await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.link("linked", target, root)),
+			),
+		)
+
+		await expect(
+			runTestEffect(
+				RepositoryService.pipe(
+					Effect.flatMap((service) => service.materialize("linked", root)),
+				),
+			),
+		).rejects.toThrow("only supported for Git workbases")
+	})
+
 	test("rejects invalid and duplicate aliases", async () => {
 		const source = join(root, "source.git")
 		await runGit(["init", "--bare", "--initial-branch=main", source])