@kynetic-ai/spec 0.1.2 → 0.4.0

package/dist/parser/yaml.js

@@ -1,14 +1,40 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { execSync } from 'node:child_process';
-import * as YAML from 'yaml';
-import { ulid } from 'ulid';
-import { TaskSchema, TasksFileSchema, ManifestSchema, SpecItemSchema, InboxItemSchema, InboxFileSchema, } from '../schema/index.js';
-import { ReferenceIndex } from './refs.js';
-import { ItemIndex } from './items.js';
-import { TraitIndex } from './traits.js';
-import { detectShadow, detectRunningFromShadowWorktree, ShadowError, } from './shadow.js';
-import { errors } from '../strings/index.js';
+import { execSync } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { ulid } from "ulid";
+import * as YAML from "yaml";
+import { InboxFileSchema, InboxItemSchema, ManifestSchema, SpecItemSchema, TaskSchema, TasksFileSchema, TriageFileSchema, TriageRecordSchema, } from "../schema/index.js";
+import { errors } from "../strings/index.js";
+import { ItemIndex } from "./items.js";
+import { ReferenceIndex } from "./refs.js";
+import { detectRunningFromShadowWorktree, detectShadow, ShadowError, } from "./shadow.js";
+import { loadProjectConfig, } from "./config.js";
+import { TraitIndex } from "./traits.js";
+/**
+ * Log a debug message (only when KSPEC_DEBUG=1)
+ */
+function debugLog(prefix, message) {
+    if (process.env.KSPEC_DEBUG === "1") {
+        console.error(`[DEBUG] ${prefix}: ${message}`);
+    }
+}
+/**
+ * Parse a manifest and emit deprecation warnings for deprecated fields.
+ *
+ * AC: @config-manifest-cleanup ac-4 — debug-level deprecation note for daemon block
+ */
+function parseManifestWithWarnings(rawManifest) {
+    const manifest = ManifestSchema.parse(rawManifest);
+    // AC: @config-manifest-cleanup ac-4 — log debug-level deprecation note for daemon block
+    if (manifest.daemon) {
+        debugLog("manifest", 'Deprecated "daemon" block found in manifest. Use kspec.config.yaml instead.');
+    }
+    // Also warn for deprecated config block
+    if (manifest.config) {
+        debugLog("manifest", 'Deprecated "config" block found in manifest. Use kspec.config.yaml instead.');
+    }
+    return manifest;
+}
 /**
  * Parse YAML content into an object
  * Uses the modern yaml library which has consistent type handling
@@ -35,16 +61,16 @@ export function toYaml(obj) {
     // Post-process to fix yaml library blank line accumulation bug.
     // Filter out lines that contain only spaces/tabs (not truly empty lines).
     yamlString = yamlString
-        .split('\n')
-        .filter(line => !/^[ \t]+$/.test(line))
-        .join('\n');
+        .split("\n")
+        .filter((line) => !/^[ \t]+$/.test(line))
+        .join("\n");
     return yamlString;
 }
 /**
  * Read and parse a YAML file
  */
 export async function readYamlFile(filePath) {
-    const content = await fs.readFile(filePath, 'utf-8');
+    const content = await fs.readFile(filePath, "utf-8");
     return parseYaml(content);
 }
 /**
@@ -52,7 +78,7 @@ export async function readYamlFile(filePath) {
  */
 export async function writeYamlFile(filePath, data) {
     const content = toYaml(data);
-    await fs.writeFile(filePath, content, 'utf-8');
+    await fs.writeFile(filePath, content, "utf-8");
 }
 /**
  * Write object to YAML file while preserving formatting and comments.
@@ -63,7 +89,7 @@ export async function writeYamlFile(filePath, data) {
  */
 export async function writeYamlFilePreserveFormat(filePath, data) {
     const content = toYaml(data);
-    await fs.writeFile(filePath, content, 'utf-8');
+    await fs.writeFile(filePath, content, "utf-8");
 }
 /**
  * Find task files in a directory
@@ -79,45 +105,47 @@ export async function findTaskFiles(dir) {
                 const subFiles = await findTaskFiles(fullPath);
                 files.push(...subFiles);
             }
-            else if (entry.isFile() && entry.name.endsWith('.tasks.yaml')) {
+            else if (entry.isFile() && entry.name.endsWith(".tasks.yaml")) {
                 files.push(fullPath);
             }
         }
     }
-    catch (error) {
+    catch (_error) {
         // Directory doesn't exist or not readable
     }
     return files;
 }
 /**
- * Find the manifest file (kynetic.yaml or kynetic.spec.yaml)
+ * Find the manifest file.
+ *
+ * Discovery algorithm per directory:
+ * 1. Check for explicit names: kynetic.yaml, kynetic.spec.yaml (backward compat)
+ * 2. If not found, scan for *.yaml files with 'kynetic:' version field
+ *
+ * Searches current dir, then spec/ subdir, then parent directories.
  */
 export async function findManifest(startDir) {
     let dir = startDir;
     while (true) {
-        const candidates = ['kynetic.yaml', 'kynetic.spec.yaml'];
-        for (const candidate of candidates) {
-            const filePath = path.join(dir, candidate);
-            try {
-                await fs.access(filePath);
-                return filePath;
-            }
-            catch {
-                // File doesn't exist, try next
-            }
+        // Check current directory
+        const manifestInDir = await findManifestInDir(dir);
+        if (manifestInDir) {
+            return manifestInDir;
         }
         // Also check in spec/ subdirectory
-        const specDir = path.join(dir, 'spec');
-        for (const candidate of candidates) {
-            const filePath = path.join(specDir, candidate);
-            try {
-                await fs.access(filePath);
-                return filePath;
-            }
-            catch {
-                // File doesn't exist, try next
+        const specDir = path.join(dir, "spec");
+        try {
+            const stat = await fs.stat(specDir);
+            if (stat.isDirectory()) {
+                const manifestInSpec = await findManifestInDir(specDir);
+                if (manifestInSpec) {
+                    return manifestInSpec;
+                }
             }
         }
+        catch {
+            // spec/ doesn't exist
+        }
         const parentDir = path.dirname(dir);
         if (parentDir === dir) {
             // Reached root
@@ -130,20 +158,60 @@ export async function findManifest(startDir) {
  * Initialize context by finding manifest.
  *
  * Detection order:
- * 1. Check for shadow branch (.kspec/ directory)
- * 2. Fall back to traditional spec/ directory
+ * 1. Load project config from git root (before shadow detection)
+ * 2. Check for shadow branch (.kspec/ directory)
+ * 3. Fall back to traditional spec/ directory
  *
  * When shadow is detected, all operations use .kspec/ as specDir.
+ *
+ * AC: @project-config ac-2 — config loaded before shadow detection
  */
 export async function initContext(startDir) {
     const cwd = startDir || process.cwd();
+    // AC: @project-config ac-2, ac-6, ac-7 — load config before shadow detection
+    // Config is loaded from git root, not cwd or KSPEC_SPEC_DIR temp dir
+    const configResult = await loadProjectConfig(cwd);
+    // AC: @project-config ac-3 — emit warning to stderr if config had issues
+    if (configResult.warning) {
+        console.error(`Warning: ${configResult.warning}`);
+    }
+    const { config } = configResult;
+    // KSPEC_SPEC_DIR override: used by batch atomic mode to redirect to temp copy
+    const specDirOverride = process.env.KSPEC_SPEC_DIR;
+    if (specDirOverride) {
+        const specDir = path.resolve(specDirOverride);
+        const manifestPath = await findManifestInDir(specDir);
+        let manifest = null;
+        if (manifestPath) {
+            try {
+                const rawManifest = await readYamlFile(manifestPath);
+                manifest = parseManifestWithWarnings(rawManifest);
+            }
+            catch {
+                // Manifest exists but may be invalid
+            }
+        }
+        return {
+            rootDir: path.dirname(specDir),
+            specDir,
+            manifestPath,
+            manifest,
+            shadow: null, // No shadow in overridden context
+            config,
+        };
+    }
     // Check if running from inside the shadow worktree
-    const mainProjectRoot = await detectRunningFromShadowWorktree(cwd);
+    // AC: @config-shadow ac-8 — pass configured directory for detection
+    const mainProjectRoot = await detectRunningFromShadowWorktree(cwd, config.shadow.directory);
     if (mainProjectRoot) {
-        throw new ShadowError(errors.project.runningFromShadow, 'RUNNING_FROM_SHADOW', `Run from project root: cd ${path.relative(cwd, mainProjectRoot) || mainProjectRoot}`);
+        throw new ShadowError(errors.project.runningFromShadow, "RUNNING_FROM_SHADOW", `Run from project root: cd ${path.relative(cwd, mainProjectRoot) || mainProjectRoot}`);
     }
     // Try to detect shadow branch first
-    const shadow = await detectShadow(cwd);
+    // AC: @config-shadow ac-1 ac-2 — use configured branch/directory names
+    const shadow = await detectShadow(cwd, {
+        branchName: config.shadow.branch,
+        directory: config.shadow.directory,
+    });
     if (shadow?.enabled) {
         // Shadow mode: use .kspec/ for everything
         const specDir = shadow.worktreeDir;
@@ -152,7 +220,7 @@ export async function initContext(startDir) {
         if (manifestPath) {
             try {
                 const rawManifest = await readYamlFile(manifestPath);
-                manifest = ManifestSchema.parse(rawManifest);
+                manifest = parseManifestWithWarnings(rawManifest);
             }
             catch {
                 // Manifest exists but may be invalid
@@ -164,6 +232,7 @@ export async function initContext(startDir) {
             manifestPath,
             manifest,
             shadow,
+            config,
         };
     }
     // Traditional mode: find manifest in spec/ or current directory
@@ -174,7 +243,7 @@ export async function initContext(startDir) {
     if (manifestPath) {
         const manifestDir = path.dirname(manifestPath);
         // Handle spec/ subdirectory
-        if (path.basename(manifestDir) === 'spec') {
+        if (path.basename(manifestDir) === "spec") {
             rootDir = path.dirname(manifestDir);
             specDir = manifestDir;
         }
@@ -184,21 +253,42 @@ export async function initContext(startDir) {
         }
         try {
             const rawManifest = await readYamlFile(manifestPath);
-            manifest = ManifestSchema.parse(rawManifest);
+            manifest = parseManifestWithWarnings(rawManifest);
         }
         catch {
             // Manifest exists but may be invalid
         }
     }
-    return { rootDir, specDir, manifestPath, manifest, shadow: null };
+    return { rootDir, specDir, manifestPath, manifest, shadow: null, config };
+}
+/**
+ * Check if a filename is a potential manifest file.
+ * Excludes files with suffixes that indicate other kspec file types.
+ *
+ * AC: @manifest-discovery ac-5 (excludes task/inbox/meta/runs files)
+ */
+function isManifestCandidate(filename) {
+    if (!filename.endsWith(".yaml"))
+        return false;
+    const exclusions = [".tasks.yaml", ".inbox.yaml", ".meta.yaml", ".runs.yaml"];
+    return !exclusions.some((excl) => filename.endsWith(excl));
 }
 /**
  * Find manifest file within a specific directory (no parent traversal).
  * Used for shadow mode where we know exactly where to look.
+ *
+ * Discovery algorithm:
+ * 1. Check for explicit names: kynetic.yaml, kynetic.spec.yaml (backward compat)
+ * 2. If not found, scan directory for *.yaml files (excluding other kspec types)
+ * 3. For each candidate, validate it contains a 'kynetic:' version field
+ * 4. Return first valid match (alphabetically after explicit names)
+ *
+ * AC: @manifest-discovery ac-1, ac-2, ac-3, ac-4, ac-5
  */
 async function findManifestInDir(dir) {
-    const candidates = ['kynetic.yaml', 'kynetic.spec.yaml'];
-    for (const candidate of candidates) {
+    // AC: @manifest-discovery ac-1, ac-2 - explicit names have priority
+    const priorityCandidates = ["kynetic.yaml", "kynetic.spec.yaml"];
+    for (const candidate of priorityCandidates) {
         const filePath = path.join(dir, candidate);
         try {
             await fs.access(filePath);
@@ -208,6 +298,28 @@ async function findManifestInDir(dir) {
             // File doesn't exist, try next
         }
     }
+    // AC: @manifest-discovery ac-3, ac-4, ac-5 - glob fallback with validation
+    try {
+        const entries = await fs.readdir(dir);
+        // AC: @manifest-discovery ac-4 - alphabetical order
+        const candidates = entries.filter(isManifestCandidate).sort();
+        for (const candidate of candidates) {
+            const filePath = path.join(dir, candidate);
+            try {
+                const raw = await readYamlFile(filePath);
+                // AC: @manifest-discovery ac-5 - validate kynetic version field
+                if (raw && typeof raw === "object" && "kynetic" in raw) {
+                    return filePath;
+                }
+            }
+            catch {
+                // Skip invalid files
+            }
+        }
+    }
+    catch {
+        // Directory read failed
+    }
     return null;
 }
 /**
@@ -223,7 +335,7 @@ async function loadTasksFromFile(filePath) {
         if (Array.isArray(raw)) {
             taskList = raw;
         }
-        else if (raw && typeof raw === 'object' && 'tasks' in raw) {
+        else if (raw && typeof raw === "object" && "tasks" in raw) {
             const parsed = TasksFileSchema.safeParse(raw);
             if (parsed.success) {
                 // Add _sourceFile to each task from this file
@@ -265,11 +377,11 @@ export async function loadAllTasks(ctx) {
         const taskFiles = await findTaskFiles(ctx.specDir);
         // Also check for standalone files in specDir
         const standaloneLocations = [
-            path.join(ctx.specDir, 'tasks.yaml'),
-            path.join(ctx.specDir, 'project.tasks.yaml'),
-            path.join(ctx.specDir, 'kynetic.tasks.yaml'),
-            path.join(ctx.specDir, 'backlog.tasks.yaml'),
-            path.join(ctx.specDir, 'active.tasks.yaml'),
+            path.join(ctx.specDir, "tasks.yaml"),
+            path.join(ctx.specDir, "project.tasks.yaml"),
+            path.join(ctx.specDir, "kynetic.tasks.yaml"),
+            path.join(ctx.specDir, "backlog.tasks.yaml"),
+            path.join(ctx.specDir, "active.tasks.yaml"),
         ];
         for (const loc of standaloneLocations) {
             try {
@@ -294,8 +406,8 @@ export async function loadAllTasks(ctx) {
     const taskFiles = await findTaskFiles(ctx.rootDir);
     // Also check common locations
     const additionalPaths = [
-        path.join(ctx.rootDir, 'tasks'),
-        path.join(ctx.rootDir, 'spec'),
+        path.join(ctx.rootDir, "tasks"),
+        path.join(ctx.rootDir, "spec"),
     ];
     for (const additionalPath of additionalPaths) {
         const files = await findTaskFiles(additionalPath);
@@ -303,11 +415,11 @@ export async function loadAllTasks(ctx) {
     }
     // Also look for standalone tasks.yaml and project.tasks.yaml
     const standaloneLocations = [
-        path.join(ctx.rootDir, 'tasks.yaml'),
-        path.join(ctx.rootDir, 'project.tasks.yaml'),
-        path.join(ctx.rootDir, 'spec', 'project.tasks.yaml'),
-        path.join(ctx.rootDir, 'backlog.tasks.yaml'),
-        path.join(ctx.rootDir, 'active.tasks.yaml'),
+        path.join(ctx.rootDir, "tasks.yaml"),
+        path.join(ctx.rootDir, "project.tasks.yaml"),
+        path.join(ctx.rootDir, "spec", "project.tasks.yaml"),
+        path.join(ctx.rootDir, "backlog.tasks.yaml"),
+        path.join(ctx.rootDir, "active.tasks.yaml"),
     ];
     for (const loc of standaloneLocations) {
         try {
@@ -333,8 +445,8 @@ export async function loadAllTasks(ctx) {
  */
 export function findTaskByRef(tasks, ref) {
     // Remove @ prefix if present
-    const cleanRef = ref.startsWith('@') ? ref.slice(1) : ref;
-    return tasks.find(task => {
+    const cleanRef = ref.startsWith("@") ? ref.slice(1) : ref;
+    return tasks.find((task) => {
         // Match full ULID
         if (task._ulid === cleanRef)
             return true;
@@ -354,7 +466,7 @@ export function findTaskByRef(tasks, ref) {
  * Otherwise: spec/project.tasks.yaml
  */
 export function getDefaultTaskFilePath(ctx) {
-    return path.join(ctx.specDir, 'project.tasks.yaml');
+    return path.join(ctx.specDir, "project.tasks.yaml");
 }
 /**
  * Strip runtime metadata before serialization
@@ -379,7 +491,9 @@ export async function saveTask(ctx, task) {
     try {
         existingRaw = await readYamlFile(taskFilePath);
         // Detect if file uses { tasks: [...] } format
-        if (existingRaw && typeof existingRaw === 'object' && 'tasks' in existingRaw) {
+        if (existingRaw &&
+            typeof existingRaw === "object" &&
+            "tasks" in existingRaw) {
             useTasksWrapper = true;
         }
     }
@@ -420,7 +534,7 @@ export async function saveTask(ctx, task) {
     // Strip runtime metadata before saving
     const cleanTask = stripRuntimeMetadata(task);
     // Update existing or add new
-    const existingIndex = fileTasks.findIndex(t => t._ulid === task._ulid);
+    const existingIndex = fileTasks.findIndex((t) => t._ulid === task._ulid);
     if (existingIndex >= 0) {
         fileTasks[existingIndex] = cleanTask;
     }
@@ -440,9 +554,9 @@ export async function saveTask(ctx, task) {
  * Delete a task from its source file.
  * Requires _sourceFile to know which file to modify.
  */
-export async function deleteTask(ctx, task) {
+export async function deleteTask(_ctx, task) {
     if (!task._sourceFile) {
-        throw new Error('Cannot delete task without _sourceFile metadata');
+        throw new Error("Cannot delete task without _sourceFile metadata");
     }
     const taskFilePath = task._sourceFile;
     // Load existing file
@@ -450,7 +564,9 @@ export async function deleteTask(ctx, task) {
     let useTasksWrapper = false;
     try {
         existingRaw = await readYamlFile(taskFilePath);
-        if (existingRaw && typeof existingRaw === 'object' && 'tasks' in existingRaw) {
+        if (existingRaw &&
+            typeof existingRaw === "object" &&
+            "tasks" in existingRaw) {
             useTasksWrapper = true;
         }
     }
@@ -488,7 +604,7 @@ export async function deleteTask(ctx, task) {
     }
     // Remove the task
     const originalCount = fileTasks.length;
-    fileTasks = fileTasks.filter(t => t._ulid !== task._ulid);
+    fileTasks = fileTasks.filter((t) => t._ulid !== task._ulid);
     if (fileTasks.length === originalCount) {
         throw new Error(`Task not found in file: ${task._ulid}`);
     }
@@ -509,8 +625,8 @@ export function createTask(input) {
         ...input,
         _ulid: input._ulid || ulid(),
         slugs: input.slugs || [],
-        type: input.type || 'task',
-        status: input.status || 'pending',
+        type: input.type || "task",
+        status: input.status || "pending",
         blocked_by: input.blocked_by || [],
         depends_on: input.depends_on || [],
         context: input.context || [],
@@ -526,23 +642,32 @@ export function createTask(input) {
  * Get author from environment with fallback chain.
  * Priority:
  *   1. KSPEC_AUTHOR env var (explicit config, agent-agnostic)
- *   2. git user.name (developer identity)
- *   3. USER/USERNAME env var (system user)
- *   4. undefined (will show as 'unknown' in output)
+ *   2. kspec.config.yaml identity.author (project-level default)
+ *   3. git user.name (developer identity)
+ *   4. USER/USERNAME env var (system user)
+ *   5. undefined (will show as 'unknown' in output)
  *
  * For Claude Code integration, add to ~/.claude/settings.json:
  *   { "env": { "KSPEC_AUTHOR": "@claude" } }
+ *
+ * AC: @config-author ac-1 ac-2 ac-3 — author priority chain
+ *
+ * @param configAuthor Optional author from kspec.config.yaml identity.author
  */
-export function getAuthor() {
-    // 1. Explicit config (works for any agent)
+export function getAuthor(configAuthor) {
+    // 1. Explicit env var (works for any agent) — AC: ac-2
     if (process.env.KSPEC_AUTHOR) {
         return process.env.KSPEC_AUTHOR;
     }
-    // 2. Git user.name
+    // 2. Project config author — AC: ac-1
+    if (configAuthor) {
+        return configAuthor;
+    }
+    // 3. Git user.name — AC: ac-3
     try {
-        const gitUser = execSync('git config user.name', {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'ignore'],
+        const gitUser = execSync("git config user.name", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "ignore"],
         }).trim();
         if (gitUser) {
             return gitUser;
@@ -551,12 +676,12 @@ export function getAuthor() {
     catch {
         // git not available or not in a repo
     }
-    // 3. System user
+    // 4. System user — AC: ac-3
     const systemUser = process.env.USER || process.env.USERNAME;
     if (systemUser) {
         return systemUser;
     }
-    // 4. No author available
+    // 5. No author available
     return undefined;
 }
 /**
@@ -597,7 +722,7 @@ export function areDependenciesMet(task, allTasks) {
         return true;
     for (const depRef of task.depends_on) {
         const depTask = findTaskByRef(allTasks, depRef);
-        if (!depTask || depTask.status !== 'completed') {
+        if (!depTask || depTask.status !== "completed") {
             return false;
         }
     }
@@ -607,7 +732,7 @@ export function areDependenciesMet(task, allTasks) {
  * Check if task is ready (pending + deps met + not blocked)
  */
 export function isTaskReady(task, allTasks) {
-    if (task.status !== 'pending')
+    if (task.status !== "pending")
         return false;
     if (task.blocked_by.length > 0)
         return false;
@@ -619,14 +744,14 @@ export function isTaskReady(task, allTasks) {
  */
 export function getReadyTasks(tasks) {
     return tasks
-        .filter(task => isTaskReady(task, tasks))
+        .filter((task) => isTaskReady(task, tasks))
         .sort((a, b) => {
         // Primary: priority (lower number = higher priority)
         if (a.priority !== b.priority) {
             return a.priority - b.priority;
         }
         // Secondary: creation time (older first - FIFO within priority)
-        return new Date(a.created_at).getTime() - new Date(b.created_at).getTime();
+        return (new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
     });
 }
 // ============================================================
@@ -637,9 +762,11 @@ export function getReadyTasks(tasks) {
  * Supports simple patterns like "modules/*.yaml" or "**\/*.yaml"
  */
 export async function expandIncludePattern(pattern, baseDir) {
-    const fullPattern = path.isAbsolute(pattern) ? pattern : path.join(baseDir, pattern);
+    const fullPattern = path.isAbsolute(pattern)
+        ? pattern
+        : path.join(baseDir, pattern);
     // If no glob characters, just return the path if it exists
-    if (!pattern.includes('*')) {
+    if (!pattern.includes("*")) {
         try {
             await fs.access(fullPattern);
             return [fullPattern];
@@ -649,17 +776,17 @@ export async function expandIncludePattern(pattern, baseDir) {
         }
     }
     // Split pattern into directory part and file pattern
-    const parts = pattern.split('/');
+    const parts = pattern.split("/");
     let currentDir = baseDir;
     const result = [];
     // Find the first part with a glob
-    let globIndex = parts.findIndex(p => p.includes('*'));
+    const globIndex = parts.findIndex((p) => p.includes("*"));
     // Navigate to the directory before the glob
     if (globIndex > 0) {
         currentDir = path.join(baseDir, ...parts.slice(0, globIndex));
     }
     // Get the remaining pattern
-    const remainingPattern = parts.slice(globIndex).join('/');
+    const remainingPattern = parts.slice(globIndex).join("/");
     await expandGlobRecursive(currentDir, remainingPattern, result);
     return result;
 }
@@ -667,9 +794,9 @@ export async function expandIncludePattern(pattern, baseDir) {
  * Recursively expand glob patterns
  */
 async function expandGlobRecursive(dir, pattern, result) {
-    const parts = pattern.split('/');
+    const parts = pattern.split("/");
     const currentPattern = parts[0];
-    const remainingPattern = parts.slice(1).join('/');
+    const remainingPattern = parts.slice(1).join("/");
     try {
         const entries = await fs.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
@@ -684,10 +811,10 @@ async function expandGlobRecursive(dir, pattern, result) {
                 }
                 else {
                     // This is the final pattern part
-                    if (currentPattern === '**') {
+                    if (currentPattern === "**") {
                         // ** matches any depth - need special handling
                         if (entry.isDirectory()) {
-                            await expandGlobRecursive(fullPath, '**', result);
+                            await expandGlobRecursive(fullPath, "**", result);
                         }
                         // Also match files at this level
                         result.push(fullPath);
@@ -698,7 +825,7 @@ async function expandGlobRecursive(dir, pattern, result) {
                 }
             }
             // Handle ** - also recurse into directories without consuming the pattern
-            if (currentPattern === '**' && entry.isDirectory()) {
+            if (currentPattern === "**" && entry.isDirectory()) {
                 const fullPath = path.join(dir, entry.name);
                 await expandGlobRecursive(fullPath, pattern, result);
             }
@@ -712,15 +839,15 @@ async function expandGlobRecursive(dir, pattern, result) {
  * Match a single path component against a glob pattern part
  */
 function matchGlobPart(name, pattern) {
-    if (pattern === '*')
+    if (pattern === "*")
         return true;
-    if (pattern === '**')
+    if (pattern === "**")
         return true;
     // Convert glob pattern to regex
     const regexPattern = pattern
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape special regex chars
-        .replace(/\*/g, '.*') // * matches anything
-        .replace(/\?/g, '.'); // ? matches single char
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&") // Escape special regex chars
+        .replace(/\*/g, ".*") // * matches anything
+        .replace(/\?/g, "."); // ? matches single char
     const regex = new RegExp(`^${regexPattern}$`);
     return regex.test(name);
 }
@@ -728,26 +855,42 @@ function matchGlobPart(name, pattern) {
  * Fields that may contain nested spec items
  */
 const NESTED_ITEM_FIELDS = [
-    'modules',
-    'features',
-    'requirements',
-    'constraints',
-    'decisions',
-    'traits',
-    'acceptance_criteria',
+    "modules",
+    "features",
+    "requirements",
+    "constraints",
+    "decisions",
+    "traits",
+    "acceptance_criteria",
 ];
 /**
  * Recursively extract all spec items from a raw YAML structure.
  * Items can be nested under modules/features/requirements/etc.
  * Tracks the path within the file for each item.
  */
-export function extractItemsFromRaw(raw, sourceFile, items = [], currentPath = '') {
-    if (!raw || typeof raw !== 'object') {
+export function extractItemsFromRaw(raw, sourceFile, items = [], currentPath = "") {
+    if (!raw || typeof raw !== "object") {
         return items;
     }
     // Check if this object is itself a spec item (has _ulid)
-    if ('_ulid' in raw && typeof raw._ulid === 'string') {
-        const result = SpecItemSchema.safeParse(raw);
+    if ("_ulid" in raw &&
+        typeof raw._ulid === "string") {
+        // Strip nested item arrays before validation since they're processed separately
+        // and the SpecItemSchema expects refs (strings), not nested objects
+        const rawObj = raw;
+        const cleanedForValidation = { ...rawObj };
+        for (const field of NESTED_ITEM_FIELDS) {
+            if (field in cleanedForValidation && Array.isArray(cleanedForValidation[field])) {
+                const arr = cleanedForValidation[field];
+                // Check if array contains nested items (objects with _ulid) vs refs (strings)
+                const hasNestedItems = arr.some((item) => item && typeof item === "object" && "_ulid" in item);
+                if (hasNestedItems) {
+                    // Strip nested items - they'll be extracted recursively
+                    delete cleanedForValidation[field];
+                }
+            }
+        }
+        const result = SpecItemSchema.safeParse(cleanedForValidation);
         if (result.success) {
             items.push({
                 ...result.data,
@@ -756,12 +899,13 @@ export function extractItemsFromRaw(raw, sourceFile, items = [], currentPath = '
             });
         }
         // Even if the item itself was added, also extract nested items
-        const rawObj = raw;
         for (const field of NESTED_ITEM_FIELDS) {
             if (field in rawObj && Array.isArray(rawObj[field])) {
                 const arr = rawObj[field];
                 for (let i = 0; i < arr.length; i++) {
-                    const nestedPath = currentPath ? `${currentPath}.${field}[${i}]` : `${field}[${i}]`;
+                    const nestedPath = currentPath
+                        ? `${currentPath}.${field}[${i}]`
+                        : `${field}[${i}]`;
                     extractItemsFromRaw(arr[i], sourceFile, items, nestedPath);
                 }
             }
@@ -781,7 +925,9 @@ export function extractItemsFromRaw(raw, sourceFile, items = [], currentPath = '
             if (field in rawObj && Array.isArray(rawObj[field])) {
                 const arr = rawObj[field];
                 for (let i = 0; i < arr.length; i++) {
-                    const nestedPath = currentPath ? `${currentPath}.${field}[${i}]` : `${field}[${i}]`;
+                    const nestedPath = currentPath
+                        ? `${currentPath}.${field}[${i}]`
+                        : `${field}[${i}]`;
                     extractItemsFromRaw(arr[i], sourceFile, items, nestedPath);
                 }
             }
@@ -795,7 +941,7 @@ export function extractItemsFromRaw(raw, sourceFile, items = [], currentPath = '
  */
 export async function loadSpecFile(filePath) {
     try {
-        const content = await fs.readFile(filePath, 'utf-8');
+        const content = await fs.readFile(filePath, "utf-8");
         const items = [];
         // Parse all YAML documents in the file (handles files with ---)
         const documents = YAML.parseAllDocuments(content);
@@ -812,7 +958,7 @@ export async function loadSpecFile(filePath) {
         }
         return items;
     }
-    catch (error) {
+    catch (_error) {
         // File doesn't exist or parse error
         return [];
     }
@@ -846,8 +992,8 @@ export async function loadAllItems(ctx) {
  */
 export function findItemByRef(items, ref) {
     // Remove @ prefix if present
-    const cleanRef = ref.startsWith('@') ? ref.slice(1) : ref;
-    return items.find(item => {
+    const cleanRef = ref.startsWith("@") ? ref.slice(1) : ref;
+    return items.find((item) => {
         // Match full ULID
         if (item._ulid === cleanRef)
             return true;
@@ -884,11 +1030,13 @@ export async function buildReferenceIndex(ctx) {
 /**
  * Build both ReferenceIndex and ItemIndex from context.
  * Use this when you need query capabilities in addition to reference resolution.
+ * Pass plans for cross-namespace slug collision detection (plans aren't loaded by default
+ * to avoid circular dependency with plans.ts).
  */
-export async function buildIndexes(ctx) {
+export async function buildIndexes(ctx, plans = []) {
     const tasks = await loadAllTasks(ctx);
     const items = await loadAllItems(ctx);
-    const refIndex = new ReferenceIndex(tasks, items);
+    const refIndex = new ReferenceIndex(tasks, items, [], plans);
     const itemIndex = new ItemIndex(tasks, items);
     const traitIndex = new TraitIndex(items, refIndex);
     return { refIndex, itemIndex, traitIndex, tasks, items };
@@ -930,7 +1078,7 @@ function navigateToPath(root, pathStr) {
     // Navigate to the parent of the last segment
     for (let i = 0; i < segments.length - 1; i++) {
         const [field, index] = segments[i];
-        if (typeof current !== 'object' || current === null)
+        if (typeof current !== "object" || current === null)
             return null;
         const obj = current;
         if (!Array.isArray(obj[field]))
@@ -939,7 +1087,7 @@ function navigateToPath(root, pathStr) {
     }
     // Get the final array and index
     const [finalField, finalIndex] = segments[segments.length - 1];
-    if (typeof current !== 'object' || current === null)
+    if (typeof current !== "object" || current === null)
         return null;
     const parent = current;
     if (!Array.isArray(parent[finalField]))
@@ -954,8 +1102,8 @@ function navigateToPath(root, pathStr) {
  * Find an item by ULID in a nested YAML structure.
  * Returns the path segments to reach it.
  */
-function findItemInStructure(root, ulid, currentPath = '') {
-    if (!root || typeof root !== 'object')
+function findItemInStructure(root, ulid, currentPath = "") {
+    if (!root || typeof root !== "object")
         return null;
     const obj = root;
     // Check if this is the item we're looking for
@@ -967,7 +1115,9 @@ function findItemInStructure(root, ulid, currentPath = '') {
         if (Array.isArray(obj[field])) {
             const arr = obj[field];
             for (let i = 0; i < arr.length; i++) {
-                const nestedPath = currentPath ? `${currentPath}.${field}[${i}]` : `${field}[${i}]`;
+                const nestedPath = currentPath
+                    ? `${currentPath}.${field}[${i}]`
+                    : `${field}[${i}]`;
                 const result = findItemInStructure(arr[i], ulid, nestedPath);
                 if (result)
                     return result;
@@ -989,6 +1139,7 @@ export function createSpecItem(input) {
         priority: input.priority,
         tags: input.tags || [],
         description: input.description,
+        acceptance_criteria: input.acceptance_criteria,
         depends_on: input.depends_on || [],
         implements: input.implements || [],
         relates_to: input.relates_to || [],
@@ -1003,12 +1154,12 @@ export function createSpecItem(input) {
  * Map from item type to the field name used to store children of that type.
  */
 const TYPE_TO_CHILD_FIELD = {
-    feature: 'features',
-    requirement: 'requirements',
-    constraint: 'constraints',
-    decision: 'decisions',
-    module: 'modules',
-    trait: 'traits',
+    feature: "features",
+    requirement: "requirements",
+    constraint: "constraints",
+    decision: "decisions",
+    module: "modules",
+    trait: "traits",
 };
 /**
  * Add a spec item as a child of a parent item.
@@ -1016,11 +1167,11 @@ const TYPE_TO_CHILD_FIELD = {
  * @param child The new child item to add
  * @param childField Optional field name override (defaults based on child.type)
  */
-export async function addChildItem(ctx, parent, child, childField) {
+export async function addChildItem(_ctx, parent, child, childField) {
     if (!parent._sourceFile) {
-        throw new Error('Parent item has no source file');
+        throw new Error("Parent item has no source file");
     }
-    const field = childField || TYPE_TO_CHILD_FIELD[child.type || 'feature'] || 'features';
+    const field = childField || TYPE_TO_CHILD_FIELD[child.type || "feature"] || "features";
     // Load the raw YAML
     const raw = await readYamlFile(parent._sourceFile);
     // Find the parent in the structure
@@ -1037,7 +1188,7 @@ export async function addChildItem(ctx, parent, child, childField) {
     else {
         // Parent is the root item
         parentObj = raw;
-        parentPath = '';
+        parentPath = "";
     }
     // Ensure the child field array exists
     if (!Array.isArray(parentObj[field])) {
@@ -1049,7 +1200,9 @@ export async function addChildItem(ctx, parent, child, childField) {
     childArray.push(cleanChild);
     // Calculate the new child's path
     const childIndex = childArray.length - 1;
-    const childPath = parentPath ? `${parentPath}.${field}[${childIndex}]` : `${field}[${childIndex}]`;
+    const childPath = parentPath
+        ? `${parentPath}.${field}[${childIndex}]`
+        : `${field}[${childIndex}]`;
     // Write back with format preservation
     await writeYamlFilePreserveFormat(parent._sourceFile, raw);
     return { item: cleanChild, path: childPath };
@@ -1058,9 +1211,9 @@ export async function addChildItem(ctx, parent, child, childField) {
  * Update a spec item in place within its source file.
  * Works with nested structures using the _path field.
  */
-export async function updateSpecItem(ctx, item, updates) {
+export async function updateSpecItem(_ctx, item, updates) {
     if (!item._sourceFile) {
-        throw new Error('Item has no source file');
+        throw new Error("Item has no source file");
     }
     // Load the raw YAML
     const raw = await readYamlFile(item._sourceFile);
@@ -1088,7 +1241,7 @@ export async function updateSpecItem(ctx, item, updates) {
     }
     // Apply updates (but never change _ulid)
     for (const [key, value] of Object.entries(updates)) {
-        if (key !== '_ulid' && key !== '_sourceFile' && key !== '_path') {
+        if (key !== "_ulid" && key !== "_sourceFile" && key !== "_path") {
             targetObj[key] = value;
         }
     }
@@ -1102,12 +1255,12 @@ export async function updateSpecItem(ctx, item, updates) {
  */
 export function findTraitImplementors(trait, allItems) {
     // Check if the item is actually a trait
-    if (trait.type !== 'trait') {
+    if (trait.type !== "trait") {
         return [];
     }
     // Find all items that reference this trait in their 'traits' array
-    const traitRefs = ['@' + trait._ulid, ...trait.slugs.map(s => '@' + s)];
-    return allItems.filter(item => {
+    const traitRefs = [`@${trait._ulid}`, ...trait.slugs.map((s) => `@${s}`)];
+    return allItems.filter((item) => {
         if (!item.traits || item.traits.length === 0)
             return false;
         return item.traits.some((traitRef) => traitRefs.includes(traitRef));
@@ -1117,7 +1270,7 @@ export function findTraitImplementors(trait, allItems) {
  * Delete a spec item from its source file.
  * Works with nested structures using the _path field.
  */
-export async function deleteSpecItem(ctx, item) {
+export async function deleteSpecItem(_ctx, item) {
     if (!item._sourceFile) {
         return false;
     }
@@ -1136,7 +1289,7 @@ export async function deleteSpecItem(ctx, item) {
         }
         // No path - try to find it by ULID
         const found = findItemInStructure(raw, item._ulid);
-        if (found && found.path) {
+        if (found?.path) {
             const nav = navigateToPath(raw, found.path);
             if (nav) {
                 nav.array.splice(nav.index, 1);
@@ -1146,7 +1299,9 @@ export async function deleteSpecItem(ctx, item) {
         }
         // Maybe it's a root-level array item
         if (Array.isArray(raw)) {
-            const index = raw.findIndex((i) => typeof i === 'object' && i !== null && i._ulid === item._ulid);
+            const index = raw.findIndex((i) => typeof i === "object" &&
+                i !== null &&
+                i._ulid === item._ulid);
             if (index >= 0) {
                 raw.splice(index, 1);
                 await writeYamlFilePreserveFormat(item._sourceFile, raw);
@@ -1170,7 +1325,7 @@ export async function saveSpecItem(ctx, item) {
         return;
     }
     // Otherwise, this is more complex - would need a parent
-    throw new Error('Cannot save new item without parent. Use addChildItem instead.');
+    throw new Error("Cannot save new item without parent. Use addChildItem instead.");
 }
 /**
  * Get the inbox file path.
@@ -1179,7 +1334,7 @@ export async function saveSpecItem(ctx, item) {
  * Otherwise: spec/project.inbox.yaml
  */
 export function getInboxFilePath(ctx) {
-    return path.join(ctx.specDir, 'project.inbox.yaml');
+    return path.join(ctx.specDir, "project.inbox.yaml");
 }
 /**
  * Load all inbox items from the project.
@@ -1189,10 +1344,13 @@ export async function loadInboxItems(ctx) {
     try {
         const raw = await readYamlFile(inboxPath);
         // Handle { inbox: [...] } format
-        if (raw && typeof raw === 'object' && 'inbox' in raw) {
+        if (raw && typeof raw === "object" && "inbox" in raw) {
             const parsed = InboxFileSchema.safeParse(raw);
             if (parsed.success) {
-                return parsed.data.inbox.map(item => ({ ...item, _sourceFile: inboxPath }));
+                return parsed.data.inbox.map((item) => ({
+                    ...item,
+                    _sourceFile: inboxPath,
+                }));
             }
         }
         // Handle plain array format
@@ -1215,14 +1373,19 @@ export async function loadInboxItems(ctx) {
 }
 /**
  * Create a new inbox item with auto-generated fields.
+ *
+ * AC: @config-author — supports config author in fallback chain
+ *
+ * @param input Inbox item input
+ * @param configAuthor Optional author from kspec.config.yaml identity.author
  */
-export function createInboxItem(input) {
+export function createInboxItem(input, configAuthor) {
     return {
         _ulid: input._ulid || ulid(),
         text: input.text,
         created_at: input.created_at || new Date().toISOString(),
         tags: input.tags || [],
-        added_by: input.added_by ?? getAuthor(),
+        added_by: input.added_by ?? getAuthor(configAuthor),
     };
 }
 /**
@@ -1244,7 +1407,7 @@ export async function saveInboxItem(ctx, item) {
     let existingItems = [];
     try {
         const raw = await readYamlFile(inboxPath);
-        if (raw && typeof raw === 'object' && 'inbox' in raw) {
+        if (raw && typeof raw === "object" && "inbox" in raw) {
             const parsed = InboxFileSchema.safeParse(raw);
             if (parsed.success) {
                 existingItems = parsed.data.inbox;
@@ -1264,7 +1427,7 @@ export async function saveInboxItem(ctx, item) {
     }
     const cleanItem = stripInboxMetadata(item);
     // Update existing or add new
-    const existingIndex = existingItems.findIndex(i => i._ulid === item._ulid);
+    const existingIndex = existingItems.findIndex((i) => i._ulid === item._ulid);
     if (existingIndex >= 0) {
         existingItems[existingIndex] = cleanItem;
     }
@@ -1282,13 +1445,13 @@ export async function deleteInboxItem(ctx, ulid) {
     try {
         const raw = await readYamlFile(inboxPath);
         let existingItems = [];
-        if (raw && typeof raw === 'object' && 'inbox' in raw) {
+        if (raw && typeof raw === "object" && "inbox" in raw) {
             const parsed = InboxFileSchema.safeParse(raw);
             if (parsed.success) {
                 existingItems = parsed.data.inbox;
             }
         }
-        const index = existingItems.findIndex(i => i._ulid === ulid);
+        const index = existingItems.findIndex((i) => i._ulid === ulid);
         if (index < 0) {
             return false;
         }
@@ -1304,8 +1467,8 @@ export async function deleteInboxItem(ctx, ulid) {
  * Find an inbox item by reference (ULID or short ULID).
  */
 export function findInboxItemByRef(items, ref) {
-    const cleanRef = ref.startsWith('@') ? ref.slice(1) : ref;
-    return items.find(item => {
+    const cleanRef = ref.startsWith("@") ? ref.slice(1) : ref;
+    return items.find((item) => {
         // Match full ULID
         if (item._ulid === cleanRef)
             return true;
@@ -1315,6 +1478,144 @@ export function findInboxItemByRef(items, ref) {
         return false;
     });
 }
+/**
+ * Get the triage file path.
+ * AC: @triage-record-schema ac-6
+ *
+ * When shadow enabled: .kspec/project.triage.yaml
+ * Otherwise: spec/project.triage.yaml
+ */
+export function getTriageFilePath(ctx) {
+    return path.join(ctx.specDir, "project.triage.yaml");
+}
+/**
+ * Load all triage records from the project.
+ * AC: @triage-record-schema ac-6, ac-7
+ */
+export async function loadTriageRecords(ctx) {
+    const triagePath = getTriageFilePath(ctx);
+    try {
+        const raw = await readYamlFile(triagePath);
+        // Handle { kynetic_triage: "1.0", triage: [...] } format
+        if (raw && typeof raw === "object" && "triage" in raw) {
+            const parsed = TriageFileSchema.safeParse(raw);
+            if (parsed.success) {
+                return parsed.data.triage.map((record) => ({
+                    ...record,
+                    _sourceFile: triagePath,
+                }));
+            }
+        }
+        // Handle plain array format
+        if (Array.isArray(raw)) {
+            const records = [];
+            for (const item of raw) {
+                const result = TriageRecordSchema.safeParse(item);
+                if (result.success) {
+                    records.push({ ...result.data, _sourceFile: triagePath });
+                }
+            }
+            return records;
+        }
+        return [];
+    }
+    catch {
+        // File doesn't exist or parse error
+        return [];
+    }
+}
+/**
+ * Strip runtime metadata before serialization.
+ */
+function stripTriageMetadata(record) {
+    const { _sourceFile, ...cleanRecord } = record;
+    return cleanRecord;
+}
+/**
+ * Save a triage record (add or update).
+ * AC: @triage-record-schema ac-8 — upsert on inbox_ref (one record per inbox item)
+ * AC: @triage-record-schema ac-9 — sets updated_at on every mutation
+ */
+export async function saveTriageRecord(ctx, record) {
+    const triagePath = getTriageFilePath(ctx);
+    // Ensure directory exists
+    const dir = path.dirname(triagePath);
+    await fs.mkdir(dir, { recursive: true });
+    // Load existing records
+    let existingRecords = [];
+    try {
+        const raw = await readYamlFile(triagePath);
+        if (raw && typeof raw === "object" && "triage" in raw) {
+            const parsed = TriageFileSchema.safeParse(raw);
+            if (parsed.success) {
+                existingRecords = parsed.data.triage;
+            }
+        }
+        else if (Array.isArray(raw)) {
+            for (const item of raw) {
+                const result = TriageRecordSchema.safeParse(item);
+                if (result.success) {
+                    existingRecords.push(result.data);
+                }
+            }
+        }
+    }
+    catch {
+        // File doesn't exist, start fresh
+    }
+    const cleanRecord = stripTriageMetadata(record);
+    // AC: ac-9 — set updated_at on every mutation
+    cleanRecord.updated_at = new Date().toISOString();
+    // AC: ac-8 — upsert: check for existing record by ULID first, then by inbox_ref
+    const existingByUlid = existingRecords.findIndex((r) => r._ulid === record._ulid);
+    if (existingByUlid >= 0) {
+        existingRecords[existingByUlid] = cleanRecord;
+    }
+    else {
+        // Check for existing record with same inbox_ref (uniqueness constraint)
+        // Preserve existing identity (_ulid, created_at) when upserting by inbox_ref
+        const existingByInboxRef = existingRecords.findIndex((r) => r.inbox_ref === record.inbox_ref);
+        if (existingByInboxRef >= 0) {
+            const existing = existingRecords[existingByInboxRef];
+            existingRecords[existingByInboxRef] = {
+                ...cleanRecord,
+                _ulid: existing._ulid,
+                created_at: existing.created_at,
+            };
+        }
+        else {
+            existingRecords.push(cleanRecord);
+        }
+    }
+    // Save with { kynetic_triage: "1.0", triage: [...] } format
+    await writeYamlFilePreserveFormat(triagePath, {
+        kynetic_triage: "1.0",
+        triage: existingRecords,
+    });
+}
+/**
+ * Find a triage record by reference (ULID or short ULID).
+ */
+export function findTriageRecordByRef(records, ref) {
+    const cleanRef = ref.startsWith("@") ? ref.slice(1) : ref;
+    return records.find((record) => {
+        // Match full ULID
+        if (record._ulid === cleanRef)
+            return true;
+        // Match short ULID (prefix)
+        if (record._ulid.toLowerCase().startsWith(cleanRef.toLowerCase()))
+            return true;
+        return false;
+    });
+}
+/**
+ * Find a triage record by inbox item reference.
+ * AC: @triage-record-schema ac-8 — lookup by inbox_ref for upsert
+ */
+export function findTriageRecordByInboxRef(records, inboxRef) {
+    const cleanRef = inboxRef.startsWith("@") ? inboxRef.slice(1) : inboxRef;
+    return records.find((record) => record.inbox_ref === cleanRef);
+}
 /**
  * Bulk patch spec items.
  * Resolves refs, validates data, applies patches.
@@ -1325,28 +1626,32 @@ export async function patchSpecItems(ctx, refIndex, items, patches, options = {}
     let stopProcessing = false;
     for (const patch of patches) {
         if (stopProcessing) {
-            results.push({ ref: patch.ref, status: 'skipped' });
+            results.push({ ref: patch.ref, status: "skipped" });
             continue;
         }
         // Resolve ref
         const resolved = refIndex.resolve(patch.ref);
         if (!resolved.ok) {
-            const errorMsg = resolved.error === 'not_found'
+            const errorMsg = resolved.error === "not_found"
                 ? `Item not found: ${patch.ref}`
-                : resolved.error === 'ambiguous'
+                : resolved.error === "ambiguous"
                     ? `Ambiguous ref: ${patch.ref}`
                     : `Duplicate slug: ${patch.ref}`;
-            results.push({ ref: patch.ref, status: 'error', error: errorMsg });
+            results.push({ ref: patch.ref, status: "error", error: errorMsg });
             if (options.failFast) {
                 stopProcessing = true;
             }
             continue;
         }
         // Find the item
-        const item = items.find(i => i._ulid === resolved.ulid);
+        const item = items.find((i) => i._ulid === resolved.ulid);
         if (!item) {
             // Ref resolved but it's not a spec item (might be a task)
-            results.push({ ref: patch.ref, status: 'error', error: 'Not a spec item' });
+            results.push({
+                ref: patch.ref,
+                status: "error",
+                error: "Not a spec item",
+            });
             if (options.failFast) {
                 stopProcessing = true;
             }
@@ -1354,17 +1659,17 @@ export async function patchSpecItems(ctx, refIndex, items, patches, options = {}
         }
         // Dry run - just record what would happen
         if (options.dryRun) {
-            results.push({ ref: patch.ref, status: 'updated', ulid: item._ulid });
+            results.push({ ref: patch.ref, status: "updated", ulid: item._ulid });
             continue;
         }
         // Apply the patch
         try {
             await updateSpecItem(ctx, item, patch.data);
-            results.push({ ref: patch.ref, status: 'updated', ulid: item._ulid });
+            results.push({ ref: patch.ref, status: "updated", ulid: item._ulid });
         }
         catch (err) {
             const errorMsg = err instanceof Error ? err.message : String(err);
-            results.push({ ref: patch.ref, status: 'error', error: errorMsg });
+            results.push({ ref: patch.ref, status: "error", error: errorMsg });
             if (options.failFast) {
                 stopProcessing = true;
             }
@@ -1374,9 +1679,9 @@ export async function patchSpecItems(ctx, refIndex, items, patches, options = {}
         results,
         summary: {
             total: patches.length,
-            updated: results.filter(r => r.status === 'updated').length,
-            failed: results.filter(r => r.status === 'error').length,
-            skipped: results.filter(r => r.status === 'skipped').length,
+            updated: results.filter((r) => r.status === "updated").length,
+            failed: results.filter((r) => r.status === "error").length,
+            skipped: results.filter((r) => r.status === "skipped").length,
         },
     };
 }