@infinitedusky/indusk-mcp 1.44.0 → 1.44.2

package/dist/bin/commands/workbench.js

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { isUsableRelPath } from "../../lib/path-segment.js";
 import { isDanglingLink, linkTrunk, listWorkbenchSubdirs, worktreeOwner, } from "../../lib/worktree/layout.js";
 import { isWorkbench, readReposRoot, readWorkbenchRepos, repoDir, } from "../../lib/worktree/repos.js";
@@ -92,15 +92,19 @@ function refuseIfIgnoreCannotHold(projectRoot, repos, skip) {
     if (skip)
         return;
     // A declared layout names its worktree directories exactly, so no
-    // deny-by-default rule is required and nothing to refuse.
-    if (allLocationsDeclared(repos))
-        return;
+    // deny-by-default rule is required and there is nothing to REFUSE. It
+    // still needs the machine-local rules, so the top-up runs first — before
+    // the early return, which used to strand every declared workbench without
+    // them.
+    const layoutDeclared = allLocationsDeclared(repos);
     // InDusk wrote this file, so InDusk may extend it. Every freshly created
     // workbench lands here — `init` scaffolds a `.gitignore`, so without this
     // the refusal fires on the product's own output.
-    if (topUpManagedIgnore(projectRoot)) {
-        console.info("Added the workbench rules to the InDusk-managed .gitignore.");
+    if (topUpManagedIgnore(projectRoot, { layoutDeclared })) {
+        console.info("Added the missing InDusk rules to the managed .gitignore.");
     }
+    if (layoutDeclared)
+        return;
     const gaps = missingIgnoreRules(projectRoot);
     if (gaps.length === 0)
         return;
@@ -126,6 +130,16 @@ function refuseIfIgnoreCannotHold(projectRoot, repos, skip) {
  * it. They are two jobs, and the four-way ternary that used to sit inline made
  * that hard to see.
  */
+/**
+ * Where restore materializes a repo: at its DECLARED location — `path`, else
+ * name — which is where health, status, doppler and the update nudge all look.
+ * Cloning at the name put a second copy beside a repo declared at a `path` and
+ * linked the trunk at the wrong one (workbench-trust-fixes, F4). One function so
+ * the clone and the line that reports it cannot name different places.
+ */
+function cloneTarget(repo, siblingParent) {
+    return join(siblingParent, repoDir(repo));
+}
 export function restoreLine(repo, status, siblingParent) {
     // `linkTrunk` deliberately refuses to replace a real directory sitting at
     // the trunk path, so both `-unlinked` cases are correct behavior that the
@@ -138,10 +152,12 @@ export function restoreLine(repo, status, siblingParent) {
             return `${repo.name} — present in the workbench at ${repoDir(repo)}/`;
         case "nested-cloned":
             return `${repo.name} — cloned into the workbench at ${repoDir(repo)}/`;
+        // The path printed is the path used — `restoreOne` clones at the
+        // declared location, so this must name it, not the sibling parent.
         case "cloned":
-            return `${repo.name} — cloned into ${siblingParent} and linked`;
+            return `${repo.name} — cloned into ${cloneTarget(repo, siblingParent)} and linked`;
         case "cloned-unlinked":
-            return `${repo.name} — cloned into ${siblingParent}/${repo.name}, but ${unlinked}`;
+            return `${repo.name} — cloned into ${cloneTarget(repo, siblingParent)}, but ${unlinked}`;
         case "present-unlinked":
             return `${repo.name} — already present, but ${unlinked}`;
         case "present":
@@ -149,7 +165,7 @@ export function restoreLine(repo, status, siblingParent) {
     }
 }
 function restoreOne(repo, workbenchRoot, siblingParent) {
-    const target = join(siblingParent, repo.name);
+    const target = cloneTarget(repo, siblingParent);
     // When the repo lives INSIDE the workbench at its trunk path — the nested
     // layout `repos_root: "."` exists to express — there is no link to make and
     // nothing wrong. Reporting that as "a real directory occupies …" describes
@@ -180,7 +196,9 @@ function restoreOne(repo, workbenchRoot, siblingParent) {
     // nowhere is not something anyone loses.
     if (isDanglingLink(target))
         rmSync(target);
-    mkdirSync(siblingParent, { recursive: true });
+    // The declared path may have its own parent (`code/alpha`); make it, not
+    // just the sibling parent, or the clone fails on a directory nothing made.
+    mkdirSync(dirname(target), { recursive: true });
     const { ok, stderr } = git(["clone", "--quiet", repo.remote, target], siblingParent);
     if (!ok) {
         return {

package/dist/bin/commands/worktree.d.ts

@@ -42,6 +42,16 @@ export declare function resolveCreateTarget(repos: readonly {
     baseBranch?: string;
 };
 export declare function worktreeCreate(args: string[], projectRoot?: string): never;
+/**
+ * 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 declare function readPostCreate(workbenchRoot: string, repo: string | undefined): string[];
 export declare function worktreeRefresh(slug: string): never;
 export declare function worktreePreflight(slug: string, baseBranch?: string): never;
 /**

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/dist/lib/worktree/shareable.d.ts

@@ -12,7 +12,9 @@ export declare function allLocationsDeclared(repos: readonly WorkbenchRepo[]): b
  *
  * Returns true when it topped up.
  */
-export declare function topUpManagedIgnore(workbenchRoot: string): boolean;
+export declare function topUpManagedIgnore(workbenchRoot: string, opts?: {
+    layoutDeclared?: boolean;
+}): boolean;
 export interface ScaffoldResult {
     created: string[];
     kept: string[];

package/dist/lib/worktree/shareable.js

@@ -24,6 +24,14 @@ import { repoDir } from "./repos.js";
  */
 const ROOT_DENY_RULE = "/*/";
 const SECRETS_RULE = ".indusk/extensions/*/.env";
+/**
+ * The worktree extension's editor schema, shipped beside the configs by its
+ * `on_enable` hook so each config's `$schema` resolves. Its contents track the
+ * installed package, so it is machine-local in the same sense as `.indusk/eval/`:
+ * real content, true only for this machine. Shared, two teammates on different
+ * versions rewrite it at each other on every enable.
+ */
+const WORKTREE_SCHEMA_RULE = ".indusk/worktree-configs/config.schema.json";
 /**
  * Root-level DIRECTORY whitelist, not a blacklist.
  *
@@ -64,6 +72,7 @@ env/*.env
 
 # Machine-local state — real content, but true only for this machine.
 .indusk/eval/
+${WORKTREE_SCHEMA_RULE}
 .indusk/current.md.lock
 .indusk/sync-stamp
 .claude/settings.local.json
@@ -97,6 +106,7 @@ env/*.env
 
 # Machine-local state — real content, but true only for this machine.
 .indusk/eval/
+${WORKTREE_SCHEMA_RULE}
 .indusk/current.md.lock
 .indusk/sync-stamp
 .claude/settings.local.json
@@ -157,7 +167,29 @@ const GITATTRIBUTES = `# InDusk workbench context repo.
  * appending deny-by-default to it would invert what they meant.
  */
 const INDUSK_MANAGED_MARKER = "# InDusk managed";
-/** Rules a flat workbench needs, in the order they should be appended. */
+/**
+ * Rules EVERY workbench needs, whatever its layout.
+ *
+ * Split out of the flat block because they were unreachable from a declared
+ * layout: `refuseIfIgnoreCannotHold` returns early there — a declared layout
+ * needs no deny-by-default rule — and the top-up sat behind that return, so a
+ * declared workbench scaffolded before a rule existed could never receive it
+ * and went on offering the file to its shared remote. A guard that returns
+ * early for one layout must not carry unrelated work behind it.
+ */
+const MACHINE_LOCAL_RULES = `
+# --- InDusk machine-local (generated) ---
+# Real content, true only for this machine: package-owned files that track the
+# installed version, and a lock.
+${WORKTREE_SCHEMA_RULE}
+.indusk/current.md.lock
+`;
+/**
+ * Rules only a FLAT workbench needs, in the order they should be appended.
+ *
+ * Deny-by-default belongs here and nowhere else. Appending it to a declared
+ * layout's ignore file would invert a file this module refuses to rewrite.
+ */
 const FLAT_WORKBENCH_RULES = `
 # --- InDusk workbench (generated) ---
 # Worktree directories are created at runtime, so they cannot be named in
@@ -172,7 +204,6 @@ ${ROOT_DENY_RULE}
 ${SECRETS_RULE}*
 !${SECRETS_RULE}.example
 env/*.env
-.indusk/current.md.lock
 `;
 /**
  * Add the flat-workbench rules to an ignore file InDusk already owns.
@@ -185,16 +216,29 @@ env/*.env
  *
  * Returns true when it topped up.
  */
-export function topUpManagedIgnore(workbenchRoot) {
+export function topUpManagedIgnore(workbenchRoot, opts = {}) {
     const path = join(workbenchRoot, ".gitignore");
     if (!existsSync(path))
         return false;
     const body = readFileSync(path, "utf-8");
     if (!body.includes(INDUSK_MANAGED_MARKER))
         return false; // a human's file — refuse elsewhere
-    if (body.includes(ROOT_DENY_RULE))
+    // Per-RULE, not per-file. An earlier version returned early whenever the
+    // root rule was present, so every rule added after that one could never
+    // reach a workbench scaffolded before it — the file looked correct and was
+    // a release behind. Each rule the flat block carries is topped up on its
+    // own, in the block's own order.
+    // A declared layout gets the machine-local rules only; the flat block's
+    // deny-by-default rule is the one thing that must never reach it.
+    const blocks = opts.layoutDeclared
+        ? [MACHINE_LOCAL_RULES]
+        : [FLAT_WORKBENCH_RULES, MACHINE_LOCAL_RULES];
+    const missing = blocks
+        .flatMap((block) => block.split("\n"))
+        .filter((line) => line.trim() !== "" && !line.startsWith("#") && !body.includes(line));
+    if (missing.length === 0)
         return false; // already correct
-    appendFileSync(path, FLAT_WORKBENCH_RULES);
+    appendFileSync(path, `${missing.join("\n")}\n`);
     return true;
 }
 /**
@@ -268,6 +312,10 @@ export function missingIgnoreRules(workbenchRoot) {
             "the root is not deny-by-default, so the next worktree directory gets committed",
         ],
         [SECRETS_RULE, "extension secrets are not ignored"],
+        [
+            WORKTREE_SCHEMA_RULE,
+            "the worktree config schema is package-owned and would be committed, so teammates on different versions rewrite it at each other",
+        ],
     ];
     return required.filter(([rule]) => !body.includes(rule)).map(([rule, why]) => `${rule} — ${why}`);
 }

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/manifest.json

@@ -7,6 +7,7 @@
 	},
 	"hooks": {
 		"on_enable": "indusk worktree _on-enable",
+		"on_update": "indusk worktree _on-enable",
 		"on_disable": "echo 'worktree extension disabled — scripts in <workbench>/scripts/worktree/ + package.json entries are left in place for manual cleanup'"
 	}
 }

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
 }