@infinitedusky/indusk-mcp 1.44.0 → 1.44.1

package/dist/bin/commands/worktree.js

@@ -175,7 +175,7 @@ function worktreeCreateResolved(slug, baseBranch, repo) {
                 if (provisionWorktreeEnv(workbenchRoot, worktreeDir)) {
                     console.info(`  doppler: auto-provisioned env for ${slug}`);
                 }
-                for (const cmd of readPostCreate(workbenchRoot)) {
+                for (const cmd of readPostCreate(workbenchRoot, repo)) {
                     console.info(`  post_create: ${cmd}`);
                     const pc = spawnSync(cmd, { cwd: worktreeDir, stdio: "inherit", shell: true });
                     if (pc.status !== 0) {
@@ -192,9 +192,16 @@ function worktreeCreateResolved(slug, baseBranch, repo) {
     }
     process.exit(code);
 }
-/** Read `post_create` commands from the workbench's worktree config — run in each new worktree after create. */
-function readPostCreate(workbenchRoot) {
-    const repo = readWorkbenchRepos(workbenchRoot)[0]?.name;
+/**
+ * Read `post_create` commands from the worktree config of THE repo being
+ * created — run in each new worktree after create.
+ *
+ * It read `repos[0]`'s config for every repo, so in a multi-repo workbench
+ * `worktree create beta <slug>` ran alpha's install steps in beta's worktree
+ * (workbench-trust-fixes, F6 / A15). The caller names the repo; with none
+ * named the bash script has already refused, so there is nothing to run.
+ */
+export function readPostCreate(workbenchRoot, repo) {
     if (!repo)
         return [];
     const p = join(workbenchRoot, ".indusk", "worktree-configs", `${repo}.json`);
@@ -210,7 +217,7 @@ function readPostCreate(workbenchRoot) {
         return [];
     }
 }
-/** Walk up from `start` to the nearest workbench root (`.indusk/config.json` with worktree.shape === "workbench"). */
+/** Walk up from `start` to the nearest workbench root — the one `isWorkbench` rule, so a shapeless `repos[]` config counts too. */
 function resolveWorkbenchRoot(start) {
     let dir = resolve(start);
     for (let i = 0; i < 40; i++) {

package/dist/lib/cleanup/oversized.js

@@ -2,6 +2,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { getCleanupConfig, resolveCapForPath } from "../config.js";
+import { isWorkbench, readWorkbenchRepos, repoDir } from "../worktree/repos.js";
 /** Run git; swallow errors to an empty string (callers tolerate absence).
  * stderr is ignored — execFileSync forwards child stderr to the parent's
  * terminal by default, which leaked raw `git diff` usage spam (round-2 F1). */
@@ -86,15 +87,26 @@ function isGeneratedOrVendored(rel) {
  * history) it falls back to `baseRef` directly.
  */
 export function listOversizedChangedFiles(projectRoot, baseRef = "origin/main") {
-    // Fail loudly on a non-git root. A workbench root (where .indusk/ lives) is
-    // deliberately NOT a git repo — silently returning [] there would make the
-    // ritual report "nothing to clean" on every workbench project (round-2 F1,
-    // the same statePath/gitPath split the eval-rail hit in 1.31.7/1.31.12).
+    // Fail loudly on a non-git root — silently returning [] would make the
+    // ritual report "nothing to clean" for a tree it never examined (round-2
+    // F1, the same statePath/gitPath split the eval rail hit in 1.31.7/1.31.12).
     if (!git(projectRoot, ["rev-parse", "--show-toplevel"])) {
         throw new Error(`listOversizedChangedFiles: ${projectRoot} is not a git repo. ` +
             "In workbench mode pass the wrapped repo/worktree path (where the code lives), " +
             "not the workbench root (where .indusk/ lives).");
     }
+    // A versioned workbench root IS a git repo, so the guard above passes and
+    // the diff it would examine is the plan documents — the code lives in repos
+    // the workbench's git ignores. Returning [] there is "checked and clean" for
+    // code that was never seen. `verify` had the identical gap and refuses by
+    // declaration (`resolveVerifyRoots`); this is cleanup's maintained refusal
+    // (workbench-trust-fixes, F3).
+    if (isWorkbench(projectRoot)) {
+        const dirs = readWorkbenchRepos(projectRoot).map(repoDir);
+        throw new Error(`listOversizedChangedFiles: ${projectRoot} is a workbench — its code lives in ${dirs.join(", ") || "repos it does not declare"}, ` +
+            "not in this repository, so a diff here cannot contain it. Refusing rather than reporting nothing to clean. " +
+            "Run the cleanup scan inside the repository the plan's code lives in.");
+    }
     const mergeBase = resolveMergeBase(projectRoot, baseRef);
     const names = new Set();
     const ranges = [[`${mergeBase}..HEAD`], ["--cached"], []];

package/dist/lib/eval/evaluator-runner.d.ts

@@ -10,8 +10,9 @@ export interface EvaluatorRunOptions {
     /**
      * Where `.indusk/` lives — the InDusk state root. All state paths
      * (results.log, evaluator-session.json, config.json, highlights) hang off
-     * this. In workbench mode this is the workbench root (NOT a git repo);
-     * in single-repo mode it equals `gitRoot`.
+     * this. In workbench mode this is the workbench root (whose own git
+     * history is plan documents, never the code); in single-repo mode it
+     * equals `gitRoot`.
      *
      * CONTRACT: `hooks/eval-trigger.js` MUST pass this key as `projectRoot`.
      * It passed `statePath` between 1.31.7 and 1.31.11, leaving `projectRoot`

package/dist/lib/stray-state-audit.js

@@ -21,7 +21,7 @@
  */
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { readWorkbenchRepos } from "./worktree/repos.js";
+import { readWorkbenchRepos, repoDir } from "./worktree/repos.js";
 /**
  * Find stray `.indusk/` directories in a workbench-shaped project.
  *
@@ -45,7 +45,10 @@ export function findStrayState(workbenchRoot) {
         return [];
     const findings = [];
     for (const repo of repos) {
-        const wrappedRepoPath = join(workbenchRoot, repo.name);
+        // At the declared location (`path`, else name): by name, a repo declared
+        // elsewhere was a directory that did not exist, silently skipped, and
+        // the audit reported clean (workbench-trust-fixes, F6 / A12).
+        const wrappedRepoPath = join(workbenchRoot, repoDir(repo));
         if (!existsSync(wrappedRepoPath))
             continue;
         const strayInsideWrapped = walkForStrayIndusk(wrappedRepoPath, 2);

package/dist/lib/trajectory/state-ops.d.ts

@@ -35,12 +35,6 @@ export declare function computePhaseCloseBlockers(body: string, phase: number):
     row: TrajectoryRow;
     message: string;
 }[];
-/**
- * Convenience: nudge text for phase start. Returns a string listing rows
- * whose `Writable at` equals the phase and are not yet written, or null
- * if nothing needs authoring.
- */
-export declare function getPhaseStartNudge(body: string, phase: number): string | null;
 /**
  * Convenience: nudge text for near-phase-close. Returns a string listing
  * rows whose `Passes at` equals the phase but state is not yet `passing`

package/dist/lib/trajectory/state-ops.js

@@ -100,21 +100,6 @@ export function computePhaseCloseBlockers(body, phase) {
         message: `  [${row.id}] ${row.asserts} — state: ${row.state} (must be 'passing' or 'skipped' to close Phase ${phase})`,
     }));
 }
-/**
- * Convenience: nudge text for phase start. Returns a string listing rows
- * whose `Writable at` equals the phase and are not yet written, or null
- * if nothing needs authoring.
- */
-export function getPhaseStartNudge(body, phase) {
-    const trajectory = parseTrajectory(body);
-    if (!trajectory.present)
-        return null;
-    const rows = getRowsWritableAt(trajectory, phase);
-    if (rows.length === 0)
-        return null;
-    const lines = rows.map((r) => `  [${r.id}] ${r.asserts}`);
-    return `Phase ${phase} opens with these tests to author (commit as failing before implementation work):\n${lines.join("\n")}`;
-}
 /**
  * Convenience: nudge text for near-phase-close. Returns a string listing
  * rows whose `Passes at` equals the phase but state is not yet `passing`

package/dist/lib/verify/roots.js

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { isWorkbench, readWorkbenchRepos } from "../worktree/repos.js";
+import { isWorkbench, readWorkbenchRepos, repoDir, resolveReposRoot } from "../worktree/repos.js";
 /**
  * Resolve both roots, or refuse.
  *
@@ -46,7 +46,10 @@ export function resolveVerifyRoots(planRoot) {
         error: `${planRoot} is a workbench: its plan documents and its code (${declared}) live in different repositories, ` +
             "and the verify ledger records a baseline from the plan repo that has no meaning in the code repo. " +
             "Refusing rather than judging code against a diff that cannot contain it. " +
-            `Run verify inside ${join(planRoot, declared)} instead; cross-repo verification is a named follow-on.`,
+            // The checkout's real location — `repos_root` + declared `path` — not
+            // `<planRoot>/<name>`, which exists only on the flat legacy layout
+            // (workbench-trust-fixes, A13).
+            `Run verify inside ${join(resolveReposRoot(planRoot), repoDir(repos[0]))} instead; cross-repo verification is a named follow-on.`,
     };
 }
 export function isRefusal(r) {

package/dist/lib/worktree/layout.js

@@ -16,8 +16,8 @@
  * one, and a trunk link that was not made reports as one that was.
  */
 import { spawnSync } from "node:child_process";
-import { existsSync, lstatSync, readdirSync, readlinkSync, realpathSync, rmSync, symlinkSync, } from "node:fs";
-import { join, relative } from "node:path";
+import { existsSync, lstatSync, mkdirSync, readdirSync, readlinkSync, realpathSync, rmSync, symlinkSync, } from "node:fs";
+import { dirname, join, relative } from "node:path";
 /**
  * Root entries that are never worktrees.
  *
@@ -120,7 +120,12 @@ export function isDanglingLink(p) {
  */
 export function linkTrunk(workbenchRoot, name, target) {
     const link = join(workbenchRoot, name);
-    const rel = relative(workbenchRoot, target);
+    // A symlink's relative target resolves from the link's OWN directory, not
+    // the workbench root — the two differ the moment `name` has more than one
+    // segment (`code/alpha`), and a link computed from the root pointed at
+    // itself. The parent must also exist before the link can (falsification
+    // A22; nothing in a flat layout could reach either).
+    const rel = relative(dirname(link), target);
     if (existsSync(link) || isDanglingLink(link)) {
         // A correct link needs nothing doing — report it as linked.
         if (isSymlink(link) && readlinkSync(link) === rel)
@@ -131,6 +136,7 @@ export function linkTrunk(workbenchRoot, name, target) {
         else
             return false;
     }
+    mkdirSync(dirname(link), { recursive: true });
     symlinkSync(rel, link);
     return true;
 }

package/dist/lib/worktree/repos.d.ts

@@ -17,7 +17,16 @@ export type { WorkbenchRepo } from "../config.js";
  * "not a workbench" exactly as they read a missing `wrapped_repo` today.
  */
 export declare function readWorkbenchRepos(root: string): WorkbenchRepo[];
-/** Whether this project is workbench-shaped at all. */
+/**
+ * Whether this project is workbench-shaped at all.
+ *
+ * `shape: "workbench"` says so explicitly; declaring repos says so just as
+ * loudly. A config with `repos[]` and no `shape` flag used to read as a flat
+ * project here while every other reader (`readWorkbenchRepos`, the bash lane,
+ * the eval hook) treated it as a workbench — so `verify` would have judged the
+ * wrapper repo's plan documents as code (workbench-trust-fixes, F6 / A14). One
+ * rule, and every refusal inherits it through this function.
+ */
 export declare function isWorkbench(root: string): boolean;
 /** The parent directory the sibling clones live in, or null when undeclared. */
 export declare function readSiblingParent(root: string): string | null;

package/dist/lib/worktree/repos.js

@@ -64,9 +64,20 @@ export function readWorkbenchRepos(root) {
     }
     return repos;
 }
-/** Whether this project is workbench-shaped at all. */
+/**
+ * Whether this project is workbench-shaped at all.
+ *
+ * `shape: "workbench"` says so explicitly; declaring repos says so just as
+ * loudly. A config with `repos[]` and no `shape` flag used to read as a flat
+ * project here while every other reader (`readWorkbenchRepos`, the bash lane,
+ * the eval hook) treated it as a workbench — so `verify` would have judged the
+ * wrapper repo's plan documents as code (workbench-trust-fixes, F6 / A14). One
+ * rule, and every refusal inherits it through this function.
+ */
 export function isWorkbench(root) {
-    return readRawConfig(root)?.worktree?.shape === "workbench";
+    if (readRawConfig(root)?.worktree?.shape === "workbench")
+        return true;
+    return readWorkbenchRepos(root).length > 0;
 }
 /** The parent directory the sibling clones live in, or null when undeclared. */
 export function readSiblingParent(root) {

package/extensions/worktree/hooks/on_enable.sh

@@ -9,9 +9,12 @@
 #      `indusk update` re-copies if upstream changes)
 #   3. Registers `wt`, `wt:pm2`, `preflight` scripts in the workbench's
 #      package.json (merges, doesn't duplicate)
-#   4. Materializes a starter `.indusk/worktree-configs/<wrapped_repo>.json`
-#      from the template if absent — substituting WRAPPED_REPO_NAME with
-#      the actual repo name from worktree.wrapped_repo config
+#   4. Ships `.indusk/worktree-configs/config.schema.json` (the editor
+#      schema the starter config's `$schema` points at), refreshed on every
+#      enable; then materializes a starter
+#      `.indusk/worktree-configs/<wrapped_repo>.json` from the template if
+#      absent — substituting WRAPPED_REPO_NAME with the actual repo name
+#      from worktree.wrapped_repo config
 #
 # Requires:
 #   - jq installed
@@ -76,8 +79,18 @@ else
 	echo "  WARN: no package.json at $PKG_JSON; skipping script registration"
 fi
 
-# 3. Materialize starter worktree-config if absent.
+# 3. Ship the config schema beside the configs, refreshed on every enable.
+#    The starter config's `$schema` points at `./config.schema.json`; enabling
+#    an extension copies only its manifest into the project, so nothing else
+#    puts the schema anywhere a relative pointer could reach. A config that
+#    already exists is left alone below; the schema is always refreshed so a
+#    package upgrade carries schema changes into the project.
 CONFIG_DIR="$WORKBENCH_ROOT/.indusk/worktree-configs"
+mkdir -p "$CONFIG_DIR"
+cp "$EXT_DIR/config.schema.json" "$CONFIG_DIR/config.schema.json"
+echo "  schema: $CONFIG_DIR/config.schema.json"
+
+# 4. Materialize starter worktree-config if absent.
 for REPO_NAME in ${DECLARED_REPOS+"${DECLARED_REPOS[@]}"}; do
 	CONFIG_FILE="$CONFIG_DIR/${REPO_NAME}.json"
 	if [[ ! -f "$CONFIG_FILE" ]]; then

package/extensions/worktree/scripts/lib/workbench-helpers.sh

@@ -268,6 +268,57 @@ _read_workbench_repo_paths() {
 	' "$config" 2>/dev/null || echo ""
 }
 
+# The worktrees directory <repo> DECLARES, relative to the workbench root, or
+# empty when it declares none (worktrees then live at the root). One reader so
+# setup-worktree.sh run directly agrees with the TS wrapper that passes
+# --worktrees-dir (workbench-trust-fixes, F5).
+_wt_declared_worktrees_dir() {
+	local repo="$1" name dir
+	while IFS=$'\t' read -r name dir; do
+		[[ "$name" == "$repo" ]] || continue
+		echo "$dir"
+		return 0
+	done < <(_read_workbench_worktree_dirs)
+	echo ""
+}
+
+# Every directory that could be a worktree: the workbench root's entries minus
+# the reserved names, plus every entry of every DECLARED worktrees dir. Callers
+# that need "all worktrees" (refresh --all) iterate this rather than scanning
+# the root alone, which could not see a declared worktrees dir at all.
+_wt_list_worktree_dirs() {
+	local entry name dir _name path
+	# Root entries that are declared LOCATIONS rather than worktrees: a declared
+	# worktrees dir itself, and the first segment of a declared repo path
+	# (`code` for `code/alpha`). Listing them as candidates produced a SKIP line
+	# per layout element on every `refresh --all` (falsification A23).
+	local -a declared_dirs=()
+	while IFS=$'\t' read -r _name dir; do
+		[[ -n "$dir" ]] && declared_dirs+=("${dir%%/*}")
+	done < <(_read_workbench_worktree_dirs)
+	while IFS=$'\t' read -r _name path; do
+		[[ -n "$path" ]] && declared_dirs+=("${path%%/*}")
+	done < <(_read_workbench_repo_paths)
+	for entry in "$WORKBENCH_ROOT"/*; do
+		[[ -d "$entry" ]] || continue
+		name="$(basename "$entry")"
+		_wt_is_reserved_name "$name" && continue
+		local skip=0 d
+		for d in "${declared_dirs[@]+"${declared_dirs[@]}"}"; do
+			[[ "$name" == "$d" ]] && skip=1
+		done
+		[[ "$skip" -eq 1 ]] && continue
+		echo "$entry"
+	done
+	while IFS=$'\t' read -r _name dir; do
+		[[ -n "$dir" && -d "$WORKBENCH_ROOT/$dir" ]] || continue
+		for entry in "$WORKBENCH_ROOT/$dir"/*; do
+			[[ -d "$entry" ]] || continue
+			echo "$entry"
+		done
+	done < <(_read_workbench_worktree_dirs)
+}
+
 # Root entries that are never worktrees. ONE definition for the bash lane —
 # wt.sh and wt-pm2.sh each carried a copy, and they had already drifted from
 # RESERVED_ROOT_DIRS in src/lib/worktree/layout.ts (`docs` was missing from
@@ -283,7 +334,7 @@ _wt_is_reserved_name() {
 #   1. The declared workbench-side location: <workbench>/<path-or-name>,
 #      which is the trunk symlink in a linked layout or the real directory in
 #      a nested one (`repos_root: "."`).
-#   2. Else <repos_root>/<name> — the checkout itself, for a workbench whose
+#   2. Else <repos_root>/<path-or-name> — the checkout itself, for a workbench whose
 #      trunk link was never made. Routing there is what "the config says where
 #      things are" means; failing because a symlink is missing is scan-luck.
 _wt_resolve_trunk_dir() {
@@ -301,11 +352,14 @@ _wt_resolve_trunk_dir() {
 	fi
 	local repos_root
 	repos_root="$(_read_repos_root)" || return 1
-	if [[ -d "$repos_root/$repo" ]]; then
-		echo "$repos_root/$repo"
+	# The checkout itself, at its DECLARED location under repos_root — not by
+	# name, which missed every repo declared at a `path` on a sibling layout
+	# (workbench-trust-fixes, F5).
+	if [[ -d "$repos_root/${declared_path:-$repo}" ]]; then
+		echo "$repos_root/${declared_path:-$repo}"
 		return 0
 	fi
-	echo "Error: trunk for repo '$repo' not found — looked at $side and $repos_root/$repo. Run \`indusk workbench restore\`." >&2
+	echo "Error: trunk for repo '$repo' not found — looked at $side and $repos_root/${declared_path:-$repo}. Run \`indusk workbench restore\`." >&2
 	return 1
 }
 

package/extensions/worktree/scripts/preflight.sh

@@ -61,55 +61,19 @@ if [[ ! -f "$CONFIG_FILE" ]]; then
 	exit 1
 fi
 
-# Reject preflighting the trunk — preflight is a feature-branch concept.
-if [[ "$SLUG" == "$REPO" ]]; then
+# One resolution surface — the root and every declared worktrees dir, exact
+# match first, `-<slug>` suffix as fallback, ambiguity refused by name — the
+# same resolver behind `wt` (workbench-trust-fixes, F5). The private root-only
+# scan that stood here could not see a declared worktrees dir and carried its
+# own reserved-name list, already drifted from the shared one.
+WORKTREE_PATH="$(_wt_resolve_target "$SLUG")" || exit 1
+TRUNK_DIR="$(_wt_resolve_trunk_dir "$REPO")" || exit 1
+# Reject preflighting the trunk — preflight is a feature-branch concept. By
+# resolved path: under a declared `path` the trunk's basename is not the name.
+if [[ "$(cd "$WORKTREE_PATH" && pwd -P)" == "$(cd "$TRUNK_DIR" && pwd -P)" ]]; then
 	echo "Error: preflight cannot target the trunk; pick a worktree slug" >&2
 	exit 1
 fi
-
-# Slug resolution (single-pass against workbench root; same as wt.sh).
-_is_reserved_name() {
-	case "$1" in
-		.indusk | .claude | .vscode | .cursor | node_modules | dist | build | .git | .next | scripts | env) return 0 ;;
-		*) return 1 ;;
-	esac
-}
-
-exact_paths=()
-suffix_paths=()
-for entry in "$WORKBENCH_ROOT"/*; do
-	[[ -d "$entry" ]] || continue
-	name="$(basename "$entry")"
-	_is_reserved_name "$name" && continue
-	# Skip the trunk symlink — preflight is for feature worktrees.
-	[[ "$name" == "$REPO" ]] && continue
-	if [[ "$name" == "$SLUG" ]]; then
-		exact_paths+=("$entry")
-	elif [[ "$name" == *"-$SLUG" ]]; then
-		suffix_paths+=("$entry")
-	fi
-done
-
-candidate_paths=()
-if [[ ${#exact_paths[@]} -gt 0 ]]; then
-	candidate_paths=("${exact_paths[@]}")
-elif [[ ${#suffix_paths[@]} -gt 0 ]]; then
-	candidate_paths=("${suffix_paths[@]}")
-fi
-
-if [[ ${#candidate_paths[@]} -eq 0 ]]; then
-	echo "Error: no worktree matching slug '$SLUG' at $WORKBENCH_ROOT" >&2
-	exit 1
-fi
-if [[ ${#candidate_paths[@]} -gt 1 ]]; then
-	echo "Error: multiple worktrees match slug '$SLUG':" >&2
-	for p in "${candidate_paths[@]}"; do
-		printf '  %s\n' "$(basename "$p")" >&2
-	done
-	exit 1
-fi
-
-WORKTREE_PATH="${candidate_paths[0]}"
 WORKTREE_NAME="$(basename "$WORKTREE_PATH")"
 
 # Read preflight[] from config. Each entry: { name, command, when? }.

package/extensions/worktree/scripts/refresh-worktree.sh

@@ -36,7 +36,9 @@ export WORKBENCH_ROOT
 REPO="$(_resolve_workbench_repo "${REPO_ARG:-}")"
 
 SIBLING_PARENT="$(_read_repos_root)"
-CLIENT_ROOT="$SIBLING_PARENT/$REPO"
+# Trunk from CONFIG (declared `path` honored) — workbench-trust-fixes, F5.
+CLIENT_ROOT="$(_wt_resolve_trunk_dir "$REPO")"
+CLIENT_ROOT_REAL="$(cd "$CLIENT_ROOT" && pwd -P)"
 
 CONFIG_FILE="$WORKBENCH_ROOT/.indusk/worktree-configs/${REPO}.json"
 if [[ ! -f "$CONFIG_FILE" ]]; then
@@ -54,8 +56,10 @@ refresh_one() {
 		echo "  SKIP: $slug — directory not found"
 		return 0
 	fi
-	if [[ "$slug" == "$REPO" ]]; then
-		return 0 # trunk symlink, not a worktree
+	# The trunk is excluded by resolved path, not by name — under a declared
+	# `path` its basename need not be the repo name.
+	if [[ "$(cd "$worktree_path" && pwd -P)" == "$CLIENT_ROOT_REAL" ]]; then
+		return 0 # the trunk checkout, not a worktree
 	fi
 	# Check this is actually a git worktree (has a .git file pointing into
 	# the canonical clone's worktrees/ dir).
@@ -65,7 +69,7 @@ refresh_one() {
 	fi
 
 	echo ""
-	echo "Refreshing: $slug"
+	echo "Refreshing: $slug ($worktree_path)"
 
 	local gitdir
 	gitdir="$(cd "$worktree_path" && git rev-parse --git-dir)"
@@ -180,13 +184,17 @@ refresh_one() {
 }
 
 if [[ "$ARG" == "--all" ]]; then
-	echo "Refreshing all worktrees in $WORKBENCH_ROOT (excluding the trunk symlink)..."
-	for d in "$WORKBENCH_ROOT"/*/; do
-		[[ -d "$d" ]] || continue
-		refresh_one "${d%/}"
-	done
+	echo "Refreshing all worktrees in $WORKBENCH_ROOT and its declared worktrees dirs (excluding the trunk)..."
+	while IFS= read -r d; do
+		[[ -n "$d" ]] && refresh_one "$d"
+	done < <(_wt_list_worktree_dirs)
 else
-	refresh_one "$WORKBENCH_ROOT/$ARG"
+	# One resolution surface for a slug — the root and every declared worktrees
+	# dir, exact match first, `-<slug>` suffix as fallback, ambiguity refused by
+	# name — the resolver behind `wt` (workbench-trust-fixes, F5). A slug that
+	# resolves to nothing is an error, not a SKIP that exits 0.
+	target="$(_wt_resolve_target "$ARG")" || exit 1
+	refresh_one "$target"
 fi
 
 echo ""

package/extensions/worktree/scripts/setup-worktree.sh

@@ -66,11 +66,19 @@ if [[ -z "$SIBLING_PARENT" ]]; then
 	exit 1
 fi
 
-CLIENT_ROOT="$SIBLING_PARENT/$REPO"
-if [[ ! -d "$CLIENT_ROOT/.git" ]]; then
-	echo "Error: $CLIENT_ROOT is not a git repo" >&2
+# The trunk checkout from CONFIG — declared `path` honored — through the one
+# resolver `wt` has used since 1.42.0. Building "$SIBLING_PARENT/$REPO" by
+# name failed outright on any repo declared at a path (workbench-trust-fixes, F5).
+CLIENT_ROOT="$(_wt_resolve_trunk_dir "$REPO")"
+if [[ ! -e "$CLIENT_ROOT/.git" ]]; then
+	echo "Error: $CLIENT_ROOT is not a git checkout" >&2
 	exit 1
 fi
+# A declared worktrees location applies whether or not the TS wrapper passed
+# --worktrees-dir — this script is also run directly.
+if [[ -z "$WORKTREES_DIR" ]]; then
+	WORKTREES_DIR="$(_wt_declared_worktrees_dir "$REPO")"
+fi
 
 CONFIG_FILE="$WORKBENCH_ROOT/.indusk/worktree-configs/${REPO}.json"
 if [[ ! -f "$CONFIG_FILE" ]]; then

package/extensions/worktree/templates/worktree-config.template.json

@@ -1,5 +1,5 @@
 {
-	"$schema": "../../config.schema.json",
+	"$schema": "./config.schema.json",
 	"trunk_branch": "main",
 	"base_branch": "main",
 	"post_create": ["pnpm install"],