@markjaquith/agency 2.47.3 → 2.48.1

package/src/services/IntegrationService.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect"
+import { createHash } from "node:crypto"
 import { join } from "node:path"
 import { FileSystemService } from "./FileSystemService"
 import { WorkbaseService } from "./WorkbaseService"
@@ -10,10 +11,6 @@ import {
 	canUpdateManagedWorkbaseOpencode,
 	managedWorkbaseOpencode,
 } from "../workbase/opencode-file"
-import {
-	canUpdateManagedWorkbaseOpencodeCommand,
-	managedWorkbaseOpencodeCommand,
-} from "../workbase/opencode-command-file"
 import {
 	canUpdateManagedWorkbaseOpencodePlugin,
 	managedWorkbaseOpencodePlugin,
@@ -33,7 +30,6 @@ interface IntegrationFileStatus {
 	readonly name:
 		| "agents"
 		| "opencode"
-		| "opencode-command"
 		| "opencode-plugin"
 		| "opencode-tui"
 		| "opencode-tui-plugin"
@@ -74,25 +70,6 @@ const describe = (
 				"Run 'agency integration sync' to install Agency instructions and whole-workbase OpenCode access.",
 		}
 	}
-	if (name === "opencode-command") {
-		return state === "managed"
-			? {
-					diagnostic: "Agency's managed OpenCode /agency command is current.",
-					remediation: null,
-				}
-			: state === "customized"
-				? {
-						diagnostic:
-							"A user-owned OpenCode /agency command is present and was preserved.",
-						remediation: null,
-					}
-				: {
-						diagnostic:
-							"The managed OpenCode /agency command needs synchronization.",
-						remediation:
-							"Run 'agency integration sync' to install the managed /agency command.",
-					}
-	}
 	if (name === "opencode-plugin") {
 		return state === "managed"
 			? {
@@ -202,8 +179,6 @@ const inspect = (root: string) =>
 		const opencodeJsonPath = join(opencodeDirectory, "opencode.json")
 		const tuiPath = join(opencodeDirectory, "tui.jsonc")
 		const tuiJsonPath = join(opencodeDirectory, "tui.json")
-		const commandPath = join(opencodeDirectory, "command", "agency.md")
-		const pluralCommandPath = join(opencodeDirectory, "commands", "agency.md")
 		const pluginPath = join(
 			opencodeDirectory,
 			"plugin",
@@ -252,29 +227,6 @@ const inspect = (root: string) =>
 			files.push(fileStatus("opencode", opencodePath, "missing"))
 		}
 
-		if ((yield* fs.readSymlinkTarget(commandPath)) !== null) {
-			files.push(fileStatus("opencode-command", commandPath, "customized"))
-		} else if (
-			(yield* fs.readSymlinkTarget(pluralCommandPath)) !== null ||
-			(yield* fs.exists(pluralCommandPath))
-		) {
-			files.push(
-				fileStatus("opencode-command", pluralCommandPath, "customized"),
-			)
-		} else if (yield* fs.exists(commandPath)) {
-			files.push(
-				classify(
-					"opencode-command",
-					commandPath,
-					yield* fs.readFile(commandPath),
-					managedWorkbaseOpencodeCommand,
-					canUpdateManagedWorkbaseOpencodeCommand,
-				),
-			)
-		} else {
-			files.push(fileStatus("opencode-command", commandPath, "missing"))
-		}
-
 		if ((yield* fs.readSymlinkTarget(pluginPath)) !== null) {
 			files.push(fileStatus("opencode-plugin", pluginPath, "customized"))
 		} else if (
@@ -348,6 +300,25 @@ const canRemoveLegacyAgents = (root: string) =>
 		return canUpdateManagedWorkbaseAgents(yield* fs.readFile(path))
 	})
 
+const canRemoveLegacyOpencodeCommand = (root: string) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		const path = join(root, ".opencode", "command", "agency.md")
+		if (
+			(yield* fs.readSymlinkTarget(path)) !== null ||
+			!(yield* fs.exists(path))
+		)
+			return false
+
+		const content = yield* fs.readFile(path)
+		const header = /^---\r?\n# agency-managed: sha256=([a-f0-9]{64})\r?\n/
+		const match = content.match(header)
+		if (!match?.[1]) return false
+
+		const canonical = content.replace(header, "---\n")
+		return createHash("sha256").update(canonical).digest("hex") === match[1]
+	})
+
 export class IntegrationService extends Effect.Service<IntegrationService>()(
 	"IntegrationService",
 	{
@@ -370,6 +341,8 @@ export class IntegrationService extends Effect.Service<IntegrationService>()(
 							(status) =>
 								status.name === "opencode" && status.state !== "customized",
 						) && (yield* canRemoveLegacyAgents(root))
+					const removeLegacyOpencodeCommand =
+						yield* canRemoveLegacyOpencodeCommand(root)
 					const files: IntegrationSyncFile[] = []
 
 					for (const status of statuses) {
@@ -382,9 +355,6 @@ export class IntegrationService extends Effect.Service<IntegrationService>()(
 							} else if (status.name === "opencode") {
 								yield* fs.createDirectory(join(root, ".opencode"))
 								yield* fs.writeFile(status.path, managedWorkbaseOpencode)
-							} else if (status.name === "opencode-command") {
-								yield* fs.createDirectory(join(root, ".opencode", "command"))
-								yield* fs.writeFile(status.path, managedWorkbaseOpencodeCommand)
 							} else if (status.name === "opencode-plugin") {
 								yield* fs.createDirectory(join(root, ".opencode", "plugin"))
 								yield* fs.writeFile(status.path, managedWorkbaseOpencodePlugin)
@@ -411,6 +381,11 @@ export class IntegrationService extends Effect.Service<IntegrationService>()(
 					}
 
 					if (removeLegacyAgents) yield* fs.deleteFile(join(root, "AGENTS.md"))
+					if (removeLegacyOpencodeCommand) {
+						yield* fs.deleteFile(
+							join(root, ".opencode", "command", "agency.md"),
+						)
+					}
 
 					return { root, files }
 				}),

package/src/workbase/AGENTS.md

@@ -16,6 +16,10 @@ Use the returned target, document paths and revisions, dependency readiness,
 authority, checkout state, PR state, and validation result. Do not infer these
 from directory names or stale prose.
 
+At the workbase root, use `agency next --json` or `agency graph --json` to choose
+work, then inspect the returned document path or explicit entity selectors. Use
+`agency --help` and `agency <command> --help` for exact command syntax.
+
 If context or doctor reports a declared but missing repository, run
 `agency repo setup --dry-run` and obtain explicit approval before
 `agency repo setup --apply`. Missing declared aliases are setup state, not a
@@ -25,27 +29,52 @@ reason to edit `agency.json` or `repos/` by hand.
 
 - An epic or multi-phase task is orchestration context and has no implementation
   write authority.
+- A single-phase task or phase is an execution unit with one writable `repo` and
+  optional read-only `repos`. Only `done` satisfies a dependency; `dropped` is
+  terminal but leaves dependents blocked.
 - For an execution unit, write code only at
   `authority.writable.checkoutPath`. Every `authority.references` checkout is
   read-only, even if filesystem permissions allow writes.
 - Keep task-wide decisions in `TASK.md` and phase-specific delivery context in
   `PHASE.md`. Use Agency commands for structural frontmatter mutations.
 
+## Consent Boundaries
+
+Require explicit user intent before initializing a workbase; changing repository
+aliases or applying repository setup or workbase sync changes; launching another
+agent from an active agent session; creating a pull request; archiving, restoring,
+dropping, or reopening work; or using `--force` to override readiness.
+
 ## Safety
 
 - Stop on validation errors, dependency blockers, an unexpected writable
   repository, or a conflicting active claim.
-- `agency work` is the local launch flow and marks execution units `working`
-  without claiming them. External orchestrators claim before launching runners.
 - Do not manually create, move, or remove worktrees under `code/`.
 - Use `agency archive`, rather than moving work item folders manually.
 - Do not edit bare repositories or repository symlinks under `repos/`.
+- Never invent entity IDs, revisions, PR state, dependency completion, or
+  checkout state. Preserve parent backlinks and dependency declarations.
+- Do not bypass dirty-worktree, active-claim, revision, or readiness protections.
 - Do not run `agency work` from an active agent session unless the user
   explicitly asks to launch another agent.
 - Run `agency validate` before worktree or pull-request operations.
 - Create a pull request only with explicit user intent, using
   `agency pr create <task> [phase]` so the URL is recorded durably.
 
+## Execution
+
+For implementation work, read the task and phase prose returned by context,
+change only the writable checkout, keep durable decisions current, and run the
+repository's formatting, type checks, build, dead-code checks, and focused tests.
+Review and commit the diff according to the repository's instructions.
+
+`agency work` is the human launch flow: it reconciles managed integration,
+selects work, checks readiness, prepares checkouts, marks execution work
+`working` without creating a claim, and starts the runner. Epic and multi-phase
+task launches remain orchestration-only. External orchestrators instead claim
+an execution unit, launch and monitor their runner separately, and finish or
+release the claim with the current document revision.
+
 ## Closeout
 
 An execution unit remains `working` after implementation is committed and while
@@ -71,15 +100,15 @@ a refinement loop, or pausing or handing off completed implementation work):
 `agency integration status` reports `managed`, `drifted`, `customized`, or
 `missing` generated files. Agency keeps these instructions in
 `.agency/AGENTS.md`, and its managed OpenCode config loads them automatically.
-It also installs `.opencode/command/agency.md`, which provides safe `/agency`
-workflows for active OpenCode sessions, a managed server plugin that exposes
-skills from the authoritative writable checkout, and an explicitly registered
-TUI companion providing `/agency-debug` without submitting an LLM prompt.
+It also installs a managed server plugin that exposes skills from the
+authoritative writable checkout and an explicitly registered TUI companion
+providing `/agency-debug` without submitting an LLM prompt.
 The workbase-root `AGENTS.md`, when present, belongs entirely to the workbase
 owner and composes with these instructions through OpenCode's normal discovery.
 `agency integration sync` updates only missing or checksum-safe drifted managed
-files and preserves user-customized files. `agency init` creates the managed
-files, and `agency work` reconciles them before launching an agent.
+files, removes checksum-valid retired artifacts, and preserves user-customized
+files. `agency init` creates the managed files, and `agency work` reconciles them
+before launching an agent.
 
 OpenCode can access the complete workbase tree, but this filesystem permission
 does not expand Agency write authority beyond the checkout reported by

package/fixtures/protocol/skill-setup-commands.json

@@ -1,18 +0,0 @@
-[
-  ["init", "/work/agency", "--json"],
-  ["workbase", "init", "/work/agency", "--json"],
-  ["repo", "add", "agency", "git@example.com:owner/agency.git", "--json"],
-  ["repo", "setup", "--dry-run", "--json"],
-  ["repo", "setup", "--apply", "--json"],
-  ["repo", "link", "agency", "/work/agency-repository", "--json"],
-  [
-    "--workbase",
-    "/work/agency",
-    "repo",
-    "link",
-    "agency",
-    "/work/agency-repository"
-  ],
-  ["validate", "/work/agency"],
-  ["--workbase", "/work/agency", "repo", "verify", "agency"]
-]

package/skills/agency/SKILL.md

@@ -1,151 +0,0 @@
----
-name: agency
-description: >
-  Operate Agency workbases, epics, tasks, phases, execution worktrees, claims,
-  and pull requests. Use when inspecting or changing Agency-managed work,
-  coordinating dependencies, launching agents, or finishing an execution unit.
-license: MIT
-compatibility: Requires the agency CLI and Git. Agent launch requires OpenCode, Claude, or a configured runner; default GitHub delivery requires gh.
----
-
-# Agency
-
-Agency keeps plans and lifecycle state in durable Markdown documents and keeps
-portable repository aliases in `agency.json`. Bare repositories under `repos/`
-and Git checkouts under `code/` are ignored local materializations. Treat tracked
-workbase state as authoritative and Agency commands as the safe mutation path.
-
-## Start With Context
-
-For an entity target, the first inspection command is:
-
-```bash
-agency context . --json
-```
-
-It identifies the target and ancestors, document revisions, dependency
-readiness, write authority, checkout state, PR state, and validation warnings.
-Use its paths and IDs instead of inferring them from the process cwd.
-
-At the workbase root, context cannot infer one entity from `.`. Use
-`agency next --json` or `agency graph --json` to choose a target, then inspect it
-with explicit `--epic`, `--task`, and `--phase` selectors or its returned document
-path. Do not pass a graph node key as a positional context target.
-
-For broader orchestration, load the graph and discover available capabilities:
-
-```bash
-agency graph --json
-agency doctor --json
-agency --help
-agency <command> --help
-```
-
-Use `agency next --json` when choosing ready execution work. Read
-[`references/contracts.md`](references/contracts.md) when consuming machine
-output or editing documents.
-
-## Mental Model
-
-- A **workbase** contains durable epics, tasks, phases, and repository aliases.
-- A repository declaration stores an alias and credential-free canonical fetch
-  remote; local bare clones and linked checkouts are replaceable machine state.
-- An **epic** coordinates tasks. It may inspect repositories but never writes code.
-- A **task** is one durable outcome. It is either an execution unit itself or a
-  container for phases.
-- A **phase** is one execution unit within a multi-phase task, normally one PR.
-- An **execution unit** has exactly one writable `repo`, optional read-only
-  `repos`, one branch, one base, and one recorded PR value.
-- `open` is eligible for readiness evaluation, `working` is actively owned, and
-  `done` or `dropped` is terminal. An open unit may still be blocked; only `done`
-  satisfies a dependency.
-
-The `authority` returned by context is decisive. Write only through
-`authority.writable.checkoutPath`. Every entry in `authority.references` is
-read-only, even if filesystem permissions permit writes.
-
-## Decide Before Acting
-
-Require explicit user intent before:
-
-- initializing a workbase;
-- adding, linking, renaming, or removing a repository alias;
-- applying repository setup or sync changes;
-- launching another agent with `agency work` from an active agent session;
-- creating a pull request;
-- archiving, restoring, dropping, or reopening work; or
-- using `--force` to override readiness.
-
-Use a single-phase task for one outcome delivered by one PR. Use phases when an
-outcome needs multiple PRs or ordered execution units. Use an epic when several
-independently meaningful tasks need coordination.
-
-## Safety Invariants
-
-- Keep task-wide decisions in `TASK.md` and phase delivery details in `PHASE.md`.
-- Never write through plural `repos` references.
-- Never edit bare repositories or repository symlinks under `repos/`.
-- Never persist local paths, symlink targets, worktrees, or credentials as
-  repository remotes.
-- Never manually create, move, or remove generated `code/` worktrees.
-- Never invent IDs, revisions, PR URLs, dependency completion, or checkout state.
-- Preserve parent backlinks and dependency declarations; use Agency mutations
-  instead of hand-editing structural frontmatter.
-- Run `agency validate` before worktree or PR operations and after structural edits.
-- Do not bypass dirty-worktree, active-claim, revision, or readiness protections.
-
-## Operating Protocol
-
-### Start
-
-1. Run `agency context . --json`.
-2. Confirm `target`, `graph.readiness`, `authority`, `workspace`, and `validation`.
-3. Read the returned task and phase document paths for prose requirements.
-4. Stop on validation errors, dependency blockers, an unexpected writable
-   repository, or a conflicting active owner. A local `agency work` launch has
-   no claim; an externally assigned agent must own the active claim.
-
-### Work
-
-1. Change files only in the declared writable checkout.
-2. Keep durable status and decisions current as the work changes.
-3. Validate structure after Agency document mutations.
-4. Run repository-specific formatting, type checks, builds, dead-code checks,
-   and focused tests before committing.
-5. Review the diff and commit according to the repository's instructions.
-
-### Finish
-
-1. Re-run `agency validate` and repository checks.
-2. Create a PR only when requested: `agency pr create <task> [phase]`.
-3. Keep committed work `working` while its pull request is open. After the
-   authoritative pull request merges, use `agency sync --apply` to reconcile it
-   to `done`.
-4. If the session has a claim, use revision-guarded `agency finish`; a successful
-   claim outcome closes ownership without marking unmerged work `done`. Use
-   `dropped` only for intentionally abandoned work.
-5. Report the durable status and PR URL. Do not manually remove the worktree.
-
-## Human Launch vs Active Agent
-
-`agency work` is a human/orchestrator launch flow. It first reconciles managed
-integration files, then selects work and checks readiness. For an execution unit,
-it materializes managed checkouts, marks it working without a claim, and starts
-the selected built-in or configured runner. Epic and multi-phase task launches
-start in orchestration context without materializing execution work. The runner
-opens without a prompt unless the human explicitly selects `--auto`.
-OpenCode launches expose the managed config file and inject runtime-only access
-rules scoped to the workbase. These grant visibility from orchestration
-directories and nested execution checkouts while denying direct edits outside
-the writable checkout. They do not make the Git-synced config machine-specific
-or replace write authority from `agency context`.
-
-An agent already running in an Agency checkout must not call `agency work` to
-start itself again. It should inspect context, perform the assigned work, and
-finish its claim or update unclaimed status directly. Launch a nested or
-replacement agent only when the user explicitly asks.
-
-Use [`references/recipes.md`](references/recipes.md) for human setup, agent
-execution, claim, PR, conversion, and recovery workflows. Use
-[`references/commands.md`](references/commands.md) only when exact command syntax
-is needed.

package/skills/agency/references/commands.md

@@ -1,188 +0,0 @@
-# Agency Command Reference
-
-Use this reference after `agency context . --json` identifies the target. The
-forms below are exact for this Agency release. Run `agency <command> --help` when
-using an option not shown here or when the installed CLI version differs.
-Commands that return Agency-owned data accept `--json` unless noted otherwise.
-
-## Discovery And Health
-
-```text
-agency context [target] [--json] [--compact | --full]
-agency graph [--json | --jsonl] [--ready | --blocked]
-  [--status <status>...] [--repository <alias>...] [--kind <kind>...]
-  [--include <bodies|workspace|git|pr>...]
-agency next [--select] [--json]
-agency status [filters] [--json]
-agency validate [path] [--json]
-agency doctor [--json]
-agency sync [--dry-run | --apply] [--json]
-agency integration status [--json]
-agency integration sync [--json]
-```
-
-`context` defaults to cwd and accepts the workbase root, entity directories,
-document paths, checkout descendants, or a task ID. Root context catalogs all
-epics, tasks, and phases in compact form and hints that `--full` includes prose.
-Entity context is complete by default; `--compact` intentionally omits prose and
-low-level Git details. `graph` computes readiness before applying filters.
-`doctor` discovers required tools, integrations, repositories, refs, worktrees,
-permissions, drift, and optional runner capabilities. `sync` is
-observational unless `--apply` is explicit. Integration status includes safe
-remediation when customized OpenCode config prevents Agency from guaranteeing
-whole-workbase access.
-
-Where `[filters]` appears, use repeatable `--status <status>` and `--repository
-<alias>`, plus `--ready` or `--blocked` and `--pr` or `--no-pr`. Each pair is
-mutually exclusive.
-
-## Workbase And Repositories
-
-```text
-agency workbase init [path] [--json]
-agency init [path] [--json] # Alias
-agency workbase add <path> [--name <name>] [--json]
-agency workbase list [--json]
-agency workbase show <id|name|path> [--json]
-agency workbase name <id|name|path> (<name> | --clear) [--json]
-agency workbase default [<id|name|path> | --clear] [--json]
-agency workbase remove <id|name|path> [--json]
-agency workbase prune [--json]
-agency repo setup [--dry-run | --apply] [--json]
-agency repo add <alias> <remote> [--json]
-agency repo link <alias> <path> [--json]
-agency repo list [--json]
-agency repo show <alias> [--json]
-agency repo fetch <alias> [--json]
-agency repo remote <alias> [remote] [--json]
-agency repo verify <alias> [--json]
-agency repo rename <alias> <new-alias> [--json]
-agency repo remove <alias> [--json]
-agency repo unlink <alias> [--json]
-```
-
-`repo setup` defaults to an observational dry-run. Apply clones declared missing
-repositories and adopts legacy materializations only when their portable origin
-is unambiguous. Invalid paths and remote drift remain unresolved.
-
-`repo add` creates a declaration and bare clone. `repo link` creates a local
-symlink while retaining or inferring a credential-free portable remote.
-`repo remove` removes both the declaration and unused local materialization;
-`repo unlink` removes only this machine's symlink and retains the declaration.
-Removal and rename refuse active references or linked worktree conflicts.
-
-## Epics, Tasks, And Phases
-
-```text
-agency epic create <id> --ticket-url <url> [--description <text>]
-  --repo <alias>:<ref>... [--json]
-agency epic list [filters] [--json]
-agency epic show <id> [--json]
-agency epic update <id> [metadata options] [--if-revision <hash>] [--json]
-agency epic rename <id> <new-id> [--if-revision <hash>] [--json]
-
-agency task new [id]
-agency task create <id> --repo <alias> [--ticket-url <url>]
-  [--description <text>] [--epic <id>] [--reference <alias>:<ref>...]
-  [--branch <name>] [--base <name>] [--json]
-agency task create <id> --multi-phase [--ticket-url <url>]
-  [--description <text>] [--epic <id>] [--json]
-agency task list [filters] [--json]
-agency task show <id> [--json]
-agency task status <id> <open|working|dropped> [--json]
-agency task update <id> [metadata options] [--if-revision <hash>] [--json]
-agency task rename <id> <new-id> [--if-revision <hash>] [--json]
-agency task move <id> (--epic <epic-id> | --no-epic)
-  [--if-revision <hash>] [--json]
-agency task dependency <add|remove> <task-id> <dependency-id>
-  [--if-revision <hash>] [--json]
-
-agency phase create <task-id> <phase-id> --repo <alias> --branch <name>
-  --base <name> [--description <text>] [--reference <alias>:<ref>...]
-  [--depends-on <phase-id>...] [--first-phase <phase-id>] [--json]
-agency phase list <task-id> [filters] [--json]
-agency phase show <task-id> <phase-id> [--json]
-agency phase status <task-id> <phase-id> <open|working|dropped> [--json]
-agency phase update <task-id> <phase-id> [metadata options]
-  [--if-revision <hash>] [--json]
-agency phase rename <task-id> <phase-id> <new-id>
-  [--if-revision <hash>] [--json]
-agency phase dependency <add|remove> <task-id> <phase-id> <dependency-id>
-  [--if-revision <hash>] [--json]
-```
-
-`task new` uses the OpenTUI Solid footer and requires a TTY. A sole repository is
-selected automatically. Agents and scripts use noninteractive `task create`.
-Mutation commands that accept `--if-revision`
-return a revision conflict instead of overwriting changed documents.
-
-## Ownership And Lifecycle
-
-```text
-agency claim <task-id> [phase-id] --claimant <id> --runner <id>
-  --session-id <id> --revision <sha256> [--expires-at <timestamp>] [--json]
-agency release <task-id> [phase-id] --session-id <id>
-  --revision <sha256> [--json]
-agency finish <task-id> [phase-id] --session-id <id>
-  --revision <sha256> --outcome <done|dropped> [--json]
-
-agency archive list [--kind <kind>] [--status <status>]
-  [--repository <alias>]
-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 phase <task-id> <phase-id> [--dry-run] [--json]
-agency restore epic <epic-id> [--dry-run] [--json]
-agency restore task <task-id> [--dry-run] [--json]
-agency restore phase <task-id> <phase-id> [--dry-run] [--json]
-```
-
-Claim mutations require the current execution-document revision. Archive and
-restore preflight graph and destination safety, remove registered clean
-worktrees when needed, preserve branches, and retain lifecycle provenance.
-
-## Worktrees, Launch, And Pull Requests
-
-```text
-agency work [<directory-or-task-id> | --epic <id> | --task <id> [--phase <id>]]
-  [--runner <name> | --opencode | --claude] [--auto] [--print-command] [--force]
-agency work prepare [target] [--dry-run] [--json]
-agency worktree list [--json]
-agency worktree inspect <task-id> [phase-id] [--json]
-agency worktree prepare <task-id> [phase-id] [--dry-run] [--json]
-agency worktree remove <task-id> [phase-id] [--dry-run] [--json]
-agency worktree rebuild <task-id> [phase-id] [--dry-run] [--json]
-agency worktree repair <task-id> [phase-id] [--dry-run] [--json]
-agency pr create <task-id> [phase-id] [--draft] [--force] [--json]
-```
-
-`work` is a local launch flow, not an active-agent step. It synchronizes managed
-integration files before launch. Execution targets are materialized and marked
-working without a claim; epics and multi-phase tasks launch in orchestration
-context without those steps. Unclaimed working targets can be launched again.
-The runner opens without a generated prompt unless `--auto` is set.
-The OpenCode runner receives a runtime managed-config path plus absolute access
-and edit rules scoped to the workbase; none are persisted, and `context` still
-defines write authority.
-`--print-command` materializes execution targets but does not launch or change
-status. `work prepare` materializes without launching or changing status.
-Destructive remove and rebuild operations refuse dirty or conflicting state.
-Conservative repair may correct registration while preserving dirty files, but
-never discards changes.
-`pr create` materializes a missing workspace, requires the resulting writable
-checkout to be clean, pushes the declared branch, invokes the configured delivery
-provider or falls back to `gh pr create --fill`, and records the returned pull
-request record.
-
-## Noninteractive Selection
-
-Use global `--workbase <id|name|path>` outside a workbase. A path may identify a
-registered workbase or an existing workbase directly. Use `--cwd <path>` to
-perform cwd inference elsewhere. Targeted commands accept `--epic`, `--task`,
-and, with a task, `--phase`. `--json`, `--no-input`, or non-TTY execution disables
-prompts; provide all selectors and required inputs explicitly.
-
-Selectors are only a resolution mechanism. There is no `assign` command. Use
-`work` for a local human launch, or use `claim` and manage an external runner
-separately.