@forgeailab/spark 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeailab/spark",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "CLI for managing feature packs in an spark-scaffolded project.",
   "repository": {
     "type": "git",
@@ -23,7 +23,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@forgeailab/spark-schema": "0.4.0",
+    "@forgeailab/spark-schema": "0.4.2",
     "@clack/prompts": "latest",
     "citty": "latest",
     "picocolors": "latest",

package/src/cli.ts

@@ -5,6 +5,8 @@ import { checkCommand } from './commands/check.ts';
 import { infoCommand } from './commands/info.ts';
 import { listCommand } from './commands/list.ts';
 import { presetCommand } from './commands/preset.ts';
+import { statusCommand } from './commands/status.ts';
+import { validateCommand } from './commands/validate.ts';
 
 const subCommands = {
   list: listCommand,
@@ -12,6 +14,8 @@ const subCommands = {
   check: checkCommand,
   add: addCommand,
   preset: presetCommand,
+  status: statusCommand,
+  validate: validateCommand,
 };
 
 const mainCommand = defineCommand({

package/src/commands/add.ts

@@ -100,10 +100,10 @@ function renderPlan(
   }
 
   if (runtimeDependencies.length > 0) {
-    lines.push(`runtime deps: ${[...new Set(runtimeDependencies)].sort().join(', ')}`);
+    lines.push(`runtime deps: ${[...new Set(runtimeDependencies)].toSorted().join(', ')}`);
   }
   if (devDependencies.length > 0) {
-    lines.push(`dev deps: ${[...new Set(devDependencies)].sort().join(', ')}`);
+    lines.push(`dev deps: ${[...new Set(devDependencies)].toSorted().join(', ')}`);
   }
 
   return lines.join('\n');
@@ -181,7 +181,7 @@ function stateEntryForPack(
   return {
     name: packName,
     version,
-    files: [...new Set(fileTargets)].sort(),
+    files: [...new Set(fileTargets)].toSorted(),
     appended_blocks: fileRecords
       .filter((record) => record.marker)
       .map((record) => ({
@@ -189,8 +189,8 @@ function stateEntryForPack(
         marker: record.marker ?? '',
         content_hash: record.contentHash,
       })),
-    env: [...new Set(envVars)].sort(),
-    tasks: [...new Set(taskIds)].sort(),
+    env: [...new Set(envVars)].toSorted(),
+    tasks: [...new Set(taskIds)].toSorted(),
   };
 }
 
@@ -236,6 +236,14 @@ export async function runAdd(requestedPacks: readonly string[], options: AddOpti
   }
 
   if (!options.yes) {
+    if (!process.stdin.isTTY) {
+      throw new Error(
+        'spark add needs interactive confirmation but stdin is not a TTY. ' +
+          'Re-run with --yes. Non-interactive callers (the /scaffold and /pack-add flows, ' +
+          'CI, or any agent-spawned process) must pass --yes — they gate approval before invoking add.',
+      );
+    }
+
     const accepted = await confirm({
       message: `Install ${plan.packs.map((pack) => pack.name).join(', ')}?`,
       initialValue: false,

package/src/commands/check.ts

@@ -33,7 +33,7 @@ async function fileExists(path: string): Promise<boolean> {
 }
 
 function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
 function hasEnvVar(content: string, key: string): boolean {
@@ -59,9 +59,9 @@ export async function runCheck(
   const state = await readState(projectRoot);
   const recordedFiles = [
     ...new Set(state.installed_packs.flatMap((pack) => pack.files)),
-  ].sort();
-  const recordedEnv = [...new Set(state.installed_packs.flatMap((pack) => pack.env))].sort();
-  const recordedTasks = [...new Set(state.installed_packs.flatMap((pack) => pack.tasks))].sort();
+  ].toSorted();
+  const recordedEnv = [...new Set(state.installed_packs.flatMap((pack) => pack.env))].toSorted();
+  const recordedTasks = [...new Set(state.installed_packs.flatMap((pack) => pack.tasks))].toSorted();
 
   const missingFiles: string[] = [];
   for (const file of recordedFiles) {

package/src/commands/list.ts

@@ -54,12 +54,12 @@ export async function runList(projectRoot = process.cwd(), output: ListOutput =
     return;
   }
 
-  for (const [category, names] of [...byCategory.entries()].sort(([left], [right]) =>
+  for (const [category, names] of [...byCategory.entries()].toSorted(([left], [right]) =>
     left.localeCompare(right),
   )) {
     output.log(pc.bold(category));
     output.log('pack                 status      scaffold');
-    for (const name of names.sort()) {
+    for (const name of names.toSorted()) {
       const status = installed.has(name) ? pc.green('installed') : 'available';
       const annotation = scaffoldAnnotation(registry, config.template, name);
       output.log(`${name.padEnd(20)} ${status.padEnd(11)} ${annotation}`);

package/src/commands/status.ts

@@ -0,0 +1,32 @@
+import { defineCommand } from 'citty';
+import { readAllChangeTasks, renderBuildStatus } from '../io/board.ts';
+import type { AggregatedTask } from '../io/board.ts';
+
+export async function runStatus(
+  projectRoot = process.cwd(),
+  opts: { change?: string } = {},
+): Promise<string> {
+  const all: AggregatedTask[] = await readAllChangeTasks(projectRoot);
+  const filtered = opts.change ? all.filter((t) => t.changeId === opts.change) : all;
+  const view = renderBuildStatus(filtered);
+  console.log(view);
+  return view;
+}
+
+export const statusCommand = defineCommand({
+  meta: {
+    name: 'status',
+    description: 'Render the build-status view from tasks.md across active changes',
+  },
+  args: {
+    change: {
+      type: 'string',
+      description: 'Limit to one change id',
+    },
+  },
+  async run({ args }) {
+    await runStatus(process.cwd(), {
+      change: typeof args.change === 'string' ? args.change : undefined,
+    });
+  },
+});

package/src/commands/validate.ts

@@ -0,0 +1,281 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { defineCommand } from 'citty';
+import pc from 'picocolors';
+import { parseTasksMarkdown } from '../io/board.ts';
+
+export type Violation = { file: string; line: number; message: string };
+
+async function dirExists(p: string): Promise<boolean> {
+  try {
+    const s = await stat(p);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function collectSpecFiles(dir: string): Promise<string[]> {
+  const results: string[] = [];
+  async function walk(current: string): Promise<void> {
+    let entries;
+    try {
+      entries = await readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile() && entry.name === 'spec.md') {
+        results.push(full);
+      }
+    }
+  }
+  await walk(dir);
+  return results;
+}
+
+function isUnderArchive(filePath: string): boolean {
+  return filePath.split('/').includes('archive');
+}
+
+const DELTA_HEADERS = new Set([
+  '## ADDED Requirements',
+  '## MODIFIED Requirements',
+  '## REMOVED Requirements',
+  '## RENAMED Requirements',
+]);
+
+function skipFrontmatterLines(lines: string[]): number {
+  if (lines.length === 0) return 0;
+  if (lines[0].trim() !== '---') return 0;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === '---') return i + 1;
+  }
+  return 0;
+}
+
+function checkDeltaHeader(relFile: string, lines: string[]): Violation | null {
+  const start = skipFrontmatterLines(lines);
+  for (let i = start; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed.length === 0) continue;
+    if (!DELTA_HEADERS.has(trimmed)) {
+      return {
+        file: relFile,
+        line: i + 1,
+        message: `expected one of "## ADDED|MODIFIED|REMOVED|RENAMED Requirements" as first non-empty line, got: "${trimmed}"`,
+      };
+    }
+    return null;
+  }
+  return { file: relFile, line: 1, message: 'spec file is empty or has no content after frontmatter' };
+}
+
+function checkRequirementsAndScenarios(relFile: string, lines: string[]): Violation[] {
+  const violations: Violation[] = [];
+
+  let reqLine = -1;
+  let hasDescription = false;
+  let hasScenario = false;
+  let scenLine = -1;
+  let scenHasWhen = false;
+  let scenHasThen = false;
+
+  function finishScenario(): void {
+    if (scenLine === -1) return;
+    if (!scenHasWhen || !scenHasThen) {
+      violations.push({
+        file: relFile,
+        line: scenLine + 1,
+        message: 'scenario must have at least one **WHEN** and one **THEN** bullet',
+      });
+    }
+    scenLine = -1;
+    scenHasWhen = false;
+    scenHasThen = false;
+  }
+
+  function finishRequirement(): void {
+    if (reqLine === -1) return;
+    finishScenario();
+    if (!hasDescription || !hasScenario) {
+      violations.push({
+        file: relFile,
+        line: reqLine + 1,
+        message:
+          'requirement must have at least one descriptive line and one "#### Scenario:" before the next requirement or EOF',
+      });
+    }
+    reqLine = -1;
+    hasDescription = false;
+    hasScenario = false;
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    if (/^#{4}\s+/.test(trimmed)) {
+      if (/^#{4}\s+Scenario:/i.test(trimmed)) {
+        finishScenario();
+        if (reqLine !== -1) hasScenario = true;
+        scenLine = i;
+        scenHasWhen = false;
+        scenHasThen = false;
+      } else {
+        finishScenario();
+      }
+      continue;
+    }
+
+    if (/^#{3}\s+/.test(trimmed)) {
+      finishRequirement();
+      if (/^#{3}\s+Requirement:/i.test(trimmed)) {
+        reqLine = i;
+        hasDescription = false;
+        hasScenario = false;
+      }
+      continue;
+    }
+
+    if (/^#{2}\s+/.test(trimmed) || /^#\s+/.test(trimmed)) {
+      finishRequirement();
+      continue;
+    }
+
+    if (scenLine !== -1 && /^\s*[-*]\s+/.test(line)) {
+      if (line.includes('**WHEN**')) scenHasWhen = true;
+      if (line.includes('**THEN**')) scenHasThen = true;
+      continue;
+    }
+
+    if (reqLine !== -1 && scenLine === -1 && trimmed.length > 0) {
+      hasDescription = true;
+    }
+  }
+
+  finishRequirement();
+  return violations;
+}
+
+export async function runValidate(
+  targetPath = 'docs/spark',
+  projectRoot = process.cwd(),
+): Promise<Violation[]> {
+  const root = join(projectRoot, targetPath);
+
+  if (!(await dirExists(root))) {
+    return [{ file: targetPath, line: 1, message: `workspace path does not exist: ${root}` }];
+  }
+
+  const violations: Violation[] = [];
+  const changesDir = join(root, 'changes');
+
+  async function getChangeIds(): Promise<string[]> {
+    if (!(await dirExists(changesDir))) return [];
+    try {
+      const dirents = await readdir(changesDir, { withFileTypes: true });
+      return dirents.filter((d) => d.isDirectory() && d.name !== 'archive').map((d) => d.name);
+    } catch {
+      return [];
+    }
+  }
+
+  const changeIds = await getChangeIds();
+
+  const deltaSpecFiles: string[] = [];
+  for (const changeId of changeIds) {
+    const specsDir = join(changesDir, changeId, 'specs');
+    if (await dirExists(specsDir)) {
+      for (const f of await collectSpecFiles(specsDir)) {
+        if (!isUnderArchive(f)) deltaSpecFiles.push(f);
+      }
+    }
+  }
+
+  const truthSpecFiles: string[] = [];
+  const truthSpecDir = join(root, 'specs');
+  if (await dirExists(truthSpecDir)) {
+    for (const f of await collectSpecFiles(truthSpecDir)) {
+      if (!isUnderArchive(f)) truthSpecFiles.push(f);
+    }
+  }
+
+  const tasksFiles: string[] = [];
+  for (const changeId of changeIds) {
+    const tasksPath = join(changesDir, changeId, 'tasks.md');
+    try {
+      await stat(tasksPath);
+      tasksFiles.push(tasksPath);
+    } catch {
+      // no tasks.md — not an error
+    }
+  }
+
+  for (const file of deltaSpecFiles) {
+    const lines = (await readFile(file, 'utf8')).split('\n');
+    const v = checkDeltaHeader(relative(projectRoot, file), lines);
+    if (v) violations.push(v);
+  }
+
+  for (const file of [...deltaSpecFiles, ...truthSpecFiles]) {
+    const lines = (await readFile(file, 'utf8')).split('\n');
+    violations.push(...checkRequirementsAndScenarios(relative(projectRoot, file), lines));
+  }
+
+  for (const tasksPath of tasksFiles) {
+    let raw: string;
+    try {
+      raw = await readFile(tasksPath, 'utf8');
+    } catch (err) {
+      violations.push({
+        file: relative(projectRoot, tasksPath),
+        line: 1,
+        message: `could not read tasks file: ${String(err)}`,
+      });
+      continue;
+    }
+    try {
+      parseTasksMarkdown(tasksPath, raw);
+    } catch (err) {
+      const msg = String(err instanceof Error ? err.message : err);
+      const lineMatch = /:(\d+):/.exec(msg);
+      violations.push({
+        file: relative(projectRoot, tasksPath),
+        line: lineMatch ? parseInt(lineMatch[1], 10) : 1,
+        message: msg,
+      });
+    }
+  }
+
+  return violations;
+}
+
+export const validateCommand = defineCommand({
+  meta: {
+    name: 'validate',
+    description: 'Lint the docs/spark spec workspace; exit non-zero on any violation',
+  },
+  args: {
+    path: {
+      type: 'positional',
+      required: false,
+      default: 'docs/spark',
+      description: 'Workspace path to validate',
+    },
+  },
+  async run({ args }) {
+    const p = typeof args.path === 'string' && args.path.length > 0 ? args.path : 'docs/spark';
+    const v = await runValidate(p);
+    if (v.length > 0) {
+      for (const x of v) console.error(pc.red(`${x.file}:${x.line} ${x.message}`));
+      console.error(pc.red(`validate: ${v.length} problem(s) found`));
+      process.exitCode = 1;
+    } else {
+      console.log(pc.green('OK: spec workspace is well-formed.'));
+    }
+  },
+});

package/src/config.ts

@@ -19,7 +19,7 @@ export async function readConfig(projectRoot: string): Promise<AppSkillsConfig>
     raw = await readFile(configPath, 'utf8');
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      throw new Error('not in an spark project: missing spark.config.json');
+      throw new Error('not in an spark project: missing spark.config.json', { cause: error });
     }
     throw error;
   }

package/src/internal/board.ts

@@ -80,7 +80,7 @@ function assertStatus(status: BoardTaskStatus, path: string): BoardTaskStatus {
 }
 
 function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
 /**
@@ -242,7 +242,7 @@ export async function readAllChangeTasks(projectRoot: string): Promise<Aggregate
     changeIds = dirents
       .filter((d) => d.isDirectory() && d.name !== 'archive')
       .map((d) => d.name)
-      .sort();
+      .toSorted();
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
     throw error;
@@ -288,7 +288,7 @@ export function renderBuildStatus(tasks: readonly AggregatedTask[]): string {
   function renderGroup(label: string, group: readonly AggregatedTask[]): void {
     if (group.length === 0) return;
     lines.push(`\n### ${label}`);
-    const sorted = [...group].sort((a, b) =>
+    const sorted = [...group].toSorted((a, b) =>
       a.changeId === b.changeId ? a.id.localeCompare(b.id) : a.changeId.localeCompare(b.changeId),
     );
     for (const task of sorted) {
@@ -328,8 +328,8 @@ function buildFrontmatter(): string {
 function generatedTaskId(packName: string, index: number): string {
   const prefix = packName
     .toUpperCase()
-    .replace(/[^A-Z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
+    .replaceAll(/[^A-Z0-9]+/g, '-')
+    .replaceAll(/^-+|-+$/g, '');
   return `${prefix || 'PACK'}-${String(index + 1).padStart(3, '0')}`;
 }
 
@@ -354,7 +354,7 @@ function formatSeedTask(task: Required<SeedTask>, packName: string): string {
   const lines = [`- [${statusMarkers[task.status]}] ${task.id}: ${task.title}`];
   lines.push('  - Status: Clarifying');
   lines.push(`  - requires_pack: ${packName}`);
-  const description = task.description.replace(/\r\n/g, '\n').replace(/\n$/u, '');
+  const description = task.description.replaceAll(/\r\n/g, '\n').replace(/\n$/u, '');
   if (description.trim().length > 0) {
     lines.push(...description.split('\n').map((l) => `  ${l}`));
   }

package/src/internal/skill-utils.ts

@@ -34,7 +34,7 @@ function rawBlocks(frontmatter: Record<string, unknown>): FrontmatterBlockMap |
 }
 
 function splitFrontmatter(source: string): { frontmatter: string; body: string } {
-  const normalized = source.replace(/\r\n/g, '\n');
+  const normalized = source.replaceAll(/\r\n/g, '\n');
   const lines = normalized.split('\n');
 
   if (lines[0] !== '---') {

package/src/internal/state.ts

@@ -13,14 +13,14 @@ function initialState(): StateFile {
 }
 
 function uniqueSorted(values: readonly string[]): string[] {
-  return [...new Set(values)].sort();
+  return [...new Set(values)].toSorted();
 }
 
 function normalizeInstalledPack(pack: StateInstalledPack): StateInstalledPack {
   return {
     ...pack,
     files: uniqueSorted(pack.files),
-    appended_blocks: [...pack.appended_blocks].sort((left, right) =>
+    appended_blocks: [...pack.appended_blocks].toSorted((left, right) =>
       `${left.to}:${left.marker}`.localeCompare(`${right.to}:${right.marker}`),
     ),
     env: uniqueSorted(pack.env),
@@ -35,7 +35,7 @@ function normalizeState(state: StateFile): StateFile {
     schema_version: 1,
     installed_packs: [...parsed.installed_packs]
       .map(normalizeInstalledPack)
-      .sort((left, right) => left.name.localeCompare(right.name)),
+      .toSorted((left, right) => left.name.localeCompare(right.name)),
   };
 }
 

package/src/io/board.ts

@@ -144,7 +144,7 @@ export async function seedBoardTasks(
     packName,
     tasks
       .filter((task) => missing.has(task.id))
-      .sort((left, right) => left.id.localeCompare(right.id))
+      .toSorted((left, right) => left.id.localeCompare(right.id))
       .map((task) => ({
         id: task.id,
         title: task.title,
@@ -154,7 +154,7 @@ export async function seedBoardTasks(
   );
 
   const missingAfter = new Set(await missingBoardTasks(projectRoot, taskIds));
-  return missingBefore.filter((taskId) => !missingAfter.has(taskId)).sort();
+  return missingBefore.filter((taskId) => !missingAfter.has(taskId)).toSorted();
 }
 
 export async function missingBoardTasks(
@@ -163,5 +163,5 @@ export async function missingBoardTasks(
 ): Promise<string[]> {
   if (taskIds.length === 0) return [];
   const existingIds = new Set((await readAllChangeTasks(projectRoot)).map((task) => task.id));
-  return taskIds.filter((id) => !existingIds.has(id)).sort();
+  return taskIds.filter((id) => !existingIds.has(id)).toSorted();
 }

package/src/io/deps.ts

@@ -6,7 +6,7 @@ export type DependencyCommand = {
 export type DependencyRunner = (command: DependencyCommand) => Promise<void>;
 
 function uniqueSorted(values: readonly string[]): string[] {
-  return [...new Set(values)].sort();
+  return [...new Set(values)].toSorted();
 }
 
 export const defaultDependencyRunner: DependencyRunner = async ({ args, cwd }) => {

package/src/io/env.ts

@@ -18,7 +18,7 @@ async function readExisting(path: string): Promise<string | undefined> {
 }
 
 function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
 function hasEnvVar(content: string, key: string): boolean {
@@ -51,7 +51,7 @@ export async function appendEnvVars(
   projectRoot: string,
   vars: readonly string[],
 ): Promise<EnvApplyResult[]> {
-  const uniqueVars = [...new Set(vars)].sort();
+  const uniqueVars = [...new Set(vars)].toSorted();
   const results: EnvApplyResult[] = [];
 
   for (const file of ['.env.example', '.env.local']) {

package/src/io/files.ts

@@ -101,7 +101,7 @@ function sortJson(value: unknown): unknown {
   }
 
   const sorted: Record<string, unknown> = {};
-  for (const key of Object.keys(value).sort()) {
+  for (const key of Object.keys(value).toSorted()) {
     sorted[key] = sortJson(value[key]);
   }
 
@@ -119,11 +119,25 @@ function lookupTemplateValue(config: AppSkillsConfig, key: string): string {
     current = current[segment];
   }
 
-  return current === undefined || current === null ? '' : String(current);
+  if (current === undefined || current === null) {
+    return '';
+  }
+
+  switch (typeof current) {
+    case 'string':
+      return current;
+    case 'number':
+    case 'boolean':
+    case 'bigint':
+    case 'symbol':
+      return String(current);
+    default:
+      return JSON.stringify(current) ?? '';
+  }
 }
 
 export function renderTemplate(template: string, config: AppSkillsConfig): string {
-  return template.replace(/{{\s*([A-Za-z0-9_.-]+)\s*}}/g, (_match, key: string) =>
+  return template.replaceAll(/{{\s*([A-Za-z0-9_.-]+)\s*}}/g, (_match, key: string) =>
     lookupTemplateValue(config, key),
   );
 }

package/src/io/registry.ts

@@ -43,7 +43,7 @@ async function readChildDirectories(root: string): Promise<string[]> {
     return entries
       .filter((entry) => entry.isDirectory())
       .map((entry) => entry.name)
-      .sort();
+      .toSorted();
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
       return [];
@@ -63,9 +63,15 @@ async function readToml(path: string): Promise<string | undefined> {
   }
 }
 
-function unwrapParseResult<T>(result: ReturnType<typeof parsePackToml> | ReturnType<typeof parsePresetToml> | ReturnType<typeof parseTemplateToml>, path: string): T {
+function unwrapParseResult(result: ReturnType<typeof parsePackToml>, path: string): PackManifest;
+function unwrapParseResult(result: ReturnType<typeof parsePresetToml>, path: string): PresetManifest;
+function unwrapParseResult(result: ReturnType<typeof parseTemplateToml>, path: string): TemplateManifest;
+function unwrapParseResult(
+  result: ReturnType<typeof parsePackToml> | ReturnType<typeof parsePresetToml> | ReturnType<typeof parseTemplateToml>,
+  path: string,
+): PackManifest | PresetManifest | TemplateManifest {
   if (result.ok) {
-    return result.data as T;
+    return result.data;
   }
 
   const details = result.error.issues?.length ? `\n${result.error.issues.join('\n')}` : '';
@@ -84,7 +90,7 @@ async function readTemplates(root: string): Promise<Map<string, TemplateRegistry
       continue;
     }
 
-    const manifest = unwrapParseResult<TemplateManifest>(parseTemplateToml(raw), manifestPath);
+    const manifest = unwrapParseResult(parseTemplateToml(raw), manifestPath);
     if (manifest.name !== dirName) {
       throw new Error(`${manifestPath}: template name "${manifest.name}" must match directory "${dirName}"`);
     }
@@ -119,7 +125,7 @@ async function readPacks(
       continue;
     }
 
-    const manifest = unwrapParseResult<PackManifest>(parsePackToml(raw), manifestPath);
+    const manifest = unwrapParseResult(parsePackToml(raw), manifestPath);
     if (manifest.name !== dirName) {
       throw new Error(`${manifestPath}: pack name "${manifest.name}" must match directory "${dirName}"`);
     }
@@ -155,7 +161,7 @@ async function readPresets(root: string): Promise<Map<string, PresetRegistryEntr
 
       const file = join(presetsRoot, entry.name);
       const raw = await readFile(file, 'utf8');
-      const manifest = unwrapParseResult<PresetManifest>(parsePresetToml(raw), file);
+      const manifest = unwrapParseResult(parsePresetToml(raw), file);
       const name = manifest.name ?? parsePath(entry.name).name;
 
       if (manifest.name && manifest.name !== parsePath(entry.name).name) {

package/src/io/skills.ts

@@ -24,7 +24,7 @@ async function walkFiles(root: string): Promise<string[]> {
     }
   }
 
-  return files.sort();
+  return files.toSorted();
 }
 
 async function directoryExists(path: string): Promise<boolean> {
@@ -124,5 +124,5 @@ export async function copyPackSkills(
     written.push(...record.claudeFiles, ...record.codexFiles);
   }
 
-  return [...new Set(written)].sort();
+  return [...new Set(written)].toSorted();
 }

package/src/io/state.ts

@@ -13,14 +13,14 @@ export function stateFilePath(projectRoot: string): string {
 }
 
 function uniqueSorted(values: readonly string[]): string[] {
-  return [...new Set(values)].sort();
+  return [...new Set(values)].toSorted();
 }
 
 function normalizeInstalledPack(pack: StateInstalledPack): StateInstalledPack {
   return {
     ...pack,
     files: uniqueSorted(pack.files),
-    appended_blocks: [...pack.appended_blocks].sort((left, right) =>
+    appended_blocks: [...pack.appended_blocks].toSorted((left, right) =>
       `${left.to}:${left.marker}`.localeCompare(`${right.to}:${right.marker}`),
     ),
     env: uniqueSorted(pack.env),
@@ -35,7 +35,7 @@ export function normalizeState(state: StateFile): StateFile {
     schema_version: 1,
     installed_packs: [...parsed.installed_packs]
       .map(normalizeInstalledPack)
-      .sort((left, right) => left.name.localeCompare(right.name)),
+      .toSorted((left, right) => left.name.localeCompare(right.name)),
   };
 }
 

package/src/resolver.ts

@@ -111,7 +111,7 @@ function findProviders(
     }
   }
 
-  return providers.sort();
+  return providers.toSorted();
 }
 
 function firstScaffoldError(
@@ -232,7 +232,7 @@ function sortInstallNames(
     }
 
     state.set(name, 'visiting');
-    const deps = [...(dependencies.get(name) ?? [])].sort();
+    const deps = [...(dependencies.get(name) ?? [])].toSorted();
     for (const dependency of deps) {
       const cycle = visit(dependency, [...path, dependency]);
       if (cycle) {