lightspec 0.1.1 → 0.2.1

package/README.md

@@ -1,9 +1,7 @@
 <p align="center">
   <a href="https://github.com/augmenter-dev/lightspec">
     <picture>
-      <source srcset="assets/lightspec_pixel_dark.svg" media="(prefers-color-scheme: dark)">
-      <source srcset="assets/lightspec_pixel_light.svg" media="(prefers-color-scheme: light)">
-      <img src="assets/lightspec_pixel_light.svg" alt="LightSpec logo" height="64">
+      <img src="assets/augmenter-lightspec.svg" alt="LightSpec logo" height="64">
     </picture>
   </a>
   
@@ -19,7 +17,7 @@
 </p>
 
 <p align="center">
-  <img src="assets/lightspec_dashboard.png" alt="LightSpec dashboard preview" width="90%">
+  <img src="assets/openspec_dashboard.png" alt="LightSpec dashboard preview" width="90%">
 </p>
 
 <p align="center">
@@ -28,7 +26,7 @@
 
 # LightSpec
 
-A fork of [LightSpec](https://github.com/Fission-AI/LightSpec) v0.23.0
+A fork of [LightSpec](https://github.com/augmenter-dev/LightSpec), focused on simplicity and skill-based agents.
 
 LightSpec aligns humans and AI coding assistants with spec-driven development so you agree on what to build before any code is written. **No API keys required.**
 
@@ -207,14 +205,14 @@ lightspec init
 
 ### Optional: Populate Project Context
 
-After `lightspec init` completes, you'll receive a suggested prompt to help populate your project context:
+After `lightspec init` completes, you'll receive a suggested command to validate and populate your project context:
 
 ```text
-Populate your project context:
-"Please read lightspec/project.md and help me fill it out with details about my project, tech stack, and conventions"
+Validate and populate your project context:
+"/lightspec:context-check"
 ```
 
-Use `lightspec/project.md` to define project-level conventions, standards, architectural patterns, and other guidelines that should be followed across all changes.
+Use the `/lightspec:context-check` skill to validate that your agent instruction file (CLAUDE.md or AGENTS.md) contains adequate project context. The skill will check for required properties like Purpose, Tech Stack, Architecture Patterns, and more. If anything is missing, it can help you explore the codebase and populate the missing information.
 
 ### Create Your First Change
 
@@ -379,6 +377,9 @@ Deltas are "patches" that show how specs change:
 
 ## How LightSpec Compares
 
+### vs. OpenSpec
+OpenSpec has evolved into a more mature yet complex tool with a rich feature set. LightSpec focuses on simplicity and ease of adoption, especially for teams new to spec-driven development. LightSpec's minimalist approach has the additional benefit of reducing the number of skills and commands needed, and reducing the risk of involuntary skill activation from AI assistants.
+
 ### vs. spec-kit
 LightSpec’s two-folder model (`lightspec/specs/` for the current truth, `lightspec/changes/` for proposed updates) keeps state and diffs separate. This scales when you modify existing features or touch multiple specs. spec-kit is strong for greenfield/0→1 but provides less structure for cross-spec updates and evolving features.
 
@@ -424,7 +425,7 @@ See [MAINTAINERS.md](MAINTAINERS.md) for the list of core maintainers and adviso
 ## Agent Skills
 
 LightSpec includes 3 Claude Code skills for the core development workflow:
-- `lightspec-new` - Create a new change
+- `lightspec-proposal` - Create a new change
 - `lightspec-apply` - Get apply instructions for implementation
 - `lightspec-archive` - Archive a completed change
 

package/dist/cli/index.js

@@ -19,23 +19,6 @@ import { maybeShowTelemetryNotice, trackCommand, shutdown } from '../telemetry/i
 const program = new Command();
 const require = createRequire(import.meta.url);
 const { version } = require('../../package.json');
-/**
- * Get the full command path for nested commands.
- * For example: 'change show' -> 'change:show'
- */
-function getCommandPath(command) {
-    const names = [];
-    let current = command;
-    while (current) {
-        const name = current.name();
-        // Skip the root 'lightspec' command
-        if (name && name !== 'lightspec') {
-            names.unshift(name);
-        }
-        current = current.parent;
-    }
-    return names.join(':') || 'lightspec';
-}
 program
     .name('lightspec')
     .description('AI-native system for spec-driven development')
@@ -43,19 +26,15 @@ program
 // Global options
 program.option('--no-color', 'Disable color output');
 // Apply global flags and telemetry before any command runs
-// Note: preAction receives (thisCommand, actionCommand) where:
-// - thisCommand: the command where hook was added (root program)
-// - actionCommand: the command actually being executed (subcommand)
-program.hook('preAction', async (thisCommand, actionCommand) => {
+program.hook('preAction', async (thisCommand) => {
     const opts = thisCommand.opts();
     if (opts.color === false) {
         process.env.NO_COLOR = '1';
     }
     // Show first-run telemetry notice (if not seen)
     await maybeShowTelemetryNotice();
-    // Track command execution (use actionCommand to get the actual subcommand)
-    const commandPath = getCommandPath(actionCommand);
-    await trackCommand(commandPath, version);
+    // Track command execution
+    await trackCommand();
 });
 // Shutdown telemetry after command completes
 program.hook('postAction', async () => {
@@ -63,10 +42,12 @@ program.hook('postAction', async () => {
 });
 const availableToolIds = AI_TOOLS.filter((tool) => tool.available).map((tool) => tool.value);
 const toolsOptionDescription = `Configure AI tools non-interactively. Use "all", "none", or a comma-separated list of: ${availableToolIds.join(', ')}`;
+const skillLocationOptionDescription = 'Install generated skills in "project" or "home" location (defaults to interactive selection).';
 program
     .command('init [path]')
     .description('Initialize LightSpec in your project')
     .option('--tools <tools>', toolsOptionDescription)
+    .option('--skills-location <location>', skillLocationOptionDescription)
     .action(async (targetPath = '.', options) => {
     try {
         // Validate that the path is a valid directory
@@ -90,8 +71,15 @@ program
             }
         }
         const { InitCommand } = await import('../core/init.js');
+        const skillLocation = options?.skillsLocation === 'project' || options?.skillsLocation === 'home'
+            ? options.skillsLocation
+            : undefined;
+        if (options?.skillsLocation && !skillLocation) {
+            throw new Error('Invalid --skills-location value. Use "project" or "home".');
+        }
         const initCommand = new InitCommand({
             tools: options?.tools,
+            skillLocation,
         });
         await initCommand.execute(targetPath);
     }

package/dist/commands/feedback.js

@@ -87,7 +87,7 @@ function formatBody(bodyText) {
  * Generate a pre-filled GitHub issue URL for manual submission
  */
 function generateManualSubmissionUrl(title, body) {
-    const repo = 'Fission-AI/LightSpec';
+    const repo = 'augmenter-dev/LightSpec';
     const encodedTitle = encodeURIComponent(title);
     const encodedBody = encodeURIComponent(body);
     const encodedLabels = encodeURIComponent('feedback');
@@ -114,7 +114,7 @@ function submitViaGhCli(title, body) {
             'issue',
             'create',
             '--repo',
-            'Fission-AI/LightSpec',
+            'augmenter-dev/LightSpec',
             '--title',
             title,
             '--body',

package/dist/core/config.d.ts

@@ -5,6 +5,7 @@ export declare const LIGHTSPEC_MARKERS: {
 };
 export interface LightSpecConfig {
     aiTools: string[];
+    skillLocation: 'project' | 'home';
 }
 export interface AIToolOption {
     name: string;

package/dist/core/config.js

@@ -20,6 +20,7 @@ export const AI_TOOLS = [
     { name: 'GitHub Copilot', value: 'github-copilot', available: true, successLabel: 'GitHub Copilot' },
     { name: 'iFlow', value: 'iflow', available: true, successLabel: 'iFlow' },
     { name: 'Kilo Code', value: 'kilocode', available: true, successLabel: 'Kilo Code' },
+    { name: 'Mistral Vibe', value: 'mistral-vibe', available: true, successLabel: 'Mistral Vibe' },
     { name: 'OpenCode', value: 'opencode', available: true, successLabel: 'OpenCode' },
     { name: 'Qoder (CLI)', value: 'qoder', available: true, successLabel: 'Qoder' },
     { name: 'Qwen Code', value: 'qwen', available: true, successLabel: 'Qwen Code' },

package/dist/core/configurators/slash/amazon-q.js

@@ -2,7 +2,8 @@ import { SlashCommandConfigurator } from './base.js';
 const FILE_PATHS = {
     proposal: '.amazonq/prompts/lightspec-proposal.md',
     apply: '.amazonq/prompts/lightspec-apply.md',
-    archive: '.amazonq/prompts/lightspec-archive.md'
+    archive: '.amazonq/prompts/lightspec-archive.md',
+    'context-check': '.aws/amazonq/commands/lightspec-context-check.md'
 };
 const FRONTMATTER = {
     proposal: `---
@@ -31,7 +32,10 @@ The user wants to archive the following deployed change. Use the lightspec instr
 
 <ChangeId>
   $ARGUMENTS
-</ChangeId>`
+</ChangeId>`,
+    'context-check': `---
+description: Validate project context in agent instruction files and help populate missing information.
+---`
 };
 export class AmazonQSlashCommandConfigurator extends SlashCommandConfigurator {
     toolId = 'amazon-q';

package/dist/core/configurators/slash/antigravity.js

@@ -2,12 +2,14 @@ import { SlashCommandConfigurator } from './base.js';
 const FILE_PATHS = {
     proposal: '.agent/workflows/lightspec-proposal.md',
     apply: '.agent/workflows/lightspec-apply.md',
-    archive: '.agent/workflows/lightspec-archive.md'
+    archive: '.agent/workflows/lightspec-archive.md',
+    'context-check': '.antigravity/commands/lightspec-context-check.md'
 };
 const DESCRIPTIONS = {
     proposal: 'Scaffold a new LightSpec change and validate strictly.',
     apply: 'Implement an approved LightSpec change and keep tasks in sync.',
-    archive: 'Archive a deployed LightSpec change and update specs.'
+    archive: 'Archive a deployed LightSpec change and update specs.',
+    'context-check': 'Validate project context in agent instruction files and help populate missing information.'
 };
 export class AntigravitySlashCommandConfigurator extends SlashCommandConfigurator {
     toolId = 'antigravity';

package/dist/core/configurators/slash/auggie.js

@@ -2,7 +2,8 @@ import { SlashCommandConfigurator } from './base.js';
 const FILE_PATHS = {
     proposal: '.augment/commands/lightspec-proposal.md',
     apply: '.augment/commands/lightspec-apply.md',
-    archive: '.augment/commands/lightspec-archive.md'
+    archive: '.augment/commands/lightspec-archive.md',
+    'context-check': '.auggie/commands/lightspec-context-check.md'
 };
 const FRONTMATTER = {
     proposal: `---
@@ -16,6 +17,12 @@ argument-hint: change-id
     archive: `---
 description: Archive a deployed LightSpec change and update specs.
 argument-hint: change-id
+---`,
+    'context-check': `---
+name: LightSpec: Context Check
+description: Validate project context in agent instruction files and help populate missing information.
+category: LightSpec
+tags: [lightspec, context, validation]
 ---`
 };
 export class AuggieSlashCommandConfigurator extends SlashCommandConfigurator {

package/dist/core/configurators/slash/base.d.ts

@@ -2,18 +2,29 @@ import { SlashCommandId } from '../../templates/index.js';
 export interface SlashCommandTarget {
     id: SlashCommandId;
     path: string;
-    kind: 'slash';
+    kind: 'skill';
 }
+export type SkillInstallLocation = 'project' | 'home';
 export declare abstract class SlashCommandConfigurator {
     abstract readonly toolId: string;
     abstract readonly isAvailable: boolean;
+    private installLocation;
+    setInstallLocation(location: SkillInstallLocation): void;
     getTargets(): SlashCommandTarget[];
     generateAll(projectPath: string, _lightspecDir: string): Promise<string[]>;
     updateExisting(projectPath: string, _lightspecDir: string): Promise<string[]>;
-    protected abstract getRelativePath(id: SlashCommandId): string;
-    protected abstract getFrontmatter(id: SlashCommandId): string | undefined;
     protected getBody(id: SlashCommandId): string;
     resolveAbsolutePath(projectPath: string, id: SlashCommandId): string;
+    private getRelativeSkillPath;
+    private getToolRoot;
+    private getHomeRootPath;
+    private getSkillName;
+    private buildSkillFile;
     protected updateBody(filePath: string, body: string): Promise<void>;
+    private cleanupLegacyArtifacts;
+    private relativeToToolRoot;
+    private removeLegacyLightSpecFiles;
+    private walkAndRemove;
+    private isLegacyLightSpecFile;
 }
 //# sourceMappingURL=base.d.ts.map

package/dist/core/configurators/slash/base.js

@@ -1,57 +1,151 @@
+import os from 'os';
+import path from 'path';
+import { promises as fs } from 'fs';
 import { FileSystemUtils } from '../../../utils/file-system.js';
 import { TemplateManager } from '../../templates/index.js';
 import { LIGHTSPEC_MARKERS } from '../../config.js';
-const ALL_COMMANDS = ['proposal', 'apply', 'archive'];
+const ALL_COMMANDS = ['proposal', 'apply', 'archive', 'context-check'];
+const TOOL_SKILL_ROOTS = {
+    'amazon-q': '.amazonq',
+    antigravity: '.antigravity',
+    auggie: '.auggie',
+    claude: '.claude',
+    cline: '.cline',
+    codex: '.codex',
+    codebuddy: '.codebuddy',
+    continue: '.continue',
+    costrict: '.cospec/lightspec',
+    crush: '.crush',
+    cursor: '.cursor',
+    factory: '.factory',
+    gemini: '.gemini',
+    'github-copilot': '.github/copilot',
+    iflow: '.iflow',
+    kilocode: '.kilocode',
+    'mistral-vibe': '.vibe',
+    opencode: '.opencode',
+    qoder: '.qoder',
+    qwen: '.qwen',
+    roocode: '.roocode',
+    windsurf: '.windsurf',
+};
+const TOOL_LEGACY_DIRS = {
+    'amazon-q': ['.amazonq/prompts', '.aws/amazonq/commands'],
+    antigravity: ['.antigravity/commands', '.agent/workflows'],
+    auggie: ['.augment/commands', '.auggie/commands'],
+    claude: ['.claude/commands'],
+    cline: ['.cline/commands', '.clinerules/workflows'],
+    codex: ['.codex/prompts'],
+    codebuddy: ['.codebuddy/commands'],
+    continue: ['.continue/prompts', '.continue/commands'],
+    costrict: ['.cospec/lightspec/commands'],
+    crush: ['.crush/commands'],
+    cursor: ['.cursor/commands'],
+    factory: ['.factory/commands'],
+    gemini: ['.gemini/commands'],
+    'github-copilot': ['.github/prompts', '.github/copilot/prompts'],
+    iflow: ['.iflow/commands'],
+    kilocode: ['.kilocode/commands', '.kilocode/workflows'],
+    'mistral-vibe': ['.vibe/commands', '.vibe/workflows', '.vibe/prompts'],
+    opencode: ['.opencode/command', '.opencode/commands'],
+    qoder: ['.qoder/commands', '.qoder/prompts'],
+    qwen: ['.qwen/commands', '.qwen/prompts'],
+    roocode: ['.roo/commands', '.roocode/commands'],
+    windsurf: ['.windsurf/workflows', '.windsurf/commands'],
+};
 export class SlashCommandConfigurator {
+    installLocation = 'project';
+    setInstallLocation(location) {
+        this.installLocation = location;
+    }
     getTargets() {
         return ALL_COMMANDS.map((id) => ({
             id,
-            path: this.getRelativePath(id),
-            kind: 'slash'
+            path: this.getRelativeSkillPath(id),
+            kind: 'skill',
         }));
     }
     async generateAll(projectPath, _lightspecDir) {
         const createdOrUpdated = [];
         for (const target of this.getTargets()) {
             const body = this.getBody(target.id);
-            const filePath = FileSystemUtils.joinPath(projectPath, target.path);
+            const filePath = this.resolveAbsolutePath(projectPath, target.id);
             if (await FileSystemUtils.fileExists(filePath)) {
                 await this.updateBody(filePath, body);
             }
             else {
-                const frontmatter = this.getFrontmatter(target.id);
-                const sections = [];
-                if (frontmatter) {
-                    sections.push(frontmatter.trim());
-                }
-                sections.push(`${LIGHTSPEC_MARKERS.start}\n${body}\n${LIGHTSPEC_MARKERS.end}`);
-                const content = sections.join('\n') + '\n';
+                const frontmatter = TemplateManager.getSlashCommandFrontmatter(target.id).trim();
+                const content = this.buildSkillFile(frontmatter, body);
                 await FileSystemUtils.writeFile(filePath, content);
             }
             createdOrUpdated.push(target.path);
         }
+        await this.cleanupLegacyArtifacts(projectPath);
         return createdOrUpdated;
     }
     async updateExisting(projectPath, _lightspecDir) {
         const updated = [];
         for (const target of this.getTargets()) {
-            const filePath = FileSystemUtils.joinPath(projectPath, target.path);
+            const filePath = this.resolveAbsolutePath(projectPath, target.id);
             if (await FileSystemUtils.fileExists(filePath)) {
                 const body = this.getBody(target.id);
                 await this.updateBody(filePath, body);
                 updated.push(target.path);
             }
         }
+        await this.cleanupLegacyArtifacts(projectPath);
         return updated;
     }
     getBody(id) {
         return TemplateManager.getSlashCommandBody(id).trim();
     }
-    // Resolve absolute path for a given slash command target. Subclasses may override
-    // to redirect to tool-specific locations (e.g., global directories).
     resolveAbsolutePath(projectPath, id) {
-        const rel = this.getRelativePath(id);
-        return FileSystemUtils.joinPath(projectPath, rel);
+        const relativePath = this.getRelativeSkillPath(id);
+        if (this.installLocation === 'project') {
+            return FileSystemUtils.joinPath(projectPath, relativePath);
+        }
+        const homeRoot = this.getHomeRootPath();
+        const rootPrefix = this.getToolRoot();
+        const normalizedRelativePath = FileSystemUtils.toPosixPath(relativePath);
+        if (!normalizedRelativePath.startsWith(`${rootPrefix}/`)) {
+            throw new Error(`Skill path '${relativePath}' does not match expected root '${rootPrefix}' for ${this.toolId}`);
+        }
+        const relativeUnderRoot = normalizedRelativePath.slice(rootPrefix.length + 1);
+        return FileSystemUtils.joinPath(homeRoot, relativeUnderRoot);
+    }
+    getRelativeSkillPath(id) {
+        const root = this.getToolRoot();
+        const skillName = this.getSkillName(id);
+        return `${root}/skills/${skillName}/SKILL.md`;
+    }
+    getToolRoot() {
+        const root = TOOL_SKILL_ROOTS[this.toolId];
+        if (!root) {
+            throw new Error(`No skill root directory configured for tool '${this.toolId}'`);
+        }
+        return root;
+    }
+    getHomeRootPath() {
+        if (this.toolId === 'codex') {
+            const codexHome = process.env.CODEX_HOME?.trim();
+            return codexHome && codexHome.length > 0
+                ? codexHome
+                : FileSystemUtils.joinPath(os.homedir(), '.codex');
+        }
+        const toolRoot = this.getToolRoot();
+        const trimmed = toolRoot.startsWith('./') ? toolRoot.slice(2) : toolRoot;
+        return path.join(os.homedir(), trimmed);
+    }
+    getSkillName(id) {
+        return `lightspec-${id}`;
+    }
+    buildSkillFile(frontmatter, body) {
+        const sections = [];
+        if (frontmatter) {
+            sections.push(frontmatter);
+        }
+        sections.push(`${LIGHTSPEC_MARKERS.start}\n${body}\n${LIGHTSPEC_MARKERS.end}`);
+        return `${sections.join('\n\n')}\n`;
     }
     async updateBody(filePath, body) {
         const content = await FileSystemUtils.readFile(filePath);
@@ -65,5 +159,55 @@ export class SlashCommandConfigurator {
         const updatedContent = `${before}\n${body}\n${after}`;
         await FileSystemUtils.writeFile(filePath, updatedContent);
     }
+    async cleanupLegacyArtifacts(projectPath) {
+        const legacyDirs = TOOL_LEGACY_DIRS[this.toolId] ?? [];
+        for (const legacyDir of legacyDirs) {
+            const absoluteDir = this.installLocation === 'project'
+                ? FileSystemUtils.joinPath(projectPath, legacyDir)
+                : FileSystemUtils.joinPath(this.getHomeRootPath(), this.relativeToToolRoot(legacyDir));
+            await this.removeLegacyLightSpecFiles(absoluteDir);
+        }
+    }
+    relativeToToolRoot(relativePath) {
+        const rootPrefix = this.getToolRoot();
+        const normalized = FileSystemUtils.toPosixPath(relativePath);
+        if (normalized.startsWith(`${rootPrefix}/`)) {
+            return normalized.slice(rootPrefix.length + 1);
+        }
+        if (normalized === rootPrefix) {
+            return '';
+        }
+        return normalized.startsWith('./') ? normalized.slice(2) : normalized;
+    }
+    async removeLegacyLightSpecFiles(dirPath) {
+        if (!(await FileSystemUtils.directoryExists(dirPath))) {
+            return;
+        }
+        await this.walkAndRemove(dirPath);
+    }
+    async walkAndRemove(currentPath) {
+        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path.join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                await this.walkAndRemove(entryPath);
+                continue;
+            }
+            if (this.isLegacyLightSpecFile(entryPath)) {
+                await fs.unlink(entryPath);
+            }
+        }
+    }
+    isLegacyLightSpecFile(filePath) {
+        const normalized = FileSystemUtils.toPosixPath(filePath).toLowerCase();
+        return (normalized.includes('/lightspec-proposal') ||
+            normalized.includes('/lightspec-apply') ||
+            normalized.includes('/lightspec-archive') ||
+            normalized.includes('/lightspec-context-check') ||
+            normalized.includes('/lightspec/proposal') ||
+            normalized.includes('/lightspec/apply') ||
+            normalized.includes('/lightspec/archive') ||
+            normalized.includes('/lightspec/context-check'));
+    }
 }
 //# sourceMappingURL=base.js.map

package/dist/core/configurators/slash/claude.js

@@ -2,7 +2,8 @@ import { SlashCommandConfigurator } from './base.js';
 const FILE_PATHS = {
     proposal: '.claude/commands/lightspec/proposal.md',
     apply: '.claude/commands/lightspec/apply.md',
-    archive: '.claude/commands/lightspec/archive.md'
+    archive: '.claude/commands/lightspec/archive.md',
+    'context-check': '.claude/commands/lightspec/context-check.md'
 };
 const FRONTMATTER = {
     proposal: `---
@@ -22,6 +23,12 @@ name: LightSpec: Archive
 description: Archive a deployed LightSpec change and update specs.
 category: LightSpec
 tags: [lightspec, archive]
+---`,
+    'context-check': `---
+name: LightSpec: Context Check
+description: Validate project context in agent instruction files and help populate missing information.
+category: LightSpec
+tags: [lightspec, context, validation]
 ---`
 };
 export class ClaudeSlashCommandConfigurator extends SlashCommandConfigurator {

package/dist/core/configurators/slash/cline.js

@@ -2,7 +2,8 @@ import { SlashCommandConfigurator } from './base.js';
 const FILE_PATHS = {
     proposal: '.clinerules/workflows/lightspec-proposal.md',
     apply: '.clinerules/workflows/lightspec-apply.md',
-    archive: '.clinerules/workflows/lightspec-archive.md'
+    archive: '.clinerules/workflows/lightspec-archive.md',
+    'context-check': '.cline/commands/lightspec-context-check.md'
 };
 export class ClineSlashCommandConfigurator extends SlashCommandConfigurator {
     toolId = 'cline';
@@ -14,7 +15,8 @@ export class ClineSlashCommandConfigurator extends SlashCommandConfigurator {
         const descriptions = {
             proposal: 'Scaffold a new LightSpec change and validate strictly.',
             apply: 'Implement an approved LightSpec change and keep tasks in sync.',
-            archive: 'Archive a deployed LightSpec change and update specs.'
+            archive: 'Archive a deployed LightSpec change and update specs.',
+            'context-check': 'Validate project context in agent instruction files and help populate missing information.'
         };
         const description = descriptions[id];
         return `# LightSpec: ${id.charAt(0).toUpperCase() + id.slice(1)}\n\n${description}`;

package/dist/core/configurators/slash/codebuddy.js

@@ -2,7 +2,8 @@ import { SlashCommandConfigurator } from './base.js';
 const FILE_PATHS = {
     proposal: '.codebuddy/commands/lightspec/proposal.md',
     apply: '.codebuddy/commands/lightspec/apply.md',
-    archive: '.codebuddy/commands/lightspec/archive.md'
+    archive: '.codebuddy/commands/lightspec/archive.md',
+    'context-check': '.codebuddy/commands/lightspec-context-check.md'
 };
 const FRONTMATTER = {
     proposal: `---
@@ -19,6 +20,12 @@ argument-hint: "[change-id]"
 name: LightSpec: Archive
 description: "Archive a deployed LightSpec change and update specs."
 argument-hint: "[change-id]"
+---`,
+    'context-check': `---
+name: LightSpec: Context Check
+description: Validate project context in agent instruction files and help populate missing information.
+category: LightSpec
+tags: [lightspec, context, validation]
 ---`
 };
 export class CodeBuddySlashCommandConfigurator extends SlashCommandConfigurator {

package/dist/core/configurators/slash/codex.d.ts

@@ -1,14 +1,6 @@
 import { SlashCommandConfigurator } from "./base.js";
-import { SlashCommandId } from "../../templates/index.js";
 export declare class CodexSlashCommandConfigurator extends SlashCommandConfigurator {
     readonly toolId = "codex";
     readonly isAvailable = true;
-    protected getRelativePath(id: SlashCommandId): string;
-    protected getFrontmatter(id: SlashCommandId): string | undefined;
-    private getGlobalPromptsDir;
-    generateAll(projectPath: string, _lightspecDir: string): Promise<string[]>;
-    updateExisting(projectPath: string, _lightspecDir: string): Promise<string[]>;
-    private updateFullFile;
-    resolveAbsolutePath(_projectPath: string, id: SlashCommandId): string;
 }
 //# sourceMappingURL=codex.d.ts.map