devrites 3.2.5 → 3.2.7

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to DevRites are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and DevRites adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Releases are generated automatically by [semantic-release](https://semantic-release.gitbook.io/) from Conventional Commits on `main`.
 
+## [3.2.7](https://github.com/ViktorsBaikers/DevRites/compare/v3.2.6...v3.2.7) (2026-07-26)
+
+### Fixed
+
+* **agents:** enforce conditional v2 dispatch ([f4169d4](https://github.com/ViktorsBaikers/DevRites/commit/f4169d41c456f352172be8d96afdcdc69800d849))
+* **ci:** satisfy staticcheck error style ([0023265](https://github.com/ViktorsBaikers/DevRites/commit/00232656283647db8d94b2ed61dccb1629091b25))
+
+## [3.2.6](https://github.com/ViktorsBaikers/DevRites/compare/v3.2.5...v3.2.6) (2026-07-25)
+
+### Changed
+
+* **devrites:** remove package-existence gate ([4cbcbe9](https://github.com/ViktorsBaikers/DevRites/commit/4cbcbe9002eaf97f8f921e13e97b4dcfc6b61b34))
+
 ## [3.2.5](https://github.com/ViktorsBaikers/DevRites/compare/v3.2.4...v3.2.5) (2026-07-25)
 
 ### Fixed

package/README.md

@@ -25,7 +25,7 @@ final commit, push, and tag, and it requires a typed `GO` confirmation.
 Unattended runs may create local WIP checkpoint commits along the way, but only
 Ship collapses and pushes them.
 
-**Status:** [`v3.2.5`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v3.2.5): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v3.2.7`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v3.2.7): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 ## Quick start
 

package/docs/cli.md

@@ -21,7 +21,6 @@ devrites-engine recovery route <class>             # typed owner/action; JSON re
 devrites-engine recovery check|record|clear ...    # durable three-failure budget; record/clear accept --class
 devrites-engine reconcile snapshot|check|close [slug] # retained writer baseline
 devrites-engine test-integrity [slug]    # reject weakened tests against that baseline
-devrites-engine package-existence [slug] # verify new imports are declared
 devrites-engine evidence-fresh [slug]    # proof freshness gate      (exit 0 fresh · 3 stale)
 devrites-engine check-acceptance <dir>   # acceptance gate           (exit 0 proven · 1 gap)
 devrites-engine ledger sync <dir>        # fold a feature's spec deltas into the living capability ledger

package/docs/command-map.md

@@ -41,7 +41,7 @@ these lanes so its owner is clear:
 
 | Lane | Commands | Owner |
 |---|---|---|
-| Workflow gates | `preamble`, `build-readiness`, `readiness-digest`, `spec-skeleton`, `spec-validate`, `check-acceptance`, `evidence-fresh`, `coverage`, `doubt-coverage`, `budget`, `test-integrity`, `mutation-gate`, `package-existence`, `review-integrity`, `footprint`, `reconcile`, `conventions`, `learnings`, `review-fingerprints`, `timeline`, `health`, `progress` | Called by the relevant `rite-*` workflow or shared reply contract. |
+| Workflow gates | `preamble`, `build-readiness`, `readiness-digest`, `spec-skeleton`, `spec-validate`, `check-acceptance`, `evidence-fresh`, `coverage`, `doubt-coverage`, `budget`, `test-integrity`, `mutation-gate`, `review-integrity`, `footprint`, `reconcile`, `conventions`, `learnings`, `review-fingerprints`, `timeline`, `health`, `progress` | Called by the relevant `rite-*` workflow or shared reply contract. |
 | Workspace utilities | `status`, `snapshot`, `analyze`, `archive-search`, `clarify-return`, `recovery`, `resolve`, `close-out`, `stuck`, `tick-afk`, `ledger`, `profile` | Called by a specific utility/phase when its condition is met. |
 | Low-level completeness API | `readiness`, `seal` | Available for scripts/CI and documented engine use. Feature rites use stricter phase-specific gates (`build-readiness`, `/rite-seal` phase contract) instead of auto-running these weaker aggregate checks. |
 | Install / operator / CI | `install`, `update`, `uninstall`, `doctor`, `migrate`, `validate-pack`, `harness-matrix`, `extensions`, `overrides`, `reviewers`, `hook`, `version` | Called by `npx devrites ...`, `/rite-doctor`, hooks, CI, or a human operator; do not auto-run during feature work just because the command exists. |

package/docs/orchestration.md

@@ -65,8 +65,7 @@ Each dispatch follows the retained-baseline sequence:
 2. The sole wright returns code/tests; the root validates its typed identity and
    exact changed-file set.
 3. `reconcile check` rejects anything outside the root allowlist.
-4. `test-integrity` and `package-existence` run against the same retained
-   baseline.
+4. `test-integrity` runs against the retained baseline.
 5. After proof and decision checks pass, `reconcile close` retires the private
    window; only then does the root write canonical records.
 

package/engine/commands.go

@@ -34,7 +34,7 @@ func rootModeFor(command string, args []string) rootMode {
 	case "first-task", "spec-dedupe", "evidence-fresh", "coverage",
 		"doubt-coverage", "budget", "preamble", "progress",
 		"build-readiness", "readiness-digest", "analyze", "mutation-gate",
-		"test-integrity", "review-integrity", "package-existence",
+		"test-integrity", "review-integrity",
 		"archive-search", "config", "reviewers", "outside-voice", "docs-stale",
 		"secret-scan", "lanes", "overrides":
 		return rootLenient

package/engine/hooks_agent_dispatch.go

@@ -25,6 +25,7 @@ const (
 	agentDispatchStateVersion = "devrites-agent-dispatch/v1"
 	agentDispatchStateDir     = "devrites-agent-dispatch-v1"
 	agentDispatchMetadataRole = "devrites-skill-contract-error"
+	agentDispatchSkillGuard   = "devrites-skill-dispatch-guard"
 	maxCodexRolloutLine       = 8 << 20
 )
 
@@ -309,22 +310,24 @@ func requiredAgentRolesFromSkill(path string) ([]string, error) {
 	return roles, nil
 }
 
-func requiredRolesInPrompt(root, text string) ([]string, error) {
+func requiredRolesInPrompt(root, text string) ([]string, bool, error) {
 	seen := map[string]struct{}{}
+	skillInvoked := false
 	skillsDir := filepath.Join(filepath.Dir(root), ".agents", "skills")
 	for _, match := range skillInvocationRe.FindAllStringSubmatch(text, -1) {
 		skill := strings.ToLower(match[1])
 		path := filepath.Join(skillsDir, skill, "SKILL.md")
 		if !safepath.WithinResolved(path, skillsDir) {
-			return nil, fmt.Errorf("unsafe skill path for %s", skill)
+			return nil, false, fmt.Errorf("unsafe skill path for %s", skill)
 		}
 		roles, err := requiredAgentRolesFromSkill(path)
 		if os.IsNotExist(err) {
 			continue
 		}
 		if err != nil {
-			return nil, fmt.Errorf("%s: %w", skill, err)
+			return nil, false, fmt.Errorf("%s: %w", skill, err)
 		}
+		skillInvoked = true
 		for _, role := range roles {
 			seen[role] = struct{}{}
 		}
@@ -334,7 +337,7 @@ func requiredRolesInPrompt(root, text string) ([]string, error) {
 		roles = append(roles, role)
 	}
 	sort.Strings(roles)
-	return roles, nil
+	return roles, skillInvoked, nil
 }
 
 func expectedAgentType(role string) string {
@@ -488,6 +491,19 @@ func durableCodexV2DispatchAttempts(
 	}
 	var attempts []*agentDispatchAttempt
 	for _, spawn := range spawns {
+		if !devritesAgentNameRe.MatchString(spawn.Role) || spawn.Role == agentDispatchSkillGuard {
+			if strings.TrimSpace(spawn.Result) != "" {
+				return nil, fmt.Errorf("codex V2 completed a default or non-DevRites child during a DevRites skill turn; %s", conditionalDispatchInstruction())
+			}
+			continue
+		}
+		armed[spawn.Role] = struct{}{}
+		attempt := &agentDispatchAttempt{
+			Role:      spawn.Role,
+			AgentType: spawn.Role,
+			Started:   true,
+		}
+		attempts = append(attempts, attempt)
 		if strings.TrimSpace(spawn.Result) == "" || !lineBetween(waitLines, spawn.SpawnLine, spawn.ResultLine) {
 			continue
 		}
@@ -504,24 +520,17 @@ func durableCodexV2DispatchAttempts(
 		if childID == "" || strings.TrimSpace(childResult) == "" {
 			continue
 		}
-		windowID := ""
+		attempt.AgentID = childID
+		attempt.Stopped = true
+		attempt.Waited = true
 		if spawn.Role == "devrites-slice-wright" {
-			windowID = currentReconcileWindowID()
-			if windowID == "" || !reconcileWindowPredates(spawn.SpawnedAt) {
+			attempt.WindowID = currentReconcileWindowID()
+			if attempt.WindowID == "" || !reconcileWindowPredates(spawn.SpawnedAt) {
 				continue
 			}
 		}
 		sum := sha256.Sum256([]byte(childResult))
-		attempts = append(attempts, &agentDispatchAttempt{
-			Role:         spawn.Role,
-			AgentType:    spawn.Role,
-			AgentID:      childID,
-			WindowID:     windowID,
-			Started:      true,
-			Stopped:      true,
-			Waited:       true,
-			ResultSHA256: hex.EncodeToString(sum[:]),
-		})
+		attempt.ResultSHA256 = hex.EncodeToString(sum[:])
 	}
 	return attempts, nil
 }
@@ -570,6 +579,7 @@ func readCodexV2ParentRollout(
 	spawns := map[string]*codexV2Spawn{}
 	var waitLines []int
 	metaSeen := false
+	_, guarded := armed[agentDispatchSkillGuard]
 	scanner := bufio.NewScanner(file)
 	scanner.Buffer(make([]byte, 64<<10), maxCodexRolloutLine)
 	for lineNumber := 1; scanner.Scan(); lineNumber++ {
@@ -604,9 +614,9 @@ func readCodexV2ParentRollout(
 			if json.Unmarshal([]byte(record.Payload.Arguments), &args) != nil {
 				continue
 			}
-			if _, required := armed[args.AgentType]; !required ||
-				args.TaskName == "" || strings.Contains(args.TaskName, "/") ||
-				args.ForkTurns != "none" {
+			_, required := armed[args.AgentType]
+			if (!required && !guarded) || args.TaskName == "" ||
+				strings.Contains(args.TaskName, "/") || args.ForkTurns != "none" {
 				continue
 			}
 			spawnedAt, err := time.Parse(time.RFC3339Nano, record.Timestamp)
@@ -797,9 +807,23 @@ func roleSatisfied(role, windowID string, attempts []*agentDispatchAttempt) bool
 	return false
 }
 
+func dispatchInstruction(role string) string {
+	return fmt.Sprintf(
+		"On MultiAgent V2 call spawn_agent with agent_type=%s, a unique task_name, and fork_turns=\"none\" so Codex loads .codex/agents/%s.toml natively. GPT-5.6 V2 may omit agent_type from the visible tool schema even though the runtime accepts it; send agent_type anyway rather than using a default child. On V1 use agent_type=%s with fork_turns=\"none\" and name that role TOML in the message. Wait for the returned child and use its non-empty result. Do not call wait before spawn_agent and do not synthesize the agent result.",
+		role, role, expectedAgentType(role),
+	)
+}
+
+func conditionalDispatchInstruction() string {
+	return "CONDITIONAL DISPATCH RULE — If this skill reaches a child-agent step, call spawn_agent with the exact named agent_type=devrites-<role> specified by the skill, a unique task_name, and fork_turns=\"none\". GPT-5.6 V2 may omit agent_type from the visible tool schema; send agent_type anyway and never use a default child. Wait for the returned child and use its non-empty result."
+}
+
 func incompleteDispatchReason(armed map[string]struct{}, attempts []*agentDispatchAttempt) string {
 	roles := make([]string, 0, len(armed))
 	for role := range armed {
+		if role == agentDispatchSkillGuard {
+			continue
+		}
 		if !roleSatisfied(role, "", attempts) {
 			roles = append(roles, role)
 		}
@@ -812,10 +836,7 @@ func incompleteDispatchReason(armed map[string]struct{}, attempts []*agentDispat
 	if role == agentDispatchMetadataRole {
 		return "DevRites could not determine this skill's required agents because its installed required-agent-roles contract is invalid. Reinstall or repair the DevRites skill pack before continuing."
 	}
-	return fmt.Sprintf(
-		"DevRites dispatch for %s is not complete. On MultiAgent V2 call spawn_agent with agent_type=%s, a unique task_name, and fork_turns=\"none\" so Codex loads .codex/agents/%s.toml natively. GPT-5.6 V2 may omit agent_type from the visible tool schema even though the runtime accepts it; send agent_type anyway rather than using a default child. On V1 use agent_type=%s with fork_turns=\"none\" and name that role TOML in the message. Wait for the returned child and use its non-empty result. Do not call wait before spawn_agent and do not synthesize the agent result.",
-		role, role, role, expectedAgentType(role),
-	)
+	return fmt.Sprintf("DevRites dispatch for %s is not complete. %s", role, dispatchInstruction(role))
 }
 
 func preToolDeny(h harness.Harness, reason string, stdout, stderr io.Writer) int {
@@ -888,7 +909,7 @@ func hookAgentDispatch(h harness.Harness, stdin io.Reader, stdout, stderr io.Wri
 
 	switch in.HookEventName {
 	case "UserPromptSubmit":
-		roles, rolesErr := requiredRolesInPrompt(root, in.Prompt)
+		roles, skillInvoked, rolesErr := requiredRolesInPrompt(root, in.Prompt)
 		if rolesErr != nil {
 			if err := appendAgentDispatchEvent(root, in.SessionID, agentDispatchEvent{
 				Event:  "armed",
@@ -899,6 +920,15 @@ func hookAgentDispatch(h harness.Harness, stdin io.Reader, stdout, stderr io.Wri
 			}
 			return stopDispatchBlock(h, "DevRites could not read the required agent roles: "+rolesErr.Error(), stdout, stderr)
 		}
+		if skillInvoked {
+			if err := appendAgentDispatchEvent(root, in.SessionID, agentDispatchEvent{
+				Event:  "armed",
+				TurnID: in.TurnID,
+				Role:   agentDispatchSkillGuard,
+			}); err != nil {
+				return stopDispatchBlock(h, "DevRites could not arm the skill dispatch guard: "+err.Error(), stdout, stderr)
+			}
+		}
 		for _, role := range roles {
 			if err := appendAgentDispatchEvent(root, in.SessionID, agentDispatchEvent{
 				Event:  "armed",
@@ -909,7 +939,21 @@ func hookAgentDispatch(h harness.Harness, stdin io.Reader, stdout, stderr io.Wri
 			}
 		}
 		if len(roles) > 0 {
-			fmt.Fprintf(stdout, "DevRites: this turn requires a confirmed %s subagent start, wait, and non-empty result; a success phrase is not evidence.", strings.Join(roles, ", "))
+			instructions := make([]string, 0, len(roles))
+			for _, role := range roles {
+				instructions = append(instructions, dispatchInstruction(role))
+			}
+			fmt.Fprintf(
+				stdout,
+				"MANDATORY DISPATCH THIS TURN — At the skill's dispatch step, execute every required child before finishing or claiming completion; a success phrase is not evidence.\n%s",
+				strings.Join(instructions, "\n"),
+			)
+		}
+		if skillInvoked {
+			if len(roles) > 0 {
+				fmt.Fprintln(stdout)
+			}
+			fmt.Fprint(stdout, conditionalDispatchInstruction())
 		}
 		return exitOK
 
@@ -949,7 +993,8 @@ func hookAgentDispatch(h harness.Harness, stdin io.Reader, stdout, stderr io.Wri
 			return stopDispatchBlock(h, "DevRites could not verify the required agent dispatch: "+err.Error(), stdout, stderr)
 		}
 		armed, attempts := dispatchTurnState(events, in.TurnID)
-		if reason := incompleteDispatchReason(armed, attempts); reason != "" {
+		_, guarded := armed[agentDispatchSkillGuard]
+		if reason := incompleteDispatchReason(armed, attempts); reason != "" || guarded && len(attempts) == 0 {
 			durable, durableErr := durableCodexV2DispatchAttempts(
 				root, in.SessionID, in.TurnID, armed,
 			)
@@ -979,10 +1024,17 @@ func hookAgentDispatchPreTool(h harness.Harness, root string, in agentDispatchHo
 	if isAgentDispatchTool(in.ToolName) {
 		agentType := in.ToolInput.AgentType
 		if agentType == "" {
-			if len(armed) == 0 {
-				return exitOK
+			roles := explicitRolesInText(in.ToolInput.Message + "\n" + in.ToolInput.TaskName)
+			if len(roles) == 1 {
+				return preToolDeny(h, "DevRites conditional dispatch requires the exact named specialist. "+dispatchInstruction(roles[0]), stdout, stderr)
+			}
+			if reason := incompleteDispatchReason(armed, attempts); reason != "" {
+				return preToolDeny(h, reason, stdout, stderr)
 			}
-			return preToolDeny(h, "DevRites MultiAgent V2 dispatch requires the exact named agent_type=devrites-<role>; omitting agent_type does not load the specialist role contract.", stdout, stderr)
+			if _, guarded := armed[agentDispatchSkillGuard]; guarded {
+				return preToolDeny(h, conditionalDispatchInstruction(), stdout, stderr)
+			}
+			return exitOK
 		}
 		role := ""
 		if strings.HasPrefix(agentType, "devrites-") {
@@ -995,11 +1047,20 @@ func hookAgentDispatchPreTool(h harness.Harness, root string, in agentDispatchHo
 		}
 		if role == "" {
 			if agentType == "explorer" || agentType == "worker" {
-				if len(armed) == 0 {
+				if reason := incompleteDispatchReason(armed, attempts); reason != "" {
+					return preToolDeny(h, reason, stdout, stderr)
+				}
+				if _, guarded := armed[agentDispatchSkillGuard]; !guarded {
 					return exitOK // Unrelated generic subagent in a DevRites repository.
 				}
 				return preToolDeny(h, "DevRites generic dispatch must name exactly one .codex/agents/devrites-<role>.toml contract.", stdout, stderr)
 			}
+			if reason := incompleteDispatchReason(armed, attempts); reason != "" {
+				return preToolDeny(h, reason, stdout, stderr)
+			}
+			if _, guarded := armed[agentDispatchSkillGuard]; guarded {
+				return preToolDeny(h, conditionalDispatchInstruction(), stdout, stderr)
+			}
 			return exitOK
 		}
 		instructions, contractErr := agentRoleDeveloperInstructions(root, role)
@@ -1016,7 +1077,7 @@ func hookAgentDispatchPreTool(h harness.Harness, root string, in agentDispatchHo
 			return preToolDeny(h, "devrites-slice-wright requires the generic worker identity and exact wright allowlist.", stdout, stderr)
 		}
 		if agentType != "" && agentType != role && agentType != expectedAgentType(role) {
-			return preToolDeny(h, fmt.Sprintf("DevRites role %s requires agent_type=%s or its exposed named role.", role, expectedAgentType(role)), stdout, stderr)
+			return preToolDeny(h, fmt.Sprintf("DevRites role %s requires agent_type=%s or its exposed named role. %s", role, expectedAgentType(role), dispatchInstruction(role)), stdout, stderr)
 		}
 		if in.ToolUseID == "" {
 			return preToolDeny(h, "DevRites cannot bind a spawn without tool_use_id.", stdout, stderr)
@@ -1057,7 +1118,11 @@ func hookAgentDispatchPreTool(h harness.Harness, root string, in agentDispatchHo
 			}
 		}
 		if len(started) == 0 {
-			return preToolDeny(h, incompleteDispatchReason(armed, attempts), stdout, stderr)
+			reason := incompleteDispatchReason(armed, attempts)
+			if reason == "" {
+				reason = conditionalDispatchInstruction()
+			}
+			return preToolDeny(h, reason, stdout, stderr)
 		}
 		targets := in.ToolInput.ReceiverThreadIDs
 		if len(targets) == 0 {

package/engine/internal/lib/reconcile.go

@@ -34,7 +34,7 @@ const (
 // clean check, another snapshot re-arms only the dispatch state for a retry while
 // retaining the original source baseline.
 // `check` compares the captured state with the current state and retains the
-// immutable baseline for the later test-integrity and package-existence gates.
+// immutable baseline for the later test-integrity gate.
 // `close` explicitly ends the window and removes its private artifacts.
 //
 //	0  clean check, snapshot/close completed, or skipped (not a git repo)

package/engine/internal/lib/reconcile_test.go

@@ -408,15 +408,13 @@ func TestReconcileCheckFailsClosedWhenObjectDatabaseIsCorrupt(t *testing.T) {
 	}
 }
 
-func TestPostSliceGatesShareBaselineUntilClose(t *testing.T) {
+func TestPostSliceTestIntegrityUsesBaselineUntilClose(t *testing.T) {
 	gitRoot := newGitRepo(t)
 	root := workspace(t, "feat")
-	writeFile(t, filepath.Join(gitRoot, "package.json"), "{}\n")
-	commitAll(t, gitRoot, "manifest")
+	writeFile(t, filepath.Join(gitRoot, "README.md"), "fixture\n")
+	commitAll(t, gitRoot, "baseline")
 
-	// These user deltas predate the slice. In particular, the undeclared import
-	// must not be blamed on the wright by package-existence.
-	writeFile(t, filepath.Join(gitRoot, "src/user-delta.ts"), `import ghost from "preexisting-user-package";`+"\n")
+	// This user delta predates the slice and must not be blamed on the wright.
 	writeFile(t, filepath.Join(gitRoot, "tests/user_delta_test.go"), "package tests\n\nfunc TestUserDelta(t *testing.T) { t.Fatal(\"baseline\") }\n")
 	writeWrightAllowlist(t, root, "feat", "seed.go")
 
@@ -432,12 +430,6 @@ func TestPostSliceGatesShareBaselineUntilClose(t *testing.T) {
 	if code := TestIntegrity(root, []string{"feat"}, &stdout, &stderr); code != 0 {
 		t.Fatalf("test-integrity = %d, want 0\nstdout: %s\nstderr: %s", code, stdout.String(), stderr.String())
 	}
-	stdout.Reset()
-	stderr.Reset()
-	if code := PackageExistence(root, []string{"feat"}, &stdout, &stderr); code != 0 {
-		t.Fatalf("package-existence = %d, want 0\nstdout: %s\nstderr: %s", code, stdout.String(), stderr.String())
-	}
-
 	if code, out := runReconcile(t, root, "close", "feat"); code != 0 {
 		t.Fatalf("close = %d, want 0\n%s", code, out)
 	}

package/engine/internal/lib/util.go

@@ -7,8 +7,8 @@ import (
 )
 
 // gitToplevel returns the absolute path of the git working tree containing dir,
-// or "" when dir is not inside a repository. The git-backed gates (test-integrity,
-// package-existence, reconcile) skip rather than block when it is empty.
+// or "" when dir is not inside a repository. The git-backed gates
+// (test-integrity and reconcile) skip rather than block when it is empty.
 func gitToplevel(dir string) string {
 	out, err := exec.Command("git", "-C", dir, "rev-parse", "--show-toplevel").Output()
 	if err != nil {

package/engine/main.go

@@ -56,7 +56,6 @@ Usage:
   devrites-engine mutation-gate [slug]     Advisory: detect the mutation runner and scope it
   devrites-engine test-integrity [slug]    Gate: no test deleted, skipped, or de-asserted
   devrites-engine review-integrity [slug]  Gate: no adversarial review axis is silent (zero findings, no justification)
-  devrites-engine package-existence [slug] Gate: every new import is declared in a manifest
   devrites-engine reconcile <sub> [slug]   A1 gate: snapshot|check|close the wright's source writes
   devrites-engine resolve <qid> "<ans>"    Resolve an open question; keep state.md consistent
   devrites-engine close-out <slug>         Archive a shipped feature and clear ACTIVE
@@ -239,8 +238,6 @@ func run(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 		return lib.TestIntegrity(root, args[1:], stdout, stderr)
 	case "review-integrity":
 		return lib.ReviewIntegrity(root, args[1:], stdout, stderr)
-	case "package-existence":
-		return lib.PackageExistence(root, args[1:], stdout, stderr)
 	case "reconcile":
 		return lib.Reconcile(root, args[1:], stdout, stderr)
 	case "resolve":

package/engine/root_routing_test.go

@@ -45,7 +45,6 @@ func TestRootModeForCoversReadAndWriteSurfaces(t *testing.T) {
 		{name: "mutation gate", command: "mutation-gate", want: rootLenient},
 		{name: "test integrity", command: "test-integrity", want: rootLenient},
 		{name: "review integrity", command: "review-integrity", want: rootLenient},
-		{name: "package existence", command: "package-existence", want: rootLenient},
 		{name: "reconcile snapshot", command: "reconcile", args: []string{"snapshot"}, want: rootStrict},
 		{name: "reconcile check", command: "reconcile", args: []string{"check"}, want: rootStrict},
 		{name: "reconcile close", command: "reconcile", args: []string{"close"}, want: rootStrict},