@danieljvdm/dev-kit 0.14.0 → 0.16.0

package/src/global-cache.ts

@@ -0,0 +1,304 @@
+import {
+  Config,
+  DateTime,
+  Effect,
+  FileSystem,
+  Option,
+  Path,
+  Schema,
+  Stream,
+  type PlatformError,
+} from "effect";
+import { ChildProcess } from "effect/unstable/process";
+
+import { printStatus } from "./cli-ui.ts";
+
+export class GlobalCacheError extends Schema.TaggedError<GlobalCacheError>()("GlobalCacheError", {
+  message: Schema.String,
+}) {}
+
+/**
+ * Resolves the machine-global dev-kit cache directory. Entries stored here are
+ * keyed by immutable identifiers (resolved commit SHAs, repository URLs), so
+ * the cache is shared safely across projects and git worktrees. Populating it
+ * is not project state: locked verification and dry-run planning may write
+ * here without violating their read-only project semantics.
+ */
+export const resolveGlobalCacheDirectory = Effect.fn("resolveGlobalCacheDirectory")(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const override = yield* Config.string("DEV_KIT_CACHE_DIR").pipe(Config.withDefault(""));
+
+  if (override.length > 0) return path.resolve(override);
+  const xdgCacheHome = yield* Config.string("XDG_CACHE_HOME").pipe(Config.withDefault(""));
+
+  if (xdgCacheHome.length > 0 && path.isAbsolute(xdgCacheHome)) {
+    return path.join(xdgCacheHome, "dev-kit");
+  }
+  const home = yield* Config.string("HOME").pipe(
+    Config.orElse(() => Config.string("USERPROFILE")),
+    Config.withDefault(""),
+  );
+
+  if (home.length === 0 || !path.isAbsolute(home)) {
+    return yield* GlobalCacheError.make({
+      message: "cannot locate the dev-kit cache; set DEV_KIT_CACHE_DIR, XDG_CACHE_HOME, or HOME",
+    });
+  }
+  // The user cache convention differs per platform; an existing Library/Caches
+  // identifies macOS without reaching for Node platform APIs.
+  const macCaches = path.join(home, "Library", "Caches");
+
+  return (yield* fs.exists(macCaches))
+    ? path.join(macCaches, "dev-kit")
+    : path.join(home, ".cache", "dev-kit");
+});
+
+/**
+ * Publishes a fully staged cache entry at its immutable destination. The
+ * staged directory must live on the same filesystem so the rename is atomic;
+ * when a concurrent writer publishes the destination first, its entry wins and
+ * the staged copy is discarded.
+ */
+export const commitCacheDirectory = Effect.fn("commitCacheDirectory")(function* (
+  staged: string,
+  destination: string,
+  isPopulated: Effect.Effect<boolean, PlatformError.PlatformError>,
+) {
+  const fs = yield* FileSystem.FileSystem;
+
+  if ((yield* fs.exists(destination)) && !(yield* isPopulated)) {
+    yield* fs.remove(destination, { force: true, recursive: true });
+  }
+
+  yield* fs.rename(staged, destination).pipe(
+    Effect.catch((error) =>
+      Effect.gen(function* () {
+        if (!(yield* isPopulated)) return yield* error;
+
+        return yield* fs.remove(staged, { force: true, recursive: true });
+      }),
+    ),
+  );
+});
+
+export const CACHE_PRUNE_AGE_DAYS = 30;
+
+const DAY_MILLIS = 24 * 60 * 60 * 1000;
+const LAST_USED_STAMP = ".last-used";
+const TAG_USAGE_DIRECTORY = "dev-kit-tag-usage";
+
+const runGit = Effect.fn("runGlobalCacheGit")(function* (cwd: string, args: ReadonlyArray<string>) {
+  const child = yield* ChildProcess.make("git", args, {
+    cwd,
+    stderr: "pipe",
+    stdout: "pipe",
+  });
+  const [output, exitCode] = yield* Effect.all([
+    Stream.mkString(Stream.decodeText(child.all)),
+    child.exitCode,
+  ]);
+
+  if (exitCode !== 0) {
+    return yield* GlobalCacheError.make({
+      message: `git ${args.join(" ")} failed: ${output.trim()}`,
+    });
+  }
+
+  return output.trim();
+});
+
+const readMtimeMillis = Effect.fn("readCacheMtimeMillis")(function* (target: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const info = yield* fs.stat(target).pipe(Effect.catch(() => Effect.void));
+
+  if (info === undefined) return undefined;
+
+  return Option.match(info.mtime, {
+    onNone: () => undefined,
+    onSome: (mtime) => mtime.getTime(),
+  });
+});
+
+const listDirectory = Effect.fn("listCacheDirectory")(function* (directory: string) {
+  const fs = yield* FileSystem.FileSystem;
+
+  return (yield* fs.exists(directory)) ? yield* fs.readDirectory(directory) : [];
+});
+
+/** Best-effort recency stamp for a catalog cache entry; read by pruning. */
+export const stampCacheEntryUsage = Effect.fn("stampCacheEntryUsage")(function* (entryDir: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+
+  yield* fs.writeFileString(path.join(entryDir, LAST_USED_STAMP), "").pipe(Effect.ignore);
+});
+
+/**
+ * Best-effort recency stamp for one tag in a shared repository. Written before
+ * the tag is fetched so pruning never mistakes an in-flight fetch for an
+ * unused tag.
+ */
+export const stampTagUsage = Effect.fn("stampTagUsage")(function* (
+  repositoryDir: string,
+  tag: string,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const usageDir = path.join(repositoryDir, TAG_USAGE_DIRECTORY);
+
+  yield* fs
+    .makeDirectory(usageDir, { recursive: true })
+    .pipe(
+      Effect.andThen(fs.writeFileString(path.join(usageDir, encodeURIComponent(tag)), "")),
+      Effect.ignore,
+    );
+});
+
+export type GlobalCachePruneOptions = {
+  readonly all?: boolean;
+  readonly maxAgeDays?: number;
+};
+
+export type GlobalCachePruneSummary = {
+  readonly removedEntries: number;
+  readonly removedRepositories: number;
+  readonly removedTags: number;
+};
+
+/**
+ * Evicts cache content that no project on the machine has used recently.
+ * Everything here is regenerable, so eviction is always safe: a wrongly
+ * removed entry is simply fetched again on the next apply.
+ */
+export const pruneGlobalCache = Effect.fn("pruneGlobalCache")(function* (
+  options: GlobalCachePruneOptions = {},
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const cacheDir = yield* resolveGlobalCacheDirectory();
+  const catalogDir = path.join(cacheDir, "catalog");
+  const repositoriesDir = path.join(cacheDir, "effect-source");
+  let removedEntries = 0;
+  let removedRepositories = 0;
+  let removedTags = 0;
+
+  if (options.all === true) {
+    for (const id of yield* listDirectory(catalogDir)) {
+      removedEntries += (yield* listDirectory(path.join(catalogDir, id))).length;
+    }
+    removedRepositories = (yield* listDirectory(repositoriesDir)).length;
+    yield* fs.remove(catalogDir, { force: true, recursive: true });
+    yield* fs.remove(repositoriesDir, { force: true, recursive: true });
+
+    return { removedEntries, removedRepositories, removedTags } satisfies GlobalCachePruneSummary;
+  }
+  const now = DateTime.toEpochMillis(yield* DateTime.now);
+  const cutoff = now - (options.maxAgeDays ?? CACHE_PRUNE_AGE_DAYS) * DAY_MILLIS;
+
+  // Catalog entries and orphaned staging directories age out individually.
+  for (const id of yield* listDirectory(catalogDir)) {
+    const idDir = path.join(catalogDir, id);
+
+    for (const entry of yield* listDirectory(idDir)) {
+      const entryDir = path.join(idDir, entry);
+      const lastUsed =
+        (yield* readMtimeMillis(path.join(entryDir, LAST_USED_STAMP))) ??
+        (yield* readMtimeMillis(path.join(entryDir, ".ready"))) ??
+        (yield* readMtimeMillis(entryDir));
+
+      if (lastUsed !== undefined && lastUsed < cutoff) {
+        yield* fs.remove(entryDir, { force: true, recursive: true }).pipe(Effect.ignore);
+        removedEntries += 1;
+      }
+    }
+  }
+  // Shared repositories drop tags individually; a repository that no longer
+  // holds any tag is removed whole.
+  for (const name of yield* listDirectory(repositoriesDir)) {
+    const repositoryDir = path.join(repositoriesDir, name);
+
+    if (!(yield* fs.exists(path.join(repositoryDir, "HEAD")))) {
+      const mtime = yield* readMtimeMillis(repositoryDir);
+
+      if (mtime !== undefined && mtime < cutoff) {
+        yield* fs.remove(repositoryDir, { force: true, recursive: true }).pipe(Effect.ignore);
+        removedRepositories += 1;
+      }
+      continue;
+    }
+    const listed = yield* runGit(repositoryDir, ["tag", "--list"]).pipe(
+      Effect.catchTag("GlobalCacheError", () => Effect.void),
+    );
+
+    if (listed === undefined) {
+      // Unreadable repository: age it out by initialization time.
+      if (((yield* readMtimeMillis(path.join(repositoryDir, "HEAD"))) ?? 0) < cutoff) {
+        yield* fs.remove(repositoryDir, { force: true, recursive: true }).pipe(Effect.ignore);
+        removedRepositories += 1;
+      }
+      continue;
+    }
+    const tags = listed.split("\n").filter((tag) => tag.length > 0);
+    let kept = 0;
+    let deleted = 0;
+
+    for (const tag of tags) {
+      const stamp = path.join(repositoryDir, TAG_USAGE_DIRECTORY, encodeURIComponent(tag));
+
+      if (((yield* readMtimeMillis(stamp)) ?? 0) < cutoff) {
+        yield* runGit(repositoryDir, ["update-ref", "-d", `refs/tags/${tag}`]).pipe(Effect.ignore);
+        yield* fs.remove(stamp, { force: true }).pipe(Effect.ignore);
+        removedTags += 1;
+        deleted += 1;
+      } else {
+        kept += 1;
+      }
+    }
+    if (kept === 0) {
+      if (
+        deleted > 0 ||
+        ((yield* readMtimeMillis(path.join(repositoryDir, "HEAD"))) ?? 0) < cutoff
+      ) {
+        yield* fs.remove(repositoryDir, { force: true, recursive: true }).pipe(Effect.ignore);
+        removedRepositories += 1;
+      }
+    } else if (deleted > 0) {
+      yield* runGit(repositoryDir, ["gc", "--prune=now", "--quiet"]).pipe(Effect.ignore);
+    }
+  }
+
+  return { removedEntries, removedRepositories, removedTags } satisfies GlobalCachePruneSummary;
+});
+
+/**
+ * Opportunistic prune for the apply lifecycle: runs the age-based sweep at
+ * most once a day so routine applies stay fast.
+ */
+export const maybePruneGlobalCache = Effect.fn("maybePruneGlobalCache")(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const cacheDir = yield* resolveGlobalCacheDirectory();
+  const marker = path.join(cacheDir, ".last-pruned");
+  const lastPruned = yield* readMtimeMillis(marker);
+  const now = DateTime.toEpochMillis(yield* DateTime.now);
+
+  if (lastPruned !== undefined && now - lastPruned < DAY_MILLIS) return;
+  yield* fs.makeDirectory(cacheDir, { recursive: true });
+  yield* fs.writeFileString(marker, "");
+  yield* pruneGlobalCache();
+});
+
+export const runCachePrune = Effect.fn("runCachePrune")(function* (
+  options: GlobalCachePruneOptions = {},
+) {
+  const cacheDir = yield* resolveGlobalCacheDirectory();
+  const summary = yield* pruneGlobalCache(options);
+
+  yield* printStatus(
+    "success",
+    options.all === true ? "Cache cleared" : "Cache pruned",
+    `removed ${summary.removedEntries} catalog entries, ${summary.removedTags} tags, ` +
+      `${summary.removedRepositories} repositories from ${cacheDir}`,
+  );
+});

package/src/index.ts

@@ -11,14 +11,14 @@ export {
   EffectTsgoSetupSchema,
   type HarnessTarget,
   TargetConfigSchema,
-  type VitePlusQualitySetup,
-  VitePlusQualitySetupSchema,
-  type VitePlusQualityWorkflowSetup,
-  VitePlusQualityWorkflowSetupSchema,
-  type VitePlusQualityWorkflowStep,
-  VitePlusQualityWorkflowStepSchema,
   type VitePlusSetup,
   VitePlusSetupSchema,
+  type VitePlusWorkflowSetup,
+  VitePlusWorkflowSetupSchema,
+  type WorktrunkConfigSetup,
+  WorktrunkConfigSetupSchema,
+  type WorktrunkSetup,
+  WorktrunkSetupSchema,
 } from "./manifest.ts";
 export {
   applyEffectSourcePlan,

package/src/manifest.ts

@@ -53,31 +53,28 @@ export const VitePlusHooksSetupSchema = Schema.Struct({
   enabled: Schema.optional(Schema.Boolean),
 });
 
-export const VitePlusQualityWorkflowStepSchema = Schema.Struct({
-  name: Schema.String,
-  run: Schema.Array(Schema.String),
-});
-export type VitePlusQualityWorkflowStep = typeof VitePlusQualityWorkflowStepSchema.Type;
-
-export const VitePlusQualityWorkflowSetupSchema = Schema.Struct({
+export const VitePlusWorkflowSetupSchema = Schema.Struct({
   enabled: Schema.optional(Schema.Boolean),
-  beforeChecks: Schema.optional(Schema.Array(VitePlusQualityWorkflowStepSchema)),
-  typecheck: Schema.optional(Schema.Array(Schema.String)),
-});
-export type VitePlusQualityWorkflowSetup = typeof VitePlusQualityWorkflowSetupSchema.Type;
-
-export const VitePlusQualitySetupSchema = Schema.Struct({
-  workflow: Schema.optional(VitePlusQualityWorkflowSetupSchema),
 });
-export type VitePlusQualitySetup = typeof VitePlusQualitySetupSchema.Type;
+export type VitePlusWorkflowSetup = typeof VitePlusWorkflowSetupSchema.Type;
 
 export const VitePlusSetupSchema = Schema.Struct({
   hooks: Schema.optional(VitePlusHooksSetupSchema),
-  quality: Schema.optional(VitePlusQualitySetupSchema),
+  workflow: Schema.optional(VitePlusWorkflowSetupSchema),
 });
 
 export type VitePlusSetup = typeof VitePlusSetupSchema.Type;
 
+export const WorktrunkConfigSetupSchema = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean),
+});
+export type WorktrunkConfigSetup = typeof WorktrunkConfigSetupSchema.Type;
+
+export const WorktrunkSetupSchema = Schema.Struct({
+  config: Schema.optional(WorktrunkConfigSetupSchema),
+});
+export type WorktrunkSetup = typeof WorktrunkSetupSchema.Type;
+
 export const DevKitManifestSchema = Schema.Struct({
   $schema: Schema.optional(Schema.String),
   include: Schema.Array(Schema.String.check(Schema.isPattern(SKILL_SELECTOR_PATTERN))),
@@ -91,6 +88,7 @@ export const DevKitManifestSchema = Schema.Struct({
       effectSource: Schema.optional(EffectSourceSetupSchema),
       effectTsgo: Schema.optional(EffectTsgoSetupSchema),
       vitePlus: Schema.optional(VitePlusSetupSchema),
+      worktrunk: Schema.optional(WorktrunkSetupSchema),
     }),
   ),
   targets: Schema.optional(
@@ -135,12 +133,13 @@ export type NormalizedManifest = {
       readonly hooks: {
         readonly enabled: boolean;
       };
-      readonly quality: {
-        readonly workflow: {
-          readonly enabled: boolean;
-          readonly beforeChecks: ReadonlyArray<VitePlusQualityWorkflowStep>;
-          readonly typecheck: ReadonlyArray<string>;
-        };
+      readonly workflow: {
+        readonly enabled: boolean;
+      };
+    };
+    readonly worktrunk: {
+      readonly config: {
+        readonly enabled: boolean;
       };
     };
   };
@@ -175,7 +174,6 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
       };
     }
   }
-  const quality = manifest.setup?.vitePlus?.quality;
 
   return {
     exclude: manifest.exclude ?? [],
@@ -203,12 +201,13 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
         hooks: {
           enabled: manifest.setup?.vitePlus?.hooks?.enabled ?? false,
         },
-        quality: {
-          workflow: {
-            enabled: quality?.workflow?.enabled ?? false,
-            beforeChecks: quality?.workflow?.beforeChecks ?? [],
-            typecheck: quality?.workflow?.typecheck ?? ["vp run typecheck"],
-          },
+        workflow: {
+          enabled: manifest.setup?.vitePlus?.workflow?.enabled ?? false,
+        },
+      },
+      worktrunk: {
+        config: {
+          enabled: manifest.setup?.worktrunk?.config?.enabled ?? false,
         },
       },
     },

package/src/oxlint.js

@@ -8,6 +8,29 @@ import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
 
 export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
 
+export const createAbsoluteImportsOxlintOverride = (options) => {
+  if (options.files.length === 0) {
+    throw new Error("absolute imports enforcement requires at least one file glob");
+  }
+  const files = [...new Set(options.files)];
+
+  if (files.length !== options.files.length) {
+    throw new Error("absolute imports file globs must be unique");
+  }
+  for (const glob of files) {
+    if (glob.trim().length === 0) {
+      throw new Error("absolute imports file globs must not be blank");
+    }
+  }
+
+  return {
+    files,
+    rules: {
+      "import/no-relative-parent-imports": "error",
+    },
+  };
+};
+
 export const recommendedOxlintConfig = {
   ignorePatterns: [...devKitToolIgnorePatterns],
   options: {

package/src/oxlint.ts

@@ -1,9 +1,45 @@
-import type { OxlintConfig } from "oxlint";
+import type { OxlintConfig, OxlintOverride } from "oxlint";
 
 import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.ts";
 
 export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.ts";
 
+export type AbsoluteImportsOptions = {
+  /** Globs that must use path-alias imports, e.g. `"apps/app/src/**"`. */
+  readonly files: ReadonlyArray<string>;
+};
+
+/**
+ * Build an Oxlint override that forbids `../` imports inside the given globs,
+ * so those files import through tsconfig path aliases such as `@/*`. Append it
+ * to a standalone Oxlint config's `overrides`, or opt in through
+ * `createRecommendedVitePlusConfig({ absoluteImports })`.
+ */
+export const createAbsoluteImportsOxlintOverride = (
+  options: AbsoluteImportsOptions,
+): OxlintOverride => {
+  if (options.files.length === 0) {
+    throw new Error("absolute imports enforcement requires at least one file glob");
+  }
+  const files = [...new Set(options.files)];
+
+  if (files.length !== options.files.length) {
+    throw new Error("absolute imports file globs must be unique");
+  }
+  for (const glob of files) {
+    if (glob.trim().length === 0) {
+      throw new Error("absolute imports file globs must not be blank");
+    }
+  }
+
+  return {
+    files,
+    rules: {
+      "import/no-relative-parent-imports": "error",
+    },
+  };
+};
+
 /**
  * High-signal Oxlint defaults for TypeScript projects.
  *

package/src/path-digest.ts

@@ -27,7 +27,6 @@ const textEncoder = new TextEncoder();
 // Git preserves only the executable distinction for regular files. Canonicalizing
 // the remaining bits keeps digests stable across checkout and copy umasks.
 const canonicalFileMode = (mode: number): number => ((mode & 0o111) === 0 ? 0o644 : 0o755);
-const rawFileMode = (mode: number): number => mode & 0o777;
 
 const frame = (value: string | Uint8Array): Uint8Array => {
   const bytes = typeof value === "string" ? textEncoder.encode(value) : value;
@@ -153,18 +152,6 @@ export const observePath = Effect.fn("observeManagedPath")(function* (absolutePa
   );
 });
 
-export const observePathWithRawModes = Effect.fn("observeManagedPathWithRawModes")(function* (
-  absolutePath: string,
-) {
-  return yield* digestFileSystemPath(absolutePath, rawFileMode).pipe(
-    Effect.mapError((cause) =>
-      Schema.is(PathInspectionError)(cause)
-        ? cause
-        : PathInspectionError.make({ path: absolutePath, operation: "inspect", cause }),
-    ),
-  );
-});
-
 export const digestText = Effect.fn("digestText")(function* (value: string) {
   return yield* digestFrames(["text-v1", value]);
 });

package/src/project-package.ts

@@ -1,4 +1,4 @@
-import { Effect, FileSystem, Path, Schema } from "effect";
+import { Effect, FileSystem, Option, Path, Schema } from "effect";
 
 export class ProjectPackageError extends Schema.TaggedError<ProjectPackageError>()(
   "ProjectPackageError",
@@ -40,23 +40,138 @@ export const readProjectPackage = Effect.fn("readProjectPackage")(function* (pro
   return manifest;
 });
 
-export const readDirectDependencyNames = Effect.fn("readDirectDependencyNames")(function* (
+export const PACKAGE_MANAGER_COMMANDS = {
+  bun: { install: "bun install", label: "Bun" },
+  npm: { install: "npm install", label: "npm" },
+  pnpm: { install: "pnpm install", label: "pnpm" },
+  yarn: { install: "yarn install", label: "Yarn" },
+} as const;
+
+export type PackageManagerName = keyof typeof PACKAGE_MANAGER_COMMANDS;
+
+const packageManagerName = (declaration: string | undefined): PackageManagerName | undefined => {
+  const name = declaration?.split("@", 1)[0];
+
+  return name !== undefined && name in PACKAGE_MANAGER_COMMANDS
+    ? (name as PackageManagerName)
+    : undefined;
+};
+
+export const detectPackageManager = Effect.fn("detectPackageManager")(function* (
   projectDir: string,
+  declaration: string | undefined,
+) {
+  const declared = packageManagerName(declaration);
+
+  if (declared !== undefined || declaration !== undefined) return declared;
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const lockfiles: ReadonlyArray<readonly [PackageManagerName, ReadonlyArray<string>]> = [
+    ["bun", ["bun.lock", "bun.lockb"]],
+    ["npm", ["package-lock.json", "npm-shrinkwrap.json"]],
+    ["pnpm", ["pnpm-lock.yaml"]],
+    ["yarn", ["yarn.lock"]],
+  ];
+  const detected: Array<PackageManagerName> = [];
+
+  for (const [manager, files] of lockfiles) {
+    let found = false;
+
+    for (const file of files) {
+      if (yield* fs.exists(path.join(projectDir, file))) {
+        found = true;
+        break;
+      }
+    }
+    if (found) {
+      detected.push(manager);
+    }
+  }
+
+  return detected.length === 1 ? detected[0] : undefined;
+});
+
+const readOptionalProjectPackage = Effect.fn("readOptionalProjectPackage")(function* (
+  packageDir: string,
 ) {
-  const manifest = yield* readProjectPackage(projectDir).pipe(
+  return yield* readProjectPackage(packageDir).pipe(
     Effect.catchTag("ProjectPackageError", (error) =>
       error.message.startsWith("package.json not found:") ? Effect.void : Effect.fail(error),
     ),
   );
+});
+
+const manifestDependencyNames = (
+  manifest: (typeof ProjectPackageSchema)["Type"] | undefined | void,
+): ReadonlyArray<string> =>
+  manifest === undefined
+    ? []
+    : [
+        ...Object.keys(manifest.dependencies ?? {}),
+        ...Object.keys(manifest.devDependencies ?? {}),
+        ...Object.keys(manifest.optionalDependencies ?? {}),
+        ...Object.keys(manifest.peerDependencies ?? {}),
+      ];
+
+export const readDirectDependencyNames = Effect.fn("readDirectDependencyNames")(function* (
+  projectDir: string,
+) {
+  const manifest = yield* readOptionalProjectPackage(projectDir);
+
+  return [...new Set(manifestDependencyNames(manifest))].sort();
+});
+
+const WorkspacePatternsSchema = Schema.Union([
+  Schema.Array(Schema.String),
+  Schema.Struct({ packages: Schema.Array(Schema.String) }),
+]);
+// `workspaces` is declared `Schema.Unknown` in the project manifest schema, so
+// this is a genuinely untyped boundary.
+const decodeWorkspacePatterns = Schema.decodeUnknownOption(WorkspacePatternsSchema);
+
+const workspacePatterns = (workspaces: unknown): ReadonlyArray<string> => {
+  const decoded = decodeWorkspacePatterns(workspaces);
+
+  if (Option.isNone(decoded)) return [];
+
+  return "packages" in decoded.value ? decoded.value.packages : decoded.value;
+};
 
-  if (manifest === undefined) return [];
+/**
+ * Direct dependency names of the project package plus every workspace member
+ * package. Only literal workspace paths and single trailing-star globs
+ * (`apps/*`) are expanded; other patterns are skipped.
+ */
+export const readWorkspaceDependencyNames = Effect.fn("readWorkspaceDependencyNames")(function* (
+  projectDir: string,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const manifest = yield* readOptionalProjectPackage(projectDir);
+  const names = new Set(manifestDependencyNames(manifest));
+
+  for (const pattern of workspacePatterns(manifest?.workspaces)) {
+    if (pattern.startsWith("!")) continue;
+    const star = pattern.indexOf("*");
+    let memberDirs: ReadonlyArray<string> = [];
+
+    if (star === -1) {
+      memberDirs = [pattern];
+    } else if (pattern.endsWith("/*") && star === pattern.length - 1) {
+      const parent = path.join(projectDir, pattern.slice(0, -2));
+
+      if (yield* fs.exists(parent)) {
+        memberDirs = (yield* fs.readDirectory(parent)).map((name) =>
+          path.join(pattern.slice(0, -2), name),
+        );
+      }
+    }
+    for (const memberDir of memberDirs) {
+      const member = yield* readOptionalProjectPackage(path.join(projectDir, memberDir));
+
+      for (const name of manifestDependencyNames(member)) names.add(name);
+    }
+  }
 
-  return [
-    ...new Set([
-      ...Object.keys(manifest.dependencies ?? {}),
-      ...Object.keys(manifest.devDependencies ?? {}),
-      ...Object.keys(manifest.optionalDependencies ?? {}),
-      ...Object.keys(manifest.peerDependencies ?? {}),
-    ]),
-  ].sort();
+  return [...names].sort();
 });

package/src/project-state.ts

@@ -49,6 +49,9 @@ export const ManagedClaudeInstructionsOutputSchema = Schema.Struct({
 });
 export type ManagedClaudeInstructionsOutput = typeof ManagedClaudeInstructionsOutputSchema.Type;
 
+// Legacy (dev-kit ≤0.14) lock entry for the previously managed check workflow.
+// Kept only so old locks and receipts still decode; planning discards these
+// entries, releasing the file to the repository. Never produced anymore.
 export const ManagedGeneratedFileOutputSchema = Schema.Struct({
   resourceId: Schema.Literal("setup:vite-plus-github-actions"),
   path: Schema.String,