@infinitedusky/indusk-mcp 1.36.2 → 1.37.0

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

@@ -0,0 +1,47 @@
+import { type WorkbenchRepo } from "./repos.js";
+/** Every repo places its worktrees somewhere nameable. */
+export declare function allLocationsDeclared(repos: readonly WorkbenchRepo[]): boolean;
+/**
+ * Add the flat-workbench rules to an ignore file InDusk already owns.
+ *
+ * Found by running `indusk setup` and then `workbench sync`: init scaffolds a
+ * `.gitignore`, so EVERY freshly created workbench tripped the refusal and
+ * could not sync at all. A guard that blocks the product's own output is not a
+ * guard, it is a bug — and no fixture caught it because fixtures ship no
+ * ignore file.
+ *
+ * Returns true when it topped up.
+ */
+export declare function topUpManagedIgnore(workbenchRoot: string): boolean;
+export interface ScaffoldResult {
+    created: string[];
+    kept: string[];
+}
+/**
+ * Ensure a workbench root carries the files that make it shareable.
+ *
+ * Idempotent and non-destructive: an existing file is reported as kept, never
+ * rewritten.
+ */
+export declare function ensureShareableScaffolding(workbenchRoot: string, repos?: readonly WorkbenchRepo[]): ScaffoldResult;
+/**
+ * Does this workbench's ignore file actually cover the machine-specific set?
+ *
+ * Used by the nudge path rather than to rewrite anything — a workbench with a
+ * hand-tuned `.gitignore` is the normal case, and silently replacing it would
+ * destroy a decision somebody made.
+ */
+export declare function missingIgnoreRules(workbenchRoot: string): string[];
+/**
+ * Drop from the index anything the ignore rules now cover.
+ *
+ * Scaffolding `.gitignore` into an EXISTING repo does not untrack what is
+ * already tracked — git ignores only untracked paths. A workbench that was
+ * git-initialized before these rules existed therefore keeps publishing its
+ * trunk symlinks and secrets to the shared remote while the ignore file sits
+ * there looking correct. That gap is invisible: `git status` is clean.
+ *
+ * `--cached` touches the INDEX only. Every file stays on disk, and the change
+ * is a commit away from being reverted.
+ */
+export declare function untrackNowIgnored(workbenchRoot: string): string[];

package/dist/lib/worktree/shareable.js

@@ -0,0 +1,301 @@
+import { spawnSync } from "node:child_process";
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { repoDir } from "./repos.js";
+/**
+ * The two files that make a workbench root safe to share.
+ *
+ * Derived from the POC's hand-written pair, which had already survived
+ * months of real use — including two rules nobody would invent from first
+ * principles (see the comments in the generated file). Productizing a working
+ * artifact beats authoring a fresh one and discovering its gaps in a client
+ * repo.
+ *
+ * Both are scaffolded ONLY when absent. A workbench that has tuned its own
+ * ignore rules must never have them overwritten by an update — the whole point
+ * of the whitelist is that a human decided what may travel.
+ */
+/**
+ * The two rules a FLAT workbench cannot do without, named once.
+ *
+ * Both the generated file and the check that looks for them read these — a
+ * restated copy is where the generator and its checker drift, which has
+ * already happened twice in this plan.
+ */
+const ROOT_DENY_RULE = "/*/";
+const SECRETS_RULE = ".indusk/extensions/*/.env";
+/**
+ * Root-level DIRECTORY whitelist, not a blacklist.
+ *
+ * Worktree directories appear at the workbench root with names invented at
+ * runtime (`indusk worktree create <slug>`), so a deny-list is always one
+ * command behind: the next worktree is a whole checkout of someone else's repo
+ * committed into your context remote. Deny-by-default is the only shape that
+ * is correct for a name nobody has thought of yet.
+ */
+const GITIGNORE_HEADER = `# InDusk workbench context repo.
+#
+# ROOT DIRECTORY whitelist. Every root DIRECTORY is ignored unless opted in
+# below — worktree directories are created at runtime by \`indusk worktree
+# create <slug>\`, so a deny-list is always one command behind, and what it
+# misses is a whole checkout of another repo committed into the context repo.
+#
+# Root FILES are deliberately NOT denied. An earlier version used \`/*\` to
+# also catch trunk symlinks (git stores those as blobs, so \`/*/\` misses them)
+# and thereby untracked every root file a real workbench had — .mcp.json,
+# biome.json, instrumentation.ts. Those are shared context. Symlinks are named
+# explicitly instead, in the generated block below.
+/*/
+!/.indusk/
+!/.claude/
+!/env/
+!/scripts/
+!/docs/
+
+# Secrets — transferred out-of-band, never committed.
+# NOTE the trailing glob: extensions also emit .env.local / .env.production
+# carrying live keys. A bare \`.env\` pattern does not match those.
+.indusk/extensions/*/.env*
+!.indusk/extensions/*/.env.example
+env/*.env
+.env
+.env.*
+!.env.example
+
+# Machine-local state — real content, but true only for this machine.
+.indusk/eval/
+.indusk/current.md.lock
+.indusk/sync-stamp
+.claude/settings.local.json
+node_modules/
+
+# Docs build artifacts
+docs/src/.vitepress/cache/
+docs/src/.vitepress/dist/
+`;
+/**
+ * The ignore file for a workbench that DECLARES where its worktrees go.
+ *
+ * No deny-by-default rule, because none is needed: every worktree lives inside
+ * a directory the config names, so each gets one precise line. That precision
+ * is what makes this appendable to a `.gitignore` somebody else wrote — it
+ * adds rules rather than inverting the file's meaning.
+ */
+const GITIGNORE_DECLARED_HEADER = `# InDusk workbench context repo.
+#
+# This workbench DECLARES where each repo's worktrees live, so the trunks and
+# worktree directories are named exactly below. No deny-by-default rule is
+# needed, and none is imposed.
+
+# Secrets — transferred out-of-band, never committed.
+.indusk/extensions/*/.env*
+!.indusk/extensions/*/.env.example
+env/*.env
+.env
+.env.*
+!.env.example
+
+# Machine-local state — real content, but true only for this machine.
+.indusk/eval/
+.indusk/current.md.lock
+.indusk/sync-stamp
+.claude/settings.local.json
+node_modules/
+`;
+/** Marker for the generated trunk-symlink block, so it can be extended later. */
+const TRUNK_BLOCK_MARKER = "# --- InDusk trunk symlinks (generated) ---";
+/**
+ * The trunk symlinks, named one per declared repo.
+ *
+ * Git stores a symlink as a blob, so the directory-only rule above (slash-star-slash)
+ * cannot see them. Naming them is more precise than broadening the rule — and precision
+ * is what keeps real root files tracked.
+ */
+function trunkBlock(repos) {
+    if (repos.length === 0)
+        return "";
+    const lines = [TRUNK_BLOCK_MARKER];
+    for (const repo of repos) {
+        lines.push(`/${repoDir(repo)}`);
+        // A DECLARED worktrees directory can be named exactly — which is the
+        // whole reason declaring it removes the need to deny the root by
+        // default. Worktree names are invented at runtime and can never be
+        // listed in advance; the directory containing them is knowable.
+        if (repo.worktrees)
+            lines.push(`/${repo.worktrees}/`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/** Every repo places its worktrees somewhere nameable. */
+export function allLocationsDeclared(repos) {
+    return repos.length > 0 && repos.every((r) => typeof r.worktrees === "string");
+}
+/**
+ * `merge=union` on the append-shaped coordination files.
+ *
+ * These are logs, not documents: two machines appending different lines both
+ * mean it, and a conflict marker in the middle of `current.md` blocks every
+ * agent on both sides. Union keeps both. It is deliberately NOT applied to
+ * plan documents, where a blind union would interleave prose.
+ */
+const GITATTRIBUTES = `# InDusk workbench context repo.
+#
+# Append-shaped coordination files: two machines appending different lines both
+# mean it, so keep both rather than raising a conflict nobody can resolve
+# usefully. Deliberately NOT applied to plan documents — a blind union there
+# would interleave prose.
+.indusk/current.md merge=union
+.indusk/highlights.jsonl merge=union
+.indusk/highlights-processed.jsonl merge=union
+`;
+/**
+ * Marker `indusk init` writes into the ignore files it owns.
+ *
+ * The line between "extend this" and "refuse to touch this". InDusk wrote the
+ * file, so InDusk may add rules to it; a file a human wrote is a decision, and
+ * 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. */
+const FLAT_WORKBENCH_RULES = `
+# --- InDusk workbench (generated) ---
+# Worktree directories are created at runtime, so they cannot be named in
+# advance — the root is deny-by-default and shared directories are opted back
+# in below. Root FILES are untouched.
+${ROOT_DENY_RULE}
+!/.indusk/
+!/.claude/
+!/env/
+!/scripts/
+!/docs/
+${SECRETS_RULE}*
+!${SECRETS_RULE}.example
+env/*.env
+.indusk/current.md.lock
+`;
+/**
+ * Add the flat-workbench rules to an ignore file InDusk already owns.
+ *
+ * Found by running `indusk setup` and then `workbench sync`: init scaffolds a
+ * `.gitignore`, so EVERY freshly created workbench tripped the refusal and
+ * could not sync at all. A guard that blocks the product's own output is not a
+ * guard, it is a bug — and no fixture caught it because fixtures ship no
+ * ignore file.
+ *
+ * Returns true when it topped up.
+ */
+export function topUpManagedIgnore(workbenchRoot) {
+    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))
+        return false; // already correct
+    appendFileSync(path, FLAT_WORKBENCH_RULES);
+    return true;
+}
+/**
+ * Ensure a workbench root carries the files that make it shareable.
+ *
+ * Idempotent and non-destructive: an existing file is reported as kept, never
+ * rewritten.
+ */
+export function ensureShareableScaffolding(workbenchRoot, repos = []) {
+    const created = [];
+    const kept = [];
+    const ignorePath = join(workbenchRoot, ".gitignore");
+    if (!existsSync(ignorePath)) {
+        // Deny-by-default only where it is NEEDED. A workbench that declares
+        // where its worktrees go can name them precisely, and a whole-root denial
+        // would be an opinion it does not require.
+        writeFileSync(ignorePath, allLocationsDeclared(repos)
+            ? `${GITIGNORE_DECLARED_HEADER}\n${trunkBlock(repos)}`
+            : `${GITIGNORE_HEADER}\n${trunkBlock(repos)}`);
+        created.push(".gitignore");
+    }
+    else {
+        // TOP UP rather than rewrite. An existing ignore file is a decision
+        // somebody made; a repo declared later still needs its symlink named, so
+        // only the missing lines are appended.
+        const body = readFileSync(ignorePath, "utf-8");
+        const missing = repos.filter((r) => !new RegExp(`^/${repoDir(r)}(/)?$`, "m").test(body));
+        if (missing.length > 0) {
+            const block = body.includes(TRUNK_BLOCK_MARKER)
+                ? `${trunkBlock(missing).split("\n").slice(1).join("\n")}`
+                : `\n${trunkBlock(missing)}`;
+            appendFileSync(ignorePath, block);
+            kept.push(`.gitignore (+${missing.length} trunk rule${missing.length === 1 ? "" : "s"})`);
+        }
+        else {
+            kept.push(".gitignore");
+        }
+    }
+    const attrPath = join(workbenchRoot, ".gitattributes");
+    if (existsSync(attrPath)) {
+        kept.push(".gitattributes");
+    }
+    else {
+        writeFileSync(attrPath, GITATTRIBUTES);
+        created.push(".gitattributes");
+    }
+    return { created, kept };
+}
+/**
+ * Does this workbench's ignore file actually cover the machine-specific set?
+ *
+ * Used by the nudge path rather than to rewrite anything — a workbench with a
+ * hand-tuned `.gitignore` is the normal case, and silently replacing it would
+ * destroy a decision somebody made.
+ */
+export function missingIgnoreRules(workbenchRoot) {
+    const path = join(workbenchRoot, ".gitignore");
+    if (!existsSync(path))
+        return [".gitignore is absent entirely"];
+    const body = readFileSync(path, "utf-8");
+    // DERIVED from what the generator actually emits, never restated.
+    //
+    // These drifted twice: the check asked for one spelling of the root rule
+    // while the header wrote another, so a correctly-scaffolded workbench
+    // reported a gap and a real gap could have gone unreported. Both times the
+    // "fix" was a second copy of a string. Reading the rule out of the constant
+    // that writes it is the only version that cannot drift.
+    const required = [
+        [
+            ROOT_DENY_RULE,
+            "the root is not deny-by-default, so the next worktree directory gets committed",
+        ],
+        [SECRETS_RULE, "extension secrets are not ignored"],
+    ];
+    return required.filter(([rule]) => !body.includes(rule)).map(([rule, why]) => `${rule} — ${why}`);
+}
+/**
+ * Drop from the index anything the ignore rules now cover.
+ *
+ * Scaffolding `.gitignore` into an EXISTING repo does not untrack what is
+ * already tracked — git ignores only untracked paths. A workbench that was
+ * git-initialized before these rules existed therefore keeps publishing its
+ * trunk symlinks and secrets to the shared remote while the ignore file sits
+ * there looking correct. That gap is invisible: `git status` is clean.
+ *
+ * `--cached` touches the INDEX only. Every file stays on disk, and the change
+ * is a commit away from being reverted.
+ */
+export function untrackNowIgnored(workbenchRoot) {
+    const listed = spawnSync("git", ["ls-files", "-i", "-c", "--exclude-standard"], {
+        cwd: workbenchRoot,
+        encoding: "utf-8",
+    });
+    if (listed.status !== 0)
+        return [];
+    const paths = (listed.stdout ?? "").trim().split("\n").filter(Boolean);
+    if (paths.length === 0)
+        return [];
+    const removed = spawnSync("git", ["rm", "-r", "--cached", "--quiet", "--", ...paths], {
+        cwd: workbenchRoot,
+        encoding: "utf-8",
+    });
+    return removed.status === 0 ? paths : [];
+}

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

@@ -0,0 +1,62 @@
+/**
+ * The workbench sync mechanism: commit → pull → push, blindly resolved.
+ *
+ * ONE function, called by every trigger. The ADR left the trigger open
+ * (watcher vs. mutation chokepoints); separating mechanism from trigger means
+ * that choice can change later without rewriting any of this. Today it is
+ * driven by the `PostToolUse` hook and by `/catchup`; a `--watch` daemon can
+ * call the same entry point when the gap is felt.
+ *
+ * **Commit BEFORE pull**, despite the brief's "pull before everything".
+ * The safety property the brief actually names is *both sides are always
+ * committed before any merge* — that is what makes blind resolution
+ * recoverable, because nothing that was lost is unreachable from `git log`.
+ * Pulling into a dirty tree would either refuse (blocking an agent) or stash
+ * (inventing a third state nobody can see). Committing first satisfies the
+ * real invariant and keeps the tree clean for the merge.
+ *
+ * Nothing here ever blocks. An unreachable remote leaves the work committed
+ * locally and exits 0 — someone else's outage must never become your inability
+ * to work.
+ */
+export interface SyncResult {
+    committed: boolean;
+    pulled: "ok" | "skipped" | "failed";
+    pushed: "ok" | "skipped" | "failed";
+    /** Human-facing lines, in order. */
+    notes: string[];
+    /** True when a remote is configured at all. */
+    hasRemote: boolean;
+}
+export declare function isGitRepo(root: string): boolean;
+/** Initialize the context repo. Local commits work with no remote at all. */
+export declare function ensureContextRepo(root: string): boolean;
+export declare function syncWorkbench(root: string, at?: Date): SyncResult;
+/**
+ * Per-repo publish state — the two-clock skew, made visible.
+ *
+ * A workbench's plan documents auto-sync in seconds while the code they
+ * describe pushes when its author decides. A developer who pulls a phase
+ * marked complete has no way to tell whether the commits behind it exist
+ * anywhere but the author's laptop. "Done" and "present" are two questions on
+ * two clocks, and the plan is the faster one.
+ */
+export interface RepoPublishState {
+    name: string;
+    present: boolean;
+    ahead: number;
+    hasRemote: boolean;
+    /**
+     * Whether this branch exists on the remote at all.
+     *
+     * Distinct from `ahead === 0`. A branch that was never pushed has no
+     * remote-tracking ref, so no count is meaningful — and calling that "in
+     * sync" is the inversion this field exists to prevent.
+     *
+     * REQUIRED, not optional: every return path sets it, so an optional type
+     * would describe a state the code cannot produce while forcing readers into
+     * `=== false` comparisons to stay correct about it.
+     */
+    published: boolean;
+}
+export declare function repoPublishState(siblingParent: string, name: string): RepoPublishState;

package/dist/lib/worktree/sync.js

@@ -0,0 +1,174 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+function git(cwd, args) {
+    const r = spawnSync("git", args, {
+        cwd,
+        encoding: "utf-8",
+        env: {
+            ...process.env,
+            // The loop authors commits, not a person. Without this a machine with
+            // no git identity fails to commit and the work is silently uncommitted.
+            GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME ?? "indusk",
+            GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL ?? "indusk@localhost",
+            GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME ?? "indusk",
+            GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL ?? "indusk@localhost",
+        },
+    });
+    return { ok: r.status === 0, out: r.stdout ?? "", err: r.stderr ?? "" };
+}
+export function isGitRepo(root) {
+    return existsSync(join(root, ".git"));
+}
+/** Initialize the context repo. Local commits work with no remote at all. */
+export function ensureContextRepo(root) {
+    if (isGitRepo(root))
+        return false;
+    git(root, ["init", "--quiet", "--initial-branch=main"]);
+    return true;
+}
+function currentBranch(root) {
+    const r = git(root, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const name = r.out.trim();
+    return name && name !== "HEAD" ? name : "main";
+}
+function remoteName(root) {
+    const r = git(root, ["remote"]);
+    const first = r.out.trim().split("\n").filter(Boolean)[0];
+    return first ?? null;
+}
+/**
+ * A timestamp, not a narrative.
+ *
+ * The workbench history is a sync log — the *content* is the record, and the
+ * message only has to be recognizable and unprompted. Anything that tried to
+ * summarize would be a lie invented by a loop that does not know why the file
+ * changed.
+ */
+function syncMessage(at) {
+    return `sync ${at.toISOString()}`;
+}
+export function syncWorkbench(root, at = new Date()) {
+    const notes = [];
+    if (ensureContextRepo(root))
+        notes.push("Initialized the workbench context repo (no remote yet).");
+    const branch = currentBranch(root);
+    const remote = remoteName(root);
+    const result = {
+        committed: false,
+        pulled: "skipped",
+        pushed: "skipped",
+        notes,
+        hasRemote: remote !== null,
+    };
+    // --- 1. COMMIT. Always first, always local, never blocked. ---
+    const dirty = git(root, ["status", "--porcelain"]).out.trim() !== "";
+    if (dirty) {
+        git(root, ["add", "-A"]);
+        const c = git(root, ["commit", "--quiet", "-m", syncMessage(at)]);
+        result.committed = c.ok;
+        if (!c.ok) {
+            // STOP. The entire safety argument for the blind merge below is
+            // "both sides are committed before any merge" — that is what makes a
+            // lost hunk recoverable from `git log`. When the commit fails the
+            // argument is void, and pulling would merge someone else's history
+            // over work that exists nowhere but this working tree.
+            //
+            // A failed commit is ordinary, not exotic: a pre-commit hook, a
+            // missing git identity, a full disk, or an `index.lock` held by a
+            // concurrent sync all produce it.
+            notes.push(`Commit failed, so nothing was pulled or pushed: ${calmly(c.err)}`);
+            notes.push("Your working tree is untouched. Fix the commit, then sync again.");
+            return result;
+        }
+        notes.push(`Committed local changes (${syncMessage(at)}).`);
+    }
+    if (!remote) {
+        notes.push("No remote configured — commits are local only. `git remote add origin <url>` to share.");
+        return result;
+    }
+    // --- 2. PULL, resolved blindly. ---
+    // `-X theirs` decides hunks that genuinely conflict; `merge=union` in
+    // .gitattributes overrides it for the append-shaped files, where BOTH sides
+    // are meant. Losing a hunk here is recoverable — step 1 committed it.
+    const pull = git(root, [
+        "-c",
+        "pull.rebase=false",
+        "pull",
+        "--no-edit",
+        "--quiet",
+        "-X",
+        "theirs",
+        remote,
+        branch,
+    ]);
+    if (pull.ok) {
+        result.pulled = "ok";
+    }
+    else {
+        // An empty remote (nothing pushed yet) is not a failure.
+        const benign = /couldn't find remote ref|no such ref|Couldn't find remote ref/i.test(pull.err);
+        result.pulled = benign ? "skipped" : "failed";
+        if (!benign)
+            notes.push(`Pull skipped — remote unreachable (${calmly(pull.err)}). Continuing with local state.`);
+    }
+    // --- 3. PUSH, best-effort, one retry through a re-pull on rejection. ---
+    let push = git(root, ["push", "--quiet", remote, branch]);
+    if (!push.ok) {
+        git(root, [
+            "-c",
+            "pull.rebase=false",
+            "pull",
+            "--no-edit",
+            "--quiet",
+            "-X",
+            "theirs",
+            remote,
+            branch,
+        ]);
+        push = git(root, ["push", "--quiet", remote, branch]);
+    }
+    result.pushed = push.ok ? "ok" : "failed";
+    if (!push.ok) {
+        notes.push(`Push deferred — remote unreachable (${calmly(push.err)}). Work is committed locally and goes out on the next sync.`);
+    }
+    return result;
+}
+/**
+ * Git's own wording, made safe to show for an expected condition.
+ *
+ * An unreachable remote is NORMAL here — the whole point of committing first
+ * is that working offline is not an error. Echoing git's raw `fatal: ...`
+ * presents a routine outage as a hard failure, which is exactly the shape A6
+ * forbids: someone else's downtime must not read as your problem to fix.
+ * The cause is kept, the alarm is not.
+ */
+function calmly(s) {
+    const line = s
+        .trim()
+        .split("\n")
+        .find((l) => l.trim() !== "") ?? "";
+    return line
+        .replace(/^fatal:\s*/i, "")
+        .replace(/^error:\s*/i, "")
+        .trim();
+}
+export function repoPublishState(siblingParent, name) {
+    const path = join(siblingParent, name);
+    if (!existsSync(join(path, ".git"))) {
+        return { name, present: false, ahead: 0, hasRemote: false, published: false };
+    }
+    const remote = remoteName(path);
+    if (!remote)
+        return { name, present: true, ahead: 0, hasRemote: false, published: false };
+    const branch = currentBranch(path);
+    // Does a remote-tracking ref exist at all? `rev-list A..B` ERRORS when it
+    // does not, and reading that error as "0 commits ahead" reports the worst
+    // case — nothing has ever left this machine — as the most reassuring one.
+    const tracked = git(path, ["rev-parse", "--verify", "--quiet", `${remote}/${branch}`]).ok;
+    if (!tracked)
+        return { name, present: true, ahead: 0, hasRemote: true, published: false };
+    const counted = git(path, ["rev-list", "--count", `${remote}/${branch}..HEAD`]);
+    const ahead = counted.ok ? Number.parseInt(counted.out.trim(), 10) || 0 : 0;
+    return { name, present: true, ahead, hasRemote: true, published: true };
+}

package/extensions/worktree/hooks/on_enable.sh

@@ -27,11 +27,18 @@ source "$EXT_DIR/scripts/lib/workbench-helpers.sh"
 WORKBENCH_ROOT="$(_resolve_workbench_root)"
 export WORKBENCH_ROOT
 
-WRAPPED_REPO="$(_read_workbench_field wrapped_repo)"
-if [[ -z "$WRAPPED_REPO" ]]; then
-	echo "Warning: .indusk/config.json missing worktree.wrapped_repo." >&2
-	echo "Worktree extension is enabled but won't function until that field is set." >&2
-	echo "Run 'indusk init --workbench --wrapped-repo <name>' (Phase 6) or hand-edit the config." >&2
+# Every declared repo, not just the first: a workbench that wraps N repos needs
+# N starter configs, and scaffolding only one leaves the others silently
+# unconfigured until someone tries to make a worktree in them.
+DECLARED_REPOS=()
+while IFS= read -r line; do
+	[[ -n "$line" ]] && DECLARED_REPOS+=("$line")
+done < <(_read_workbench_repos 2>/dev/null || true)
+
+if [[ ${#DECLARED_REPOS[@]} -eq 0 ]]; then
+	echo "Warning: .indusk/config.json declares no repos (worktree.repos[] or worktree.wrapped_repo)." >&2
+	echo "Worktree extension is enabled but won't function until one is set." >&2
+	echo "Run 'indusk init --workbench --wrapped-repo <name>' or hand-edit the config." >&2
 	# Don't fail — the extension is enabled, just inert until configured.
 fi
 
@@ -70,17 +77,17 @@ else
 fi
 
 # 3. Materialize starter worktree-config if absent.
-if [[ -n "$WRAPPED_REPO" ]]; then
-	CONFIG_DIR="$WORKBENCH_ROOT/.indusk/worktree-configs"
-	CONFIG_FILE="$CONFIG_DIR/${WRAPPED_REPO}.json"
+CONFIG_DIR="$WORKBENCH_ROOT/.indusk/worktree-configs"
+for REPO_NAME in ${DECLARED_REPOS+"${DECLARED_REPOS[@]}"}; do
+	CONFIG_FILE="$CONFIG_DIR/${REPO_NAME}.json"
 	if [[ ! -f "$CONFIG_FILE" ]]; then
 		mkdir -p "$CONFIG_DIR"
-		sed "s/WRAPPED_REPO_NAME/${WRAPPED_REPO}/g" \
+		sed "s/WRAPPED_REPO_NAME/${REPO_NAME}/g" \
 			"$EXT_DIR/templates/worktree-config.template.json" > "$CONFIG_FILE"
 		echo "  starter config: $CONFIG_FILE"
 	else
 		echo "  starter config: $CONFIG_FILE already exists, leaving in place"
 	fi
-fi
+done
 
 echo "Worktree extension scaffolding complete."