@savvy-web/cli 0.3.0 → 0.4.0

package/841.js

@@ -1,2394 +0,0 @@
-import { Args, Command, Options } from "@effect/cli";
-import { NodeContext, NodeRuntime } from "@effect/platform-node";
-import { BiomeSchemaSync, BiomeSchemaSyncLive, ChangesetConfigReaderLive, Changesets, CheckResult, Commitlint, ConfigDiscovery, ConfigDiscoveryLive, Lint, ManagedSection, ManagedSectionLive, SavvyBaseSection, SavvyHooksSection, SectionDefinition, SilkPublishabilityDetectorLive, ToolDefinition, ToolDiscovery, ToolDiscoveryLive, VersioningStrategy, VersioningStrategyLive, savvyBasePreamble, savvyHooksHygiene, savvyToolSection } from "@savvy-web/silk-effects";
-import { Data, Effect, Layer, Option, Schema } from "effect";
-import { PackageManagerDetector, PackageManagerDetectorLive, WorkspaceDiscovery, WorkspaceDiscoveryLive, WorkspaceRoot, WorkspaceRootLive } from "workspaces-effect";
-import { dirname, join, resolve, sep } from "node:path";
-import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
-import { execFile, execSync } from "node:child_process";
-import { applyEdits, modify, parse } from "jsonc-effect";
-import { FileSystem } from "@effect/platform";
-import { chmod, glob, realpath, rm } from "node:fs/promises";
-import { isDeepStrictEqual, promisify } from "node:util";
-import { parse as external_yaml_parse, stringify } from "yaml";
-const { BranchAnalyzer: BranchAnalyzer } = Changesets;
-const cwdOption = Options.directory("cwd").pipe(Options.withDescription("Project root (defaults to the current working directory)"), Options.withDefault("."));
-const baseOption = Options.text("base").pipe(Options.withDescription("Override the base branch (defaults to config baseBranch or origin/HEAD)"), Options.optional);
-const jsonOption = Options.boolean("json").pipe(Options.withDescription("Emit JSON instead of human-readable output"), Options.withDefault(false));
-function renderHuman(analysis) {
-    const lines = [];
-    lines.push(`Base branch:    ${analysis.baseBranch}`);
-    lines.push(`Merge base SHA: ${analysis.mergeBaseSha}`);
-    lines.push("");
-    if (analysis.packagesAffected.length > 0) {
-        lines.push(`Packages affected (${analysis.packagesAffected.length}):`);
-        for (const p of analysis.packagesAffected)lines.push(`  ${p}`);
-    } else lines.push("Packages affected: (none)");
-    lines.push("");
-    if (0 === analysis.files.length) lines.push("Changes: (no files changed)");
-    else {
-        lines.push(`Changes (${analysis.files.length}):`);
-        const statusGlyph = {
-            added: "A",
-            modified: "M",
-            deleted: "D",
-            renamed: "R",
-            copied: "C",
-            typechange: "T",
-            unmerged: "U",
-            unknown: "?"
-        };
-        for (const f of analysis.files){
-            const glyph = statusGlyph[f.status] ?? "?";
-            const owner = f.package ?? "<unmapped>";
-            const reason = "workspace" === f.reason ? "workspace" : null !== f.reason ? `${f.reason.kind}: ${f.reason.glob}` : "—";
-            lines.push(`  ${glyph}  ${f.path}\t${owner}\t${reason}`);
-        }
-    }
-    if (analysis.unmappedFiles.length > 0) {
-        lines.push("");
-        lines.push(`Unmapped (${analysis.unmappedFiles.length}):`);
-        for (const p of analysis.unmappedFiles)lines.push(`  ${p}`);
-    }
-    return lines.join("\n");
-}
-function runAnalyzeBranch(cwd, base, json) {
-    return Effect.gen(function*() {
-        const analyzer = yield* BranchAnalyzer;
-        const resolvedCwd = resolve(cwd);
-        const baseBranch = Option.getOrUndefined(base);
-        const analysis = yield* analyzer.analyzeBranch(resolvedCwd, baseBranch ? {
-            baseBranch
-        } : void 0).pipe(Effect.catchTags({
-            ConfigurationError: (err)=>{
-                process.exitCode = 1;
-                return Effect.fail(err);
-            },
-            GitError: (err)=>{
-                process.exitCode = 1;
-                return Effect.fail(err);
-            }
-        }));
-        const output = json ? JSON.stringify(analysis, null, 2) : renderHuman(analysis);
-        yield* Effect.log(output);
-    });
-}
-const analyzeBranchCommand = Command.make("analyze-branch", {
-    cwd: cwdOption,
-    base: baseOption,
-    json: jsonOption
-}, ({ cwd, base, json })=>runAnalyzeBranch(cwd, base, json)).pipe(Command.withDescription("Diff the current branch and classify every changed file by owning package"));
-const { ConfigInspector: ConfigInspector } = Changesets;
-const pathsArg = Args.text({
-    name: "path"
-}).pipe(Args.repeated);
-const classify_cwdOption = Options.directory("cwd").pipe(Options.withDescription("Project root (defaults to the current working directory)"), Options.withDefault("."));
-const classify_jsonOption = Options.boolean("json").pipe(Options.withDescription("Emit JSON instead of human-readable output"), Options.withDefault(false));
-function renderClassificationLine(c) {
-    if (null === c.package) return `${c.path}\t<unmapped>`;
-    if ("workspace" === c.reason) return `${c.path}\t${c.package}\tworkspace`;
-    if (null !== c.reason) return `${c.path}\t${c.package}\t${c.reason.kind}: ${c.reason.glob}`;
-    return `${c.path}\t${c.package}`;
-}
-function runClassify(cwd, paths, json) {
-    return Effect.gen(function*() {
-        const inspector = yield* ConfigInspector;
-        const resolvedCwd = resolve(cwd);
-        const classifications = yield* inspector.classify(resolvedCwd, paths).pipe(Effect.catchTag("ConfigurationError", (err)=>{
-            process.exitCode = 1;
-            return Effect.fail(err);
-        }));
-        if (json) return void (yield* Effect.log(JSON.stringify(classifications, null, 2)));
-        for (const c of classifications)yield* Effect.log(renderClassificationLine(c));
-    });
-}
-const classifyCommand = Command.make("classify", {
-    paths: pathsArg,
-    cwd: classify_cwdOption,
-    json: classify_jsonOption
-}, ({ paths, cwd, json })=>runClassify(cwd, paths, json)).pipe(Command.withDescription("Map paths to their owning package per .changeset/config.json"));
-const { ConfigInspector: config_show_ConfigInspector } = Changesets;
-const dirArg = Args.directory({
-    name: "dir"
-}).pipe(Args.withDefault("."));
-const config_show_jsonOption = Options.boolean("json").pipe(Options.withDescription("Emit JSON instead of human-readable output"), Options.withDefault(false));
-function config_show_renderHuman(config) {
-    const lines = [];
-    lines.push(`Config:    ${config.configPath}`);
-    lines.push(`Project:   ${config.projectDir}`);
-    lines.push(`Changelog: ${config.changelog ?? "(none)"}`);
-    lines.push(`Base:      ${config.baseBranch}`);
-    lines.push(`Access:    ${config.access}`);
-    if (config.ignore.length > 0) lines.push(`Ignore:    ${config.ignore.join(", ")}`);
-    if (config.legacyVersionFilesUsed) {
-        lines.push("");
-        lines.push("⚠ This config still uses the deprecated top-level `versionFiles[]`.");
-        lines.push("  Migrate to `packages[<name>].versionFiles` — required for 1.0.0.");
-    }
-    lines.push("");
-    if (0 === config.packages.length) {
-        lines.push("Packages: (none declared)");
-        return lines.join("\n");
-    }
-    lines.push(`Packages (${config.packages.length}):`);
-    for (const pkg of config.packages){
-        lines.push("");
-        lines.push(`  ${pkg.name}  v${pkg.version}`);
-        lines.push(`    workspace: ${pkg.workspaceDir}`);
-        if (pkg.additionalScopes.length > 0) {
-            lines.push(`    additionalScopes (${pkg.additionalScopes.length}):`);
-            for (const g of pkg.additionalScopes)lines.push(`      - ${g}`);
-            lines.push(`    additionalScopeFiles (${pkg.additionalScopeFiles.length}):`);
-            for (const f of pkg.additionalScopeFiles)lines.push(`      ${f}`);
-        }
-        if (pkg.versionFiles.length > 0) {
-            lines.push(`    versionFiles (${pkg.versionFiles.length}):`);
-            for (const vf of pkg.versionFiles){
-                lines.push(`      ${vf.glob} → ${vf.paths.join(", ")}  (${vf.matchedFiles.length} file${1 === vf.matchedFiles.length ? "" : "s"} matched)`);
-                for (const f of vf.matchedFiles)lines.push(`        ${f}`);
-            }
-        }
-    }
-    return lines.join("\n");
-}
-function runConfigShow(dir, json) {
-    return Effect.gen(function*() {
-        const inspector = yield* config_show_ConfigInspector;
-        const resolved = resolve(dir);
-        const config = yield* inspector.inspect(resolved).pipe(Effect.catchTag("ConfigurationError", (err)=>{
-            process.exitCode = 1;
-            return Effect.fail(err);
-        }));
-        const output = json ? JSON.stringify(config, null, 2) : config_show_renderHuman(config);
-        yield* Effect.log(output);
-    });
-}
-const configShowCommand = Command.make("show", {
-    dir: dirArg,
-    json: config_show_jsonOption
-}, ({ dir, json })=>runConfigShow(dir, json)).pipe(Command.withDescription("Print the resolved .changeset/config.json"));
-const { ConfigInspector: config_validate_ConfigInspector } = Changesets;
-const config_validate_dirArg = Args.directory({
-    name: "dir"
-}).pipe(Args.withDefault("."));
-function runConfigValidate(dir) {
-    return Effect.gen(function*() {
-        const inspector = yield* config_validate_ConfigInspector;
-        const resolved = resolve(dir);
-        const result = yield* inspector.inspect(resolved).pipe(Effect.map((config)=>({
-                ok: true,
-                config
-            })), Effect.catchTag("ConfigurationError", (err)=>Effect.succeed({
-                ok: false,
-                field: err.field,
-                reason: err.reason
-            })));
-        if (result.ok) {
-            const { config } = result;
-            const pkgCount = config.packages.length;
-            const note = config.legacyVersionFilesUsed ? " (warning: legacy versionFiles in use)" : "";
-            yield* Effect.log(`OK  ${config.configPath} — ${pkgCount} package${1 === pkgCount ? "" : "s"} declared${note}`);
-            return;
-        }
-        yield* Effect.log(`FAIL  ${result.field}: ${result.reason}`);
-        process.exitCode = 1;
-    });
-}
-const configValidateCommand = Command.make("validate", {
-    dir: config_validate_dirArg
-}, ({ dir })=>runConfigValidate(dir)).pipe(Command.withDescription("Validate .changeset/config.json without rendering it"));
-const { ConfigInspector: deps_detect_ConfigInspector, WorkspaceSnapshotReader: WorkspaceSnapshotReader, computeWorkspaceDependencyDiffs: computeWorkspaceDependencyDiffs, gitMergeBase: gitMergeBase, listPublishablePackageNames: listPublishablePackageNames, serializeDependencyTableToMarkdown: serializeDependencyTableToMarkdown, snapshotFromWorktree: snapshotFromWorktree } = Changesets;
-const fromOption = Options.text("from").pipe(Options.withDescription("Older ref to diff from (defaults to merge-base with base branch)"), Options.optional);
-const toOption = Options.text("to").pipe(Options.withDescription("Newer ref to diff to (defaults to working tree)"), Options.optional);
-const deps_detect_cwdOption = Options.directory("cwd").pipe(Options.withDescription("Project root (defaults to the current working directory)"), Options.withDefault("."));
-const packageOption = Options.text("package").pipe(Options.withDescription("Restrict output to a single workspace package"), Options.optional);
-const deps_detect_jsonOption = Options.boolean("json").pipe(Options.withDescription("Emit JSON (default)"), Options.withDefault(false));
-const markdownOption = Options.boolean("markdown").pipe(Options.withDescription("Emit one CSH005 markdown block per workspace package"), Options.withDefault(false));
-function renderMarkdownBlocks(diffs) {
-    const blocks = [];
-    for (const diff of diffs){
-        const frontmatter = `---\n"${diff.package}": patch\n---`;
-        const table = serializeDependencyTableToMarkdown([
-            ...diff.rows
-        ]);
-        blocks.push(`${frontmatter}\n\n## Dependencies\n\n${table}\n`);
-    }
-    return blocks.join("\n");
-}
-function runDepsDetect(cwd, from, to, pkg, json, markdown) {
-    return Effect.gen(function*() {
-        const reader = yield* WorkspaceSnapshotReader;
-        const resolvedCwd = resolve(cwd);
-        let fromRef = Option.getOrUndefined(from);
-        if (!fromRef) {
-            const inspector = yield* deps_detect_ConfigInspector;
-            const inspected = yield* inspector.inspect(resolvedCwd).pipe(Effect.catchTag("ConfigurationError", ()=>Effect.succeed({
-                    baseBranch: "main"
-                })));
-            fromRef = yield* gitMergeBase(resolvedCwd, inspected.baseBranch).pipe(Effect.catchTag("GitError", (err)=>{
-                process.exitCode = 1;
-                return Effect.fail(err);
-            }));
-        }
-        const toRef = Option.getOrUndefined(to);
-        const beforeSnaps = yield* reader.snapshotAt(resolvedCwd, fromRef).pipe(Effect.catchTag("GitError", (err)=>{
-            process.exitCode = 1;
-            return Effect.fail(err);
-        }));
-        const afterSnaps = toRef ? yield* reader.snapshotAt(resolvedCwd, toRef).pipe(Effect.catchTag("GitError", (err)=>{
-            process.exitCode = 1;
-            return Effect.fail(err);
-        })) : snapshotFromWorktree(resolvedCwd);
-        let diffs = computeWorkspaceDependencyDiffs(beforeSnaps, afterSnaps);
-        const targetPkg = Option.getOrUndefined(pkg);
-        if (targetPkg) diffs = diffs.filter((d)=>d.package === targetPkg);
-        else {
-            const discovery = yield* WorkspaceDiscovery;
-            const livePackages = yield* discovery.listPackages(resolvedCwd).pipe(Effect.catchAll(()=>Effect.succeed([])));
-            const publishable = yield* listPublishablePackageNames(livePackages);
-            diffs = diffs.filter((d)=>publishable.has(d.package));
-        }
-        const emitMarkdown = markdown && !json;
-        if (emitMarkdown) return void (yield* Effect.log(renderMarkdownBlocks(diffs)));
-        yield* Effect.log(JSON.stringify(diffs, null, 2));
-    });
-}
-const depsDetectCommand = Command.make("detect", {
-    from: fromOption,
-    to: toOption,
-    cwd: deps_detect_cwdOption,
-    package: packageOption,
-    json: deps_detect_jsonOption,
-    markdown: markdownOption
-}, ({ from, to, cwd, package: pkg, json, markdown })=>runDepsDetect(cwd, from, to, pkg, json, markdown)).pipe(Command.withDescription("Compute the dependency diff between two refs"));
-const { ConfigInspector: deps_regen_ConfigInspector, WorkspaceSnapshotReader: deps_regen_WorkspaceSnapshotReader, computeWorkspaceDependencyDiffs: deps_regen_computeWorkspaceDependencyDiffs, gitMergeBase: deps_regen_gitMergeBase, listPublishablePackageNames: deps_regen_listPublishablePackageNames, serializeDependencyTableToMarkdown: deps_regen_serializeDependencyTableToMarkdown, snapshotFromWorktree: deps_regen_snapshotFromWorktree } = Changesets;
-const deps_regen_cwdOption = Options.directory("cwd").pipe(Options.withDescription("Project root (defaults to the current working directory)"), Options.withDefault("."));
-const deps_regen_baseOption = Options.text("base").pipe(Options.withDescription("Override the base branch (defaults to config baseBranch)"), Options.optional);
-const deps_regen_packageOption = Options.text("package").pipe(Options.withDescription("Restrict regeneration to a single workspace package"), Options.optional);
-const dryRunOption = Options.boolean("dry-run").pipe(Options.withDescription("Print the plan without writing or deleting"), Options.withDefault(false));
-const deps_regen_jsonOption = Options.boolean("json").pipe(Options.withDescription("Emit a structured plan as JSON"), Options.withDefault(false));
-const ADJECTIVES = [
-    "brave",
-    "clever",
-    "swift",
-    "silver",
-    "lucky",
-    "happy",
-    "calm",
-    "bright",
-    "quiet",
-    "wild"
-];
-const NOUNS = [
-    "dogs",
-    "cats",
-    "wolves",
-    "foxes",
-    "cups",
-    "ships",
-    "trees",
-    "owls",
-    "cranes",
-    "hills"
-];
-const VERBS = [
-    "laugh",
-    "dream",
-    "fly",
-    "sing",
-    "dance",
-    "wander",
-    "soar",
-    "rest",
-    "leap",
-    "ponder"
-];
-function pickRandomTriplet() {
-    const a = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
-    const n = NOUNS[Math.floor(Math.random() * NOUNS.length)];
-    const v = VERBS[Math.floor(Math.random() * VERBS.length)];
-    return `${a}-${n}-${v}`;
-}
-function randomFilename(changesetDir) {
-    for(let i = 0; i < 20; i++){
-        const candidate = pickRandomTriplet();
-        if (!existsSync(join(changesetDir, `${candidate}.md`))) return candidate;
-    }
-    return `${pickRandomTriplet()}-${Date.now()}`;
-}
-function isPureDependencyChangeset(content) {
-    const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-    if (!fmMatch) return {
-        isPure: false,
-        package: null
-    };
-    const frontmatter = fmMatch[1];
-    const body = (fmMatch[2] ?? "").trim();
-    const fmLines = frontmatter.split(/\r?\n/).filter((l)=>l.trim().length > 0 && !/^\s*#/.test(l));
-    if (1 !== fmLines.length) return {
-        isPure: false,
-        package: null
-    };
-    const pkgLine = fmLines[0];
-    const pkgMatch = pkgLine.match(/^\s*["']?([^"':\s]+)["']?\s*:\s*([a-z]+)\s*$/);
-    if (!pkgMatch) return {
-        isPure: false,
-        package: null
-    };
-    const pkg = pkgMatch[1];
-    const bodyTrimmed = body.replace(/^\s+/, "");
-    if (!/^## Dependencies\b/.test(bodyTrimmed)) return {
-        isPure: false,
-        package: null
-    };
-    const h2Matches = bodyTrimmed.match(/^## /gm) ?? [];
-    if (1 !== h2Matches.length) return {
-        isPure: false,
-        package: null
-    };
-    if (/^# /m.test(bodyTrimmed)) return {
-        isPure: false,
-        package: null
-    };
-    return {
-        isPure: true,
-        package: pkg
-    };
-}
-function listChangesetFiles(changesetDir) {
-    if (!existsSync(changesetDir)) return [];
-    return readdirSync(changesetDir).filter((f)=>f.endsWith(".md") && "README.md" !== f).map((f)=>join(changesetDir, f));
-}
-function findPureDependencyChangesets(changesetDir) {
-    const result = [];
-    for (const file of listChangesetFiles(changesetDir)){
-        let content;
-        try {
-            content = readFileSync(file, "utf8");
-        } catch  {
-            continue;
-        }
-        const detection = isPureDependencyChangeset(content);
-        if (detection.isPure && detection.package) result.push({
-            file,
-            package: detection.package
-        });
-    }
-    return result;
-}
-function findMixedDependencyChangesets(changesetDir) {
-    const result = [];
-    for (const file of listChangesetFiles(changesetDir)){
-        let content;
-        try {
-            content = readFileSync(file, "utf8");
-        } catch  {
-            continue;
-        }
-        if (/^## Dependencies\b/m.test(content) && !isPureDependencyChangeset(content).isPure) result.push(file);
-    }
-    return result;
-}
-function renderChangesetContent(diff) {
-    const frontmatter = `---\n"${diff.package}": patch\n---`;
-    const table = deps_regen_serializeDependencyTableToMarkdown([
-        ...diff.rows
-    ]);
-    return `${frontmatter}\n\n## Dependencies\n\n${table}\n`;
-}
-function runDepsRegen(cwd, base, pkg, dryRun, json) {
-    return Effect.gen(function*() {
-        const resolvedCwd = resolve(cwd);
-        const changesetDir = join(resolvedCwd, ".changeset");
-        const reader = yield* deps_regen_WorkspaceSnapshotReader;
-        let baseBranch = Option.getOrUndefined(base);
-        if (!baseBranch) {
-            const inspector = yield* deps_regen_ConfigInspector;
-            const inspected = yield* inspector.inspect(resolvedCwd).pipe(Effect.catchTag("ConfigurationError", ()=>Effect.succeed({
-                    baseBranch: "main"
-                })));
-            baseBranch = inspected.baseBranch;
-        }
-        const mergeBase = yield* deps_regen_gitMergeBase(resolvedCwd, baseBranch).pipe(Effect.catchTag("GitError", (err)=>{
-            process.exitCode = 1;
-            return Effect.fail(err);
-        }));
-        const beforeSnaps = yield* reader.snapshotAt(resolvedCwd, mergeBase).pipe(Effect.catchTag("GitError", (err)=>{
-            process.exitCode = 1;
-            return Effect.fail(err);
-        }));
-        const afterSnaps = deps_regen_snapshotFromWorktree(resolvedCwd);
-        let diffs = deps_regen_computeWorkspaceDependencyDiffs(beforeSnaps, afterSnaps);
-        const targetPkg = Option.getOrUndefined(pkg);
-        const discovery = yield* WorkspaceDiscovery;
-        const livePackages = yield* discovery.listPackages(resolvedCwd).pipe(Effect.catchAll(()=>Effect.succeed([])));
-        const publishable = yield* deps_regen_listPublishablePackageNames(livePackages);
-        diffs = targetPkg ? diffs.filter((d)=>d.package === targetPkg) : diffs.filter((d)=>publishable.has(d.package));
-        const existingPure = findPureDependencyChangesets(changesetDir);
-        const skippedMixed = findMixedDependencyChangesets(changesetDir);
-        const toDelete = targetPkg ? existingPure.filter((p)=>p.package === targetPkg) : existingPure.filter((p)=>publishable.has(p.package));
-        const toWrite = diffs.map((diff)=>({
-                file: join(changesetDir, `${randomFilename(changesetDir)}.md`),
-                package: diff.package,
-                diff
-            }));
-        const plan = {
-            toDelete,
-            toWrite,
-            skippedMixed
-        };
-        if (dryRun) {
-            if (json) yield* Effect.log(JSON.stringify(plan, null, 2));
-            else yield* renderHumanPlan(plan);
-            return;
-        }
-        for (const entry of toDelete)try {
-            unlinkSync(entry.file);
-        } catch (error) {
-            yield* Effect.logWarning(`Failed to delete ${entry.file}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        for (const entry of toWrite)writeFileSync(entry.file, renderChangesetContent(entry.diff));
-        if (json) yield* Effect.log(JSON.stringify(plan, null, 2));
-        else yield* renderHumanPlan(plan);
-    });
-}
-function renderHumanPlan(plan) {
-    return Effect.gen(function*() {
-        if (0 === plan.toDelete.length && 0 === plan.toWrite.length) yield* Effect.log("No dependency changes to regenerate.");
-        else {
-            if (plan.toDelete.length > 0) {
-                yield* Effect.log(`Deleted ${plan.toDelete.length} pure dependency changeset(s):`);
-                for (const entry of plan.toDelete)yield* Effect.log(`  - ${entry.file}  (${entry.package})`);
-            }
-            if (plan.toWrite.length > 0) {
-                yield* Effect.log(`Wrote ${plan.toWrite.length} fresh dependency changeset(s):`);
-                for (const entry of plan.toWrite)yield* Effect.log(`  + ${entry.file}  (${entry.package} — ${entry.diff.rows.length} row${1 === entry.diff.rows.length ? "" : "s"})`);
-            }
-        }
-        if (plan.skippedMixed.length > 0) {
-            yield* Effect.log(`\nSkipped ${plan.skippedMixed.length} mixed changeset(s) (have Dependencies but also other content):`);
-            for (const file of plan.skippedMixed)yield* Effect.log(`  ~ ${file}`);
-        }
-    });
-}
-const depsRegenCommand = Command.make("regen", {
-    cwd: deps_regen_cwdOption,
-    base: deps_regen_baseOption,
-    package: deps_regen_packageOption,
-    dryRun: dryRunOption,
-    json: deps_regen_jsonOption
-}, ({ cwd, base, package: pkg, dryRun, json })=>runDepsRegen(cwd, base, pkg, dryRun, json)).pipe(Command.withDescription("Delete pure dependency changesets and regenerate them from the current diff"));
-const { ChangesetLinter: ChangesetLinter } = Changesets;
-const lint_dirArg = Args.directory({
-    name: "dir"
-}).pipe(Args.withDefault(".changeset"));
-const quietOption = Options.boolean("quiet").pipe(Options.withAlias("q"), Options.withDescription("Only output errors, no summary"), Options.withDefault(false));
-function runLint(dir, quiet) {
-    return Effect.gen(function*() {
-        const resolved = resolve(dir);
-        const messages = yield* Effect["try"](()=>ChangesetLinter.validate(resolved));
-        for (const msg of messages)yield* Effect.log(`${msg.file}:${msg.line}:${msg.column} ${msg.rule} ${msg.message}`);
-        if (!quiet && 0 === messages.length) yield* Effect.log("No lint errors found.");
-        if (messages.length > 0) process.exitCode = 1;
-    });
-}
-const lintCommand = Command.make("lint", {
-    dir: lint_dirArg,
-    quiet: quietOption
-}, ({ dir, quiet })=>runLint(dir, quiet)).pipe(Command.withDescription("Validate changeset files"));
-const { ConfigInspector: release_surface_ConfigInspector, ConfigurationError: ConfigurationError } = Changesets;
-const packageArg = Args.text({
-    name: "package"
-});
-const release_surface_cwdOption = Options.directory("cwd").pipe(Options.withDescription("Project root (defaults to the current working directory)"), Options.withDefault("."));
-const release_surface_jsonOption = Options.boolean("json").pipe(Options.withDescription("Emit JSON instead of human-readable output"), Options.withDefault(false));
-function release_surface_renderHuman(pkg) {
-    const lines = [];
-    lines.push(`Package:   ${pkg.name}  v${pkg.version}`);
-    lines.push(`Workspace: ${pkg.workspaceDir}`);
-    if (0 === pkg.additionalScopes.length && 0 === pkg.versionFiles.length) {
-        lines.push("");
-        lines.push("(no additionalScopes or versionFiles — workspace dir is the entire release surface)");
-        return lines.join("\n");
-    }
-    if (pkg.additionalScopes.length > 0) {
-        lines.push("");
-        lines.push(`additionalScopes (${pkg.additionalScopes.length} glob${1 === pkg.additionalScopes.length ? "" : "s"}):`);
-        for (const g of pkg.additionalScopes)lines.push(`  - ${g}`);
-        lines.push(`Resolved files (${pkg.additionalScopeFiles.length}):`);
-        for (const f of pkg.additionalScopeFiles)lines.push(`  ${f}`);
-    }
-    if (pkg.versionFiles.length > 0) {
-        lines.push("");
-        lines.push(`versionFiles (${pkg.versionFiles.length}):`);
-        for (const vf of pkg.versionFiles){
-            lines.push(`  ${vf.glob} → ${vf.paths.join(", ")}`);
-            for (const f of vf.matchedFiles)lines.push(`    ${f}`);
-        }
-    }
-    return lines.join("\n");
-}
-function runReleaseSurface(cwd, pkgName, json) {
-    return Effect.gen(function*() {
-        const inspector = yield* release_surface_ConfigInspector;
-        const resolvedCwd = resolve(cwd);
-        const config = yield* inspector.inspect(resolvedCwd).pipe(Effect.catchTag("ConfigurationError", (err)=>{
-            process.exitCode = 1;
-            return Effect.fail(err);
-        }));
-        const scope = config.packages.find((p)=>p.name === pkgName);
-        if (!scope) {
-            process.exitCode = 1;
-            return yield* Effect.fail(new ConfigurationError({
-                field: `packages["${pkgName}"]`,
-                reason: `Package "${pkgName}" is not declared in .changeset/config.json#packages. Declared packages: ${config.packages.map((p)=>p.name).join(", ") || "(none)"}.`
-            }));
-        }
-        const output = json ? JSON.stringify(scope, null, 2) : release_surface_renderHuman(scope);
-        yield* Effect.log(output);
-    });
-}
-const releaseSurfaceCommand = Command.make("release-surface", {
-    package: packageArg,
-    cwd: release_surface_cwdOption,
-    json: release_surface_jsonOption
-}, ({ package: pkgName, cwd, json })=>runReleaseSurface(cwd, pkgName, json)).pipe(Command.withDescription("Print every path owned by a package — workspace dir, additionalScopes, versionFiles"));
-const { ConfigInspector: config_gate_ConfigInspector } = Changesets;
-function requireValidConfig(cwd) {
-    return Effect.gen(function*() {
-        const projectDir = resolve(cwd);
-        const configPath = join(projectDir, ".changeset", "config.json");
-        if (!existsSync(configPath)) return;
-        const inspector = yield* config_gate_ConfigInspector;
-        yield* inspector.inspect(projectDir).pipe(Effect.catchTag("ConfigurationError", (err)=>{
-            process.exitCode = 1;
-            return Effect.fail(err);
-        }));
-    });
-}
-const { ChangelogTransformer: ChangelogTransformer } = Changesets;
-const fileArg = Args.file({
-    name: "file"
-}).pipe(Args.withDefault("CHANGELOG.md"));
-const transform_dryRunOption = Options.boolean("dry-run").pipe(Options.withAlias("n"), Options.withDescription("Print transformed output instead of writing"), Options.withDefault(false));
-const checkOption = Options.boolean("check").pipe(Options.withAlias("c"), Options.withDescription("Exit 1 if file would change (for CI)"), Options.withDefault(false));
-function runTransform(file, dryRun, check) {
-    return Effect.gen(function*() {
-        const resolved = resolve(file);
-        yield* requireValidConfig(dirname(resolved));
-        const content = yield* Effect["try"](()=>readFileSync(resolved, "utf-8"));
-        const result = ChangelogTransformer.transformContent(content);
-        if (dryRun) return void (yield* Effect.log(result));
-        if (check) {
-            if (result !== content) {
-                yield* Effect.log(`${resolved} would be modified by transform.`);
-                process.exitCode = 1;
-            } else yield* Effect.log(`${resolved} is already formatted.`);
-            return;
-        }
-        yield* Effect["try"](()=>writeFileSync(resolved, result, "utf-8"));
-        yield* Effect.log(`Transformed ${resolved}`);
-    });
-}
-const transformCommand = Command.make("transform", {
-    file: fileArg,
-    dryRun: transform_dryRunOption,
-    check: checkOption
-}, ({ file, dryRun, check })=>runTransform(file, dryRun, check)).pipe(Command.withDescription("Post-process CHANGELOG.md"));
-const { ChangesetLinter: validate_file_ChangesetLinter } = Changesets;
-const validate_file_fileArg = Args.file({
-    name: "file"
-});
-function runValidateFile(filePath) {
-    return Effect.gen(function*() {
-        const result = yield* Effect["try"](()=>validate_file_ChangesetLinter.validateFile(filePath)).pipe(Effect.catchAll((error)=>Effect.gen(function*() {
-                yield* Effect.log(`Error: ${error instanceof Error ? error.message : String(error)}`);
-                process.exitCode = 1;
-                return null;
-            })));
-        if (null === result) return;
-        for (const msg of result)yield* Effect.log(`${msg.file}:${msg.line}:${msg.column} ${msg.rule} ${msg.message}`);
-        if (result.length > 0) process.exitCode = 1;
-        else yield* Effect.log("Valid.");
-    });
-}
-const validateFileCommand = Command.make("validate-file", {
-    file: validate_file_fileArg
-}, ({ file })=>runValidateFile(file)).pipe(Command.withDescription("Validate a single changeset file"));
-const { ChangelogTransformer: version_ChangelogTransformer, ConfigInspector: version_ConfigInspector, VersionFileError: VersionFileError, VersionFiles: VersionFiles } = Changesets;
-function getChangesetVersionCommand(pm) {
-    switch(pm){
-        case "pnpm":
-            return "pnpm exec changeset version";
-        case "yarn":
-            return "yarn exec changeset version";
-        case "bun":
-            return "bun x changeset version";
-        default:
-            return "npx changeset version";
-    }
-}
-const version_dryRunOption = Options.boolean("dry-run").pipe(Options.withAlias("n"), Options.withDescription("Skip changeset version, only transform existing CHANGELOGs"), Options.withDefault(false));
-function runVersion(dryRun) {
-    return Effect.gen(function*() {
-        const cwd = process.cwd();
-        const detector = yield* PackageManagerDetector;
-        const detected = yield* detector.detect(cwd).pipe(Effect.catchAll(()=>Effect.succeed({
-                type: "npm",
-                version: void 0
-            })));
-        const pm = detected.type;
-        yield* Effect.log(`Detected package manager: ${pm}`);
-        yield* requireValidConfig(cwd);
-        if (dryRun) yield* Effect.log("Dry run: skipping changeset version");
-        else {
-            const cmd = getChangesetVersionCommand(pm);
-            yield* Effect.log(`Running: ${cmd}`);
-            yield* Effect["try"]({
-                try: ()=>execSync(cmd, {
-                        cwd,
-                        stdio: "inherit"
-                    }),
-                catch: (error)=>new Error(`changeset version failed: ${error instanceof Error ? error.message : String(error)}`)
-            });
-        }
-        const discovery = yield* WorkspaceDiscovery;
-        const packages = yield* discovery.listPackages().pipe(Effect.catchAll(()=>Effect.succeed([])));
-        const changelogs = [];
-        const seen = new Set();
-        const resolvedCwd = resolve(cwd);
-        for (const pkg of packages){
-            const changelogPath = join(pkg.path, "CHANGELOG.md");
-            if (existsSync(changelogPath) && !seen.has(pkg.path)) {
-                seen.add(pkg.path);
-                changelogs.push({
-                    name: pkg.name,
-                    path: pkg.path,
-                    changelogPath
-                });
-            }
-        }
-        if (!seen.has(resolvedCwd)) {
-            const rootChangelog = join(resolvedCwd, "CHANGELOG.md");
-            if (existsSync(rootChangelog)) {
-                let rootName = "root";
-                try {
-                    const pkg = JSON.parse(readFileSync(join(resolvedCwd, "package.json"), "utf-8"));
-                    if (pkg.name) rootName = pkg.name;
-                } catch  {}
-                changelogs.push({
-                    name: rootName,
-                    path: resolvedCwd,
-                    changelogPath: rootChangelog
-                });
-            }
-        }
-        if (0 === changelogs.length) yield* Effect.log("No CHANGELOG.md files found.");
-        else {
-            yield* Effect.log(`Found ${changelogs.length} CHANGELOG.md file(s)`);
-            for (const entry of changelogs){
-                yield* Effect["try"]({
-                    try: ()=>version_ChangelogTransformer.transformFile(entry.changelogPath),
-                    catch: (error)=>new Error(`Failed to transform ${entry.changelogPath}: ${error instanceof Error ? error.message : String(error)}`)
-                });
-                yield* Effect.log(`Transformed ${entry.name} → ${entry.changelogPath}`);
-            }
-        }
-        const configPath = join(resolvedCwd, ".changeset", "config.json");
-        if (!existsSync(configPath)) return;
-        const inspector = yield* version_ConfigInspector;
-        const inspected = yield* inspector.inspect(resolvedCwd);
-        const scopesWithVersionFiles = inspected.packages.filter((p)=>p.versionFiles.length > 0).map((p)=>{
-            const fresh = readPackageVersionFromDisk(p.workspaceDir);
-            return fresh && fresh !== p.version ? {
-                ...p,
-                version: fresh
-            } : p;
-        });
-        if (0 === scopesWithVersionFiles.length) return;
-        yield* Effect.log(`Found ${scopesWithVersionFiles.length} package${1 === scopesWithVersionFiles.length ? "" : "s"} with versionFiles`);
-        const updates = yield* Effect["try"]({
-            try: ()=>VersionFiles.processResolvedVersionFiles(scopesWithVersionFiles, dryRun),
-            catch: (error)=>{
-                const message = error instanceof Error ? error.message : String(error);
-                return new VersionFileError({
-                    filePath: message.match(/Failed to update (.+?):/)?.[1] ?? cwd,
-                    reason: message
-                });
-            }
-        });
-        for (const update of updates){
-            const action = dryRun ? "Would update" : "Updated";
-            yield* Effect.log(`${action} ${update.filePath} → ${update.version}`);
-        }
-    });
-}
-function readPackageVersionFromDisk(workspaceDir) {
-    try {
-        const pkg = JSON.parse(readFileSync(join(workspaceDir, "package.json"), "utf-8"));
-        return pkg.version ?? null;
-    } catch  {
-        return null;
-    }
-}
-const versionCommand = Command.make("version", {
-    dryRun: version_dryRunOption
-}, ({ dryRun })=>runVersion(dryRun)).pipe(Command.withDescription("Run changeset version and transform all CHANGELOGs"));
-const { ChangesetLinter: check_ChangesetLinter } = Changesets;
-const check_dirArg = Args.directory({
-    name: "dir"
-}).pipe(Args.withDefault(".changeset"));
-function runChangesetCheck(dir) {
-    return Effect.gen(function*() {
-        const resolved = resolve(dir);
-        const messages = yield* Effect["try"]({
-            try: ()=>check_ChangesetLinter.validate(resolved),
-            catch: (e)=>new Error(String(e))
-        });
-        const byFile = new Map();
-        for (const msg of messages){
-            const existing = byFile.get(msg.file);
-            if (existing) existing.push(msg);
-            else byFile.set(msg.file, [
-                msg
-            ]);
-        }
-        for (const [file, fileMessages] of byFile){
-            yield* Effect.log(`\n${file}`);
-            for (const msg of fileMessages)yield* Effect.log(`  ${msg.line}:${msg.column}  ${msg.rule}  ${msg.message}`);
-        }
-        const errorCount = messages.length;
-        const filesWithErrors = byFile.size;
-        if (errorCount > 0) {
-            yield* Effect.log(`\n${filesWithErrors} file(s) with errors, ${errorCount} error(s) found`);
-            process.exitCode = 1;
-        } else yield* Effect.log("All changeset files passed validation.");
-    });
-}
-Command.make("check", {
-    dir: check_dirArg
-}, ({ dir })=>runChangesetCheck(dir)).pipe(Command.withDescription("Full changeset validation with summary"));
-const { LegacyVersionFilesSchema: LegacyVersionFilesSchema } = Changesets;
-const CHANGELOG_ENTRY = "@savvy-web/silk/changesets/changelog";
-const LEGACY_CHANGELOG_ENTRY = "@savvy-web/changesets/changelog";
-const ACCEPTED_CHANGELOG_ENTRIES = [
-    CHANGELOG_ENTRY,
-    LEGACY_CHANGELOG_ENTRY
-];
-const CUSTOM_RULES_ENTRY = "@savvy-web/silk/changesets/markdownlint";
-const LEGACY_CUSTOM_RULES_ENTRY = "@savvy-web/changesets/markdownlint";
-const ACCEPTED_CUSTOM_RULES_ENTRIES = [
-    CUSTOM_RULES_ENTRY,
-    LEGACY_CUSTOM_RULES_ENTRY
-];
-const MARKDOWNLINT_CONFIG_PATHS = [
-    "lib/configs/.markdownlint-cli2.jsonc",
-    "lib/configs/.markdownlint-cli2.json",
-    ".markdownlint-cli2.jsonc",
-    ".markdownlint-cli2.json"
-];
-const RULE_NAMES = [
-    "changeset-heading-hierarchy",
-    "changeset-required-sections",
-    "changeset-content-structure",
-    "changeset-uncategorized-content",
-    "changeset-dependency-table-format"
-];
-const DEFAULT_CONFIG = {
-    $schema: "https://unpkg.com/@changesets/config@3.1.1/schema.json",
-    changelog: [
-        CHANGELOG_ENTRY,
-        {
-            repo: "owner/repo"
-        }
-    ],
-    commit: false,
-    access: "restricted",
-    baseBranch: "main",
-    updateInternalDependencies: "patch",
-    ignore: [],
-    privatePackages: {
-        tag: true,
-        version: true
-    }
-};
-const InitErrorBase = Data.TaggedError("InitError");
-class InitError extends InitErrorBase {
-    get message() {
-        return `Init failed at ${this.step}: ${this.reason}`;
-    }
-}
-const forceOption = Options.boolean("force").pipe(Options.withAlias("f"), Options.withDescription("Overwrite existing config files"));
-const init_quietOption = Options.boolean("quiet").pipe(Options.withAlias("q"), Options.withDescription("Silence warnings, always exit 0"));
-const skipMarkdownlintOption = Options.boolean("skip-markdownlint").pipe(Options.withDescription("Skip registering rules in base markdownlint config"));
-const init_checkOption = Options.boolean("check").pipe(Options.withDescription("Check configuration without writing (for postinstall scripts)"));
-function detectGitHubRepo(cwd) {
-    try {
-        const url = execSync("git remote get-url origin", {
-            cwd,
-            encoding: "utf-8"
-        }).trim();
-        const https = url.match(/github\.com\/([^/]+)\/([^/.]+)/);
-        if (https) return `${https[1]}/${https[2]}`;
-        const ssh = url.match(/github\.com:([^/]+)\/([^/.]+)/);
-        if (ssh) return `${ssh[1]}/${ssh[2]}`;
-    } catch  {}
-    return null;
-}
-const JSONC_FORMAT = {
-    tabSize: 1,
-    insertSpaces: false
-};
-function resolveWorkspaceRoot(cwd) {
-    return WorkspaceRoot.pipe(Effect.flatMap((wr)=>wr.find(cwd)), Effect.catchAll(()=>Effect.succeed(cwd)));
-}
-function findMarkdownlintConfig(root) {
-    for (const configPath of MARKDOWNLINT_CONFIG_PATHS)if (existsSync(join(root, configPath))) return configPath;
-    return null;
-}
-function ensureChangesetDir(root) {
-    return Effect["try"]({
-        try: ()=>{
-            const dir = join(root, ".changeset");
-            mkdirSync(dir, {
-                recursive: true
-            });
-            return dir;
-        },
-        catch: (error)=>new InitError({
-                step: ".changeset directory",
-                reason: error instanceof Error ? error.message : String(error)
-            })
-    });
-}
-function handleConfig(changesetDir, repoSlug, force) {
-    return Effect["try"]({
-        try: ()=>{
-            const configPath = join(changesetDir, "config.json");
-            if (force || !existsSync(configPath)) {
-                const config = {
-                    ...DEFAULT_CONFIG,
-                    changelog: [
-                        CHANGELOG_ENTRY,
-                        {
-                            repo: repoSlug
-                        }
-                    ]
-                };
-                writeFileSync(configPath, `${JSON.stringify(config, null, "\t")}\n`);
-                return force ? "Overwrote .changeset/config.json" : "Created .changeset/config.json";
-            }
-            const existing = JSON.parse(readFileSync(configPath, "utf-8"));
-            const currentOptions = Array.isArray(existing.changelog) && "object" == typeof existing.changelog[1] && null !== existing.changelog[1] ? existing.changelog[1] : {};
-            existing.changelog = [
-                CHANGELOG_ENTRY,
-                {
-                    ...currentOptions,
-                    repo: repoSlug
-                }
-            ];
-            writeFileSync(configPath, `${JSON.stringify(existing, null, "\t")}\n`);
-            return "Patched changelog in .changeset/config.json";
-        },
-        catch: (error)=>new InitError({
-                step: ".changeset/config.json",
-                reason: error instanceof Error ? error.message : String(error)
-            })
-    });
-}
-function detectLegacyVersionFiles(config) {
-    if ("object" != typeof config || null === config) return false;
-    const cfg = config;
-    const changelog = cfg.changelog;
-    if (!Array.isArray(changelog) || changelog.length < 2) return false;
-    const options = changelog[1];
-    if ("object" != typeof options || null === options) return false;
-    return Array.isArray(options.versionFiles) && options.versionFiles.length > 0;
-}
-function legacyVersionFilesWarning(configPath) {
-    return [
-        `DEPRECATION: ${configPath} uses the legacy top-level \`versionFiles[]\` array.`,
-        "  Migrate each entry to `changelog[1].packages[<entry.package>].versionFiles`",
-        "  and remove the top-level field. Run `savvy changeset config show --json`",
-        "  to see the normalized form, or check the 0.9.0 release notes for examples.",
-        "  Removed in @savvy-web/changesets 1.0.0."
-    ].join("\n");
-}
-function warnIfLegacyVersionFiles(changesetDir) {
-    return Effect.gen(function*() {
-        const configPath = join(changesetDir, "config.json");
-        if (!existsSync(configPath)) return;
-        let parsed;
-        try {
-            parsed = JSON.parse(readFileSync(configPath, "utf-8"));
-        } catch  {
-            return;
-        }
-        if (detectLegacyVersionFiles(parsed)) yield* Effect.logWarning(legacyVersionFilesWarning(configPath));
-    });
-}
-function handleBaseMarkdownlint(root) {
-    const foundPath = findMarkdownlintConfig(root);
-    if (!foundPath) return Effect.succeed(`Warning: no markdownlint config found (checked ${MARKDOWNLINT_CONFIG_PATHS.join(", ")})`);
-    return Effect.gen(function*() {
-        const fullPath = join(root, foundPath);
-        let text;
-        try {
-            text = readFileSync(fullPath, "utf-8");
-        } catch (error) {
-            return yield* Effect.fail(new InitError({
-                step: "markdownlint config",
-                reason: error instanceof Error ? error.message : String(error)
-            }));
-        }
-        let parsed = yield* parse(text);
-        const currentRules = Array.isArray(parsed.customRules) ? parsed.customRules : null;
-        if (null === currentRules) {
-            const edits = yield* modify(text, [
-                "customRules"
-            ], [
-                CUSTOM_RULES_ENTRY
-            ], {
-                formattingOptions: JSONC_FORMAT
-            });
-            text = yield* applyEdits(text, edits);
-        } else {
-            const desired = currentRules.filter((r)=>r !== LEGACY_CUSTOM_RULES_ENTRY && r !== CUSTOM_RULES_ENTRY);
-            desired.push(CUSTOM_RULES_ENTRY);
-            const changed = desired.length !== currentRules.length || desired.some((r, i)=>r !== currentRules[i]);
-            if (changed) {
-                const edits = yield* modify(text, [
-                    "customRules"
-                ], desired, {
-                    formattingOptions: JSONC_FORMAT
-                });
-                text = yield* applyEdits(text, edits);
-            }
-        }
-        parsed = yield* parse(text);
-        const currentConfig = parsed.config;
-        if ("object" != typeof currentConfig || null === currentConfig) {
-            const edits = yield* modify(text, [
-                "config"
-            ], {}, {
-                formattingOptions: JSONC_FORMAT
-            });
-            text = yield* applyEdits(text, edits);
-        }
-        parsed = yield* parse(text);
-        const config = parsed.config;
-        for (const rule of RULE_NAMES)if (!(rule in config)) {
-            const edits = yield* modify(text, [
-                "config",
-                rule
-            ], false, {
-                formattingOptions: JSONC_FORMAT
-            });
-            text = yield* applyEdits(text, edits);
-        }
-        try {
-            writeFileSync(fullPath, text);
-        } catch (error) {
-            return yield* Effect.fail(new InitError({
-                step: "markdownlint config",
-                reason: error instanceof Error ? error.message : String(error)
-            }));
-        }
-        return `Updated ${foundPath}`;
-    }).pipe(Effect.catchAll((error)=>{
-        if (error instanceof InitError) return Effect.fail(error);
-        return Effect.fail(new InitError({
-            step: "markdownlint config",
-            reason: error instanceof Error ? error.message : String(error)
-        }));
-    }));
-}
-function handleChangesetMarkdownlint(changesetDir, root, force) {
-    return Effect["try"]({
-        try: ()=>{
-            const mdlintPath = join(changesetDir, ".markdownlint.json");
-            const baseConfig = findMarkdownlintConfig(root);
-            if (force || !existsSync(mdlintPath)) {
-                const mdlintConfig = {};
-                if (baseConfig) mdlintConfig.extends = `../${baseConfig}`;
-                mdlintConfig.default = false;
-                mdlintConfig.MD041 = false;
-                for (const rule of RULE_NAMES)mdlintConfig[rule] = true;
-                writeFileSync(mdlintPath, `${JSON.stringify(mdlintConfig, null, "\t")}\n`);
-                return force ? "Overwrote .changeset/.markdownlint.json" : "Created .changeset/.markdownlint.json";
-            }
-            const existing = JSON.parse(readFileSync(mdlintPath, "utf-8"));
-            for (const rule of RULE_NAMES)existing[rule] = true;
-            writeFileSync(mdlintPath, `${JSON.stringify(existing, null, "\t")}\n`);
-            return "Patched rules in .changeset/.markdownlint.json";
-        },
-        catch: (error)=>new InitError({
-                step: ".changeset/.markdownlint.json",
-                reason: error instanceof Error ? error.message : String(error)
-            })
-    });
-}
-function checkChangesetDir(root) {
-    const dir = join(root, ".changeset");
-    if (!existsSync(dir)) return [
-        {
-            file: ".changeset/",
-            message: "directory does not exist"
-        }
-    ];
-    return [];
-}
-function checkConfig(changesetDir, repoSlug) {
-    const configPath = join(changesetDir, "config.json");
-    if (!existsSync(configPath)) return [
-        {
-            file: ".changeset/config.json",
-            message: "file does not exist"
-        }
-    ];
-    try {
-        const config = JSON.parse(readFileSync(configPath, "utf-8"));
-        const issues = [];
-        const changelog = config.changelog;
-        const entry = Array.isArray(changelog) ? changelog[0] : changelog;
-        const repo = Array.isArray(changelog) ? changelog[1]?.repo : void 0;
-        if (ACCEPTED_CHANGELOG_ENTRIES.includes(entry)) {
-            if (repo !== repoSlug) issues.push({
-                file: ".changeset/config.json",
-                message: `changelog repo is "${repo ?? "(not set)"}", expected "${repoSlug}"`
-            });
-        } else issues.push({
-            file: ".changeset/config.json",
-            message: `changelog formatter is "${entry}", expected "${CHANGELOG_ENTRY}"`
-        });
-        const options = Array.isArray(changelog) ? changelog[1] : void 0;
-        if (options && "object" == typeof options && "versionFiles" in options) {
-            const result = Schema.decodeUnknownEither(LegacyVersionFilesSchema)(options.versionFiles);
-            if ("Left" === result._tag) issues.push({
-                file: ".changeset/config.json",
-                message: "versionFiles config is invalid"
-            });
-        }
-        if (detectLegacyVersionFiles(config)) issues.push({
-            file: ".changeset/config.json",
-            message: "uses the legacy top-level `versionFiles[]` array (deprecated; removed in 1.0.0). Migrate to `packages[<name>].versionFiles`."
-        });
-        return issues;
-    } catch  {
-        return [
-            {
-                file: ".changeset/config.json",
-                message: "could not parse file"
-            }
-        ];
-    }
-}
-function checkBaseMarkdownlint(root) {
-    const foundPath = findMarkdownlintConfig(root);
-    if (!foundPath) return [
-        {
-            file: "markdownlint config",
-            message: `not found (checked ${MARKDOWNLINT_CONFIG_PATHS.join(", ")})`
-        }
-    ];
-    try {
-        const raw = readFileSync(join(root, foundPath), "utf-8");
-        const parsed = Effect.runSync(parse(raw));
-        const issues = [];
-        if (!Array.isArray(parsed.customRules) || !parsed.customRules.some((r)=>ACCEPTED_CUSTOM_RULES_ENTRIES.includes(r))) issues.push({
-            file: foundPath,
-            message: `customRules does not include ${CUSTOM_RULES_ENTRY}`
-        });
-        const config = parsed.config;
-        if ("object" != typeof config || null === config) issues.push({
-            file: foundPath,
-            message: "config section is missing"
-        });
-        else for (const rule of RULE_NAMES)if (!(rule in config)) issues.push({
-            file: foundPath,
-            message: `rule "${rule}" is not configured`
-        });
-        return issues;
-    } catch  {
-        return [
-            {
-                file: foundPath,
-                message: "could not parse file"
-            }
-        ];
-    }
-}
-function checkChangesetMarkdownlint(changesetDir) {
-    const mdlintPath = join(changesetDir, ".markdownlint.json");
-    if (!existsSync(mdlintPath)) return [
-        {
-            file: ".changeset/.markdownlint.json",
-            message: "file does not exist"
-        }
-    ];
-    try {
-        const existing = JSON.parse(readFileSync(mdlintPath, "utf-8"));
-        const issues = [];
-        for (const rule of RULE_NAMES)if (true !== existing[rule]) issues.push({
-            file: ".changeset/.markdownlint.json",
-            message: `rule "${rule}" is not enabled`
-        });
-        return issues;
-    } catch  {
-        return [
-            {
-                file: ".changeset/.markdownlint.json",
-                message: "could not parse file"
-            }
-        ];
-    }
-}
-function runChangesetInit(opts) {
-    const { force, quiet, skipMarkdownlint, check } = opts;
-    return Effect.gen(function*() {
-        const root = yield* resolveWorkspaceRoot(process.cwd());
-        const repo = detectGitHubRepo(root);
-        if (!repo && !quiet) yield* Effect.log("Warning: could not detect GitHub repo from git remote, using placeholder");
-        const repoSlug = repo ?? "owner/repo";
-        if (check) {
-            const changesetDir = join(root, ".changeset");
-            const issues = [
-                ...checkChangesetDir(root),
-                ...checkConfig(changesetDir, repoSlug),
-                ...skipMarkdownlint ? [] : checkBaseMarkdownlint(root),
-                ...checkChangesetMarkdownlint(changesetDir)
-            ];
-            if (0 === issues.length) return void (yield* Effect.log("All @savvy-web/changesets config files are up to date."));
-            for (const issue of issues)yield* Effect.logWarning(`${issue.file}: ${issue.message}`);
-            yield* Effect.logWarning('Run "savvy init --force" to fix.');
-            return;
-        }
-        const changesetDir = yield* ensureChangesetDir(root);
-        yield* Effect.log("Ensured .changeset/ directory");
-        const errors = [];
-        const configResult = yield* handleConfig(changesetDir, repoSlug, force).pipe(Effect.either);
-        if ("Right" === configResult._tag) {
-            yield* Effect.log(configResult.right);
-            if (!quiet) yield* warnIfLegacyVersionFiles(changesetDir);
-        } else errors.push(configResult.left);
-        if (!skipMarkdownlint) {
-            const baseResult = yield* handleBaseMarkdownlint(root).pipe(Effect.either);
-            if ("Right" === baseResult._tag) yield* Effect.log(baseResult.right);
-            else errors.push(baseResult.left);
-        }
-        const mdlintResult = yield* handleChangesetMarkdownlint(changesetDir, root, force).pipe(Effect.either);
-        if ("Right" === mdlintResult._tag) yield* Effect.log(mdlintResult.right);
-        else errors.push(mdlintResult.left);
-        if (errors.length > 0) {
-            for (const err of errors)yield* Effect.logError(err.message);
-            if (!quiet) process.exitCode = 1;
-            return;
-        }
-        yield* Effect.log("Init complete.");
-    }).pipe(Effect.catchAll((error)=>Effect.gen(function*() {
-            if (!quiet) {
-                yield* Effect.logError(error instanceof InitError ? error.message : `Init failed: ${String(error)}`);
-                process.exitCode = 1;
-            }
-        })));
-}
-Command.make("init", {
-    force: forceOption,
-    quiet: init_quietOption,
-    skipMarkdownlint: skipMarkdownlintOption,
-    check: init_checkOption
-}, (opts)=>runChangesetInit(opts)).pipe(Command.withDescription("Bootstrap a repo for @savvy-web/changesets"));
-const configGroup = Command.make("config").pipe(Command.withSubcommands([
-    configShowCommand,
-    configValidateCommand
-]), Command.withDescription("Inspect or validate .changeset/config.json"));
-const depsGroup = Command.make("deps").pipe(Command.withSubcommands([
-    depsDetectCommand,
-    depsRegenCommand
-]), Command.withDescription("Generate or regenerate dependency changesets"));
-const _changesetCommand = Command.make("changeset").pipe(Command.withSubcommands([
-    lintCommand,
-    transformCommand,
-    validateFileCommand,
-    versionCommand,
-    classifyCommand,
-    analyzeBranchCommand,
-    releaseSurfaceCommand,
-    configGroup,
-    depsGroup
-]), Command.withDescription("Section-aware changeset tooling"));
-const changesetCommand = _changesetCommand;
-const HUSKY_HOOK_PATH = ".husky/commit-msg";
-const POST_CHECKOUT_HOOK_PATH = ".husky/post-checkout";
-const POST_MERGE_HOOK_PATH = ".husky/post-merge";
-const EXECUTABLE_MODE = 493;
-const DEFAULT_CONFIG_PATH = "lib/configs/commitlint.config.ts";
-const SECTION_DEF = SectionDefinition.make({
-    toolName: "savvy-commit"
-});
-const COMMIT_MSG_HEADER = "#!/usr/bin/env sh\n# Commit-msg hook with savvy managed sections\n# Custom hooks can go above, below, or between the managed sections\n\n";
-const HYGIENE_HEADER = "#!/usr/bin/env sh\n# Managed by savvy-hooks\n# Custom hooks can go above or below the managed section\n\n";
-function commitlintCommand(configPath) {
-    return `commitlint --config "$ROOT/${configPath}" --edit "$1"`;
-}
-function savvyCommitBlock(configPath) {
-    return savvyToolSection("savvy-commit", commitlintCommand(configPath));
-}
-function ensureHookFile(path, header) {
-    return Effect.gen(function*() {
-        const fs = yield* FileSystem.FileSystem;
-        const exists = yield* fs.exists(path);
-        if (!exists) yield* fs.writeFileString(path, header);
-    });
-}
-const init_forceOption = Options.boolean("force").pipe(Options.withAlias("f"), Options.withDescription("Overwrite the commit-msg hook and config file entirely (managed sections in post-checkout/post-merge are never force-reset)"), Options.withDefault(false));
-const configOption = Options.text("config").pipe(Options.withAlias("c"), Options.withDescription("Relative path for the commitlint config file (from repo root)"), Options.withDefault(DEFAULT_CONFIG_PATH));
-const CONFIG_CONTENT = `import { CommitlintConfig } from "@savvy-web/silk/commitlint";
-
-export default CommitlintConfig.silk();
-`;
-function makeExecutable(path) {
-    return Effect.tryPromise({
-        try: ()=>chmod(path, EXECUTABLE_MODE),
-        catch: (e)=>new Error(String(e))
-    });
-}
-function runCommitInit(opts) {
-    const { force, config } = opts;
-    return Effect.gen(function*() {
-        const fs = yield* FileSystem.FileSystem;
-        const ms = yield* ManagedSection;
-        if (config.startsWith("/")) yield* Effect.fail(new Error("Config path must be relative to repository root, not absolute"));
-        yield* Effect.log("Initializing commitlint configuration...\n");
-        yield* fs.makeDirectory(".husky", {
-            recursive: true
-        });
-        if (force) yield* fs.writeFileString(HUSKY_HOOK_PATH, COMMIT_MSG_HEADER);
-        else yield* ensureHookFile(HUSKY_HOOK_PATH, COMMIT_MSG_HEADER);
-        const commitResults = yield* ms.syncMany(HUSKY_HOOK_PATH, [
-            SavvyBaseSection.block(savvyBasePreamble()),
-            savvyCommitBlock(config)
-        ]);
-        yield* makeExecutable(HUSKY_HOOK_PATH);
-        yield* Effect.log(`✓ ${force ? "Replaced" : "Synced"} ${HUSKY_HOOK_PATH} (${commitResults.map((r)=>r._tag).join(", ")})`);
-        for (const hookPath of [
-            POST_CHECKOUT_HOOK_PATH,
-            POST_MERGE_HOOK_PATH
-        ]){
-            yield* ensureHookFile(hookPath, HYGIENE_HEADER);
-            yield* ms.sync(hookPath, SavvyHooksSection.block(savvyHooksHygiene()));
-            yield* makeExecutable(hookPath);
-            yield* Effect.log(`✓ Synced ${hookPath}`);
-        }
-        const configExists = yield* fs.exists(config);
-        if (configExists && !force) yield* Effect.log(`⚠ ${config} already exists (use --force to overwrite)`);
-        else {
-            const configDir = dirname(config);
-            if (configDir && "." !== configDir) yield* fs.makeDirectory(configDir, {
-                recursive: true
-            });
-            yield* fs.writeFileString(config, CONFIG_CONTENT);
-            yield* Effect.log(`✓ Created ${config}`);
-        }
-        yield* Effect.log("\nDone! Install @commitlint/cli if not already installed.");
-    });
-}
-Command.make("init", {
-    force: init_forceOption,
-    config: configOption
-}, (opts)=>runCommitInit(opts)).pipe(Command.withDescription("Initialize commitlint configuration and husky hooks"));
-const CROSS_MARK = "✗";
-const BULLET = "•";
-const CONFIG_FILES = [
-    "commitlint.config.ts",
-    "commitlint.config.mts",
-    "commitlint.config.cts",
-    "commitlint.config.js",
-    "commitlint.config.mjs",
-    "commitlint.config.cjs",
-    "lib/configs/commitlint.config.ts",
-    "lib/configs/commitlint.config.mts",
-    "lib/configs/commitlint.config.cts",
-    "lib/configs/commitlint.config.js",
-    "lib/configs/commitlint.config.mjs",
-    "lib/configs/commitlint.config.cjs",
-    ".commitlintrc",
-    ".commitlintrc.json",
-    ".commitlintrc.yaml",
-    ".commitlintrc.yml",
-    ".commitlintrc.js",
-    ".commitlintrc.cjs",
-    ".commitlintrc.mjs",
-    ".commitlintrc.ts",
-    ".commitlintrc.cts",
-    ".commitlintrc.mts"
-];
-const DCO_FILE_PATH = "DCO";
-const STRATEGY_TO_FORMAT = {
-    single: "semver",
-    "fixed-group": "semver",
-    independent: "packages"
-};
-function findConfigFile(fs) {
-    return Effect.gen(function*() {
-        for (const file of CONFIG_FILES)if (yield* fs.exists(file)) return file;
-        return null;
-    });
-}
-function extractConfigPathFromManaged(managedContent) {
-    const match = managedContent.match(/commitlint --config "\$ROOT\/([^"]+)"/);
-    return match ? match[1] : null;
-}
-const detectReleaseFormat = Effect.gen(function*() {
-    const versioning = yield* VersioningStrategy;
-    const discovery = yield* WorkspaceDiscovery;
-    const packages = yield* Effect.catchAll(discovery.listPackages(), ()=>Effect.succeed([]));
-    const publishableNames = packages.filter((pkg)=>!pkg.private || pkg.publishConfig?.access !== void 0).map((pkg)=>pkg.name);
-    const result = yield* Effect.catchAll(versioning.detect(publishableNames, process.cwd()), ()=>Effect.succeed({
-            type: "single"
-        }));
-    return STRATEGY_TO_FORMAT[result.type] ?? "semver";
-});
-function runCommitCheck() {
-    return Effect.gen(function*() {
-        const fs = yield* FileSystem.FileSystem;
-        const ms = yield* ManagedSection;
-        yield* Effect.log("Checking commitlint configuration...\n");
-        const foundConfig = yield* findConfigFile(fs);
-        if (foundConfig) yield* Effect.log(`✓ Config file: ${foundConfig}`);
-        else yield* Effect.log(`${CROSS_MARK} No commitlint config file found`);
-        const hasHuskyHook = yield* fs.exists(HUSKY_HOOK_PATH);
-        if (hasHuskyHook) yield* Effect.log(`✓ Husky hook: ${HUSKY_HOOK_PATH}`);
-        else yield* Effect.log(`${CROSS_MARK} No husky commit-msg hook found`);
-        let sectionsHealthy = true;
-        if (hasHuskyHook) {
-            const baseStatus = yield* ms.check(HUSKY_HOOK_PATH, SavvyBaseSection.block(savvyBasePreamble()));
-            if (CheckResult.$is("Found")(baseStatus) && baseStatus.isUpToDate) yield* Effect.log("✓ Base section: up-to-date");
-            else if (CheckResult.$is("Found")(baseStatus)) {
-                sectionsHealthy = false;
-                yield* Effect.log("⚠ Base section: outdated (run 'savvy init' to update)");
-            } else {
-                sectionsHealthy = false;
-                yield* Effect.log(`${BULLET} Base section: not found (run 'savvy init' to add)`);
-            }
-            const block = yield* ms.read(HUSKY_HOOK_PATH, SECTION_DEF);
-            if (block) {
-                const configPath = extractConfigPathFromManaged(block.content);
-                if (configPath) {
-                    const status = yield* ms.check(HUSKY_HOOK_PATH, savvyCommitBlock(configPath));
-                    if (CheckResult.$is("Found")(status) && status.isUpToDate) yield* Effect.log("✓ Commit section: up-to-date");
-                    else {
-                        sectionsHealthy = false;
-                        yield* Effect.log("⚠ Commit section: outdated (run 'savvy init' to update)");
-                    }
-                } else {
-                    sectionsHealthy = false;
-                    yield* Effect.log("⚠ Commit section: outdated (run 'savvy init' to update)");
-                }
-            } else {
-                sectionsHealthy = false;
-                yield* Effect.log(`${BULLET} Commit section: not found (run 'savvy init' to add)`);
-            }
-        }
-        for (const hookPath of [
-            POST_CHECKOUT_HOOK_PATH,
-            POST_MERGE_HOOK_PATH
-        ]){
-            const hygieneExists = yield* fs.exists(hookPath);
-            if (!hygieneExists) {
-                sectionsHealthy = false;
-                yield* Effect.log(`${BULLET} Hygiene hook: ${hookPath} not found (run 'savvy init' to add)`);
-                continue;
-            }
-            const hygieneStatus = yield* ms.check(hookPath, SavvyHooksSection.block(savvyHooksHygiene()));
-            if (CheckResult.$is("Found")(hygieneStatus) && hygieneStatus.isUpToDate) yield* Effect.log(`✓ Hygiene hook: ${hookPath}`);
-            else if (CheckResult.$is("Found")(hygieneStatus)) {
-                sectionsHealthy = false;
-                yield* Effect.log(`⚠ Hygiene hook: ${hookPath} outdated (run 'savvy init' to update)`);
-            } else {
-                sectionsHealthy = false;
-                yield* Effect.log(`${BULLET} Hygiene hook: ${hookPath} section not found (run 'savvy init' to add)`);
-            }
-        }
-        const hasDCOFile = yield* fs.exists(DCO_FILE_PATH);
-        if (hasDCOFile) yield* Effect.log(`✓ DCO file: ${DCO_FILE_PATH}`);
-        else yield* Effect.log(`${BULLET} No DCO file (signoff not required)`);
-        yield* Effect.log("\nDetected settings:");
-        yield* Effect.log(`  DCO required: ${Commitlint.detectDCO()}`);
-        const releaseFormat = yield* detectReleaseFormat;
-        yield* Effect.log(`  Release format: ${releaseFormat}`);
-        const scopes = yield* Effect.catchAll(Commitlint.detectScopes, ()=>Effect.succeed([]));
-        const scopeDisplay = scopes.length > 0 ? scopes.join(", ") : "(none - not a monorepo or no packages found)";
-        yield* Effect.log(`  Detected scopes: ${scopeDisplay}`);
-        yield* Effect.log("");
-        const hasIssues = !foundConfig || !hasHuskyHook || !sectionsHealthy;
-        if (hasIssues) yield* Effect.log(`${CROSS_MARK} Commitlint needs configuration. Run: savvy init`);
-        else yield* Effect.log("✓ Commitlint is configured correctly.");
-    });
-}
-Command.make("check", {}, ()=>runCommitCheck()).pipe(Command.withDescription("Check current commitlint configuration and detected settings"));
-const check_CHECK_MARK = "✓";
-const check_CROSS_MARK = "✗";
-const check_WARNING = "⚠";
-const check_BULLET = "•";
-const check_CONFIG_FILES = [
-    "lint-staged.config.ts",
-    "lint-staged.config.js",
-    "lint-staged.config.mjs",
-    "lint-staged.config.cjs",
-    ".lintstagedrc",
-    ".lintstagedrc.json",
-    ".lintstagedrc.yaml",
-    ".lintstagedrc.yml",
-    ".lintstagedrc.js",
-    ".lintstagedrc.cjs",
-    ".lintstagedrc.mjs"
-];
-const CONFIG_SEARCH_PATHS = [
-    "lib/configs/lint-staged.config.ts",
-    "lib/configs/lint-staged.config.js",
-    ...check_CONFIG_FILES
-];
-function check_findConfigFile(fs) {
-    return Effect.gen(function*() {
-        for (const file of CONFIG_SEARCH_PATHS)if (yield* fs.exists(file)) return file;
-        return null;
-    });
-}
-function findConfig(discovery, names) {
-    return Effect.gen(function*() {
-        for (const name of names){
-            const result = yield* discovery.find(name);
-            if (result) return result.path;
-        }
-        return null;
-    });
-}
-function check_extractConfigPathFromManaged(managedContent) {
-    const match = managedContent.match(/lint-staged --config "\$ROOT\/([^"]+)"/);
-    return match ? match[1] : null;
-}
-function checkMarkdownlintConfig(content) {
-    return Effect.gen(function*() {
-        const parsed = yield* parse(content);
-        const schemaMatches = parsed.$schema === Lint.MARKDOWNLINT_SCHEMA;
-        const existingConfig = parsed.config;
-        const configMatches = void 0 !== existingConfig && isDeepStrictEqual(existingConfig, Lint.MARKDOWNLINT_CONFIG);
-        return {
-            exists: true,
-            schemaMatches,
-            configMatches,
-            isUpToDate: schemaMatches && configMatches
-        };
-    });
-}
-function checkBiomeSchemas() {
-    return Effect.gen(function*() {
-        const version = process.env.__BIOME_PEER_VERSION__;
-        const statuses = [];
-        if (!version) return {
-            statuses,
-            warnings: []
-        };
-        const fs = yield* FileSystem.FileSystem;
-        const warnings = [];
-        const expectedSchema = `https://biomejs.dev/schemas/${version}/schema.json`;
-        const configPaths = Lint.Biome.findAllConfigs();
-        for (const configPath of configPaths){
-            const content = yield* fs.readFileString(configPath);
-            const parsed = yield* parse(content);
-            const currentSchema = parsed.$schema;
-            if (currentSchema === expectedSchema) statuses.push({
-                path: configPath,
-                matches: true
-            });
-            else {
-                statuses.push({
-                    path: configPath,
-                    matches: false
-                });
-                warnings.push(`${check_WARNING}  ${configPath}: biome $schema is outdated.\n   Run 'savvy init' to update it.`);
-            }
-        }
-        return {
-            statuses,
-            warnings
-        };
-    });
-}
-const check_quietOption = Options.boolean("quiet").pipe(Options.withAlias("q"), Options.withDescription("Only output warnings (for postinstall usage)"), Options.withDefault(false));
-function runLintCheck(opts) {
-    const { quiet } = opts;
-    return Effect.gen(function*() {
-        const fs = yield* FileSystem.FileSystem;
-        const ms = yield* ManagedSection;
-        const td = yield* ToolDiscovery;
-        const discovery = yield* ConfigDiscovery;
-        const warnings = [];
-        const foundConfig = yield* check_findConfigFile(fs);
-        const hasHuskyHook = yield* fs.exists(Lint.HUSKY_HOOK_PATH);
-        let sectionsHealthy = true;
-        let baseStatusLabel = "missing";
-        let lintStatusLabel = "missing";
-        let detectedConfigPath = null;
-        if (hasHuskyHook) {
-            const baseResult = yield* ms.check(Lint.HUSKY_HOOK_PATH, SavvyBaseSection.block(savvyBasePreamble()));
-            if (CheckResult.$is("Found")(baseResult)) {
-                baseStatusLabel = baseResult.isUpToDate ? "up-to-date" : "outdated";
-                if (!baseResult.isUpToDate) sectionsHealthy = false;
-            } else sectionsHealthy = false;
-            const existing = yield* ms.read(Lint.HUSKY_HOOK_PATH, Lint.SavvyLintSectionDef);
-            if (existing) {
-                const configPath = check_extractConfigPathFromManaged(existing.content);
-                detectedConfigPath = configPath;
-                if (configPath) {
-                    const lintResult = yield* ms.check(Lint.HUSKY_HOOK_PATH, Lint.savvyLintBlock(configPath));
-                    if (CheckResult.$is("Found")(lintResult)) {
-                        lintStatusLabel = lintResult.isUpToDate ? "up-to-date" : "outdated";
-                        if (!lintResult.isUpToDate) sectionsHealthy = false;
-                    } else {
-                        lintStatusLabel = "outdated";
-                        sectionsHealthy = false;
-                    }
-                } else {
-                    lintStatusLabel = "outdated";
-                    sectionsHealthy = false;
-                }
-            } else sectionsHealthy = false;
-            if ("up-to-date" !== baseStatusLabel || "up-to-date" !== lintStatusLabel) warnings.push(`${check_WARNING}  Your ${Lint.HUSKY_HOOK_PATH} managed sections are out of date.\n   Run 'savvy init' to update (preserves your custom hooks).`);
-        } else {
-            sectionsHealthy = false;
-            warnings.push(`${check_WARNING}  No husky pre-commit hook found.\n   Run 'savvy init' to create it.`);
-        }
-        if (!foundConfig) warnings.push(`${check_WARNING}  No lint-staged config file found.\n   Run 'savvy init' to create one.`);
-        const shellHookPaths = [
-            Lint.POST_CHECKOUT_HOOK_PATH,
-            Lint.POST_MERGE_HOOK_PATH
-        ];
-        const shellHookStatuses = [];
-        for (const hookPath of shellHookPaths){
-            const hookExists = yield* fs.exists(hookPath);
-            if (!hookExists) {
-                shellHookStatuses.push({
-                    path: hookPath,
-                    found: false,
-                    isUpToDate: false
-                });
-                continue;
-            }
-            const hygieneResult = yield* ms.check(hookPath, SavvyHooksSection.block(savvyHooksHygiene()));
-            const found = CheckResult.$is("Found")(hygieneResult);
-            const isUpToDate = CheckResult.$is("Found")(hygieneResult) && hygieneResult.isUpToDate;
-            shellHookStatuses.push({
-                path: hookPath,
-                found,
-                isUpToDate
-            });
-            if (found) {
-                if (!isUpToDate) {
-                    sectionsHealthy = false;
-                    warnings.push(`${check_WARNING}  ${hookPath} savvy-hooks section is outdated.\n   Run 'savvy init' to update.`);
-                }
-            } else {
-                sectionsHealthy = false;
-                warnings.push(`${check_WARNING}  ${hookPath} has no savvy-hooks section.\n   Run 'savvy init' to add it.`);
-            }
-        }
-        const biomeSchemaStatus = yield* checkBiomeSchemas().pipe(Effect.catchAll(()=>Effect.succeed({
-                statuses: [],
-                warnings: [
-                    `${check_WARNING}  Could not check biome $schema URLs.`
-                ]
-            })));
-        warnings.push(...biomeSchemaStatus.warnings);
-        const hasMarkdownlintConfig = yield* fs.exists(Lint.MARKDOWNLINT_CONFIG_PATH);
-        let markdownlintStatus = {
-            exists: false,
-            schemaMatches: false,
-            configMatches: false,
-            isUpToDate: false
-        };
-        if (hasMarkdownlintConfig) {
-            const mdContent = yield* fs.readFileString(Lint.MARKDOWNLINT_CONFIG_PATH);
-            markdownlintStatus = yield* checkMarkdownlintConfig(mdContent);
-            if (!markdownlintStatus.schemaMatches) warnings.push(`${check_WARNING}  ${Lint.MARKDOWNLINT_CONFIG_PATH}: $schema differs from template.\n   Run 'savvy init' to update it.`);
-            if (!markdownlintStatus.configMatches) warnings.push(`${check_WARNING}  ${Lint.MARKDOWNLINT_CONFIG_PATH}: config rules differ from template.\n   Run 'savvy init --force' to overwrite.`);
-        }
-        if (quiet) {
-            if (warnings.length > 0) for (const warning of warnings)yield* Effect.log(warning);
-            return;
-        }
-        yield* Effect.log("Checking lint-staged configuration...\n");
-        if (foundConfig) yield* Effect.log(`${check_CHECK_MARK} Config file: ${foundConfig}`);
-        else yield* Effect.log(`${check_CROSS_MARK} No lint-staged config file found`);
-        if (hasHuskyHook) yield* Effect.log(`${check_CHECK_MARK} Husky hook: ${Lint.HUSKY_HOOK_PATH}`);
-        else yield* Effect.log(`${check_CROSS_MARK} No husky pre-commit hook found`);
-        if (hasHuskyHook) {
-            if ("up-to-date" === baseStatusLabel) yield* Effect.log(`${check_CHECK_MARK} Base section: up-to-date`);
-            else if ("outdated" === baseStatusLabel) yield* Effect.log(`${check_WARNING} Base section: outdated (run 'savvy init' to update)`);
-            else yield* Effect.log(`${check_BULLET} Base section: not found (run 'savvy init' to add)`);
-            const lintLabel = detectedConfigPath ? ` (config: ${detectedConfigPath})` : "";
-            if ("up-to-date" === lintStatusLabel) yield* Effect.log(`${check_CHECK_MARK} Lint section: up-to-date${lintLabel}`);
-            else if ("outdated" === lintStatusLabel) yield* Effect.log(`${check_WARNING} Lint section: outdated (run 'savvy init' to update)`);
-            else yield* Effect.log(`${check_BULLET} Lint section: not found (run 'savvy init' to add)`);
-        }
-        for (const status of shellHookStatuses)if (status.found) if (status.isUpToDate) yield* Effect.log(`${check_CHECK_MARK} ${status.path}: up-to-date`);
-        else yield* Effect.log(`${check_WARNING} ${status.path}: outdated (run 'savvy init' to update)`);
-        else yield* Effect.log(`${check_BULLET} ${status.path}: savvy-hooks section not found`);
-        yield* Effect.log("\nTool availability:");
-        const biomeAvailable = yield* td.isAvailable(ToolDefinition.make({
-            name: "biome"
-        }));
-        const biomeConfig = yield* findConfig(discovery, [
-            "biome.jsonc",
-            "biome.json"
-        ]);
-        if (biomeAvailable) {
-            const configInfo = biomeConfig ? ` (config: ${biomeConfig})` : "";
-            yield* Effect.log(`  ${check_CHECK_MARK} Biome${configInfo}`);
-        } else yield* Effect.log(`  ${check_BULLET} Biome: not installed`);
-        const markdownAvailable = yield* td.isAvailable(ToolDefinition.make({
-            name: "markdownlint-cli2"
-        }));
-        const markdownConfig = yield* findConfig(discovery, [
-            ".markdownlint-cli2.jsonc",
-            ".markdownlint-cli2.json",
-            ".markdownlint-cli2.yaml",
-            ".markdownlint-cli2.cjs",
-            ".markdownlint.jsonc",
-            ".markdownlint.json",
-            ".markdownlint.yaml"
-        ]);
-        if (markdownAvailable) {
-            const configInfo = markdownConfig ? ` (config: ${markdownConfig})` : "";
-            yield* Effect.log(`  ${check_CHECK_MARK} markdownlint-cli2${configInfo}`);
-        } else yield* Effect.log(`  ${check_BULLET} markdownlint-cli2: not installed`);
-        const tsgoAvailable = yield* td.isAvailable(ToolDefinition.make({
-            name: "tsgo"
-        }));
-        const tscAvailable = yield* td.isAvailable(ToolDefinition.make({
-            name: "tsc"
-        }));
-        if (tsgoAvailable) yield* Effect.log(`  ${check_CHECK_MARK} TypeScript (tsgo)`);
-        else if (tscAvailable) yield* Effect.log(`  ${check_CHECK_MARK} TypeScript (tsc)`);
-        else yield* Effect.log(`  ${check_BULLET} TypeScript: not installed`);
-        if (hasMarkdownlintConfig) if (markdownlintStatus.isUpToDate) yield* Effect.log(`  ${check_CHECK_MARK} ${Lint.MARKDOWNLINT_CONFIG_PATH}: up-to-date`);
-        else {
-            const issues = [];
-            if (!markdownlintStatus.schemaMatches) issues.push("$schema");
-            if (!markdownlintStatus.configMatches) issues.push("config");
-            yield* Effect.log(`  ${check_WARNING} ${Lint.MARKDOWNLINT_CONFIG_PATH}: ${issues.join(", ")} differ from template`);
-        }
-        else yield* Effect.log(`  ${check_BULLET} ${Lint.MARKDOWNLINT_CONFIG_PATH}: not found`);
-        for (const status of biomeSchemaStatus.statuses)if (status.matches) yield* Effect.log(`  ${check_CHECK_MARK} ${status.path}: biome $schema up-to-date`);
-        else yield* Effect.log(`  ${check_WARNING} ${status.path}: biome $schema outdated (run 'savvy init' to update)`);
-        yield* Effect.log("");
-        const hasMarkdownlintIssues = hasMarkdownlintConfig && !markdownlintStatus.isUpToDate;
-        const hasBiomeSchemaIssues = biomeSchemaStatus.statuses.some((s)=>!s.matches);
-        const hasIssues = !foundConfig || !hasHuskyHook || !sectionsHealthy || hasMarkdownlintIssues || hasBiomeSchemaIssues;
-        if (hasIssues) yield* Effect.log(`${check_WARNING} Some issues found. Run 'savvy init' to fix.`);
-        else yield* Effect.log(`${check_CHECK_MARK} Lint-staged is configured correctly.`);
-    });
-}
-Command.make("check", {
-    quiet: check_quietOption
-}, (opts)=>runLintCheck(opts)).pipe(Command.withDescription("Check current lint-staged configuration and tool availability"));
-const DEFAULT_CHANGESET_DIR = ".changeset";
-const changesetDirOption = Options.text("changeset-dir").pipe(Options.withDescription("Path to the changeset directory"), Options.withDefault(DEFAULT_CHANGESET_DIR));
-const commands_check_quietOption = Options.boolean("quiet").pipe(Options.withAlias("q"), Options.withDescription("Only output warnings from lint check"), Options.withDefault(false));
-function runCheck(steps) {
-    return Effect.all([
-        steps.changeset,
-        steps.commit,
-        steps.lint
-    ], {
-        concurrency: 1,
-        mode: "validate"
-    }).pipe(Effect.asVoid);
-}
-const _checkCommand = Command.make("check", {
-    changesetDir: changesetDirOption,
-    quiet: commands_check_quietOption
-}, (opts)=>runCheck({
-        changeset: runChangesetCheck(opts.changesetDir),
-        commit: runCommitCheck(),
-        lint: runLintCheck({
-            quiet: opts.quiet
-        })
-    })).pipe(Command.withDescription("Validate all Silk Suite tool configurations in one pass"));
-const commands_check_checkCommand = _checkCommand;
-const DEFAULT_GLOBS = [
-    "dist",
-    ".turbo",
-    "coverage",
-    "node_modules",
-    ".rslib"
-];
-const NO_DESCEND = new Set([
-    "node_modules",
-    ".git"
-]);
-class CleanError extends Data.TaggedError("CleanError") {
-}
-function collectTargets(pkgPath, patterns) {
-    return Effect.tryPromise({
-        try: async ()=>{
-            const rootReal = await realpath(pkgPath);
-            const seen = new Map();
-            for await (const entry of glob(patterns, {
-                cwd: pkgPath,
-                withFileTypes: true,
-                exclude: (dirent)=>NO_DESCEND.has(dirent.name) && dirent.isDirectory()
-            })){
-                const abs = join(entry.parentPath, entry.name);
-                let real;
-                try {
-                    real = await realpath(abs);
-                } catch  {
-                    continue;
-                }
-                if (real !== rootReal && real.startsWith(rootReal + sep)) {
-                    if (real !== join(rootReal, "package.json")) seen.set(abs, {
-                        path: abs,
-                        kind: entry.isDirectory() ? "dir" : "file"
-                    });
-                }
-            }
-            return [
-                ...seen.values()
-            ];
-        },
-        catch: (e)=>new CleanError({
-                step: `glob ${pkgPath}`,
-                reason: e instanceof Error ? e.message : String(e)
-            })
-    });
-}
-const REMOVE_CONCURRENCY = 8;
-function removeTargets(targets, dryRun) {
-    return Effect.gen(function*() {
-        const results = yield* Effect.forEach(targets, (target)=>dryRun ? Effect.succeed({
-                target,
-                reason: null
-            }) : Effect.tryPromise(()=>rm(target.path, {
-                    recursive: true,
-                    force: true
-                })).pipe(Effect.match({
-                onSuccess: ()=>({
-                        target,
-                        reason: null
-                    }),
-                onFailure: (e)=>({
-                        target,
-                        reason: e instanceof Error ? e.message : String(e)
-                    })
-            })), {
-            concurrency: REMOVE_CONCURRENCY
-        });
-        return {
-            removed: results.filter((r)=>null === r.reason).map((r)=>r.target),
-            failed: results.filter((r)=>null !== r.reason).map((r)=>({
-                    target: r.target,
-                    reason: r.reason
-                }))
-        };
-    });
-}
-const clean_CHECK_MARK = "✓";
-const clean_BULLET = "•";
-const WARN_MARK = "⚠";
-function parseGlobs(raw) {
-    const parts = raw.split(",").map((s)=>s.trim()).filter((s)=>s.length > 0);
-    return parts.length > 0 ? parts : DEFAULT_GLOBS;
-}
-function runClean(opts) {
-    const patterns = parseGlobs(opts.globs);
-    return Effect.gen(function*() {
-        const discovery = yield* WorkspaceDiscovery;
-        const packages = yield* discovery.listPackages(process.cwd()).pipe(Effect.mapError((e)=>new CleanError({
-                step: "discover workspaces",
-                reason: e.message
-            })));
-        const leaves = packages.filter((p)=>!p.isRootWorkspace);
-        const roots = packages.filter((p)=>p.isRootWorkspace);
-        const ordered = [
-            ...leaves,
-            ...roots
-        ];
-        const planned = yield* Effect.forEach(ordered, (pkg)=>collectTargets(pkg.path, patterns).pipe(Effect.map((targets)=>({
-                    pkg,
-                    targets
-                }))));
-        const seen = new Set();
-        const groups = planned.map(({ pkg, targets })=>{
-            const unique = targets.filter((t)=>{
-                if (seen.has(t.path)) return false;
-                seen.add(t.path);
-                return true;
-            });
-            return {
-                pkg,
-                targets: unique
-            };
-        });
-        const leafGroups = groups.filter((g)=>!g.pkg.isRootWorkspace);
-        const rootGroups = groups.filter((g)=>g.pkg.isRootWorkspace);
-        const verb = opts.dryRun ? "would remove" : "removed";
-        let total = 0;
-        const failures = [];
-        for (const phase of [
-            leafGroups,
-            rootGroups
-        ]){
-            const reports = yield* Effect.forEach(phase, (g)=>removeTargets(g.targets, opts.dryRun).pipe(Effect.map((report)=>({
-                        g,
-                        report
-                    }))));
-            for (const { g, report } of reports)if (0 !== g.targets.length) {
-                yield* Effect.log(`\n${"." === g.pkg.relativePath ? "<root>" : g.pkg.relativePath}`);
-                for (const t of report.removed)yield* Effect.log(`  ${clean_BULLET} ${verb} [${t.kind}] ${t.path}`);
-                for (const f of report.failed)yield* Effect.log(`  ${WARN_MARK} failed [${f.target.kind}] ${f.target.path}: ${f.reason}`);
-                total += report.removed.length;
-                failures.push(...report.failed);
-            }
-        }
-        yield* Effect.log(`\n${clean_CHECK_MARK} ${opts.dryRun ? "Would remove" : "Removed"} ${total} item(s).`);
-        if (failures.length > 0) {
-            for (const f of failures)yield* Effect.logError(`Failed to remove ${f.target.path}: ${f.reason}`);
-            return yield* Effect.fail(new CleanError({
-                step: "remove",
-                reason: `${failures.length} target(s) could not be removed`
-            }));
-        }
-    });
-}
-const globsOption = Options.text("globs").pipe(Options.withAlias("g"), Options.withDescription(`Comma-separated glob patterns to remove from each workspace root (default: ${DEFAULT_GLOBS.join(",")})`), Options.withDefault(DEFAULT_GLOBS.join(",")));
-const clean_dryRunOption = Options.boolean("dry-run").pipe(Options.withAlias("n"), Options.withDescription("Report what would be removed without deleting anything"), Options.withDefault(false));
-const _cleanCommand = Command.make("clean", {
-    globs: globsOption,
-    dryRun: clean_dryRunOption
-}, (opts)=>runClean(opts)).pipe(Command.withDescription("Remove build/cache artifacts across the workspace (leaves first, root last)"));
-const cleanCommand = _cleanCommand;
-const execFileP = promisify(execFile);
-function buildPostCommitAdvice(i) {
-    const lines = [];
-    if (i.commitlintFailed) lines.push("The commit you just created fails commitlint validation. Run pnpm exec commitlint --last to see the violations, then fix with git commit --amend.");
-    if (i.autoSignEnabled) {
-        if ("N" === i.sigStatus) lines.push("The commit was unsigned but commit.gpgsign=true is configured. Re-sign with: git commit --amend --no-edit -S");
-        else if ([
-            "B",
-            "X",
-            "Y",
-            "R",
-            "E"
-        ].includes(i.sigStatus)) lines.push(`The commit signature status is '${i.sigStatus}' (B=bad, X=expired sig, Y=expired key, R=revoked, E=missing key). Investigate your signing setup and amend.`);
-    }
-    if (null !== i.branchTicketId && !i.bodyHasClosing) lines.push(`Branch implies ticket #${i.branchTicketId} but the commit body has no Closes/Fixes/Resolves trailer for it. If this commit closes #${i.branchTicketId}, amend with: git commit --amend --no-edit --trailer "Closes: #${i.branchTicketId}"`);
-    return 0 === lines.length ? null : lines.join("\n\n");
-}
-function buildCommitlintInvocation(pm, configPath) {
-    const tail = configPath ? [
-        "commitlint",
-        "--config",
-        configPath,
-        "--last"
-    ] : [
-        "commitlint",
-        "--last"
-    ];
-    switch(pm){
-        case "pnpm":
-            return {
-                command: "pnpm",
-                args: [
-                    "exec",
-                    ...tail
-                ]
-            };
-        case "yarn":
-            return {
-                command: "yarn",
-                args: [
-                    "exec",
-                    ...tail
-                ]
-            };
-        case "bun":
-            return {
-                command: "bunx",
-                args: tail
-            };
-        case "npm":
-            return {
-                command: "npx",
-                args: [
-                    "--no",
-                    "--",
-                    ...tail
-                ]
-            };
-    }
-}
-async function getRepoRoot() {
-    try {
-        const { stdout } = await execFileP("git", [
-            "rev-parse",
-            "--show-toplevel"
-        ]);
-        return stdout.trim();
-    } catch  {
-        return process.cwd();
-    }
-}
-async function runCommitlintLast() {
-    const root = await getRepoRoot();
-    const pm = await Commitlint.detectPackageManager(root);
-    const configPath = await Commitlint.readCommitlintConfigPath(root);
-    const { command, args } = buildCommitlintInvocation(pm, configPath);
-    try {
-        await execFileP(command, args, {
-            cwd: root
-        });
-        return false;
-    } catch  {
-        return true;
-    }
-}
-async function readSignatureStatus() {
-    try {
-        const { stdout } = await execFileP("git", [
-            "log",
-            "-1",
-            "--format=%G?"
-        ]);
-        return stdout.trim();
-    } catch  {
-        return "N";
-    }
-}
-async function readLastCommitBody() {
-    try {
-        const { stdout } = await execFileP("git", [
-            "log",
-            "-1",
-            "--format=%B"
-        ]);
-        return stdout;
-    } catch  {
-        return "";
-    }
-}
-const postCommitVerifyCommand = Command.make("post-commit-verify", {}, ()=>Effect.gen(function*() {
-        const branch = yield* Commitlint.readBranchInfo();
-        const signing = yield* Commitlint.readSigningDiagnostic();
-        const commitlintFailed = yield* Effect.promise(runCommitlintLast);
-        const sigStatus = yield* Effect.promise(readSignatureStatus);
-        const body = yield* Effect.promise(readLastCommitBody);
-        const bodyHasClosing = null !== branch.inferredTicketId && Commitlint.hasClosingTrailer(body, branch.inferredTicketId);
-        const advice = buildPostCommitAdvice({
-            commitlintFailed,
-            sigStatus,
-            autoSignEnabled: signing.autoSignEnabled,
-            branchTicketId: branch.inferredTicketId,
-            bodyHasClosing
-        });
-        if (null !== advice) yield* Effect.sync(()=>process.stdout.write(`${JSON.stringify(Commitlint.postToolUseAdvise(advice))}\n`));
-    }).pipe(Effect.provide(Commitlint.HookSilencer))).pipe(Command.withDescription("Verify the most recent commit (commitlint replay + signature + closes trailer)"));
-async function evaluateMessage(command, ctx) {
-    const parsed = Commitlint.parseBashCommand(command);
-    if ("unknown" === parsed.kind) return Commitlint.preToolUseSilent();
-    if (null === parsed.message) return Commitlint.preToolUseSilent();
-    const hits = [];
-    const collect = async (eff)=>{
-        const h = await Effect.runPromise(eff);
-        if (h) hits.push(h);
-    };
-    await collect(Commitlint.forbiddenContentRule.check({
-        message: parsed.message
-    }, void 0));
-    await collect(Commitlint.planLeakageRule.check({
-        message: parsed.message
-    }, void 0));
-    await collect(Commitlint.softWrapRule.check({
-        message: parsed.message
-    }, void 0));
-    await collect(Commitlint.verbosityRule.check({
-        message: parsed.message
-    }, void 0));
-    await collect(Commitlint.closesTrailerRule.check({
-        message: parsed.message
-    }, {
-        branchInfo: ctx.branchInfo,
-        openIssues: ctx.openIssues
-    }));
-    await collect(Commitlint.signingFlagConflictRule.check({
-        flags: parsed.flags
-    }, {
-        autoSignEnabled: ctx.autoSignEnabled
-    }));
-    const { deny, advise } = Commitlint.partitionHits(hits);
-    if (deny.length > 0) return Commitlint.preToolUseDeny([
-        "The following rules denied this commit message:",
-        ...deny.map((h)=>`- ${h.message}`)
-    ].join("\n"));
-    if (advise.length > 0) return Commitlint.preToolUseAdvise([
-        "The commit message you are about to write has issues that should be addressed:",
-        ...advise.map((h)=>`- ${h.message}`)
-    ].join("\n"));
-    return Commitlint.preToolUseSilent();
-}
-const preCommitMessageCommand = Command.make("pre-commit-message", {}, ()=>Effect.gen(function*() {
-        const stdin = yield* Effect.promise(readStdin);
-        let envelope;
-        try {
-            envelope = Schema.decodeUnknownSync(Commitlint.PreToolUseEnvelope)(JSON.parse(stdin));
-        } catch  {
-            return;
-        }
-        const command = String(envelope.tool_input.command ?? "");
-        if (!command) return;
-        const branchInfo = yield* Commitlint.readBranchInfo();
-        const signing = yield* Commitlint.readSigningDiagnostic();
-        const issuesPath = resolve(process.env.CLAUDE_PROJECT_DIR ?? process.cwd(), Commitlint.ISSUES_CACHE_RELATIVE_PATH);
-        const issues = (yield* Commitlint.readOpenIssuesFromCache(issuesPath)) ?? [];
-        const out = yield* Effect.promise(()=>evaluateMessage(command, {
-                branchInfo,
-                openIssues: issues,
-                autoSignEnabled: signing.autoSignEnabled
-            }));
-        if (null !== out) yield* Effect.sync(()=>process.stdout.write(`${JSON.stringify(out)}\n`));
-    }).pipe(Effect.provide(Commitlint.HookSilencer))).pipe(Command.withDescription("Validate a candidate git commit / gh pr command's message"));
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin)chunks.push(chunk);
-    return Buffer.concat(chunks).toString("utf8");
-}
-const sessionStartCommand = Command.make("session-start", {}, ()=>Effect.gen(function*() {
-        const branch = yield* Commitlint.readBranchInfo();
-        const signing = yield* Commitlint.readSigningDiagnostic();
-        const issuesCachePath = resolve(process.env.CLAUDE_PROJECT_DIR ?? process.cwd(), Commitlint.ISSUES_CACHE_RELATIVE_PATH);
-        const issues = yield* Commitlint.readOrFetchOpenIssues(issuesCachePath);
-        const blocks = [];
-        blocks.push(buildSkillDirectiveBlock());
-        if (branch.branch) blocks.push(buildBranchBlock(branch.branch, branch.inferredTicketId, issues));
-        blocks.push(buildSigningBlock(signing));
-        const ctx = `<EXTREMELY_IMPORTANT>\n${blocks.join("\n\n")}\n</EXTREMELY_IMPORTANT>`;
-        const out = Commitlint.sessionStartContext(ctx);
-        yield* Effect.sync(()=>process.stdout.write(`${JSON.stringify(out)}\n`));
-    }).pipe(Effect.provide(Commitlint.HookSilencer))).pipe(Command.withDescription("Emit the SessionStart additionalContext for the commitlint plugin"));
-function buildSkillDirectiveBlock() {
-    return "Before you run git commit, gh pr create, gh pr edit, amend a commit, or compose\nany commit message, you MUST invoke the commitlint:commit-create skill. It\ncontains the complete type enum, tdd scope grammar, subject and body rules, DCO\nsignoff format, Closes trailer pattern, and signing guidance.\n\nYOU DO NOT HAVE A CHOICE. Even if you believe the commit message is obvious,\nyou MUST load the skill first. This is not negotiable. You cannot rationalize\nyour way around it. The commit-msg hook will reject messages that violate the\nrules defined in that skill.";
-}
-function buildBranchBlock(branch, ticketId, issues) {
-    const lines = [
-        "<branch_context>",
-        `<current_branch>${branch}</current_branch>`,
-        `<inferred_ticket_id>${ticketId ?? "null"}</inferred_ticket_id>`
-    ];
-    if (issues && issues.length > 0) {
-        lines.push("<open_issues_in_repo>");
-        for (const i of issues)lines.push(`  - #${i.number}  ${i.title}`);
-        lines.push("</open_issues_in_repo>");
-    }
-    lines.push("</branch_context>");
-    return lines.join("\n");
-}
-function buildSigningBlock(d) {
-    const lines = [
-        "<signing_diagnostic>",
-        `<format>${d.format}</format>`,
-        `<auto_sign_enabled>${d.autoSignEnabled}</auto_sign_enabled>`,
-        `<signing_key_configured>${d.signingKeyConfigured}</signing_key_configured>`,
-        `<key_resolves>${d.keyResolves}</key_resolves>`,
-        `<agent_responsive>${d.agentResponsive}</agent_responsive>`,
-        "<warnings>"
-    ];
-    for (const w of d.warnings)lines.push(`  - ${w}`);
-    lines.push("</warnings>", "</signing_diagnostic>");
-    return lines.join("\n");
-}
-const TRIGGER = /(\bcommit\b|\bcommitting\b|\bship (it|this)\b|\bwrap (it )?up\b|\b(create|open) a (pr|pull request)\b|\bfinalize\b|\/finalize\b|\bsquash\b|\bamend\b)/i;
-function reminderForPrompt(prompt) {
-    if (!TRIGGER.test(prompt)) return null;
-    return "<commit_reminder>\nBefore composing this commit message, invoke the commitlint:commit-create skill.\nIt defines the complete type enum, scope rules, DCO signoff format, and body\nconstraints enforced by @savvy-web/commitlint.\n</commit_reminder>";
-}
-const userPromptSubmitCommand = Command.make("user-prompt-submit", {}, ()=>Effect.gen(function*() {
-        const stdin = yield* Effect.promise(user_prompt_submit_readStdin);
-        let envelope;
-        try {
-            envelope = Schema.decodeUnknownSync(Commitlint.UserPromptSubmitEnvelope)(JSON.parse(stdin));
-        } catch  {
-            return;
-        }
-        const reminder = reminderForPrompt(envelope.prompt);
-        if (null === reminder) return;
-        yield* Effect.sync(()=>process.stdout.write(`${JSON.stringify(Commitlint.userPromptSubmitContext(reminder))}\n`));
-    }).pipe(Effect.provide(Commitlint.HookSilencer))).pipe(Command.withDescription("Inject a commit-quality reminder when the user prompt mentions commits"));
-async function user_prompt_submit_readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin)chunks.push(chunk);
-    return Buffer.concat(chunks).toString("utf8");
-}
-const hookCommand = Command.make("hook").pipe(Command.withSubcommands([
-    sessionStartCommand,
-    preCommitMessageCommand,
-    postCommitVerifyCommand,
-    userPromptSubmitCommand
-])).pipe(Command.withDescription("Internal hook handlers used by the @savvy-web/commitlint plugin"));
-const _commitCommand = Command.make("commit").pipe(Command.withSubcommands([
-    hookCommand
-]), Command.withDescription("Commit standards: config, checks, and Claude hook handlers"));
-const commitCommand = _commitCommand;
-const init_CHECK_MARK = "✓";
-const init_WARNING = "⚠";
-const init_EXECUTABLE_MODE = 493;
-const init_JSONC_FORMAT = {
-    tabSize: 1,
-    insertSpaces: false
-};
-const PRE_COMMIT_HEADER = "#!/usr/bin/env sh\n# Pre-commit hook with savvy managed sections\n# Custom hooks can go above, below, or between the managed sections\n\n";
-const init_HYGIENE_HEADER = "#!/usr/bin/env sh\n# Managed by savvy-hooks\n# Custom hooks can go above or below the managed section\n\n";
-function presetIncludesShellScripts(preset) {
-    return "minimal" !== preset;
-}
-function presetIncludesMarkdown(preset) {
-    return "minimal" !== preset;
-}
-function generateConfigContent(preset) {
-    return `/**
- * lint-staged configuration
- * Generated by savvy lint init
- */
-import { Preset } from "@savvy-web/silk/lint";
-
-export default Preset.${preset}();
-`;
-}
-function writeMarkdownlintConfig(fs, preset, force) {
-    return Effect.gen(function*() {
-        const configExists = yield* fs.exists(Lint.MARKDOWNLINT_CONFIG_PATH);
-        const fullTemplate = JSON.stringify(Lint.MARKDOWNLINT_TEMPLATE, null, "\t");
-        if (!configExists) {
-            yield* fs.makeDirectory("lib/configs", {
-                recursive: true
-            });
-            yield* fs.writeFileString(Lint.MARKDOWNLINT_CONFIG_PATH, `${fullTemplate}\n`);
-            yield* Effect.log(`${init_CHECK_MARK} Created ${Lint.MARKDOWNLINT_CONFIG_PATH}`);
-            return;
-        }
-        if ("silk" !== preset) return void (yield* Effect.log(`${init_CHECK_MARK} ${Lint.MARKDOWNLINT_CONFIG_PATH}: exists (not managed by ${preset} preset)`));
-        if (force) {
-            yield* fs.writeFileString(Lint.MARKDOWNLINT_CONFIG_PATH, `${fullTemplate}\n`);
-            yield* Effect.log(`${init_CHECK_MARK} Replaced ${Lint.MARKDOWNLINT_CONFIG_PATH} (--force)`);
-            return;
-        }
-        const existingText = yield* fs.readFileString(Lint.MARKDOWNLINT_CONFIG_PATH);
-        const existingParsed = yield* parse(existingText);
-        let updatedText = existingText;
-        let schemaUpdated = false;
-        if (existingParsed.$schema !== Lint.MARKDOWNLINT_SCHEMA) {
-            const edits = yield* modify(updatedText, [
-                "$schema"
-            ], Lint.MARKDOWNLINT_SCHEMA, {
-                formattingOptions: init_JSONC_FORMAT
-            });
-            updatedText = yield* applyEdits(updatedText, edits);
-            schemaUpdated = true;
-        }
-        const existingConfig = existingParsed.config;
-        const configMatches = void 0 !== existingConfig && isDeepStrictEqual(existingConfig, Lint.MARKDOWNLINT_CONFIG);
-        if (!configMatches) {
-            yield* Effect.log(`${init_WARNING} ${Lint.MARKDOWNLINT_CONFIG_PATH}: config rules differ from template (use --force to overwrite)`);
-            if (schemaUpdated) {
-                yield* fs.writeFileString(Lint.MARKDOWNLINT_CONFIG_PATH, updatedText);
-                yield* Effect.log(`${init_CHECK_MARK} Updated $schema in ${Lint.MARKDOWNLINT_CONFIG_PATH}`);
-            }
-            return;
-        }
-        if (schemaUpdated) {
-            yield* fs.writeFileString(Lint.MARKDOWNLINT_CONFIG_PATH, updatedText);
-            yield* Effect.log(`${init_CHECK_MARK} Updated $schema in ${Lint.MARKDOWNLINT_CONFIG_PATH}`);
-        } else yield* Effect.log(`${init_CHECK_MARK} ${Lint.MARKDOWNLINT_CONFIG_PATH}: up-to-date`);
-    });
-}
-function syncBiomeSchemas() {
-    return Effect.gen(function*() {
-        const version = process.env.__BIOME_PEER_VERSION__;
-        if (!version) return;
-        const syncer = yield* BiomeSchemaSync;
-        const result = yield* syncer.sync(version);
-        for (const configPath of result.current)yield* Effect.log(`${init_CHECK_MARK} ${configPath}: biome $schema up-to-date`);
-        for (const configPath of result.updated)yield* Effect.log(`${init_CHECK_MARK} Updated $schema in ${configPath}`);
-    });
-}
-const lint_init_forceOption = Options.boolean("force").pipe(Options.withAlias("f"), Options.withDescription("Overwrite the pre-commit hook and config file entirely (managed sections in post-checkout/post-merge are never force-reset)"), Options.withDefault(false));
-const init_configOption = Options.text("config").pipe(Options.withAlias("c"), Options.withDescription("Relative path for the lint-staged config file (from repo root)"), Options.withDefault(Lint.DEFAULT_CONFIG_PATH));
-const presetOption = Options.choice("preset", [
-    "minimal",
-    "standard",
-    "silk"
-]).pipe(Options.withAlias("p"), Options.withDescription("Preset to use: minimal, standard, or silk"), Options.withDefault("silk"));
-function init_makeExecutable(path) {
-    return Effect.tryPromise({
-        try: ()=>chmod(path, init_EXECUTABLE_MODE),
-        catch: (e)=>new Error(String(e))
-    });
-}
-function init_ensureHookFile(path, header) {
-    return Effect.gen(function*() {
-        const fs = yield* FileSystem.FileSystem;
-        const exists = yield* fs.exists(path);
-        if (!exists) yield* fs.writeFileString(path, header);
-    });
-}
-function runLintInit(opts) {
-    const { force, config, preset } = opts;
-    return Effect.gen(function*() {
-        const fs = yield* FileSystem.FileSystem;
-        const ms = yield* ManagedSection;
-        if (config.startsWith("/")) yield* Effect.fail(new Error("Config path must be relative to repository root, not absolute"));
-        yield* Effect.log("Initializing lint-staged configuration...\n");
-        yield* fs.makeDirectory(".husky", {
-            recursive: true
-        });
-        if (force) yield* fs.writeFileString(Lint.HUSKY_HOOK_PATH, PRE_COMMIT_HEADER);
-        else yield* init_ensureHookFile(Lint.HUSKY_HOOK_PATH, PRE_COMMIT_HEADER);
-        const preCommitResults = yield* ms.syncMany(Lint.HUSKY_HOOK_PATH, [
-            SavvyBaseSection.block(savvyBasePreamble()),
-            Lint.savvyLintBlock(config)
-        ]);
-        yield* init_makeExecutable(Lint.HUSKY_HOOK_PATH);
-        yield* Effect.log(`${init_CHECK_MARK} ${force ? "Replaced" : "Synced"} ${Lint.HUSKY_HOOK_PATH} (${preCommitResults.map((r)=>r._tag).join(", ")})`);
-        if (presetIncludesShellScripts(preset)) for (const hookPath of [
-            Lint.POST_CHECKOUT_HOOK_PATH,
-            Lint.POST_MERGE_HOOK_PATH
-        ]){
-            yield* init_ensureHookFile(hookPath, init_HYGIENE_HEADER);
-            yield* ms.remove(hookPath, Lint.LegacySavvyLintHygieneDef);
-            yield* ms.sync(hookPath, SavvyHooksSection.block(savvyHooksHygiene()));
-            yield* init_makeExecutable(hookPath);
-            yield* Effect.log(`${init_CHECK_MARK} Synced ${hookPath}`);
-        }
-        if (presetIncludesMarkdown(preset)) yield* writeMarkdownlintConfig(fs, preset, force);
-        yield* syncBiomeSchemas().pipe(Effect.catchTag("BiomeSyncError", (e)=>Effect.log(`${init_WARNING} Could not sync biome $schema: ${e.message}`)));
-        const configExists = yield* fs.exists(config);
-        if (configExists && !force) yield* Effect.log(`${init_WARNING} ${config} already exists (use --force to overwrite)`);
-        else {
-            const configDir = dirname(config);
-            if (configDir && "." !== configDir) yield* fs.makeDirectory(configDir, {
-                recursive: true
-            });
-            yield* fs.writeFileString(config, generateConfigContent(preset));
-            yield* Effect.log(`${init_CHECK_MARK} Created ${config} (preset: ${preset})`);
-        }
-        yield* Effect.log("\nDone! Lint-staged is ready to use.");
-    });
-}
-Command.make("init", {
-    force: lint_init_forceOption,
-    config: init_configOption,
-    preset: presetOption
-}, (opts)=>runLintInit(opts)).pipe(Command.withDescription("Initialize lint-staged configuration and husky hooks"));
-const DEFAULT_COMMIT_CONFIG = "lib/configs/commitlint.config.ts";
-const DEFAULT_LINT_CONFIG = "lib/configs/lint-staged.config.ts";
-const commands_init_forceOption = Options.boolean("force").pipe(Options.withAlias("f"), Options.withDescription("Overwrite existing config files and hooks across all tools"), Options.withDefault(false));
-const commitConfigOption = Options.text("commit-config").pipe(Options.withDescription("Relative path for the commitlint config file"), Options.withDefault(DEFAULT_COMMIT_CONFIG));
-const lintConfigOption = Options.text("lint-config").pipe(Options.withDescription("Relative path for the lint-staged config file"), Options.withDefault(DEFAULT_LINT_CONFIG));
-const lintPresetOption = Options.choice("lint-preset", [
-    "minimal",
-    "standard",
-    "silk"
-]).pipe(Options.withDescription("lint-staged preset: minimal, standard, or silk"), Options.withDefault("silk"));
-function runInit(steps) {
-    return Effect.gen(function*() {
-        yield* steps.changeset;
-        yield* steps.commit;
-        yield* steps.lint;
-    });
-}
-const _initCommand = Command.make("init", {
-    force: commands_init_forceOption,
-    commitConfig: commitConfigOption,
-    lintConfig: lintConfigOption,
-    lintPreset: lintPresetOption
-}, (opts)=>runInit({
-        changeset: runChangesetInit({
-            force: opts.force,
-            quiet: false,
-            skipMarkdownlint: false,
-            check: false
-        }),
-        commit: runCommitInit({
-            force: opts.force,
-            config: opts.commitConfig
-        }),
-        lint: runLintInit({
-            force: opts.force,
-            config: opts.lintConfig,
-            preset: opts.lintPreset
-        })
-    })).pipe(Command.withDescription("Bootstrap a repository for all Silk Suite tools in one pass"));
-const commands_init_initCommand = _initCommand;
-const YAML_STRINGIFY_OPTIONS = {
-    indent: 2,
-    lineWidth: 0,
-    singleQuote: false
-};
-const filesArg = Args.repeated(Args.file({
-    name: "files",
-    exists: "yes"
-}));
-const packageJsonCommand = Command.make("package-json", {
-    files: filesArg
-}, ({ files })=>Effect.sync(()=>{
-        for (const filepath of files){
-            const content = readFileSync(filepath, "utf-8");
-            const sorted = Lint.PackageJson.sortContent(content);
-            if (sorted !== content) writeFileSync(filepath, sorted, "utf-8");
-        }
-    }));
-const pnpmWorkspaceCommand = Command.make("pnpm-workspace", {}, ()=>Effect.sync(()=>{
-        const filepath = "pnpm-workspace.yaml";
-        if (!existsSync(filepath)) return;
-        const content = readFileSync(filepath, "utf-8");
-        const parsed = external_yaml_parse(content);
-        const sorted = Lint.PnpmWorkspace.sortContent(parsed);
-        const formatted = stringify(sorted, YAML_STRINGIFY_OPTIONS);
-        writeFileSync(filepath, formatted, "utf-8");
-    }));
-const yamlCommand = Command.make("yaml", {
-    files: filesArg
-}, ({ files })=>Effect.gen(function*() {
-        for (const filepath of files)yield* Effect.promise(()=>Lint.Yaml.formatFile(filepath));
-    }));
-const _fmtCommand = Command.make("fmt").pipe(Command.withSubcommands([
-    packageJsonCommand,
-    pnpmWorkspaceCommand,
-    yamlCommand
-]));
-const fmtCommand = _fmtCommand;
-const _lintCommand = Command.make("lint").pipe(Command.withSubcommands([
-    fmtCommand
-]), Command.withDescription("Code-quality: lint-staged config, checks, and in-place formatting"));
-const lint_lintCommand = _lintCommand;
-const rootCommand = Command.make("savvy").pipe(Command.withSubcommands([
-    commands_init_initCommand,
-    commands_check_checkCommand,
-    cleanCommand,
-    commitCommand,
-    changesetCommand,
-    lint_lintCommand
-]));
-const cli = Command.run(rootCommand, {
-    name: "savvy",
-    version: "0.3.0"
-});
-const WorkspaceLive = Layer.mergeAll(WorkspaceRootLive, PackageManagerDetectorLive, WorkspaceDiscoveryLive.pipe(Layer.provide(WorkspaceRootLive)));
-const BaseLive = Layer.mergeAll(WorkspaceLive, ChangesetConfigReaderLive, ManagedSectionLive, BiomeSchemaSyncLive, ConfigDiscoveryLive, SilkPublishabilityDetectorLive, Changesets.WorkspaceSnapshotReaderLive);
-const InspectorAndAnalyzerLive = Changesets.BranchAnalyzerLive.pipe(Layer.provideMerge(Changesets.ConfigInspectorLive));
-const AppLive = Layer.mergeAll(ToolDiscoveryLive, VersioningStrategyLive, InspectorAndAnalyzerLive).pipe(Layer.provideMerge(BaseLive), Layer.provideMerge(NodeContext.layer));
-function runCli() {
-    const main = Effect.suspend(()=>cli(process.argv)).pipe(Effect.provide(AppLive));
-    NodeRuntime.runMain(main);
-}
-export { changesetCommand, commands_check_checkCommand as checkCommand, commands_init_initCommand as initCommand, commitCommand, lint_lintCommand as lintCommand, runChangesetCheck, runChangesetInit, runCheck, runCli, runCommitCheck, runCommitInit, runInit, runLintCheck, runLintInit };